opentool 0.8.22 → 0.8.24

package/dist/adapters/hyperliquid/index.js

@@ -6,6 +6,29 @@ import { hexToBytes, concatBytes, bytesToHex } from '@noble/hashes/utils';
 // src/adapters/hyperliquid/index.ts
 
 // src/store/index.ts
+var STORE_EVENT_LEVELS = [
+  "decision",
+  "execution",
+  "lifecycle"
+];
+var STORE_EVENT_LEVEL_SET = new Set(STORE_EVENT_LEVELS);
+var MARKET_REQUIRED_ACTIONS = [
+  "swap",
+  "bridge",
+  "order",
+  "trade",
+  "lend",
+  "borrow",
+  "repay",
+  "stake",
+  "unstake",
+  "withdraw",
+  "provide_liquidity",
+  "remove_liquidity",
+  "claim"
+];
+var MARKET_REQUIRED_ACTIONS_SET = new Set(MARKET_REQUIRED_ACTIONS);
+var EXECUTION_ACTIONS_SET = new Set(MARKET_REQUIRED_ACTIONS);
 var StoreError = class extends Error {
   constructor(message, status, causeData) {
     super(message);
@@ -14,13 +37,57 @@ var StoreError = class extends Error {
     this.name = "StoreError";
   }
 };
+var normalizeAction = (action) => {
+  const normalized = action?.trim().toLowerCase();
+  return normalized ? normalized : null;
+};
+var coerceEventLevel = (value) => {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized || !STORE_EVENT_LEVEL_SET.has(normalized)) return null;
+  return normalized;
+};
 var requiresMarketIdentity = (input) => {
-  const action = (input.action ?? "").toLowerCase();
-  if (action === "order" || action === "swap" || action === "trade") return true;
-  return false;
+  const action = normalizeAction(input.action);
+  if (!action) return false;
+  return MARKET_REQUIRED_ACTIONS_SET.has(action);
 };
 var hasMarketIdentity = (value) => {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  const requiredKeys = ["market_type", "venue", "environment", "canonical_symbol"];
+  return requiredKeys.every((key) => {
+    const field = record[key];
+    return typeof field === "string" && field.trim().length > 0;
+  });
+};
+var resolveEventLevel = (input) => {
+  const direct = coerceEventLevel(input.eventLevel);
+  if (direct) return direct;
+  const metadataLevel = coerceEventLevel(input.metadata?.eventLevel);
+  if (metadataLevel) return metadataLevel;
+  const action = normalizeAction(input.action);
+  if (action && EXECUTION_ACTIONS_SET.has(action) && (input.metadata?.lifecycle === true || typeof input.metadata?.executionRef === "string" || typeof input.metadata?.parentExecutionRef === "string")) {
+    return "lifecycle";
+  }
+  if (action && EXECUTION_ACTIONS_SET.has(action) || hasMarketIdentity(input.market)) {
+    return "execution";
+  }
+  if (action) return "decision";
+  return null;
+};
+var normalizeStoreInput = (input) => {
+  const metadata = { ...input.metadata ?? {} };
+  const eventLevel = resolveEventLevel({ ...input, metadata });
+  if (eventLevel) {
+    metadata.eventLevel = eventLevel;
+  }
+  const hasMetadata = Object.keys(metadata).length > 0;
+  return {
+    ...input,
+    ...eventLevel ? { eventLevel } : {},
+    ...hasMetadata ? { metadata } : {}
+  };
 };
 function resolveConfig(options) {
   const baseUrl = options?.baseUrl ?? process.env.BASE_URL ?? "https://api.openpond.ai";
@@ -41,8 +108,26 @@ function resolveConfig(options) {
   return { baseUrl: normalizedBaseUrl, apiKey, fetchFn };
 }
 async function store(input, options) {
-  if (requiresMarketIdentity(input) && !hasMarketIdentity(input.market)) {
-    throw new StoreError("market is required for trade events");
+  const normalizedInput = normalizeStoreInput(input);
+  const eventLevel = normalizedInput.eventLevel;
+  const normalizedAction = normalizeAction(normalizedInput.action);
+  if (eventLevel === "execution" || eventLevel === "lifecycle") {
+    if (!normalizedAction || !EXECUTION_ACTIONS_SET.has(normalizedAction)) {
+      throw new StoreError(
+        `eventLevel "${eventLevel}" requires an execution action`
+      );
+    }
+  }
+  if (eventLevel === "execution" && !hasMarketIdentity(normalizedInput.market)) {
+    throw new StoreError(
+      `market is required for execution events. market must include market_type, venue, environment, canonical_symbol`
+    );
+  }
+  const shouldApplyLegacyMarketRule = eventLevel == null || eventLevel === "execution";
+  if (shouldApplyLegacyMarketRule && requiresMarketIdentity(normalizedInput) && !hasMarketIdentity(normalizedInput.market)) {
+    throw new StoreError(
+      `market is required for action "${normalizedInput.action}". market must include market_type, venue, environment, canonical_symbol`
+    );
   }
   const { baseUrl, apiKey, fetchFn } = resolveConfig(options);
   const url = `${baseUrl}/apps/positions/tx`;
@@ -54,7 +139,7 @@ async function store(input, options) {
         "content-type": "application/json",
         "openpond-api-key": apiKey
       },
-      body: JSON.stringify(input)
+      body: JSON.stringify(normalizedInput)
     });
   } catch (error) {
     throw new StoreError("Failed to reach store endpoint", void 0, error);
@@ -120,6 +205,7 @@ var BUILDER_CODE = {
   fee: 100
 };
 var metaCache = /* @__PURE__ */ new Map();
+var spotMetaCache = /* @__PURE__ */ new Map();
 var perpDexsCache = /* @__PURE__ */ new Map();
 var UNKNOWN_SYMBOL = "UNKNOWN";
 var extractDexPrefix = (value) => {
@@ -142,6 +228,14 @@ var normalizeHyperliquidBase = (value) => {
   if (!normalized || normalized === UNKNOWN_SYMBOL) return null;
   return normalized;
 };
+var normalizeSpotTokenName = (value) => {
+  const raw = (value ?? "").trim().toUpperCase();
+  if (!raw) return "";
+  if (raw.endsWith("0") && raw.length > 1) {
+    return raw.slice(0, -1);
+  }
+  return raw;
+};
 var parseHyperliquidPair = (value) => {
   if (!value) return null;
   const trimmed = value.trim();
@@ -288,6 +382,29 @@ async function getUniverse(args) {
   metaCache.set(cacheKey, { fetchedAt: Date.now(), universe: json.universe });
   return json.universe;
 }
+async function getSpotMeta(args) {
+  const cacheKey = `${args.environment}:${args.baseUrl}`;
+  const cached = spotMetaCache.get(cacheKey);
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return { universe: cached.universe, tokens: cached.tokens };
+  }
+  const response = await args.fetcher(`${args.baseUrl}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ type: "spotMeta" })
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok || !json?.universe) {
+    throw new HyperliquidApiError(
+      "Unable to load Hyperliquid spot metadata.",
+      json ?? { status: response.status }
+    );
+  }
+  const universe = json.universe ?? [];
+  const tokens = json.tokens ?? [];
+  spotMetaCache.set(cacheKey, { fetchedAt: Date.now(), universe, tokens });
+  return { universe, tokens };
+}
 function resolveAssetIndex(symbol, universe) {
   const [raw] = symbol.split("-");
   const target = raw.trim();
@@ -331,11 +448,57 @@ async function resolveDexIndex(args) {
   }
   return index;
 }
+function buildSpotTokenIndexMap(tokens) {
+  const map = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    const name = normalizeSpotTokenName(token?.name);
+    const index = typeof token?.index === "number" && Number.isFinite(token.index) ? token.index : null;
+    if (!name || index == null) continue;
+    if (!map.has(name) || token?.isCanonical) {
+      map.set(name, index);
+    }
+  }
+  return map;
+}
+function resolveSpotTokenIndex(tokenMap, value) {
+  const normalized = normalizeSpotTokenName(value);
+  if (!normalized) return null;
+  const direct = tokenMap.get(normalized);
+  if (direct != null) return direct;
+  if (!normalized.startsWith("U")) {
+    const prefixed = tokenMap.get(`U${normalized}`);
+    if (prefixed != null) return prefixed;
+  }
+  return null;
+}
+function resolveSpotMarketIndex(args) {
+  for (let i = 0; i < args.universe.length; i += 1) {
+    const entry = args.universe[i];
+    const tokens = Array.isArray(entry?.tokens) ? entry.tokens : null;
+    const baseToken = tokens?.[0] ?? entry?.baseToken ?? null;
+    const quoteToken = tokens?.[1] ?? entry?.quoteToken ?? null;
+    if (baseToken === args.baseToken && quoteToken === args.quoteToken) {
+      if (typeof entry?.index === "number" && Number.isFinite(entry.index)) {
+        return entry.index;
+      }
+      return i;
+    }
+  }
+  return null;
+}
 async function resolveHyperliquidAssetIndex(args) {
   const trimmed = args.symbol.trim();
   if (!trimmed) {
     throw new Error("Hyperliquid symbol must be a non-empty string.");
   }
+  if (trimmed.startsWith("@")) {
+    const rawIndex = trimmed.slice(1).trim();
+    const index = Number(rawIndex);
+    if (!Number.isFinite(index)) {
+      throw new Error(`Hyperliquid spot market index is invalid: ${trimmed}`);
+    }
+    return 1e4 + index;
+  }
   const separator = trimmed.indexOf(":");
   if (separator > 0) {
     const dex = trimmed.slice(0, separator).trim();
@@ -362,6 +525,29 @@ async function resolveHyperliquidAssetIndex(args) {
     }
     return 1e5 + dexIndex * 1e4 + assetIndex;
   }
+  const pair = parseHyperliquidPair(trimmed);
+  if (pair) {
+    const { universe: universe2, tokens } = await getSpotMeta({
+      baseUrl: args.baseUrl,
+      environment: args.environment,
+      fetcher: args.fetcher
+    });
+    const tokenMap = buildSpotTokenIndexMap(tokens);
+    const baseToken = resolveSpotTokenIndex(tokenMap, pair.base);
+    const quoteToken = resolveSpotTokenIndex(tokenMap, pair.quote);
+    if (baseToken == null || quoteToken == null) {
+      throw new Error(`Unknown Hyperliquid spot symbol: ${trimmed}`);
+    }
+    const marketIndex = resolveSpotMarketIndex({
+      universe: universe2,
+      baseToken,
+      quoteToken
+    });
+    if (marketIndex == null) {
+      throw new Error(`Unknown Hyperliquid spot symbol: ${trimmed}`);
+    }
+    return 1e4 + marketIndex;
+  }
   const universe = await getUniverse({
     baseUrl: args.baseUrl,
     environment: args.environment,