opentool 0.8.11 → 0.8.13

package/dist/index.js

@@ -1832,6 +1832,7 @@ var BUILDER_CODE = {
   fee: 100
 };
 var metaCache = /* @__PURE__ */ new Map();
+var perpDexsCache = /* @__PURE__ */ new Map();
 var HyperliquidApiError = class extends Error {
   constructor(message, response) {
     super(message);
@@ -1870,7 +1871,8 @@ function createMonotonicNonceFactory(start = Date.now()) {
   };
 }
 async function getUniverse(args) {
-  const cacheKey = `${args.environment}:${args.baseUrl}`;
+  const dexKey = args.dex ? args.dex.trim().toLowerCase() : "";
+  const cacheKey = `${args.environment}:${args.baseUrl}:${dexKey}`;
   const cached = metaCache.get(cacheKey);
   if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
     return cached.universe;
@@ -1878,7 +1880,9 @@ async function getUniverse(args) {
   const response = await args.fetcher(`${args.baseUrl}/info`, {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ type: "meta" })
+    body: JSON.stringify(
+      dexKey ? { type: "meta", dex: dexKey } : { type: "meta" }
+    )
   });
   const json = await response.json().catch(() => null);
   if (!response.ok || !json?.universe) {
@@ -1901,6 +1905,76 @@ function resolveAssetIndex(symbol, universe) {
   }
   return index;
 }
+async function getPerpDexs(args) {
+  const cacheKey = `${args.environment}:${args.baseUrl}`;
+  const cached = perpDexsCache.get(cacheKey);
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.dexs;
+  }
+  const response = await args.fetcher(`${args.baseUrl}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ type: "perpDexs" })
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok || !Array.isArray(json)) {
+    throw new HyperliquidApiError(
+      "Unable to load Hyperliquid perp dex metadata.",
+      json ?? { status: response.status }
+    );
+  }
+  perpDexsCache.set(cacheKey, { fetchedAt: Date.now(), dexs: json });
+  return json;
+}
+async function resolveDexIndex(args) {
+  const dexs = await getPerpDexs(args);
+  const target = args.dex.trim().toLowerCase();
+  const index = dexs.findIndex(
+    (entry) => entry?.name?.toLowerCase() === target
+  );
+  if (index === -1) {
+    throw new Error(`Unknown Hyperliquid perp dex: ${args.dex}`);
+  }
+  return index;
+}
+async function resolveHyperliquidAssetIndex(args) {
+  const trimmed = args.symbol.trim();
+  if (!trimmed) {
+    throw new Error("Hyperliquid symbol must be a non-empty string.");
+  }
+  const separator = trimmed.indexOf(":");
+  if (separator > 0) {
+    const dex = trimmed.slice(0, separator).trim();
+    if (!dex) {
+      throw new Error("Hyperliquid dex name is required.");
+    }
+    const dexIndex = await resolveDexIndex({
+      baseUrl: args.baseUrl,
+      environment: args.environment,
+      fetcher: args.fetcher,
+      dex
+    });
+    const universe2 = await getUniverse({
+      baseUrl: args.baseUrl,
+      environment: args.environment,
+      fetcher: args.fetcher,
+      dex
+    });
+    const assetIndex = universe2.findIndex(
+      (entry) => entry.name.toUpperCase() === trimmed.toUpperCase()
+    );
+    if (assetIndex === -1) {
+      throw new Error(`Unknown Hyperliquid asset symbol: ${trimmed}`);
+    }
+    return 1e5 + dexIndex * 1e4 + assetIndex;
+  }
+  const universe = await getUniverse({
+    baseUrl: args.baseUrl,
+    environment: args.environment,
+    fetcher: args.fetcher
+  });
+  return resolveAssetIndex(trimmed, universe);
+}
 function toApiDecimal(value) {
   if (typeof value === "string") {
     return value;
@@ -2555,12 +2629,12 @@ async function placeHyperliquidTwapOrder(options) {
   assertPositiveDecimal(twap.size, "size");
   assertPositiveNumber(twap.minutes, "minutes");
   const env = options.environment ?? "mainnet";
-  const universe = await getUniverse({
+  const asset = await resolveHyperliquidAssetIndex({
+    symbol: twap.symbol,
     baseUrl: API_BASES[env],
     environment: env,
     fetcher: fetch
   });
-  const asset = resolveAssetIndex(twap.symbol, universe);
   const action = {
     type: "twapOrder",
     twap: {
@@ -2577,12 +2651,12 @@ async function placeHyperliquidTwapOrder(options) {
 async function cancelHyperliquidTwapOrder(options) {
   assertSymbol(options.cancel.symbol);
   const env = options.environment ?? "mainnet";
-  const universe = await getUniverse({
+  const asset = await resolveHyperliquidAssetIndex({
+    symbol: options.cancel.symbol,
     baseUrl: API_BASES[env],
     environment: env,
     fetcher: fetch
   });
-  const asset = resolveAssetIndex(options.cancel.symbol, universe);
   const action = {
     type: "twapCancel",
     a: asset,
@@ -2594,12 +2668,12 @@ async function updateHyperliquidLeverage(options) {
   assertSymbol(options.input.symbol);
   assertPositiveNumber(options.input.leverage, "leverage");
   const env = options.environment ?? "mainnet";
-  const universe = await getUniverse({
+  const asset = await resolveHyperliquidAssetIndex({
+    symbol: options.input.symbol,
     baseUrl: API_BASES[env],
     environment: env,
     fetcher: fetch
   });
-  const asset = resolveAssetIndex(options.input.symbol, universe);
   const action = {
     type: "updateLeverage",
     asset,
@@ -2612,12 +2686,12 @@ async function updateHyperliquidIsolatedMargin(options) {
   assertSymbol(options.input.symbol);
   assertPositiveNumber(options.input.ntli, "ntli");
   const env = options.environment ?? "mainnet";
-  const universe = await getUniverse({
+  const asset = await resolveHyperliquidAssetIndex({
+    symbol: options.input.symbol,
     baseUrl: API_BASES[env],
     environment: env,
     fetcher: fetch
   });
-  const asset = resolveAssetIndex(options.input.symbol, universe);
   const action = {
     type: "updateIsolatedMargin",
     asset,
@@ -2720,14 +2794,14 @@ async function submitExchangeAction(options, action) {
 }
 async function withAssetIndexes(options, entries, mapper) {
   const env = options.environment ?? "mainnet";
-  const universe = await getUniverse({
-    baseUrl: API_BASES[env],
-    environment: env,
-    fetcher: fetch
-  });
   return Promise.all(
     entries.map(async (entry) => {
-      const assetIndex = resolveAssetIndex(entry.symbol, universe);
+      const assetIndex = await resolveHyperliquidAssetIndex({
+        symbol: entry.symbol,
+        baseUrl: API_BASES[env],
+        environment: env,
+        fetcher: fetch
+      });
       return mapper(assetIndex, entry);
     })
   );
@@ -2737,12 +2811,12 @@ async function buildOrder(intent, options) {
   assertPositiveDecimal(intent.price, "price");
   assertPositiveDecimal(intent.size, "size");
   const env = options.environment ?? "mainnet";
-  const universe = await getUniverse({
+  const assetIndex = await resolveHyperliquidAssetIndex({
+    symbol: intent.symbol,
     baseUrl: API_BASES[env],
     environment: env,
     fetcher: fetch
   });
-  const assetIndex = resolveAssetIndex(intent.symbol, universe);
   const limitOrTrigger = intent.trigger ? mapTrigger(intent.trigger) : {
     limit: {
       tif: intent.tif ?? "Ioc"
@@ -2865,37 +2939,39 @@ async function placeHyperliquidOrder(options) {
   }
   const inferredEnvironment = environment ?? "mainnet";
   const resolvedBaseUrl = API_BASES[inferredEnvironment];
-  const universe = await getUniverse({
-    baseUrl: resolvedBaseUrl,
-    environment: inferredEnvironment,
-    fetcher: fetch
-  });
-  const preparedOrders = orders.map((intent) => {
-    const assetIndex = resolveAssetIndex(intent.symbol, universe);
-    const limitOrTrigger = intent.trigger ? {
-      trigger: {
-        isMarket: Boolean(intent.trigger.isMarket),
-        triggerPx: toApiDecimal(intent.trigger.triggerPx),
-        tpsl: intent.trigger.tpsl
-      }
-    } : {
-      limit: {
-        tif: intent.tif ?? "Ioc"
-      }
-    };
-    const order = {
-      a: assetIndex,
-      b: intent.side === "buy",
-      p: toApiDecimal(intent.price),
-      s: toApiDecimal(intent.size),
-      r: intent.reduceOnly ?? false,
-      t: limitOrTrigger,
-      ...intent.clientId ? {
-        c: normalizeHex(intent.clientId)
-      } : {}
-    };
-    return order;
-  });
+  const preparedOrders = await Promise.all(
+    orders.map(async (intent) => {
+      const assetIndex = await resolveHyperliquidAssetIndex({
+        symbol: intent.symbol,
+        baseUrl: resolvedBaseUrl,
+        environment: inferredEnvironment,
+        fetcher: fetch
+      });
+      const limitOrTrigger = intent.trigger ? {
+        trigger: {
+          isMarket: Boolean(intent.trigger.isMarket),
+          triggerPx: toApiDecimal(intent.trigger.triggerPx),
+          tpsl: intent.trigger.tpsl
+        }
+      } : {
+        limit: {
+          tif: intent.tif ?? "Ioc"
+        }
+      };
+      const order = {
+        a: assetIndex,
+        b: intent.side === "buy",
+        p: toApiDecimal(intent.price),
+        s: toApiDecimal(intent.size),
+        r: intent.reduceOnly ?? false,
+        t: limitOrTrigger,
+        ...intent.clientId ? {
+          c: normalizeHex(intent.clientId)
+        } : {}
+      };
+      return order;
+    })
+  );
   const action = {
     type: "order",
     orders: preparedOrders,