opentool 0.8.22 → 0.8.23

package/dist/adapters/hyperliquid/index.js

@@ -120,6 +120,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 +143,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 +297,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 +363,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 +440,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,