@continuumdao/ctm-mpc-defi 0.2.9 → 0.2.10

package/dist/protocols/evm/hyperliquid/index.cjs

@@ -26,6 +26,12 @@ function hyperliquidVaultStatsUrl(chainId) {
   return chainId === 998 ? null : "https://stats-data.hyperliquid.xyz/Mainnet/vaults";
 }
 var HYPERLIQUID_HLP_VAULT_ADDRESS = "0xdfc24b077bc1425ad1dea75bcb6f8158e10df303";
+function hyperliquidInferDexFromCoin(coin) {
+  const trimmed = coin.trim();
+  const sep = trimmed.indexOf(":");
+  if (sep <= 0) return void 0;
+  return trimmed.slice(0, sep);
+}
 
 // src/protocols/evm/hyperliquid/constants.ts
 var HYPERLIQUID_CORE_WRITER_ADDRESS = "0x3333333333333333333333333333333333333333";
@@ -36,6 +42,28 @@ var HYPERLIQUID_TIF = {
   gtc: 2,
   ioc: 3
 };
+var HYPERLIQUID_INTERVAL_MS = {
+  "1m": 6e4,
+  "3m": 18e4,
+  "5m": 3e5,
+  "15m": 9e5,
+  "30m": 18e5,
+  "1h": 36e5,
+  "2h": 72e5,
+  "4h": 144e5,
+  "8h": 288e5,
+  "12h": 432e5,
+  "1d": 864e5,
+  "3d": 2592e5,
+  "1w": 6048e5,
+  "1M": 2592e6
+};
+var HYPERLIQUID_DEFAULT_OHLCV_INTERVAL = "15m";
+var HYPERLIQUID_DEFAULT_CANDLE_LIMIT = 48;
+var HYPERLIQUID_MAX_CANDLE_LIMIT = 200;
+var HYPERLIQUID_MAX_OHLCV_BARS = 2e3;
+var HYPERLIQUID_DEFAULT_LOOKBACK_DAYS = 1;
+var HYPERLIQUID_MAX_LOOKBACK_DAYS = 90;
 
 // src/protocols/evm/hyperliquid/api.ts
 async function hyperliquidInfoPost(chainId, body) {
@@ -86,19 +114,8 @@ async function hyperliquidFetchAllMids(args) {
   const mids = await hyperliquidInfoPost(args.chainId, req);
   return { mids };
 }
-async function hyperliquidFetchCandles(args) {
-  const endTime = args.endTimeMs ?? Date.now();
-  const startTime = args.startTimeMs ?? endTime - 7 * 24 * 60 * 60 * 1e3;
-  const raw = await hyperliquidInfoPost(args.chainId, {
-    type: "candleSnapshot",
-    req: {
-      coin: args.coin,
-      interval: args.interval,
-      startTime,
-      endTime
-    }
-  });
-  const candles = (raw ?? []).map((c) => ({
+function hyperliquidMapCandles(raw) {
+  return (raw ?? []).map((c) => ({
     timestampMs: c.t,
     open: c.o,
     high: c.h,
@@ -106,20 +123,180 @@ async function hyperliquidFetchCandles(args) {
     close: c.c,
     volume: c.v
   }));
-  return { candles };
+}
+async function hyperliquidFetchCandlesRaw(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "candleSnapshot",
+    req: {
+      coin: args.coin,
+      interval: args.interval,
+      startTime: args.startTimeMs,
+      endTime: args.endTimeMs
+    }
+  });
+  return hyperliquidMapCandles(raw);
+}
+function hyperliquidResolveOhlcvWindow(args) {
+  const endTimeMs = args.endTimeMs ?? Date.now();
+  const intervalMs = HYPERLIQUID_INTERVAL_MS[args.interval] ?? HYPERLIQUID_INTERVAL_MS["15m"];
+  let startTimeMs;
+  if (args.startTimeMs != null) {
+    startTimeMs = args.startTimeMs;
+  } else if (args.lookbackDays != null) {
+    if (args.lookbackDays <= 0 || args.lookbackDays > HYPERLIQUID_MAX_LOOKBACK_DAYS) {
+      throw new Error(`lookbackDays must be between 1 and ${HYPERLIQUID_MAX_LOOKBACK_DAYS}`);
+    }
+    startTimeMs = endTimeMs - args.lookbackDays * 864e5;
+  } else if (args.lookbackHours != null) {
+    if (args.lookbackHours <= 0 || args.lookbackHours > HYPERLIQUID_MAX_LOOKBACK_DAYS * 24) {
+      throw new Error(`lookbackHours must be between 1 and ${HYPERLIQUID_MAX_LOOKBACK_DAYS * 24}`);
+    }
+    startTimeMs = endTimeMs - args.lookbackHours * 36e5;
+  } else {
+    startTimeMs = endTimeMs - HYPERLIQUID_DEFAULT_LOOKBACK_DAYS * 864e5;
+  }
+  if (!Number.isFinite(startTimeMs) || !Number.isFinite(endTimeMs) || startTimeMs >= endTimeMs) {
+    throw new Error("Invalid OHLCV time range: startTimeMs must be before endTimeMs");
+  }
+  const expectedBars = Math.ceil((endTimeMs - startTimeMs) / intervalMs);
+  if (expectedBars > HYPERLIQUID_MAX_OHLCV_BARS) {
+    throw new Error(
+      `OHLCV range needs ~${expectedBars} bars at ${args.interval} (max ${HYPERLIQUID_MAX_OHLCV_BARS}). Use a coarser interval or shorter lookback.`
+    );
+  }
+  return { startTimeMs, endTimeMs, expectedBars };
+}
+async function hyperliquidFetchCandles(args) {
+  const endTime = args.endTimeMs ?? Date.now();
+  const intervalMs = HYPERLIQUID_INTERVAL_MS[args.interval] ?? HYPERLIQUID_INTERVAL_MS["15m"];
+  const limit = Math.min(Math.max(args.limit ?? HYPERLIQUID_DEFAULT_CANDLE_LIMIT, 1), HYPERLIQUID_MAX_CANDLE_LIMIT);
+  const startTime = args.startTimeMs ?? endTime - intervalMs * (limit + 4);
+  const candles = await hyperliquidFetchCandlesRaw({
+    chainId: args.chainId,
+    coin: args.coin,
+    interval: args.interval,
+    startTimeMs: startTime,
+    endTimeMs: endTime
+  });
+  return { candles: candles.slice(-limit) };
+}
+async function hyperliquidFetchOhlcvRange(args) {
+  const coin = args.coin.trim();
+  const interval = args.interval ?? HYPERLIQUID_DEFAULT_OHLCV_INTERVAL;
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin) || null;
+  const { startTimeMs, endTimeMs, expectedBars } = hyperliquidResolveOhlcvWindow({
+    interval,
+    lookbackDays: args.lookbackDays,
+    lookbackHours: args.lookbackHours,
+    startTimeMs: args.startTimeMs,
+    endTimeMs: args.endTimeMs
+  });
+  const candles = await hyperliquidFetchCandlesRaw({
+    chainId: args.chainId,
+    coin,
+    interval,
+    startTimeMs,
+    endTimeMs
+  });
+  if (candles.length === 0) {
+    throw new Error(
+      `No OHLCV data for ${coin} between ${startTimeMs} and ${endTimeMs} at ${interval}. Check coin/dex.`
+    );
+  }
+  const latestCandle = candles.length > 0 ? candles[candles.length - 1] : null;
+  return {
+    coin,
+    dex,
+    interval,
+    startTimeMs,
+    endTimeMs,
+    expectedBars,
+    candleCount: candles.length,
+    latestCandle,
+    candles,
+    fetchedAtMs: Date.now()
+  };
+}
+async function hyperliquidFetchPerpAssetContext(args) {
+  const coin = args.coin.trim();
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin) || "";
+  const req = { type: "metaAndAssetCtxs" };
+  if (dex) req.dex = dex;
+  const raw = await hyperliquidInfoPost(args.chainId, req);
+  const universe = raw?.[0]?.universe ?? [];
+  const contexts = raw?.[1] ?? [];
+  const idx = universe.findIndex((u) => u.name === coin);
+  if (idx < 0) {
+    throw new Error(`Hyperliquid asset context not found for ${coin}${dex ? ` on dex ${dex}` : ""}`);
+  }
+  const ctx = contexts[idx] ?? {};
+  const str = (v) => {
+    const s = String(v ?? "").trim();
+    return s || null;
+  };
+  return {
+    markPx: str(ctx.markPx),
+    midPx: str(ctx.midPx),
+    oraclePx: str(ctx.oraclePx),
+    prevDayPx: str(ctx.prevDayPx),
+    funding: str(ctx.funding),
+    openInterest: str(ctx.openInterest)
+  };
+}
+function hyperliquidPickLivePrice(args) {
+  const midUsd = args.midPx ?? args.markPx ?? args.midFromAllMids;
+  if (!midUsd) {
+    throw new Error("Could not fetch live Hyperliquid price (mark, mid, and allMids all empty)");
+  }
+  const source = args.midPx ? "midPx" : args.markPx ? "markPx" : "allMids";
+  return {
+    markPx: args.markPx,
+    midPx: args.midPx,
+    oraclePx: null,
+    prevDayPx: null,
+    midUsd,
+    source
+  };
 }
 async function hyperliquidFetchMarketSnapshot(args) {
-  const interval = args.interval ?? "1h";
-  const [{ mids }, { candles }] = await Promise.all([
-    hyperliquidFetchAllMids({ chainId: args.chainId, dex: args.dex }),
-    hyperliquidFetchCandles({ chainId: args.chainId, coin: args.coin, interval })
+  const coin = args.coin.trim();
+  const interval = args.interval ?? HYPERLIQUID_DEFAULT_OHLCV_INTERVAL;
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin) || null;
+  const candleLimit = Math.min(
+    Math.max(args.candleLimit ?? HYPERLIQUID_DEFAULT_CANDLE_LIMIT, 1),
+    HYPERLIQUID_MAX_CANDLE_LIMIT
+  );
+  const [{ mids }, assetCtx, { candles }] = await Promise.all([
+    hyperliquidFetchAllMids({ chainId: args.chainId, dex: dex ?? void 0 }),
+    hyperliquidFetchPerpAssetContext({ chainId: args.chainId, coin, dex: dex ?? void 0 }),
+    hyperliquidFetchCandles({
+      chainId: args.chainId,
+      coin,
+      interval,
+      limit: candleLimit
+    })
   ]);
+  const midFromAllMids = mids[coin] ?? null;
+  const livePrice = {
+    ...hyperliquidPickLivePrice({
+      markPx: assetCtx.markPx,
+      midPx: assetCtx.midPx,
+      midFromAllMids
+    }),
+    oraclePx: assetCtx.oraclePx,
+    prevDayPx: assetCtx.prevDayPx
+  };
+  const latestCandle = candles.length > 0 ? candles[candles.length - 1] : null;
   return {
-    coin: args.coin,
-    midUsd: mids[args.coin] ?? null,
+    coin,
+    dex,
+    livePrice,
+    midUsd: livePrice.midUsd,
     fetchedAtMs: Date.now(),
     interval,
-    candles
+    latestCandle,
+    candles,
+    candleCount: candles.length
   };
 }
 async function hyperliquidFetchClearinghouseState(args) {
@@ -264,6 +441,21 @@ async function hyperliquidFetchDexList(args) {
   }
   return { dexes };
 }
+async function hyperliquidFetchPerpConciseAnnotations(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "perpConciseAnnotations"
+  });
+  const map = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) return map;
+  for (const entry of raw) {
+    if (!Array.isArray(entry) || entry.length < 2) continue;
+    const coin = String(entry[0] ?? "").trim();
+    const meta = entry[1];
+    if (!coin || !meta || typeof meta !== "object") continue;
+    map.set(coin, meta);
+  }
+  return map;
+}
 async function hyperliquidFetchDelegations(args) {
   const raw = await hyperliquidInfoPost(args.chainId, {
     type: "delegations",
@@ -279,13 +471,138 @@ async function hyperliquidFetchStakingSummary(args) {
   return { delegated: raw?.delegated ?? "0", undelegated: raw?.undelegated ?? "0" };
 }
 
+// src/protocols/evm/hyperliquid/marketSearch.ts
+function normalizeQuery(value) {
+  return value.trim().toLowerCase();
+}
+function compactCoin(value) {
+  return normalizeQuery(value).replace(/[^a-z0-9]/g, "");
+}
+function hyperliquidMarketSymbol(coin) {
+  const sep = coin.indexOf(":");
+  return sep >= 0 ? coin.slice(sep + 1) : coin;
+}
+function scoreMarketMatch(query, market, annotation) {
+  const q = normalizeQuery(query);
+  if (!q) return null;
+  const coin = market.name;
+  const symbol = hyperliquidMarketSymbol(coin);
+  const coinLower = normalizeQuery(coin);
+  const symbolLower = normalizeQuery(symbol);
+  if (coinLower === q) return { score: 100, reason: "exact coin name" };
+  if (symbolLower === q) return { score: 95, reason: "exact ticker symbol" };
+  if (compactCoin(coin) === compactCoin(q)) return { score: 92, reason: "coin name without separators" };
+  if (annotation?.displayName) {
+    const display = normalizeQuery(annotation.displayName);
+    if (display === q) return { score: 94, reason: "exact display name" };
+    if (display.includes(q) || q.includes(display)) return { score: 72, reason: "display name partial match" };
+  }
+  for (const keyword of annotation?.keywords ?? []) {
+    const kw = normalizeQuery(keyword);
+    if (!kw) continue;
+    if (kw === q) return { score: 88, reason: `keyword "${keyword}"` };
+    if (kw.includes(q) || q.includes(kw)) return { score: 68, reason: `keyword partial "${keyword}"` };
+  }
+  if (symbolLower.includes(q) || q.includes(symbolLower)) {
+    return { score: 78, reason: "ticker partial match" };
+  }
+  if (!coin.includes(":") && coinLower.includes(q)) {
+    return { score: 65, reason: "native coin partial match" };
+  }
+  if (market.dex && normalizeQuery(market.dex) === q) {
+    return { score: 40, reason: "dex name match" };
+  }
+  return null;
+}
+async function hyperliquidCollectAllPerpMarkets(args) {
+  const dexFilter = args.dex?.trim();
+  const { dexes } = await hyperliquidFetchDexList({ chainId: args.chainId });
+  if (dexFilter) {
+    const { markets: markets2 } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: dexFilter });
+    return { markets: markets2.map((m) => ({ ...m, dex: dexFilter })), dexes };
+  }
+  const { markets: nativeMarkets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId });
+  const markets = [...nativeMarkets];
+  const hip3Batches = await Promise.all(
+    dexes.map(async (d) => {
+      const { markets: dexMarkets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: d.name });
+      return dexMarkets.map((m) => ({ ...m, dex: d.name }));
+    })
+  );
+  for (const batch of hip3Batches) markets.push(...batch);
+  return { markets, dexes };
+}
+async function hyperliquidSearchMarkets(args) {
+  const query = args.query.trim();
+  if (!query) return { matches: [] };
+  const limit = Math.max(1, Math.min(args.limit ?? 20, 50));
+  const [{ markets }, annotationMap] = await Promise.all([
+    hyperliquidCollectAllPerpMarkets({ chainId: args.chainId, dex: args.dex?.trim() }),
+    hyperliquidFetchPerpConciseAnnotations({ chainId: args.chainId })
+  ]);
+  const hits = [];
+  for (const market of markets) {
+    const annotation = annotationMap.get(market.name);
+    const scored = scoreMarketMatch(query, market, annotation);
+    if (!scored || scored.score < 40) continue;
+    hits.push({
+      coin: market.name,
+      symbol: hyperliquidMarketSymbol(market.name),
+      dex: market.dex,
+      asset: market.asset,
+      szDecimals: market.szDecimals,
+      maxLeverage: market.maxLeverage,
+      onlyIsolated: market.onlyIsolated,
+      displayName: annotation?.displayName,
+      category: annotation?.category,
+      keywords: annotation?.keywords,
+      matchScore: scored.score,
+      matchReason: scored.reason
+    });
+  }
+  hits.sort((a, b) => b.matchScore - a.matchScore || a.coin.localeCompare(b.coin));
+  return { matches: hits.slice(0, limit) };
+}
+async function hyperliquidResolvePerpMarket(args) {
+  const coin = args.coin.trim();
+  if (!coin) throw new Error("coin is required");
+  const dex = args.dex?.trim() || hyperliquidInferDexFromCoin(coin);
+  if (dex || !coin.includes(":")) {
+    const { markets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex });
+    const direct = markets.find((m) => m.name.toLowerCase() === coin.toLowerCase());
+    if (direct) {
+      return {
+        ...direct,
+        dex: dex || direct.dex,
+        symbol: hyperliquidMarketSymbol(direct.name)
+      };
+    }
+  }
+  const { matches } = await hyperliquidSearchMarkets({ chainId: args.chainId, query: coin, dex: args.dex, limit: 10 });
+  const bestScore = matches[0]?.matchScore ?? 0;
+  if (bestScore < 60) throw new Error(`Unknown Hyperliquid perp market: ${coin}`);
+  const top = matches.filter((m) => m.matchScore === bestScore);
+  if (top.length === 1) {
+    const m = top[0];
+    return {
+      name: m.coin,
+      asset: m.asset,
+      szDecimals: m.szDecimals,
+      maxLeverage: m.maxLeverage,
+      onlyIsolated: m.onlyIsolated,
+      dex: m.dex,
+      symbol: m.symbol
+    };
+  }
+  throw new Error(
+    `Ambiguous Hyperliquid market for "${coin}": ${top.map((m) => m.coin).join(", ")}. Pass dex or full coin name (e.g. xyz:AAPL).`
+  );
+}
+
 // src/protocols/evm/hyperliquid/assets.ts
 async function hyperliquidResolvePerpAsset(args) {
-  const coin = args.coin.trim();
-  const { markets } = await hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: args.dex });
-  const hit = markets.find((m) => m.name.toLowerCase() === coin.toLowerCase());
-  if (!hit) throw new Error(`Unknown Hyperliquid perp market: ${coin}`);
-  return { asset: hit.asset, szDecimals: hit.szDecimals, maxLeverage: hit.maxLeverage };
+  const resolved = await hyperliquidResolvePerpMarket(args);
+  return { asset: resolved.asset, szDecimals: resolved.szDecimals, maxLeverage: resolved.maxLeverage };
 }
 async function hyperliquidResolveSpotAsset(args) {
   const coin = args.coin.trim();
@@ -359,10 +676,16 @@ function mapPositionRow(p) {
 }
 async function hyperliquidFetchOpenMarketContext(args) {
   const user = args.executorAddress.trim().toLowerCase();
-  const coin = args.coin.trim();
+  const resolved = await hyperliquidResolvePerpMarket({
+    chainId: args.chainId,
+    coin: args.coin,
+    dex: args.dex
+  });
+  const coin = resolved.name;
+  const dex = args.dex?.trim() || resolved.dex;
   const [{ activeAsset }, { state }] = await Promise.all([
     hyperliquidFetchActiveAssetData({ chainId: args.chainId, user, coin }),
-    hyperliquidFetchClearinghouseState({ chainId: args.chainId, user, dex: args.dex })
+    hyperliquidFetchClearinghouseState({ chainId: args.chainId, user, dex })
   ]);
   return {
     context: {
@@ -397,12 +720,15 @@ async function hyperliquidFetchOrdersForExecutor(args) {
   });
 }
 async function hyperliquidFetchMarketsSummary(args) {
-  const [{ markets }, { dexes }] = await Promise.all([
-    hyperliquidFetchPerpMeta({ chainId: args.chainId, dex: args.dex }),
-    hyperliquidFetchDexList({ chainId: args.chainId })
-  ]);
+  const { markets, dexes } = await hyperliquidCollectAllPerpMarkets({
+    chainId: args.chainId,
+    dex: args.dex?.trim()
+  });
   return { markets, dexes };
 }
+async function hyperliquidSearchMarketsSummary(args) {
+  return hyperliquidSearchMarkets(args);
+}
 async function hyperliquidFetchPositionsForExecutor(args) {
   const { rows } = await hyperliquidFetchPositionDisplayRows(args);
   return { positions: rows };
@@ -448,8 +774,37 @@ async function hyperliquidFetchDelegationsForExecutor(args) {
   return { delegations };
 }
 async function hyperliquidFetchMarketSnapshotSummary(args) {
-  const snapshot = await hyperliquidFetchMarketSnapshot(args);
-  return { snapshot };
+  const resolved = await hyperliquidResolvePerpMarket({
+    chainId: args.chainId,
+    coin: args.coin,
+    dex: args.dex
+  });
+  const snapshot = await hyperliquidFetchMarketSnapshot({
+    chainId: args.chainId,
+    coin: resolved.name,
+    interval: args.interval,
+    dex: args.dex?.trim() || resolved.dex,
+    candleLimit: args.candleLimit
+  });
+  return { snapshot, resolvedCoin: resolved.name, dex: resolved.dex ?? null };
+}
+async function hyperliquidFetchOhlcvSummary(args) {
+  const resolved = await hyperliquidResolvePerpMarket({
+    chainId: args.chainId,
+    coin: args.coin,
+    dex: args.dex
+  });
+  const ohlcv = await hyperliquidFetchOhlcvRange({
+    chainId: args.chainId,
+    coin: resolved.name,
+    interval: args.interval,
+    dex: args.dex?.trim() || resolved.dex,
+    lookbackDays: args.lookbackDays,
+    lookbackHours: args.lookbackHours,
+    startTimeMs: args.startTimeMs,
+    endTimeMs: args.endTimeMs
+  });
+  return { ohlcv, resolvedCoin: resolved.name, dex: resolved.dex ?? null };
 }
 var coreWriterAbi = viem.parseAbi(["function sendRawAction(bytes data) external"]);
 var ACTION_LIMIT_ORDER = 1;
@@ -1108,7 +1463,14 @@ registerProtocolModule(hyperliquidProtocolModule);
 
 exports.HYPERLIQUID_CORE_WRITER_ADDRESS = HYPERLIQUID_CORE_WRITER_ADDRESS;
 exports.HYPERLIQUID_CORE_WRITER_GAS_FALLBACK = HYPERLIQUID_CORE_WRITER_GAS_FALLBACK;
+exports.HYPERLIQUID_DEFAULT_CANDLE_LIMIT = HYPERLIQUID_DEFAULT_CANDLE_LIMIT;
+exports.HYPERLIQUID_DEFAULT_LOOKBACK_DAYS = HYPERLIQUID_DEFAULT_LOOKBACK_DAYS;
+exports.HYPERLIQUID_DEFAULT_OHLCV_INTERVAL = HYPERLIQUID_DEFAULT_OHLCV_INTERVAL;
 exports.HYPERLIQUID_HLP_VAULT_ADDRESS = HYPERLIQUID_HLP_VAULT_ADDRESS;
+exports.HYPERLIQUID_INTERVAL_MS = HYPERLIQUID_INTERVAL_MS;
+exports.HYPERLIQUID_MAX_CANDLE_LIMIT = HYPERLIQUID_MAX_CANDLE_LIMIT;
+exports.HYPERLIQUID_MAX_LOOKBACK_DAYS = HYPERLIQUID_MAX_LOOKBACK_DAYS;
+exports.HYPERLIQUID_MAX_OHLCV_BARS = HYPERLIQUID_MAX_OHLCV_BARS;
 exports.HYPERLIQUID_PROTOCOL_ID = HYPERLIQUID_PROTOCOL_ID;
 exports.HYPERLIQUID_SPOT_ASSET_OFFSET = HYPERLIQUID_SPOT_ASSET_OFFSET;
 exports.HYPERLIQUID_SUPPORTED_CHAIN_IDS = HYPERLIQUID_SUPPORTED_CHAIN_IDS;
@@ -1134,6 +1496,7 @@ exports.buildEvmMultisignBodyHyperliquidVaultDepositBatch = buildEvmMultisignBod
 exports.buildEvmMultisignBodyHyperliquidVaultWithdrawBatch = buildEvmMultisignBodyHyperliquidVaultWithdrawBatch;
 exports.coreWriterStep = coreWriterStep;
 exports.hyperliquidApiBaseUrl = hyperliquidApiBaseUrl;
+exports.hyperliquidCollectAllPerpMarkets = hyperliquidCollectAllPerpMarkets;
 exports.hyperliquidEncodePx8 = hyperliquidEncodePx8;
 exports.hyperliquidEncodeUsd6 = hyperliquidEncodeUsd6;
 exports.hyperliquidEncodeWei8 = hyperliquidEncodeWei8;
@@ -1147,11 +1510,15 @@ exports.hyperliquidFetchDexList = hyperliquidFetchDexList;
 exports.hyperliquidFetchMarketSnapshot = hyperliquidFetchMarketSnapshot;
 exports.hyperliquidFetchMarketSnapshotSummary = hyperliquidFetchMarketSnapshotSummary;
 exports.hyperliquidFetchMarketsSummary = hyperliquidFetchMarketsSummary;
+exports.hyperliquidFetchOhlcvRange = hyperliquidFetchOhlcvRange;
+exports.hyperliquidFetchOhlcvSummary = hyperliquidFetchOhlcvSummary;
 exports.hyperliquidFetchOpenContextSummary = hyperliquidFetchOpenContextSummary;
 exports.hyperliquidFetchOpenMarketContext = hyperliquidFetchOpenMarketContext;
 exports.hyperliquidFetchOpenOrders = hyperliquidFetchOpenOrders;
 exports.hyperliquidFetchOpenOrdersSummary = hyperliquidFetchOpenOrdersSummary;
 exports.hyperliquidFetchOrdersForExecutor = hyperliquidFetchOrdersForExecutor;
+exports.hyperliquidFetchPerpAssetContext = hyperliquidFetchPerpAssetContext;
+exports.hyperliquidFetchPerpConciseAnnotations = hyperliquidFetchPerpConciseAnnotations;
 exports.hyperliquidFetchPerpMeta = hyperliquidFetchPerpMeta;
 exports.hyperliquidFetchPositionDisplayRows = hyperliquidFetchPositionDisplayRows;
 exports.hyperliquidFetchPositionsForExecutor = hyperliquidFetchPositionsForExecutor;
@@ -1165,12 +1532,18 @@ exports.hyperliquidFetchUserVaultEquities = hyperliquidFetchUserVaultEquities;
 exports.hyperliquidFetchUserVaultEquitiesSummary = hyperliquidFetchUserVaultEquitiesSummary;
 exports.hyperliquidFetchVaultCatalogSummary = hyperliquidFetchVaultCatalogSummary;
 exports.hyperliquidFetchVaultSummaries = hyperliquidFetchVaultSummaries;
+exports.hyperliquidInferDexFromCoin = hyperliquidInferDexFromCoin;
 exports.hyperliquidIsSpotAssetId = hyperliquidIsSpotAssetId;
+exports.hyperliquidMarketSymbol = hyperliquidMarketSymbol;
 exports.hyperliquidProtocolModule = hyperliquidProtocolModule;
 exports.hyperliquidResolveAsset = hyperliquidResolveAsset;
+exports.hyperliquidResolveOhlcvWindow = hyperliquidResolveOhlcvWindow;
 exports.hyperliquidResolvePerpAsset = hyperliquidResolvePerpAsset;
+exports.hyperliquidResolvePerpMarket = hyperliquidResolvePerpMarket;
 exports.hyperliquidResolveSpotAsset = hyperliquidResolveSpotAsset;
 exports.hyperliquidResolveTif = hyperliquidResolveTif;
+exports.hyperliquidSearchMarkets = hyperliquidSearchMarkets;
+exports.hyperliquidSearchMarketsSummary = hyperliquidSearchMarketsSummary;
 exports.hyperliquidVaultStatsUrl = hyperliquidVaultStatsUrl;
 exports.isHyperliquidChainSupported = isHyperliquidChainSupported;
 //# sourceMappingURL=index.cjs.map