@sherwoodagent/cli 0.42.0 → 0.51.0

package/dist/chunk-OMW47WOO.js

@@ -0,0 +1,700 @@
+// src/agent/technical.ts
+function calculateSMA(values, period) {
+  if (values.length === 0) return [];
+  const result = [];
+  for (let i = 0; i < values.length; i++) {
+    if (i < period - 1) {
+      result.push(NaN);
+    } else {
+      let sum = 0;
+      for (let j = i - period + 1; j <= i; j++) {
+        sum += values[j];
+      }
+      result.push(sum / period);
+    }
+  }
+  return result;
+}
+function calculateEMA(values, period) {
+  if (values.length === 0) return [];
+  const result = [];
+  const k = 2 / (period + 1);
+  for (let i = 0; i < values.length; i++) {
+    if (i < period - 1) {
+      result.push(NaN);
+    } else if (i === period - 1) {
+      let sum = 0;
+      let count = 0;
+      for (let j = 0; j < period; j++) {
+        if (!isNaN(values[j])) {
+          sum += values[j];
+          count++;
+        }
+      }
+      if (count > 0) {
+        result.push(sum / count);
+      } else {
+        result.push(NaN);
+      }
+    } else {
+      const prev = result[i - 1];
+      const current = values[i];
+      if (!isNaN(current) && !isNaN(prev)) {
+        result.push(current * k + prev * (1 - k));
+      } else {
+        result.push(NaN);
+      }
+    }
+  }
+  return result;
+}
+function calculateRSI(candles, period = 14) {
+  if (candles.length < 2) return [];
+  const closes = candles.map((c) => c.close);
+  const result = [];
+  const changes = [];
+  for (let i = 0; i < closes.length; i++) {
+    if (i === 0) {
+      changes.push(0);
+    } else {
+      changes.push(closes[i] - closes[i - 1]);
+    }
+  }
+  let avgGain = 0;
+  let avgLoss = 0;
+  for (let i = 0; i < closes.length; i++) {
+    if (i < period) {
+      result.push(NaN);
+      continue;
+    }
+    if (i === period) {
+      let sumGain = 0;
+      let sumLoss = 0;
+      for (let j = 1; j <= period; j++) {
+        const change = changes[j];
+        sumGain += Math.max(change, 0);
+        sumLoss += Math.max(-change, 0);
+      }
+      avgGain = sumGain / period;
+      avgLoss = sumLoss / period;
+    } else {
+      const change = changes[i];
+      const alpha = 1 / period;
+      avgGain = (1 - alpha) * avgGain + alpha * Math.max(change, 0);
+      avgLoss = (1 - alpha) * avgLoss + alpha * Math.max(-change, 0);
+    }
+    if (avgLoss === 0) {
+      result.push(100);
+    } else {
+      const rs = avgGain / avgLoss;
+      result.push(100 - 100 / (1 + rs));
+    }
+  }
+  return result;
+}
+function calculateMACD(candles, fast = 12, slow = 26, signalPeriod = 9) {
+  const closes = candles.map((c) => c.close);
+  const emaFast = calculateEMA(closes, fast);
+  const emaSlow = calculateEMA(closes, slow);
+  const macdLine = [];
+  for (let i = 0; i < closes.length; i++) {
+    if (isNaN(emaFast[i]) || isNaN(emaSlow[i])) {
+      macdLine.push(NaN);
+    } else {
+      macdLine.push(emaFast[i] - emaSlow[i]);
+    }
+  }
+  const signalLine = calculateEMA(macdLine, signalPeriod);
+  const histogram = [];
+  for (let i = 0; i < macdLine.length; i++) {
+    if (isNaN(macdLine[i]) || isNaN(signalLine[i])) {
+      histogram.push(NaN);
+    } else {
+      histogram.push(macdLine[i] - signalLine[i]);
+    }
+  }
+  return { macd: macdLine, signal: signalLine, histogram };
+}
+function calculateBollingerBands(candles, period = 20, stdDevMult = 2) {
+  if (candles.length === 0) {
+    return { upper: [], middle: [], lower: [], width: [] };
+  }
+  const closes = candles.map((c) => c.close);
+  const middle = calculateSMA(closes, period);
+  const upper = [];
+  const lower = [];
+  const width = [];
+  for (let i = 0; i < closes.length; i++) {
+    if (isNaN(middle[i])) {
+      upper.push(NaN);
+      lower.push(NaN);
+      width.push(NaN);
+    } else {
+      let sumSq = 0;
+      for (let j = i - period + 1; j <= i; j++) {
+        sumSq += (closes[j] - middle[i]) ** 2;
+      }
+      const sd = Math.sqrt(sumSq / period);
+      upper.push(middle[i] + stdDevMult * sd);
+      lower.push(middle[i] - stdDevMult * sd);
+      width.push(middle[i] !== 0 ? stdDevMult * 2 * sd / middle[i] : 0);
+    }
+  }
+  return { upper, middle, lower, width };
+}
+function calculateATR(candles, period = 14) {
+  if (candles.length === 0) return [];
+  const trueRanges = [];
+  for (let i = 0; i < candles.length; i++) {
+    const c = candles[i];
+    if (i === 0) {
+      trueRanges.push(c.high - c.low);
+    } else {
+      const prev = candles[i - 1];
+      const tr = Math.max(c.high - c.low, Math.abs(c.high - prev.close), Math.abs(c.low - prev.close));
+      trueRanges.push(tr);
+    }
+  }
+  const result = [];
+  for (let i = 0; i < trueRanges.length; i++) {
+    if (i < period - 1) {
+      result.push(NaN);
+    } else if (i === period - 1) {
+      let sum = 0;
+      for (let j = 0; j < period; j++) sum += trueRanges[j];
+      result.push(sum / period);
+    } else {
+      result.push((result[i - 1] * (period - 1) + trueRanges[i]) / period);
+    }
+  }
+  return result;
+}
+function calculateVWAP(candles) {
+  const result = [];
+  let cumulativeTPV = 0;
+  let cumulativeVolume = 0;
+  for (const c of candles) {
+    const typicalPrice = (c.high + c.low + c.close) / 3;
+    cumulativeTPV += typicalPrice * c.volume;
+    cumulativeVolume += c.volume;
+    result.push(cumulativeVolume > 0 ? cumulativeTPV / cumulativeVolume : typicalPrice);
+  }
+  return result;
+}
+function detectBBSqueeze(candles) {
+  const bb = calculateBollingerBands(candles, 20, 2);
+  const validWidths = bb.width.filter((w) => !isNaN(w));
+  if (validWidths.length < 20) return false;
+  const current = validWidths[validWidths.length - 1];
+  const recent20 = validWidths.slice(-20);
+  const minWidth = Math.min(...recent20);
+  return current <= minWidth * 1.01;
+}
+function getLatestSignals(candles) {
+  if (candles.length < 2) {
+    throw new Error("Need at least 2 candles for technical analysis");
+  }
+  const last = (arr) => {
+    for (let i = arr.length - 1; i >= 0; i--) {
+      if (!isNaN(arr[i])) return arr[i];
+    }
+    return NaN;
+  };
+  const rsiArr = calculateRSI(candles, 8);
+  const macdResult = calculateMACD(candles, 12, 26, 9);
+  const bbResult = calculateBollingerBands(candles, 20, 2);
+  const closes = candles.map((c) => c.close);
+  const ema8 = calculateEMA(closes, 8);
+  const ema21 = calculateEMA(closes, 21);
+  const ema50 = calculateEMA(closes, 50);
+  const ema200 = calculateEMA(closes, 200);
+  const atrArr = calculateATR(candles, 14);
+  const vwapArr = calculateVWAP(candles);
+  const volumes = candles.map((c) => c.volume);
+  const currentVol = volumes[volumes.length - 1] ?? 0;
+  const recent20Vol = volumes.slice(-20);
+  const avg20Vol = recent20Vol.length > 0 ? recent20Vol.reduce((a, b) => a + b, 0) / recent20Vol.length : 0;
+  return {
+    rsi: last(rsiArr),
+    macd: {
+      value: last(macdResult.macd),
+      signal: last(macdResult.signal),
+      histogram: last(macdResult.histogram)
+    },
+    bb: {
+      upper: last(bbResult.upper),
+      middle: last(bbResult.middle),
+      lower: last(bbResult.lower),
+      width: last(bbResult.width),
+      squeeze: detectBBSqueeze(candles)
+    },
+    ema: {
+      ema8: last(ema8),
+      ema21: last(ema21),
+      ema50: last(ema50),
+      ema200: last(ema200)
+    },
+    atr: last(atrArr),
+    vwap: last(vwapArr),
+    volume: {
+      current: currentVol,
+      avg20: avg20Vol,
+      ratio: avg20Vol > 0 ? currentVol / avg20Vol : 0
+    }
+  };
+}
+
+// src/providers/data/hyperliquid.ts
+import { mkdir, readFile, writeFile, rename } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var HYPERLIQUID_BASE = "https://api.hyperliquid.xyz/info";
+function safeNumber(x) {
+  if (x === void 0 || x === null) return null;
+  const n = typeof x === "number" ? x : parseFloat(x);
+  return Number.isFinite(n) ? n : null;
+}
+var OI_STALE_MS = 30 * 60 * 1e3;
+var TOKEN_TO_COIN = {
+  bitcoin: "BTC",
+  ethereum: "ETH",
+  solana: "SOL",
+  arbitrum: "ARB",
+  chainlink: "LINK",
+  aave: "AAVE",
+  uniswap: "UNI",
+  dogecoin: "DOGE",
+  avalanche: "AVAX",
+  "avalanche-2": "AVAX",
+  near: "NEAR",
+  sui: "SUI",
+  aptos: "APT",
+  injective: "INJ",
+  pendle: "PENDLE",
+  pepe: "PEPE",
+  polygon: "MATIC",
+  optimism: "OP",
+  litecoin: "LTC",
+  cosmos: "ATOM",
+  filecoin: "FIL",
+  maker: "MKR",
+  cardano: "ADA",
+  polkadot: "DOT",
+  render: "RENDER",
+  jupiter: "JUP",
+  // Extended for full agent watchlist — all HL perps
+  hyperliquid: "HYPE",
+  ethena: "ENA",
+  zcash: "ZEC",
+  ripple: "XRP",
+  bittensor: "TAO",
+  fartcoin: "FARTCOIN",
+  binancecoin: "BNB",
+  blur: "BLUR",
+  "worldcoin-wld": "WLD",
+  "pudgy-penguins": "PENGU",
+  "fetch-ai": "FET"
+};
+var HyperliquidProvider = class {
+  cacheDir;
+  cacheTTL = 2 * 60 * 1e3;
+  // 2 minutes
+  oiCache = /* @__PURE__ */ new Map();
+  // persisted; see loadOiCache
+  oiCacheFile;
+  oiCacheLoaded = false;
+  oiCacheLoadPromise = null;
+  oiCacheSeq = 0;
+  // per-process monotonically-increasing tmp suffix
+  constructor() {
+    this.cacheDir = join(homedir(), ".sherwood", "agent", "cache");
+    this.oiCacheFile = join(this.cacheDir, "hl-oi.json");
+    this.oiCacheLoadPromise = this.loadOiCache();
+  }
+  /** Load the OI cache from disk. Called once at construction. Never throws. */
+  async loadOiCache() {
+    try {
+      const raw = await readFile(this.oiCacheFile, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") {
+        for (const [coin, entry] of Object.entries(parsed)) {
+          if (entry && Number.isFinite(entry.openInterest) && Number.isFinite(entry.timestamp)) {
+            this.oiCache.set(coin, entry);
+          }
+        }
+      }
+    } catch {
+    } finally {
+      this.oiCacheLoaded = true;
+    }
+  }
+  async ensureOiCacheLoaded() {
+    if (this.oiCacheLoaded) return;
+    if (this.oiCacheLoadPromise) await this.oiCacheLoadPromise;
+  }
+  /**
+   * Persist the OI cache to disk using an atomic tmp-rename write.
+   * Fire-and-forget: callers do NOT await this. Errors are logged as warnings
+   * so a slow or full disk never blocks the signal hot path.
+   */
+  persistOiCache() {
+    const snapshot = {};
+    for (const [coin, entry] of this.oiCache.entries()) {
+      snapshot[coin] = entry;
+    }
+    const tmp = `${this.oiCacheFile}.tmp.${process.pid}.${++this.oiCacheSeq}`;
+    void (async () => {
+      try {
+        await mkdir(this.cacheDir, { recursive: true });
+        await writeFile(tmp, JSON.stringify(snapshot), "utf-8");
+        await rename(tmp, this.oiCacheFile);
+      } catch (err) {
+        console.warn(`[hyperliquid] oi-cache persist failed: ${err.message}`);
+      }
+    })();
+  }
+  /** Get comprehensive Hyperliquid data for a token. Returns null if token not supported or API failure. */
+  async getHyperliquidData(tokenId) {
+    const coin = TOKEN_TO_COIN[tokenId];
+    if (!coin) return null;
+    const cached = await this.readCache(tokenId);
+    if (cached) return cached;
+    await this.ensureOiCacheLoaded();
+    try {
+      const [metaResult, bookResult, tradesResult] = await Promise.allSettled([
+        this.fetchMetaAndAssetCtxs(),
+        this.fetchL2Book(coin),
+        this.fetchRecentTrades(coin)
+      ]);
+      if (metaResult.status !== "fulfilled" || !metaResult.value) {
+        return null;
+      }
+      const [meta, assetCtxs] = metaResult.value;
+      const assetIdx = meta.universe.findIndex((asset) => asset.name === coin);
+      if (assetIdx === -1 || !assetCtxs[assetIdx]) {
+        return null;
+      }
+      const assetData = assetCtxs[assetIdx];
+      const fundingRate = safeNumber(assetData.funding);
+      const openInterest = safeNumber(assetData.openInterest);
+      const volume24h = safeNumber(assetData.dayNtlVlm);
+      const markPrice = safeNumber(assetData.markPx);
+      const oraclePrice = safeNumber(assetData.oraclePx);
+      const prevDayPrice = safeNumber(assetData.prevDayPx);
+      if (fundingRate === null || openInterest === null || volume24h === null || markPrice === null || oraclePrice === null || prevDayPrice === null) {
+        return null;
+      }
+      const prior = this.oiCache.get(coin);
+      const now = Date.now();
+      const priorIsFresh = prior !== void 0 && now - prior.timestamp < OI_STALE_MS;
+      const prevOI = priorIsFresh ? prior.openInterest : openInterest;
+      const oiChangePct = prevOI > 0 ? (openInterest - prevOI) / prevOI * 100 : 0;
+      this.oiCache.set(coin, { openInterest, timestamp: now });
+      this.persistOiCache();
+      let orderBookImbalance = 0;
+      if (bookResult.status === "fulfilled" && bookResult.value) {
+        orderBookImbalance = this.calculateOrderBookImbalance(bookResult.value);
+      }
+      let largeTradesBias = 0;
+      if (tradesResult.status === "fulfilled" && tradesResult.value) {
+        largeTradesBias = this.calculateLargeTradesBias(tradesResult.value);
+      }
+      const data = {
+        fundingRate,
+        openInterest,
+        oiChangePct,
+        volume24h,
+        markPrice,
+        oraclePrice,
+        prevDayPrice,
+        orderBookImbalance,
+        largeTradesBias
+      };
+      await this.writeCache(tokenId, data);
+      return data;
+    } catch (err) {
+      console.error(`Hyperliquid API error for ${tokenId}: ${err.message}`);
+      return null;
+    }
+  }
+  /** Fetch metadata and asset contexts (funding, OI, volume, prices). */
+  async fetchMetaAndAssetCtxs() {
+    const response = await fetch(HYPERLIQUID_BASE, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "metaAndAssetCtxs" })
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data;
+  }
+  /** Fetch L2 order book for a coin. */
+  async fetchL2Book(coin) {
+    const response = await fetch(HYPERLIQUID_BASE, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "l2Book", coin })
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  }
+  /**
+   * Fetch OHLCV candles from Hyperliquid. Free, no rate limit, real-time.
+   * Replaces CoinGecko OHLC as the primary candle source so the technical
+   * signal stack doesn't go blind when CG's free tier 429s.
+   *
+   * @param tokenId CoinGecko token ID (resolved via TOKEN_TO_COIN)
+   * @param interval  HL interval string: '1h', '4h', '1d'
+   * @param lookbackMs  How far back to fetch (default 30 days)
+   * @returns Array of Candle objects, or null if the token isn't mapped
+   */
+  async getCandles(tokenId, interval = "4h", lookbackMs = 30 * 24 * 60 * 60 * 1e3) {
+    const coin = TOKEN_TO_COIN[tokenId];
+    if (!coin) return null;
+    try {
+      const now = Date.now();
+      const response = await fetch(HYPERLIQUID_BASE, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          type: "candleSnapshot",
+          req: { coin, interval, startTime: now - lookbackMs, endTime: now }
+        })
+      });
+      if (!response.ok) return null;
+      const raw = await response.json();
+      if (!Array.isArray(raw) || raw.length === 0) return null;
+      return raw.map((c) => {
+        const o = safeNumber(c.o);
+        const h = safeNumber(c.h);
+        const l = safeNumber(c.l);
+        const close = safeNumber(c.c);
+        const v = safeNumber(c.v);
+        if (o === null || h === null || l === null || close === null) return null;
+        return { timestamp: c.t, open: o, high: h, low: l, close, volume: v ?? 0 };
+      }).filter((c) => c !== null);
+    } catch {
+      return null;
+    }
+  }
+  /** Fetch recent trades for a coin. */
+  async fetchRecentTrades(coin) {
+    const response = await fetch(HYPERLIQUID_BASE, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ type: "recentTrades", coin })
+    });
+    if (!response.ok) return null;
+    return await response.json();
+  }
+  /** Calculate order book imbalance from L2 book. */
+  calculateOrderBookImbalance(book) {
+    const [bids, asks] = book.levels;
+    const sumDepth = (levels) => levels.slice(0, 10).reduce((sum, level) => {
+      const sz = safeNumber(level.sz);
+      return sz === null ? sum : sum + sz;
+    }, 0);
+    const bidDepth = sumDepth(bids);
+    const askDepth = sumDepth(asks);
+    const totalDepth = bidDepth + askDepth;
+    if (totalDepth === 0) return 0;
+    return (bidDepth - askDepth) / totalDepth;
+  }
+  /** Calculate large trades bias from recent trades (>$50K in last hour). */
+  calculateLargeTradesBias(trades) {
+    const oneHourAgo = Date.now() - 60 * 60 * 1e3;
+    const recentTrades = trades.filter((t) => t.time > oneHourAgo);
+    let buyVolume = 0;
+    let sellVolume = 0;
+    for (const trade of recentTrades) {
+      const size = safeNumber(trade.sz);
+      const price = safeNumber(trade.px);
+      if (size === null || price === null) continue;
+      const notional = size * price;
+      if (notional > 5e4) {
+        if (trade.side === "B") {
+          buyVolume += notional;
+        } else if (trade.side === "A") {
+          sellVolume += notional;
+        }
+      }
+    }
+    const totalVolume = buyVolume + sellVolume;
+    if (totalVolume === 0) return 0;
+    return (buyVolume - sellVolume) / totalVolume;
+  }
+  /** Read cached Hyperliquid data. */
+  async readCache(tokenId) {
+    try {
+      const cacheFile = join(this.cacheDir, `hl-${tokenId}.json`);
+      const raw = await readFile(cacheFile, "utf-8");
+      const cached = JSON.parse(raw);
+      if (Date.now() - cached.ts < this.cacheTTL) {
+        return cached.data;
+      }
+    } catch {
+    }
+    return null;
+  }
+  /** Write Hyperliquid data to cache. */
+  async writeCache(tokenId, data) {
+    try {
+      await mkdir(this.cacheDir, { recursive: true });
+      const cacheFile = join(this.cacheDir, `hl-${tokenId}.json`);
+      await writeFile(cacheFile, JSON.stringify({ ts: Date.now(), data }), "utf-8");
+    } catch {
+    }
+  }
+};
+
+// src/lib/hyperliquid-executor.ts
+import { execFile } from "child_process";
+import { resolve } from "path";
+import { homedir as homedir2 } from "os";
+var HL_SCRIPT = resolve(
+  homedir2(),
+  ".hermes/skills/openclaw-imports/hyperliquid/scripts/hyperliquid.mjs"
+);
+var TOKEN_TO_HL_COIN = {
+  bitcoin: "BTC",
+  ethereum: "ETH",
+  solana: "SOL",
+  arbitrum: "ARB",
+  dogecoin: "DOGE",
+  chainlink: "LINK",
+  aave: "AAVE",
+  uniswap: "UNI",
+  ripple: "XRP",
+  polkadot: "DOT",
+  avalanche: "AVAX",
+  hyperliquid: "HYPE",
+  zcash: "ZEC",
+  bittensor: "TAO",
+  "worldcoin-wld": "WLD",
+  fartcoin: "FARTCOIN",
+  "fetch-ai": "FET",
+  pepe: "PEPE",
+  pendle: "PENDLE",
+  sui: "SUI",
+  near: "NEAR",
+  aptos: "APT"
+};
+function resolveHLCoin(tokenId) {
+  return TOKEN_TO_HL_COIN[tokenId];
+}
+function runHLScript(command, args = []) {
+  return new Promise((resolve2, reject) => {
+    const env = { ...process.env };
+    if (process.env.HYPERLIQUID_PRIVATE_KEY) {
+      env.HYPERLIQUID_PRIVATE_KEY = process.env.HYPERLIQUID_PRIVATE_KEY;
+    }
+    if (process.env.HYPERLIQUID_ADDRESS) {
+      env.HYPERLIQUID_ADDRESS = process.env.HYPERLIQUID_ADDRESS;
+    }
+    execFile(
+      "node",
+      [HL_SCRIPT, command, ...args],
+      { env, timeout: 3e4 },
+      (error, stdout, stderr) => {
+        if (error) {
+          const msg = stderr?.trim() || error.message;
+          reject(new Error(`HL script failed: ${msg}`));
+          return;
+        }
+        resolve2(stdout.trim());
+      }
+    );
+  });
+}
+function parseOrderResponse(raw) {
+  try {
+    const data = JSON.parse(raw);
+    const statuses = data?.response?.data?.statuses;
+    if (!statuses || statuses.length === 0) {
+      if (data?.response?.type === "error") {
+        return { success: false, error: data.response.data || "Unknown HL error" };
+      }
+      return { success: false, error: `Unexpected response: ${raw.slice(0, 200)}` };
+    }
+    const status = statuses[0];
+    if (status.filled) {
+      return {
+        success: true,
+        orderId: String(status.filled.oid),
+        executedPrice: parseFloat(status.filled.avgPx),
+        executedSize: parseFloat(status.filled.totalSz)
+      };
+    }
+    if (status.resting) {
+      return {
+        success: true,
+        orderId: String(status.resting.oid)
+      };
+    }
+    if (status.error) {
+      return { success: false, error: status.error };
+    }
+    return { success: false, error: `Unrecognized status: ${JSON.stringify(status)}` };
+  } catch {
+    return { success: false, error: `Failed to parse HL response: ${raw.slice(0, 200)}` };
+  }
+}
+async function hlMarketBuy(coin, sizeInToken) {
+  const raw = await runHLScript("market-buy", [coin, String(sizeInToken)]);
+  return parseOrderResponse(raw);
+}
+async function hlMarketSell(coin, sizeInToken) {
+  const raw = await runHLScript("market-sell", [coin, String(sizeInToken)]);
+  return parseOrderResponse(raw);
+}
+async function hlPlaceLimitOrder(coin, isBuy, sizeInToken, limitPrice) {
+  const cmd = isBuy ? "limit-buy" : "limit-sell";
+  const raw = await runHLScript(cmd, [coin, String(sizeInToken), String(limitPrice)]);
+  return parseOrderResponse(raw);
+}
+async function hlCancelAllOrders(coin) {
+  const args = coin ? [coin] : [];
+  return runHLScript("cancel-all", args);
+}
+function validateHLEnv() {
+  if (!process.env.HYPERLIQUID_PRIVATE_KEY) {
+    throw new Error(
+      "HYPERLIQUID_PRIVATE_KEY env var is required for hyperliquid-perp mode. Export it before running with --mode hyperliquid-perp."
+    );
+  }
+}
+var META_TTL_MS = 60 * 60 * 1e3;
+var _metaCache = null;
+var _metaCachedAt = 0;
+async function hlGetMeta() {
+  if (_metaCache && Date.now() - _metaCachedAt < META_TTL_MS) return _metaCache;
+  const raw = await runHLScript("meta");
+  const universe = JSON.parse(raw);
+  const fresh = /* @__PURE__ */ new Map();
+  for (const u of universe) {
+    const pxDecimals = 6 - u.szDecimals;
+    fresh.set(u.name, { name: u.name, szDecimals: u.szDecimals, pxDecimals });
+  }
+  _metaCache = fresh;
+  _metaCachedAt = Date.now();
+  return _metaCache;
+}
+
+export {
+  safeNumber,
+  HyperliquidProvider,
+  calculateEMA,
+  calculateRSI,
+  calculateMACD,
+  calculateBollingerBands,
+  calculateATR,
+  getLatestSignals,
+  resolveHLCoin,
+  hlMarketBuy,
+  hlMarketSell,
+  hlPlaceLimitOrder,
+  hlCancelAllOrders,
+  validateHLEnv,
+  hlGetMeta
+};
+//# sourceMappingURL=chunk-OMW47WOO.js.map