@deeeed/metamask-harness 0.80.0 → 0.82.0

package/dist/discovery.js

@@ -1,15 +0,0 @@
-import { assessRecipe } from "@farmslot/recipe-cli";
-import {
-  loadRecipeLibraries
-} from "@farmslot/recipe-runner";
-import { resolveActionManifest } from "./manifest.js";
-async function runnableLibraryRecipes(adapter, sources) {
-  const resolution = await loadRecipeLibraries(sources, { adapter });
-  const { manifest } = await resolveActionManifest(adapter, void 0, sources);
-  return [...resolution.recipes.values()].filter(
-    (recipe) => assessRecipe({ resolution, manifest }, recipe).length === 0
-  );
-}
-export {
-  runnableLibraryRecipes
-};

package/dist/metamask-action-validation.js

@@ -1,68 +0,0 @@
-import { adapterRegistry } from "./adapters/registry.js";
-import { getAdapterSurface } from "./adapters/surface.js";
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function resolveMetaMaskParameterValue(value, params) {
-  if (typeof value === "string") {
-    const exact = /^\{\{params\.([A-Za-z0-9_.-]+)\}\}$/u.exec(value);
-    if (!exact) return value;
-    let current = params;
-    for (const segment of exact[1].split(".")) {
-      if (!isRecord(current) || !Object.hasOwn(current, segment)) return value;
-      current = current[segment];
-    }
-    return current;
-  }
-  if (Array.isArray(value)) return value.map((entry) => resolveMetaMaskParameterValue(entry, params));
-  if (!isRecord(value)) return value;
-  return Object.fromEntries(
-    Object.entries(value).map(([key, entry]) => [key, resolveMetaMaskParameterValue(entry, params)])
-  );
-}
-function validateMetaMaskActionInputs(recipe, adapter, params) {
-  if (!isRecord(recipe) || !isRecord(recipe.workflow)) return [];
-  const nodes = isRecord(recipe.workflow.nodes) ? recipe.workflow.nodes : void 0;
-  if (!nodes) return [];
-  const surface = adapter && adapterRegistry.has(adapter) ? getAdapterSurface(adapter) : void 0;
-  const findings = [];
-  for (const [nodeId, rawNode] of Object.entries(nodes)) {
-    const node = params ? resolveMetaMaskParameterValue(rawNode, params) : rawNode;
-    if (!isRecord(node)) continue;
-    const action = node.action;
-    findings.push(...surface?.actions.inputFindings?.(nodeId, node) ?? []);
-    const state = typeof node.state === "string" ? node.state.toLowerCase() : void 0;
-    const createsOrder = action === "metamask.perps.place_order" || !surface?.actions.ensureChecksOnly && (action === "metamask.perps.ensure_positions" || action === "metamask.perps.ensure_orders") && (state === "open" || state === "present");
-    if (!createsOrder) continue;
-    const requireOneOf = (names, message) => {
-      const present = names.some((name) => {
-        const value = node[name];
-        return value !== void 0 && value !== null && value !== "";
-      });
-      if (present) return;
-      findings.push({
-        severity: "error",
-        code: "recipe.missing_param",
-        path: `workflow.nodes.${nodeId}.${names[0]}`,
-        message
-      });
-    };
-    requireOneOf(
-      ["market", "symbol"],
-      `${action} requires market=<symbol> (or symbol=<symbol>) before it may create an order`
-    );
-    requireOneOf(
-      ["side"],
-      `${action} requires side=long or side=short before it may create an order`
-    );
-    requireOneOf(
-      ["amount", "notional"],
-      `${action} requires amount=<usd> or notional=<usd> before it may create an order`
-    );
-  }
-  return findings;
-}
-export {
-  resolveMetaMaskParameterValue,
-  validateMetaMaskActionInputs
-};

package/dist/network-observation.js

@@ -1,290 +0,0 @@
-import path from "node:path";
-import brokerModule from "@farmslot/recipe-runner/cdp-broker";
-import configModule from "@farmslot/adapter-rn/bridge-runtime/lib/config.cjs";
-import {
-  createExtensionNetworkObserver
-} from "./adapters/extension/network-observer.js";
-import { getAdapterSurface } from "./adapters/surface.js";
-import {
-  indexArtifactManifest,
-  writeContainedArtifact
-} from "@farmslot/recipe-cli/harness";
-const AUTO_CAPTURE_ID = "run-network";
-const AUTO_ARTIFACT_PATH = "network/run-summary.json";
-const { brokerSocketPath, createBrokerClient } = brokerModule;
-const { resolvePort } = configModule;
-const sessions = /* @__PURE__ */ new Map();
-async function startRunNetworkObservation(adapter, target, artifactsDir, env, ports = {}) {
-  const network = getAdapterSurface(adapter).observation?.network;
-  if (!network) return void 0;
-  const runtimeEnv = {
-    ...env,
-    ...ports.cdpPort ? { CDP_PORT: ports.cdpPort, RECIPE_CDP_PORT: ports.cdpPort } : {},
-    ...ports.watcherPort ? { WATCHER_PORT: ports.watcherPort } : {}
-  };
-  const key = path.resolve(artifactsDir);
-  const session = {
-    artifactsDir: key,
-    autoStarted: false,
-    autoStartedAt: Date.now(),
-    nodeEvents: []
-  };
-  sessions.set(key, session);
-  try {
-    session.backend = await network.backend(target, runtimeEnv, key);
-  } catch (error) {
-    session.setupError = boundedError(error);
-  }
-  if (runtimeEnv.MM_HARNESS_AUTO_NETWORK_CAPTURE !== "0") {
-    session.autoStartedAt = Date.now();
-    if (session.backend) {
-      try {
-        await session.backend.start({
-          id: AUTO_CAPTURE_ID,
-          bodyJsonFields: ["type"],
-          maxDurationMs: 60 * 60 * 1e3,
-          maxRequests: 1e4,
-          methods: [],
-          urlIncludes: []
-        });
-        session.autoStarted = true;
-      } catch (error) {
-        session.setupError = boundedError(error);
-      }
-    }
-  }
-  return {
-    onActionEvent(event) {
-      session.nodeEvents.push({ ...event, epochMs: Date.now() });
-    },
-    async finalize(artifactManifestPath) {
-      try {
-        if (runtimeEnv.MM_HARNESS_AUTO_NETWORK_CAPTURE !== "0") {
-          const summary = await automaticSummary(session);
-          await writeSummary(key, AUTO_ARTIFACT_PATH, summary);
-          if (artifactManifestPath) {
-            await indexArtifact(
-              artifactManifestPath,
-              AUTO_ARTIFACT_PATH,
-              "Automatic network observation"
-            );
-          }
-        }
-      } finally {
-        sessions.delete(key);
-        await session.backend?.close();
-      }
-    }
-  };
-}
-async function handleRunNetworkAction(platform, action, node, context) {
-  if (!getAdapterSurface(platform).observation?.network?.actions) return null;
-  if (action === "app.network_assert") {
-    const assertion = await import("../library/actions/shared/app/network-assert.mjs");
-    return {
-      output: await assertion.assertNetwork({ action, node, context })
-    };
-  }
-  if (action !== "app.network_capture") return null;
-  const phase = String(node.phase ?? "").toLowerCase();
-  const id = String(node.id ?? "").trim();
-  if (!["start", "end"].includes(phase) || !id) {
-    throw new Error(
-      "app.network_capture requires phase=start|end and a non-empty id."
-    );
-  }
-  const session = sessions.get(path.resolve(context.artifactsDir));
-  if (!session?.backend) {
-    throw new Error(
-      `Extension network observation is unavailable: ${session?.setupError ?? "run observer was not started"}.`
-    );
-  }
-  if (phase === "start") {
-    const result = await session.backend.start(captureParams(id, node));
-    return {
-      output: {
-        action,
-        phase,
-        ...asRecord(result)
-      }
-    };
-  }
-  const artifactPath = String(
-    node.artifact_path ?? `network/${id}-summary.json`
-  );
-  const summary = await session.backend.end(id);
-  await writeSummary(context.artifactsDir, artifactPath, summary);
-  return {
-    output: {
-      action,
-      phase,
-      ...summary
-    },
-    artifacts: [
-      {
-        path: artifactPath,
-        type: "report",
-        nodeId: context.nodeId
-      }
-    ]
-  };
-}
-async function createMobileNetworkBackend(target, env) {
-  const { client } = await connectMobileBroker(target, env);
-  return {
-    start(params) {
-      return client.control("capture-start", params, 1e4);
-    },
-    async end(id) {
-      return asRecord(await client.control("capture-end", { id }, 1e4));
-    },
-    async close() {
-      client.close();
-    }
-  };
-}
-async function connectMobileBroker(target, env) {
-  const runtimeDir = env.RECIPE_RUNTIME_DIR ? path.resolve(target, env.RECIPE_RUNTIME_DIR) : path.join(target, "temp", "recipe", "runtime");
-  const socketPath = brokerSocketPath(
-    runtimeDir,
-    resolvePort(env, target)
-  );
-  const discoveryClient = await createBrokerClient(socketPath, "", 1e4);
-  let targets;
-  try {
-    targets = await discoveryClient.control(
-      "resolve-targets",
-      { nameIncludes: mobileTargetPin(env) },
-      1e4
-    );
-  } finally {
-    discoveryClient.close();
-  }
-  const deviceId = selectMobileBrokerTarget(targets, env);
-  const client = await createBrokerClient(socketPath, deviceId, 1e4);
-  return { client, deviceId };
-}
-function selectMobileBrokerTarget(value, env) {
-  const targets = Array.isArray(value) ? value.map(asRecord).filter((target) => target.deviceId) : [];
-  const pin = mobileTargetPin(env);
-  const candidates = pin ? targets.filter(
-    (target) => String(target.name ?? "").toLowerCase().includes(pin.toLowerCase())
-  ) : targets;
-  if (candidates.length !== 1) {
-    throw new Error(
-      `Mobile network observation requires one broker target; found ${candidates.length}.`
-    );
-  }
-  return String(candidates[0].deviceId);
-}
-function mobileTargetPin(env) {
-  const platform = String(
-    env.RECIPE_RN_EXPLICIT_PLATFORM ?? env.RECIPE_HARNESS_PLATFORM ?? ""
-  ).toLowerCase();
-  return String(
-    platform === "android" ? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? "" : platform === "ios" ? env.IOS_SIMULATOR ?? "" : env.IOS_SIMULATOR ?? env.ANDROID_TARGET_DEVICE_NAME ?? env.ANDROID_DEVICE ?? ""
-  ).trim();
-}
-async function automaticSummary(session) {
-  let summary;
-  if (session.autoStarted && session.backend) {
-    try {
-      summary = await session.backend.end(AUTO_CAPTURE_ID);
-    } catch (error) {
-      summary = unavailableSummary(session.autoStartedAt, boundedError(error));
-    }
-  } else {
-    summary = unavailableSummary(
-      session.autoStartedAt,
-      session.setupError ?? "Network observer did not start."
-    );
-  }
-  const startedAt = Number(summary.startedAtEpochMs ?? session.autoStartedAt);
-  return {
-    ...summary,
-    nodeEvents: session.nodeEvents.map((event) => ({
-      action: event.action,
-      elapsedMs: Math.max(0, event.epochMs - startedAt),
-      nodeId: event.nodeId,
-      status: event.status
-    }))
-  };
-}
-function unavailableSummary(startedAtEpochMs, reason) {
-  return {
-    schemaVersion: 1,
-    id: AUTO_CAPTURE_ID,
-    status: "unavailable",
-    startedAtEpochMs,
-    endedAtEpochMs: Date.now(),
-    maxDurationMs: 60 * 60 * 1e3,
-    reconnects: 0,
-    droppedRequests: 0,
-    unavailableReasons: [reason],
-    coverageGapReasons: [],
-    uninspectableBodyRequests: 0,
-    projectedBodyFields: ["type"],
-    totalRequests: 0,
-    requestsByMethod: {},
-    requestsByHost: {},
-    requestsByType: {},
-    requests: []
-  };
-}
-function captureParams(id, node) {
-  return {
-    id,
-    urlIncludes: node.url_includes ?? [],
-    methods: node.methods ?? [],
-    bodyJsonFields: node.body_json_fields ?? [],
-    maxRequests: node.max_requests,
-    maxDurationMs: node.max_duration_ms
-  };
-}
-async function writeSummary(artifactsDir, relativePath, summary) {
-  await writeContainedArtifact(
-    artifactsDir,
-    relativePath,
-    `${JSON.stringify(summary, null, 2)}
-`,
-    "Network artifact"
-  );
-}
-async function indexArtifact(artifactManifestPath, relativePath, label) {
-  await indexArtifactManifest(
-    artifactManifestPath,
-    [
-      {
-        path: relativePath,
-        type: "report",
-        label,
-        category: "diagnostic"
-      }
-    ]
-  );
-}
-async function createExtensionNetworkBackend(env, artifactsDir) {
-  return createExtensionNetworkObserver(extensionCdpPort(env), artifactsDir);
-}
-function extensionCdpPort(env) {
-  const port = Number(
-    env.CDP_PORT ?? env.RECIPE_CDP_PORT ?? process.env.CDP_PORT
-  );
-  if (!Number.isInteger(port) || port <= 0) {
-    throw new Error("Extension network observation requires CDP_PORT.");
-  }
-  return port;
-}
-function boundedError(error) {
-  return String(error instanceof Error ? error.message : error).slice(0, 256);
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-export {
-  connectMobileBroker,
-  createExtensionNetworkBackend,
-  createMobileNetworkBackend,
-  handleRunNetworkAction,
-  startRunNetworkObservation
-};

package/library/actions/terminal/perps/_venue.mjs

@@ -1,242 +0,0 @@
-// Read and clean up Hyperliquid venue state for a terminal fixture account.
-// Reads use the public info API. Writes (cleanup, agent revoke) are testnet-only,
-// signed in this process by the fixture account through the target checkout's
-// own @nktkas/hyperliquid, and never pass through the browser wallet.
-
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-export const INFO_URLS = Object.freeze({
-  testnet: 'https://api.hyperliquid-testnet.xyz/info',
-  mainnet: 'https://api.hyperliquid.xyz/info',
-});
-
-// Agents the Web Terminal approves are named "mm-terminal" plus an optional
-// " valid_until <ms>" expiry suffix.
-export const TERMINAL_AGENT_PREFIX = 'mm-terminal';
-
-export function resolveNetwork(node = {}) {
-  const network = node.network == null ? 'testnet' : String(node.network);
-  if (network !== 'testnet' && network !== 'mainnet') {
-    throw new Error(`network must be testnet or mainnet, got ${JSON.stringify(node.network)}.`);
-  }
-  return network;
-}
-
-export const MAINNET_CONFIRMATION = 'REAL_FUNDS';
-
-// Venue mutations default to testnet. Mainnet needs the explicit
-// mainnet_confirmation=REAL_FUNDS on the node, as every library mutation does.
-export function requireTestnet(node = {}, action = 'this action') {
-  const network = resolveNetwork(node);
-  if (network === 'mainnet' && node.mainnet_confirmation === MAINNET_CONFIRMATION) return network;
-  if (network !== 'testnet') {
-    throw new Error(
-      `${action} mutates venue state; refusing network=${network} without mainnet_confirmation=${MAINNET_CONFIRMATION}.`,
-    );
-  }
-  return network;
-}
-
-export async function info(network, body, fetchImpl = globalThis.fetch) {
-  const response = await fetchImpl(INFO_URLS[network], {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  });
-  if (!response.ok) {
-    throw new Error(`Hyperliquid ${network} info ${body.type} returned HTTP ${response.status}.`);
-  }
-  return response.json();
-}
-
-export function normalizePosition(entry) {
-  const position = entry?.position ?? entry;
-  const size = Number(position.szi);
-  return {
-    market: String(position.coin).toUpperCase(),
-    side: size >= 0 ? 'long' : 'short',
-    size: String(Math.abs(size)),
-    entryPrice: position.entryPx ?? null,
-    // Numeric entry notional in USD, for cap assertions.
-    notional: position.entryPx == null ? null : Number((Math.abs(size) * Number(position.entryPx)).toFixed(2)),
-    leverage: position.leverage?.value ?? null,
-    marginMode: position.leverage?.type ?? null,
-    liquidationPrice: position.liquidationPx ?? null,
-  };
-}
-
-const TRIGGER_TYPES = {
-  'Stop Market': 'stop_market',
-  'Stop Limit': 'stop_limit',
-  'Take Profit Market': 'take_profit_market',
-  'Take Profit Limit': 'take_profit_limit',
-};
-
-export function normalizeOrder(order) {
-  return {
-    orderId: String(order.oid),
-    market: String(order.coin).toUpperCase(),
-    side: order.side === 'B' ? 'buy' : 'sell',
-    price: order.limitPx ?? null,
-    size: order.sz ?? null,
-    orderType: order.orderType ?? null,
-    triggerType: TRIGGER_TYPES[order.orderType] ?? null,
-    isTrigger: Boolean(order.isTrigger),
-    triggerPrice: order.isTrigger ? order.triggerPx ?? null : null,
-    reduceOnly: Boolean(order.reduceOnly),
-    isPositionTpsl: Boolean(order.isPositionTpsl),
-    timestamp: order.timestamp ?? null,
-  };
-}
-
-// Only a public EVM address ever leaves this process for the info API.
-export function venueUser(address) {
-  const value = String(address ?? '');
-  if (!/^0x[0-9a-fA-F]{40}$/u.test(value)) throw new Error('venue reads need a 0x-prefixed 20-byte account address.');
-  return `0x${value.slice(2).toLowerCase()}`;
-}
-
-export async function readVenueState({ network, user: rawUser, fetchImpl }) {
-  const user = venueUser(rawUser);
-  const [clearinghouse, openOrders, agents] = await Promise.all([
-    info(network, { type: 'clearinghouseState', user }, fetchImpl),
-    info(network, { type: 'frontendOpenOrders', user }, fetchImpl),
-    info(network, { type: 'extraAgents', user }, fetchImpl),
-  ]);
-  return {
-    network,
-    user,
-    positions: (clearinghouse.assetPositions ?? []).map(normalizePosition),
-    orders: (openOrders ?? []).map(normalizeOrder),
-    agents: (agents ?? []).map((agent) => ({
-      name: agent.name,
-      address: agent.address,
-      validUntil: agent.validUntil ?? null,
-    })),
-    accountValue: clearinghouse.marginSummary?.accountValue ?? null,
-    withdrawable: clearinghouse.withdrawable ?? null,
-  };
-}
-
-// Market selection mirrors the core adapter: market/symbol or markets/symbols,
-// with mode=all selecting every item. Positions match side long|short, orders
-// match the side they would open (buy=long, sell=short).
-export function requestedMarkets(node = {}) {
-  const selector = node.selector && typeof node.selector === 'object' ? node.selector : {};
-  if ((node.mode ?? selector.mode) === 'all') return null;
-  const list = [
-    node.market,
-    node.symbol,
-    selector.market,
-    selector.symbol,
-    ...(Array.isArray(node.markets) ? node.markets : []),
-    ...(Array.isArray(node.symbols) ? node.symbols : []),
-    ...(Array.isArray(selector.markets) ? selector.markets : []),
-    ...(Array.isArray(selector.symbols) ? selector.symbols : []),
-  ]
-    .filter((value) => typeof value === 'string' && value.trim())
-    .map((value) => value.trim().toUpperCase());
-  if (list.length === 0) {
-    throw new Error('Select a market (market, markets) or pass mode=all; refusing an implicit account-wide selection.');
-  }
-  return new Set(list);
-}
-
-export function selectItems(node, items, kind) {
-  const markets = requestedMarkets(node);
-  const rawSide = node.side ?? node.selector?.side;
-  const side = rawSide == null ? null : String(rawSide).toLowerCase();
-  return items.filter((item) => {
-    if (markets && !markets.has(item.market)) return false;
-    if (!side) return true;
-    if (kind === 'position') return item.side === side;
-    return (item.side === 'buy' ? 'long' : 'short') === side;
-  });
-}
-
-export function expectedOpen(node, action) {
-  if (node.state == null) throw new Error(`${action} requires state=open or state=none.`);
-  const state = String(node.state).toLowerCase();
-  if (state === 'open' || state === 'present') return true;
-  if (state === 'none' || state === 'closed' || state === 'absent') return false;
-  throw new Error(`${action} received unsupported state: ${state}`);
-}
-
-function sameNumber(actual, expected, tolerancePct = 0) {
-  const a = Number(actual);
-  const e = Number(expected);
-  if (!Number.isFinite(a) || !Number.isFinite(e)) return false;
-  if (tolerancePct <= 0) return a === e;
-  return Math.abs(a - e) <= Math.abs(e) * (tolerancePct / 100);
-}
-
-// Order expectations beyond presence; each failing order is reported.
-export function orderExpectationFailures(node, orders) {
-  const failures = [];
-  const tolerance = Number(node.price_tolerance_pct ?? 0);
-  for (const order of orders) {
-    if (node.expect_limit_price != null && !sameNumber(order.price, node.expect_limit_price, tolerance)) {
-      failures.push(`order ${order.orderId} limit price ${order.price} != ${node.expect_limit_price}`);
-    }
-    if (node.expect_trigger_price != null && !sameNumber(order.triggerPrice, node.expect_trigger_price, tolerance)) {
-      failures.push(`order ${order.orderId} trigger price ${order.triggerPrice} != ${node.expect_trigger_price}`);
-    }
-    if (node.expect_trigger_order_type != null && order.triggerType !== node.expect_trigger_order_type) {
-      failures.push(`order ${order.orderId} trigger type ${order.triggerType} != ${node.expect_trigger_order_type}`);
-    }
-    if (node.expect_reduce_only != null && order.reduceOnly !== Boolean(node.expect_reduce_only)) {
-      failures.push(`order ${order.orderId} reduceOnly ${order.reduceOnly} != ${node.expect_reduce_only}`);
-    }
-    if (node.expect_size != null && !sameNumber(order.size, node.expect_size)) {
-      failures.push(`order ${order.orderId} size ${order.size} != ${node.expect_size}`);
-    }
-  }
-  return failures;
-}
-
-export function filterOrderKind(node, orders) {
-  let selected = orders;
-  if (node.only_trigger_orders === true || node.order_kind === 'trigger') selected = selected.filter((order) => order.isTrigger);
-  if (node.order_kind === 'limit') selected = selected.filter((order) => !order.isTrigger);
-  if (node.trigger_kind === 'take_profit') selected = selected.filter((order) => order.triggerType?.startsWith('take_profit'));
-  if (node.trigger_kind === 'stop_loss') selected = selected.filter((order) => order.triggerType?.startsWith('stop'));
-  if (Array.isArray(node.order_ids) && node.order_ids.length > 0) {
-    const ids = new Set(node.order_ids.map(String));
-    selected = selected.filter((order) => ids.has(order.orderId));
-  }
-  return selected;
-}
-
-export async function pollUntil(read, done, timeoutMs, intervalMs = 750) {
-  const deadline = Date.now() + Math.max(0, Number(timeoutMs) || 0);
-  let value = await read();
-  while (!done(value) && Date.now() < deadline) {
-    await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs, Math.max(1, deadline - Date.now()))));
-    value = await read();
-  }
-  return value;
-}
-
-// The terminal checkout ships the SDK it trades with; use that exact copy.
-export async function loadTargetHyperliquid(projectRoot) {
-  const require = createRequire(path.join(projectRoot, 'package.json'));
-  let entry;
-  try {
-    entry = require.resolve('@nktkas/hyperliquid');
-  } catch {
-    throw new Error(
-      `@nktkas/hyperliquid is not installed in ${projectRoot}.\nNext: npm ci in the terminal checkout.`,
-    );
-  }
-  return import(pathToFileURL(entry).href);
-}
-
-// Hyperliquid prices: at most 5 significant figures and (6 - szDecimals)
-// decimals for perps.
-export function venuePrice(raw, szDecimals) {
-  const decimals = Math.max(0, 6 - szDecimals);
-  const significant = Number(Number(raw).toPrecision(5));
-  return String(Number(significant.toFixed(decimals)));
-}

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

@@ -1,54 +0,0 @@
-// Assert presence, absence, count and field expectations (limit/trigger price,
-// trigger type, reduce-only, size) of the selected venue open orders.
-
-import { isDirectRun, resolveAccountAddress, runAdapter } from '../platform/runtime.mjs';
-import {
-  expectedOpen,
-  filterOrderKind,
-  orderExpectationFailures,
-  pollUntil,
-  readVenueState,
-  resolveNetwork,
-  selectItems,
-} from './_venue.mjs';
-
-export async function assertOrders(input, deps = {}) {
-  const node = input.node ?? {};
-  const expectOpen = expectedOpen(node, 'metamask.perps.assert_orders');
-  const network = resolveNetwork(node);
-  const { name, address } = await resolveAccountAddress(input);
-  const expectCount = node.expect_count ?? node.expectCount;
-  const reached = (matching) => {
-    if (!expectOpen) return matching.length === 0;
-    const countOk = expectCount == null ? matching.length > 0 : matching.length === Number(expectCount);
-    return countOk && orderExpectationFailures(node, matching).length === 0;
-  };
-  const matching = await pollUntil(
-    async () => filterOrderKind(node, selectItems(node, (await readVenueState({ network, user: address, fetchImpl: deps.fetchImpl })).orders, 'order')),
-    reached,
-    node.timeout_ms,
-  );
-  if (!reached(matching)) {
-    const failures = expectOpen ? orderExpectationFailures(node, matching) : [];
-    const wanted = !expectOpen ? 'no' : expectCount == null ? 'at least one' : `exactly ${expectCount}`;
-    throw new Error(
-      `Expected ${wanted} matching venue order(s), found ${matching.length}` +
-      `${failures.length ? `; ${failures.join('; ')}` : ''}: ${JSON.stringify(matching)}`,
-    );
-  }
-  return {
-    action: input.action,
-    source: 'hyperliquid-info-frontendOpenOrders',
-    network,
-    account: address,
-    accountName: name,
-    expectedOpen: expectOpen,
-    matchingCount: matching.length,
-    expectedCount: expectCount == null ? null : Number(expectCount),
-    orders: matching,
-    orderIds: matching.map((order) => order.orderId),
-    proofPath: 'venue-frontendOpenOrders',
-  };
-}
-
-if (isDirectRun(import.meta.url)) runAdapter((input) => assertOrders(input));