@deeeed/metamask-harness 0.18.0 → 0.19.1

package/library/actions/mobile/perps/perps.mjs

@@ -24,7 +24,10 @@ function symbolForItem(item) {
 }
 
 function sideForItem(item) {
-  return String(item?.side ?? item?.direction ?? '').toLowerCase();
+  const side = String(item?.side ?? item?.direction ?? '').toLowerCase();
+  if (side === 'buy' || side === 'b') return 'long';
+  if (side === 'sell' || side === 'a' || side === 's') return 'short';
+  return side;
 }
 
 function configuredSymbols(input, items) {
@@ -34,20 +37,68 @@ function configuredSymbols(input, items) {
   const explicit = input.node?.markets ?? input.node?.symbols ?? selector.markets ?? selector.symbols;
   if (Array.isArray(explicit) && explicit.length > 0) return uniqueSymbols(explicit.map(normalizeMarketSymbol));
   if (typeof explicit === 'string' && explicit.length > 0) return uniqueSymbols(explicit.split(',').map((part) => normalizeMarketSymbol(part.trim())).filter(Boolean));
-  return [marketSymbol(input)];
+  const single = input.node?.market ?? input.node?.symbol ?? selector.market ?? selector.symbol;
+  return single ? [normalizeMarketSymbol(single)] : [];
 }
 
-function selectedItems(input, items) {
-  const symbols = new Set(configuredSymbols(input, items));
+export function selectedItems(input, items) {
+  const requested = configuredSymbols(input, items);
+  const symbols = requested.length > 0 ? new Set(requested) : null;
   const selector = input.node?.selector && typeof input.node.selector === 'object' ? input.node.selector : {};
   const side = input.node?.side ?? selector.side;
   return items.filter((item) => {
-    if (!symbols.has(symbolForItem(item))) return false;
+    if (symbols && !symbols.has(symbolForItem(item))) return false;
     if (side && sideForItem(item) && sideForItem(item) !== String(side).toLowerCase()) return false;
     return true;
   });
 }
 
+function requireExplicitSelection(input) {
+  const node = input.node ?? {};
+  const selector = node.selector && typeof node.selector === 'object' ? node.selector : {};
+  const values = [node.market, node.symbol, node.markets, node.symbols, selector.market, selector.symbol, selector.markets, selector.symbols];
+  const selected = values.some((value) => Array.isArray(value) ? value.length > 0 : value != null && String(value).trim() !== '');
+  if (!selected && node.mode !== 'all' && selector.mode !== 'all') {
+    throw new Error(`${input.action} requires market=<symbol> or mode=all.`);
+  }
+}
+
+function requirePlaceOrderInputs(input) {
+  const node = input.node ?? {};
+  if (node.market == null && node.symbol == null) throw new Error(`${input.action} requires market=<symbol>.`);
+  if (node.side == null) throw new Error(`${input.action} requires side=long or side=short.`);
+  if (node.amount == null && node.notional == null) throw new Error(`${input.action} requires amount=<usd> or notional=<usd>.`);
+}
+
+function resolveOrderType(input) {
+  const value = String(input.node?.order_type ?? input.node?.orderType ?? 'market').toLowerCase();
+  if (value !== 'market' && value !== 'limit') {
+    throw new Error(`${input.action} received unsupported order_type: ${value}.`);
+  }
+  return value;
+}
+
+function resolveLimitPrice(input, isBuy, currentPrice) {
+  const explicit = input.node?.limit_price ?? input.node?.limitPrice ?? input.node?.price;
+  if (explicit != null && String(explicit).length > 0) {
+    const value = Number(explicit);
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`${input.action} received invalid limit_price: ${explicit}.`);
+    }
+    return value;
+  }
+  const rawOffset = input.node?.offset_pct ?? input.node?.offsetPct;
+  const offset = rawOffset == null ? (isBuy ? -30 : 30) : Number(rawOffset);
+  if (!Number.isFinite(offset)) {
+    throw new Error(`${input.action} received invalid offset_pct: ${rawOffset}.`);
+  }
+  const value = currentPrice * (1 + offset / 100);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${input.action} computed a non-positive limit price (${value}).`);
+  }
+  return value;
+}
+
 function uniqueSymbols(symbols) {
   return Array.from(new Set(symbols.filter(Boolean)));
 }
@@ -124,6 +175,20 @@ async function waitForPositionPresent(input, symbol, timeoutMs = 30000) {
   return last;
 }
 
+async function waitForSelectedState(input, readItems, expectedOpen, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let items;
+  while (true) {
+    items = await readItems(input);
+    const matching = selectedItems(input, items);
+    if (expectedOpen ? matching.length > 0 : matching.length === 0) {
+      return matching;
+    }
+    if (Date.now() >= deadline) return matching;
+    await sleep(Math.min(500, Math.max(1, deadline - Date.now())));
+  }
+}
+
 function redactPosition(position) {
   return {
     symbol: position.symbol ?? position.coin ?? null,
@@ -250,20 +315,32 @@ export async function readOrders(input) {
 }
 
 export async function assertPositions(input, expectedOpen) {
-  const positions = await readPositions(input);
-  const matching = selectedItems(input, positions);
+  requireExplicitSelection(input);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const matching = await waitForSelectedState(
+    input,
+    readPositions,
+    expectedOpen,
+    timeoutMs,
+  );
   const hasPosition = matching.length > 0;
-  if (expectedOpen && !hasPosition) throw new Error(`Expected selected Perps position(s), but none matched ${JSON.stringify(input.node)}.`);
-  if (!expectedOpen && hasPosition) throw new Error(`Expected no selected Perps positions, but ${matching.length} matched ${JSON.stringify(input.node)}.`);
+  if (expectedOpen && !hasPosition) throw new Error('Expected at least one matching open Perps position, but found none.');
+  if (!expectedOpen && hasPosition) throw new Error(`Expected no matching open Perps positions, but found ${matching.length}.`);
   return { action: input.action, expectedOpen, matchingCount: matching.length, positions: matching.map(redactPosition), source: 'mobile-perps-controller' };
 }
 
 export async function assertOrders(input, expectedOpen) {
-  const orders = await readOpenOrders(input);
-  const matching = selectedItems(input, orders);
+  requireExplicitSelection(input);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 0);
+  const matching = await waitForSelectedState(
+    input,
+    readOpenOrders,
+    expectedOpen,
+    timeoutMs,
+  );
   const hasOrders = matching.length > 0;
-  if (expectedOpen && !hasOrders) throw new Error(`Expected selected Perps order(s), but none matched ${JSON.stringify(input.node)}.`);
-  if (!expectedOpen && hasOrders) throw new Error(`Expected no selected Perps orders, but ${matching.length} matched ${JSON.stringify(input.node)}.`);
+  if (expectedOpen && !hasOrders) throw new Error('Expected at least one matching open Perps order, but found none.');
+  if (!expectedOpen && hasOrders) throw new Error(`Expected no matching open Perps orders, but found ${matching.length}.`);
   return { action: input.action, expectedOpen, matchingCount: matching.length, orders: matching.map(redactOrder), source: 'mobile-perps-controller-open-orders' };
 }
 
@@ -315,6 +392,7 @@ async function closePositionItem(input, position) {
 }
 
 export async function closePositions(input) {
+  requireExplicitSelection(input);
   const before = await readPositions(input);
   const matching = selectedItems(input, before);
   const symbols = uniqueSymbols(matching.map(symbolForItem));
@@ -336,6 +414,7 @@ export async function closePositions(input) {
 }
 
 export async function closeOrders(input) {
+  requireExplicitSelection(input);
   const before = await readOpenOrders(input);
   const matching = selectedItems(input, before);
   const symbols = uniqueSymbols(matching.map(symbolForItem));
@@ -380,15 +459,47 @@ export async function closeOrders(input) {
 }
 
 export async function placeOrder(input) {
+  requirePlaceOrderInputs(input);
   const symbol = marketSymbol(input);
-  const side = String(input.node?.side ?? 'long').toLowerCase();
-  const amount = String(input.node?.amount ?? input.node?.notional ?? '11');
-  const size = String(input.node?.size ?? '0.0001');
+  const side = String(input.node.side).toLowerCase();
+  const amount = String(input.node.amount ?? input.node.notional);
   const leverage = Number(input.node?.leverage ?? 3);
   const maxSlippageBps = Number(input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300);
   const isBuy = orderSideIsBuy(side);
+  const orderType = resolveOrderType(input);
   const currentPrice = await currentPriceForOrder(input, symbol);
-  const result = await evalAsync(input, `Engine.context.PerpsController.placeOrder({ symbol: ${JSON.stringify(symbol)}, isBuy: ${JSON.stringify(isBuy)}, orderType: 'market', size: ${JSON.stringify(size)}, usdAmount: ${JSON.stringify(amount)}, leverage: ${JSON.stringify(leverage)}, currentPrice: ${JSON.stringify(currentPrice)}, maxSlippageBps: ${JSON.stringify(maxSlippageBps)} }).then(function(r){return JSON.stringify(r)})`);
+  const limitPrice = orderType === 'limit'
+    ? resolveLimitPrice(input, isBuy, currentPrice)
+    : null;
+  const size = String(
+    input.node?.size
+      ?? ((Number(amount) * leverage) / (limitPrice ?? currentPrice)),
+  );
+  const orderParams = orderType === 'limit'
+    ? {
+      symbol,
+      isBuy,
+      orderType,
+      size,
+      price: String(limitPrice),
+      timeInForce: 'GTC',
+      leverage,
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+    }
+    : {
+      symbol,
+      isBuy,
+      orderType,
+      size,
+      usdAmount: amount,
+      leverage,
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+    };
+  const result = await evalAsync(input, `Engine.context.PerpsController.placeOrder(${JSON.stringify(orderParams)}).then(function(r){return JSON.stringify(r)})`);
   if (result?.success === false || result == null) {
     throw new Error(`Failed to place ${symbol} ${side}: ${result?.error || JSON.stringify(result)}`);
   }
@@ -396,12 +507,18 @@ export async function placeOrder(input) {
     input,
     'globalThis.__AGENTIC__ && globalThis.__AGENTIC__.refreshPerpsStreams ? globalThis.__AGENTIC__.refreshPerpsStreams().then(function(r){return JSON.stringify(r)}) : Promise.resolve(JSON.stringify({ ok: false, reason: "refreshPerpsStreams unavailable" }))',
   );
-  await waitForPositionPresent(input, symbol, Number(input.node?.timeout_ms ?? 30000));
-  return { action: input.action, market: symbol, side, amount, size, leverage, submitted: true, result, refresh, proofPath: 'mobile-perps-controller-place-order' };
+  if (orderType === 'limit') {
+    await waitForSelectedState(input, readOpenOrders, true, Number(input.node?.timeout_ms ?? 30000));
+  } else {
+    await waitForPositionPresent(input, symbol, Number(input.node?.timeout_ms ?? 30000));
+  }
+  return { action: input.action, market: symbol, side, orderType, amount, size, leverage, limitPrice, submitted: true, result, refresh, proofPath: 'mobile-perps-controller-place-order' };
 }
 
 export async function ensurePositions(input) {
-  const state = String(input.node?.state ?? input.node?.position ?? 'none').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.ensure_positions requires state=open or state=none.');
+  requireExplicitSelection(input);
+  const state = String(input.node.state).toLowerCase();
   if (state === 'none' || state === 'closed' || state === 'absent') {
     const close = await closePositions(input);
     return { ...(await assertPositions(input, false)), close };
@@ -415,12 +532,21 @@ export async function ensurePositions(input) {
 }
 
 export async function ensureOrders(input) {
-  const state = String(input.node?.state ?? input.node?.orders ?? 'none').toLowerCase();
+  if (input.node?.state == null) throw new Error('metamask.perps.ensure_orders requires state=open or state=none.');
+  requireExplicitSelection(input);
+  const state = String(input.node.state).toLowerCase();
   if (state === 'none' || state === 'closed' || state === 'absent') {
     const close = await closeOrders(input);
     return { ...(await assertOrders(input, false)), close };
   }
-  if (state === 'open' || state === 'present') return assertOrders(input, true);
+  if (state === 'open' || state === 'present') {
+    const current = await readOpenOrders(input);
+    let order = null;
+    if (selectedItems(input, current).length === 0) {
+      order = await placeOrder({ ...input, node: { ...input.node, order_type: 'limit' } });
+    }
+    return { ...(await assertOrders(input, true)), order };
+  }
   throw new Error(`metamask.perps.ensure_orders received unsupported state: ${state}`);
 }
 

package/library/library.json

@@ -3,5 +3,5 @@
   "schema_version": 1,
   "name": "metamask",
   "owner": "mm-harness-runner",
-  "description": "Canonical MetaMask recipe library: minimal, stable flows every recipe can compose. Team and personal libraries layer on top and win resolution by default."
+  "description": "Canonical MetaMask library of reusable, parameterized recipes. Team and personal libraries layer on top and win resolution by default."
 }