@deeeed/metamask-harness 0.2.0

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

@@ -0,0 +1,53 @@
+import {
+  getCoreController,
+  isDirectRun,
+  redactOrder,
+  runAdapter,
+  selectedItems,
+} from './_controller.mjs';
+
+// core Assert selected live Perps open orders are present or absent. Pure read
+// over the controller's standalone getOpenOrders path (no signer / provider init
+// needed) — throws on mismatch so the recipe fails loudly. Mirrors
+// assert_positions.mjs.
+
+export function expectedOpen(input) {
+  const state = String(input.node?.state ?? input.node?.order ?? 'open').toLowerCase();
+  if (state === 'open' || state === 'present') return true;
+  if (state === 'none' || state === 'closed' || state === 'absent') return false;
+  throw new Error(`metamask.perps.assert_orders received unsupported state: ${state}`);
+}
+
+export async function assertOrders(input, expectOpen = expectedOpen(input)) {
+  const { controller, accountAddress, network } = await getCoreController(input);
+  const orders = await controller.getOpenOrders({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const matching = selectedItems(input, orders);
+  const hasOrder = matching.length > 0;
+
+  if (expectOpen && !hasOrder) {
+    throw new Error(
+      `Expected selected Perps open order(s), but none matched ${JSON.stringify(input.node)}.`,
+    );
+  }
+  if (!expectOpen && hasOrder) {
+    throw new Error(
+      `Expected no selected Perps open orders, but ${matching.length} matched ${JSON.stringify(input.node)}.`,
+    );
+  }
+
+  return {
+    action: input.action,
+    source: 'perps-controller-standalone',
+    network,
+    account: accountAddress,
+    expectedOpen: expectOpen,
+    matchingCount: matching.length,
+    orders: matching.map(redactOrder),
+    proofPath: 'perps-controller-getOpenOrders',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter((input) => assertOrders(input));

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

@@ -0,0 +1,52 @@
+import {
+  getCoreController,
+  isDirectRun,
+  redactPosition,
+  runAdapter,
+  selectedItems,
+} from './_controller.mjs';
+
+// core Assert selected live Perps positions are present or absent. Pure read
+// over the controller's standalone path (no signer / provider init needed) —
+// throws on mismatch so the recipe fails loudly.
+
+export function expectedOpen(input) {
+  const state = String(input.node?.state ?? input.node?.position ?? 'open').toLowerCase();
+  if (state === 'open' || state === 'present') return true;
+  if (state === 'none' || state === 'closed' || state === 'absent') return false;
+  throw new Error(`metamask.perps.assert_positions received unsupported state: ${state}`);
+}
+
+export async function assertPositions(input, expectOpen = expectedOpen(input)) {
+  const { controller, accountAddress, network } = await getCoreController(input);
+  const positions = await controller.getPositions({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const matching = selectedItems(input, positions);
+  const hasPosition = matching.length > 0;
+
+  if (expectOpen && !hasPosition) {
+    throw new Error(
+      `Expected selected Perps position(s), but none matched ${JSON.stringify(input.node)}.`,
+    );
+  }
+  if (!expectOpen && hasPosition) {
+    throw new Error(
+      `Expected no selected Perps positions, but ${matching.length} matched ${JSON.stringify(input.node)}.`,
+    );
+  }
+
+  return {
+    action: input.action,
+    source: 'perps-controller-standalone',
+    network,
+    account: accountAddress,
+    expectedOpen: expectOpen,
+    matchingCount: matching.length,
+    positions: matching.map(redactPosition),
+    proofPath: 'perps-controller-getPositions',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter((input) => assertPositions(input));

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

@@ -0,0 +1,97 @@
+import {
+  getCoreControllerWithSigner,
+  isDirectRun,
+  redactOrder,
+  runAdapter,
+  selectedItems,
+  symbolForItem,
+} from './_controller.mjs';
+
+// core Cancel selected live Perps open orders on HyperLiquid testnet by driving
+// the headless PerpsController.cancelOrders() through the full signing/provider
+// path (Slice 2). Mirrors close_positions.mjs: read open orders → cancel the
+// selected subset via the controller → verify the selected orders are gone.
+//
+// cancelOrders() resolves the concrete orders to cancel via the ACTIVE provider's
+// getOpenOrders() (PerpsController wires getOpenOrders: () => this.getOpenOrders()
+// into the cancel context) and then batch-cancels by symbol. We pass the selected
+// symbols; with mode=all (no explicit market) we cancel every open order.
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForOrdersAbsent(controller, accountAddress, symbols, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let orders = [];
+  for (;;) {
+    orders = await controller.getOpenOrders({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    const remaining = orders.filter((order) => symbols.includes(symbolForItem(order)));
+    if (remaining.length === 0) return orders;
+    if (Date.now() >= deadline) return orders;
+    await sleep(1000);
+  }
+}
+
+export async function closeOrders(input) {
+  const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+
+  const orders = await controller.getOpenOrders({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const matching = selectedItems(input, orders);
+  const symbols = Array.from(new Set(matching.map(symbolForItem)));
+
+  if (symbols.length === 0) {
+    return {
+      action: input.action,
+      source: 'perps-controller-cancelOrders',
+      network,
+      account: accountAddress,
+      canceled: false,
+      matchingCount: 0,
+      symbols,
+      reason: 'no matching open orders',
+      proofPath: 'perps-controller-cancelOrders',
+    };
+  }
+
+  // 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 after = await waitForOrdersAbsent(controller, accountAddress, symbols, timeoutMs);
+  const stillOpen = after.filter((order) => symbols.includes(symbolForItem(order)));
+  if (stillOpen.length > 0) {
+    throw new Error(
+      `Expected selected orders to cancel, but ${stillOpen.length} remain: ${JSON.stringify(result)}`,
+    );
+  }
+
+  return {
+    action: input.action,
+    source: 'perps-controller-cancelOrders',
+    network,
+    account: accountAddress,
+    canceled: true,
+    matchingCount: matching.length,
+    successCount: result.successCount,
+    failureCount: result.failureCount,
+    symbols,
+    results: result.results,
+    orders: stillOpen.map(redactOrder),
+    proofPath: 'perps-controller-cancelOrders',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(closeOrders);

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

@@ -0,0 +1,118 @@
+import {
+  currentMarketPrice,
+  getCoreControllerWithSigner,
+  isDirectRun,
+  redactPosition,
+  runAdapter,
+  selectedItems,
+  symbolForItem,
+} from './_controller.mjs';
+
+// core Close selected live Perps positions on HyperLiquid testnet by driving the
+// headless PerpsController.closePosition() per matching position (full close)
+// through the full signing/provider path (Slice 2). Mirrors the extension
+// adapter: read → close each matching position with a fresh price → verify the
+// selected positions are gone.
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForPositionsAbsent(controller, accountAddress, symbols, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let positions = [];
+  for (;;) {
+    positions = await controller.getPositions({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    const remaining = positions.filter((position) =>
+      symbols.includes(symbolForItem(position)),
+    );
+    if (remaining.length === 0) return positions;
+    if (Date.now() >= deadline) return positions;
+    await sleep(1000);
+  }
+}
+
+export async function closePositions(input) {
+  const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
+  const timeoutMs = Number(input.node?.timeout_ms ?? 30000);
+  const maxSlippageBps = Number(
+    input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300,
+  );
+
+  const positions = await controller.getPositions({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const matching = selectedItems(input, positions);
+  const symbols = Array.from(new Set(matching.map(symbolForItem)));
+
+  if (symbols.length === 0) {
+    return {
+      action: input.action,
+      source: 'perps-controller-closePosition',
+      network,
+      account: accountAddress,
+      closed: false,
+      matchingCount: 0,
+      symbols,
+      reason: 'no matching open positions',
+      proofPath: 'perps-controller-closePosition',
+    };
+  }
+
+  const results = [];
+  let successCount = 0;
+  for (const position of matching) {
+    const symbol = symbolForItem(position);
+    const currentPrice = await currentMarketPrice(controller, symbol);
+    // Full close: omit size so the provider closes 100% of the position. Pass
+    // live position + fresh price so the provider skips a REST refetch and the
+    // slippage guard has a current anchor.
+    const result = await controller.closePosition({
+      symbol,
+      orderType: 'market',
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+      position,
+    });
+    const success = result?.success === true;
+    results.push({ symbol, success, currentPrice, result });
+    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 after = await waitForPositionsAbsent(controller, accountAddress, symbols, timeoutMs);
+  const stillOpen = after.filter((position) => symbols.includes(symbolForItem(position)));
+  if (stillOpen.length > 0) {
+    throw new Error(
+      `Expected selected positions to close, but ${stillOpen.length} remain: ${JSON.stringify(results)}`,
+    );
+  }
+
+  return {
+    action: input.action,
+    source: 'perps-controller-closePosition',
+    network,
+    account: accountAddress,
+    closed: true,
+    matchingCount: matching.length,
+    successCount,
+    symbols,
+    results,
+    positions: stillOpen.map(redactPosition),
+    proofPath: 'perps-controller-closePosition',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(closePositions);

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

@@ -0,0 +1,40 @@
+import { getCoreController, isDirectRun, runAdapter, selectedItems } from './_controller.mjs';
+import { assertOrders } from './assert_orders.mjs';
+import { closeOrders } from './close_orders.mjs';
+import { placeOrder } from './place_order.mjs';
+
+// core Higher-level wrapper that reads selected open orders, converges them to the
+// requested `state` (open/none) by canceling or placing, then asserts the final
+// order state. Mirrors ensure_positions.mjs.
+
+export async function ensureOrders(input) {
+  const state = String(input.node?.state ?? input.node?.order ?? 'none').toLowerCase();
+
+  if (state === 'none' || state === 'closed' || state === 'absent') {
+    const close = await closeOrders(input);
+    const assertion = await assertOrders(input, false);
+    return { ...assertion, ensured: 'none', close };
+  }
+
+  if (state === 'open' || state === 'present') {
+    // Only place a resting order when no matching open order already exists
+    // (idempotent ensure). Placing to reach state=open requires a limit order
+    // (orderType=limit + price/offset_pct) so it rests on the book instead of
+    // filling — see place_order.mjs.
+    const { controller, accountAddress } = await getCoreController(input);
+    const orders = await controller.getOpenOrders({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    let order = null;
+    if (selectedItems(input, orders).length === 0) {
+      order = await placeOrder({ ...input, node: { ...input.node, order_type: 'limit' } });
+    }
+    const assertion = await assertOrders(input, true);
+    return { ...assertion, ensured: 'open', order };
+  }
+
+  throw new Error(`metamask.perps.ensure_orders received unsupported state: ${state}`);
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(ensureOrders);

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

@@ -0,0 +1,37 @@
+import { getCoreController, isDirectRun, runAdapter, selectedItems } from './_controller.mjs';
+import { assertPositions } from './assert_positions.mjs';
+import { closePositions } from './close_positions.mjs';
+import { placeOrder } from './place_order.mjs';
+
+// core Higher-level wrapper that reads selected positions, converges them to the
+// requested `state` (open/none) by placing or closing, then asserts the final
+// state. Mirrors the extension ensure_positions semantics.
+
+export async function ensurePositions(input) {
+  const state = String(input.node?.state ?? input.node?.position ?? 'none').toLowerCase();
+
+  if (state === 'none' || state === 'closed' || state === 'absent') {
+    const close = await closePositions(input);
+    const assertion = await assertPositions(input, false);
+    return { ...assertion, ensured: 'none', close };
+  }
+
+  if (state === 'open' || state === 'present') {
+    // Only place when no matching position already exists (idempotent ensure).
+    const { controller, accountAddress } = await getCoreController(input);
+    const positions = await controller.getPositions({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+    let order = null;
+    if (selectedItems(input, positions).length === 0) {
+      order = await placeOrder(input);
+    }
+    const assertion = await assertPositions(input, true);
+    return { ...assertion, ensured: 'open', order };
+  }
+
+  throw new Error(`metamask.perps.ensure_positions received unsupported state: ${state}`);
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(ensurePositions);

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

@@ -0,0 +1,201 @@
+import {
+  configuredSymbols,
+  currentMarketPrice,
+  getCoreControllerWithSigner,
+  isDirectRun,
+  redactOrder,
+  redactPosition,
+  runAdapter,
+  selectedItems,
+} from './_controller.mjs';
+
+// core Place a real Perps order on HyperLiquid testnet by driving the headless
+// PerpsController.placeOrder() through the full signing/provider path (Slice 2).
+// Mirrors the extension adapter's input vocabulary and notional→size math:
+//   size = (usdAmount * leverage) / currentPrice
+// The HyperLiquidProvider recalculates size from usdAmount internally; we still
+// pass a derived size for the controller's own validation, plus currentPrice/
+// priceAtCalculation so the provider's slippage guard has a fresh anchor.
+//
+// LIMIT orders (orderType=limit) place a RESTING order on the book instead of
+// filling: the provider sends tif=Gtc and uses the provided `price` verbatim
+// (calculateOrderPriceAndSize / buildOrdersArray in core's orderCalculations.ts).
+// The limit price is derived from the live mid by `offset_pct` (e.g. -30 places a
+// BUY 30% below mid that will NOT fill), or supplied absolutely via `limit_price`.
+// For a limit order we size from the LIMIT price (not mid) and omit usdAmount so
+// the controller uses our explicit size verbatim — that guarantees the
+// 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).
+
+function resolveSymbol(input) {
+  const symbols = configuredSymbols(input, []);
+  if (symbols.length !== 1) {
+    throw new Error(
+      `metamask.perps.place_order requires exactly one market; got ${JSON.stringify(symbols)}.`,
+    );
+  }
+  return symbols[0];
+}
+
+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}.`);
+  }
+  return raw;
+}
+
+/**
+ * Resolve the resting limit price for a limit order.
+ * Precedence: explicit absolute `limit_price` → `offset_pct` from mid.
+ * A BUY uses a negative offset (below mid) to rest; a SELL a positive offset.
+ * Defaults to a -30% (buy) / +30% (sell) offset so the order will not fill.
+ *
+ * @param input - Adapter input (node.limit_price / node.offset_pct).
+ * @param isBuy - Order direction.
+ * @param mid - Current mid price.
+ */
+function resolveLimitPrice(input, isBuy, mid) {
+  const absolute = input.node?.limit_price ?? input.node?.limitPrice ?? input.node?.price;
+  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 limit_price: ${absolute}.`);
+    }
+    return numeric;
+  }
+  const rawOffset = input.node?.offset_pct ?? input.node?.offsetPct;
+  // Default far-from-mid offset so the resting order does not fill.
+  const offsetPct = rawOffset === undefined || rawOffset === null ? (isBuy ? -30 : 30) : Number(rawOffset);
+  if (!Number.isFinite(offsetPct)) {
+    throw new Error(`metamask.perps.place_order received invalid 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 limit price (${price}).`);
+  }
+  return price;
+}
+
+export async function placeOrder(input) {
+  const { controller, accountAddress, network } = await getCoreControllerWithSigner(input);
+  const symbol = resolveSymbol(input);
+  const side = String(input.node?.side ?? 'long').toLowerCase();
+  const isBuy = side !== 'short';
+  const orderType = resolveOrderType(input);
+  const usdAmount = String(input.node?.amount ?? input.node?.notional ?? '11');
+  const leverage = Number(input.node?.leverage ?? 3);
+  const maxSlippageBps = Number(
+    input.node?.max_slippage_bps ?? input.node?.maxSlippageBps ?? 300,
+  );
+
+  const usdNumeric = Number(usdAmount);
+  if (!Number.isFinite(usdNumeric) || usdNumeric <= 0) {
+    throw new Error(`metamask.perps.place_order received invalid notional: ${usdAmount}.`);
+  }
+  if (!Number.isFinite(leverage) || leverage <= 0) {
+    throw new Error(`metamask.perps.place_order received invalid leverage: ${leverage}.`);
+  }
+
+  const currentPrice = await currentMarketPrice(controller, symbol);
+
+  let orderParams;
+  let limitPrice = null;
+  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.
+    const size = ((usdNumeric * leverage) / limitPrice).toString();
+    orderParams = {
+      symbol,
+      isBuy,
+      size,
+      orderType: 'limit',
+      price: String(limitPrice),
+      timeInForce: 'GTC',
+      leverage,
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+    };
+  } else {
+    const size = ((usdNumeric * leverage) / currentPrice).toString();
+    orderParams = {
+      symbol,
+      isBuy,
+      size,
+      orderType: 'market',
+      leverage,
+      usdAmount,
+      currentPrice,
+      priceAtCalculation: currentPrice,
+      maxSlippageBps,
+    };
+  }
+
+  const result = await controller.placeOrder(orderParams);
+  if (!result || result.success !== true) {
+    throw new Error(
+      `core placeOrder failed for ${symbol} (${orderType}): ${result?.error ?? 'unknown error'} (currentPrice=${currentPrice}${limitPrice ? `, limitPrice=${limitPrice}` : ''}).`,
+    );
+  }
+
+  // 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 = [];
+  let positions = [];
+  if (orderType === 'limit') {
+    openOrders = await controller.getOpenOrders({
+      standalone: true,
+      userAddress: accountAddress,
+    });
+  } 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) {
+    throw new Error(
+      `core placeOrder (limit) for ${symbol} reported success but no resting open order is visible (orderId=${result.orderId ?? 'null'}, limitPrice=${limitPrice}).`,
+    );
+  }
+  if (orderType === 'market' && matchingPositions.length === 0) {
+    throw new Error(
+      `core placeOrder (market) for ${symbol} reported success but no matching position is visible (orderId=${result.orderId ?? 'null'}).`,
+    );
+  }
+
+  return {
+    action: input.action,
+    source: 'perps-controller-placeOrder',
+    network,
+    account: accountAddress,
+    market: symbol,
+    side,
+    orderType,
+    notional: usdAmount,
+    leverage,
+    size: orderParams.size,
+    currentPrice,
+    limitPrice,
+    submitted: true,
+    orderId: result.orderId ?? null,
+    filledSize: result.filledSize ?? null,
+    averagePrice: result.averagePrice ?? null,
+    matchingCount: orderType === 'limit' ? matchingOrders.length : matchingPositions.length,
+    orders: matchingOrders.map(redactOrder),
+    positions: matchingPositions.map(redactPosition),
+    order: result,
+    proofPath: 'perps-controller-placeOrder',
+  };
+}
+
+if (isDirectRun(import.meta.url)) runAdapter(placeOrder);

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

@@ -0,0 +1,30 @@
+import { getCoreController, runAdapter } from './_controller.mjs';
+
+function redactAccount(account) {
+  return {
+    totalBalance: account?.totalBalance ?? null,
+    spendableBalance: account?.spendableBalance ?? null,
+    withdrawableBalance: account?.withdrawableBalance ?? null,
+    marginUsed: account?.marginUsed ?? null,
+    unrealizedPnl: account?.unrealizedPnl ?? null,
+    returnOnEquity: account?.returnOnEquity ?? null,
+  };
+}
+
+export async function readAccount(input) {
+  const { controller, accountAddress, network } = await getCoreController(input);
+  const account = await controller.getAccountState({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  return {
+    action: input.action,
+    source: 'perps-controller-standalone',
+    network,
+    account: accountAddress,
+    accountState: redactAccount(account),
+    proofPath: 'perps-controller-getAccountState',
+  };
+}
+
+runAdapter(readAccount);

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

@@ -0,0 +1,27 @@
+import {
+  getCoreController,
+  redactOrder,
+  runAdapter,
+  selectedItems,
+} from './_controller.mjs';
+
+export async function readOrders(input) {
+  const { controller, accountAddress, network } = await getCoreController(input);
+  const orders = await controller.getOpenOrders({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const matching = selectedItems(input, orders);
+  return {
+    action: input.action,
+    source: 'perps-controller-standalone',
+    network,
+    account: accountAddress,
+    count: orders.length,
+    matchingCount: matching.length,
+    orders: matching.map(redactOrder),
+    proofPath: 'perps-controller-getOpenOrders',
+  };
+}
+
+runAdapter(readOrders);

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

@@ -0,0 +1,27 @@
+import {
+  getCoreController,
+  redactPosition,
+  runAdapter,
+  selectedItems,
+} from './_controller.mjs';
+
+export async function readPositions(input) {
+  const { controller, accountAddress, network } = await getCoreController(input);
+  const positions = await controller.getPositions({
+    standalone: true,
+    userAddress: accountAddress,
+  });
+  const matching = selectedItems(input, positions);
+  return {
+    action: input.action,
+    source: 'perps-controller-standalone',
+    network,
+    account: accountAddress,
+    count: positions.length,
+    matchingCount: matching.length,
+    positions: matching.map(redactPosition),
+    proofPath: 'perps-controller-getPositions',
+  };
+}
+
+runAdapter(readPositions);