@tradejs/cli 2.0.12 → 2.0.14

package/dist/lib/hyperliquidWhaleStream.js

@@ -0,0 +1,326 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/hyperliquidWhaleStream.ts
+var hyperliquidWhaleStream_exports = {};
+__export(hyperliquidWhaleStream_exports, {
+  parseHyperliquidTradesMessage: () => parseHyperliquidTradesMessage,
+  parseHyperliquidUserFillsMessage: () => parseHyperliquidUserFillsMessage,
+  runHyperliquidWhaleStream: () => runHyperliquidWhaleStream
+});
+module.exports = __toCommonJS(hyperliquidWhaleStream_exports);
+var import_ws = require("ws");
+var import_timescale = require("@tradejs/infra/timescale");
+var import_strategies = require("@tradejs/node/strategies");
+
+// src/lib/hyperliquidWhaleData.ts
+var HYPERLIQUID_WHALE_BUCKET_MS = 6e4;
+var finiteNumber = (value) => {
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var POSITION_EPSILON = 1e-12;
+var normalizePosition = (value) => Math.abs(value) <= POSITION_EPSILON ? 0 : value;
+var classifyHyperliquidPositionChange = (params) => {
+  const startValue = finiteNumber(params.startPosition);
+  const size = finiteNumber(params.size);
+  const side = String(params.side ?? "").toUpperCase();
+  if (startValue == null || size == null || size <= 0) return null;
+  if (side !== "B" && side !== "A") return null;
+  const startPosition = normalizePosition(startValue);
+  const endPosition = normalizePosition(
+    startPosition + (side === "B" ? size : -size)
+  );
+  const startLong = Math.max(startPosition, 0);
+  const endLong = Math.max(endPosition, 0);
+  const startShort = Math.max(-startPosition, 0);
+  const endShort = Math.max(-endPosition, 0);
+  const longEntrySize = Math.max(0, endLong - startLong);
+  const shortEntrySize = Math.max(0, endShort - startShort);
+  const longExitSize = Math.max(0, startLong - endLong);
+  const shortExitSize = Math.max(0, startShort - endShort);
+  const flipped = startPosition * endPosition < 0;
+  const opened = startPosition === 0;
+  const closed = endPosition === 0;
+  const increased = Math.sign(startPosition) === Math.sign(endPosition) && Math.abs(endPosition) > Math.abs(startPosition);
+  return {
+    startPosition,
+    endPosition,
+    action: flipped ? "flip" : opened ? "open" : closed ? "close" : increased ? "increase" : "reduce",
+    longEntrySize,
+    shortEntrySize,
+    longExitSize,
+    shortExitSize
+  };
+};
+var normalizeAddress = (value) => typeof value === "string" && /^0x[0-9a-fA-F]{40}$/.test(value) ? value.toLowerCase() : null;
+var normalizeTradeFields = (value) => {
+  const symbol = typeof value.coin === "string" ? value.coin.trim() : "";
+  const price = finiteNumber(value.px);
+  const size = finiteNumber(value.sz);
+  const timestamp = finiteNumber(value.time);
+  const tid = typeof value.tid === "string" || typeof value.tid === "number" ? String(value.tid) : "";
+  if (!symbol || price == null || size == null || timestamp == null || !tid || price <= 0 || size <= 0) {
+    return null;
+  }
+  return {
+    symbol,
+    price,
+    size,
+    timestamp,
+    tid,
+    notionalUsd: price * size
+  };
+};
+var normalizeHyperliquidUserFill = (params) => {
+  const normalized = normalizeTradeFields(params.fill);
+  if (!normalized || !params.trackedSymbols.has(normalized.symbol)) return null;
+  const address = normalizeAddress(params.address);
+  if (!address) return null;
+  const side = String(params.fill.side ?? "").toUpperCase();
+  if (side !== "B" && side !== "A") return null;
+  const positionChange = classifyHyperliquidPositionChange({
+    startPosition: params.fill.startPosition,
+    side,
+    size: normalized.size
+  });
+  const closedPnl = finiteNumber(params.fill.closedPnl);
+  const liquidation = params.fill.liquidation != null && typeof params.fill.liquidation === "object";
+  const positionFields = positionChange ? side === "B" ? {
+    buyerStartPosition: positionChange.startPosition,
+    buyerEndPosition: positionChange.endPosition,
+    buyerPositionAction: positionChange.action,
+    buyerClosedPnl: closedPnl,
+    buyerLiquidation: liquidation
+  } : {
+    sellerStartPosition: positionChange.startPosition,
+    sellerEndPosition: positionChange.endPosition,
+    sellerPositionAction: positionChange.action,
+    sellerClosedPnl: closedPnl,
+    sellerLiquidation: liquidation
+  } : {};
+  return {
+    symbol: normalized.symbol,
+    ts: new Date(normalized.timestamp),
+    tid: normalized.tid,
+    price: normalized.price,
+    size: normalized.size,
+    notionalUsd: normalized.notionalUsd,
+    buyerAddress: side === "B" ? address : null,
+    sellerAddress: side === "A" ? address : null,
+    buyerTracked: side === "B",
+    sellerTracked: side === "A",
+    ...positionFields,
+    ...params.identity,
+    source: "hyperliquid_user_fills"
+  };
+};
+
+// src/lib/hyperliquidWhaleStream.ts
+var DEFAULT_WS_URL = "wss://api.hyperliquid.xyz/ws";
+var EVENT_BATCH_SIZE = 500;
+var FLUSH_INTERVAL_MS = 2e3;
+var FINALIZE_INTERVAL_MS = 15e3;
+var FINALIZE_LAG_MS = 5e3;
+var REBUILD_LOOKBACK_MS = 10 * 6e4;
+var RAW_EVENT_RETENTION_MS = 48 * 60 * 6e4;
+var sleep = (ms, signal) => new Promise((resolve) => {
+  if (signal.aborted) return resolve();
+  const timer = setTimeout(resolve, ms);
+  signal.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timer);
+      resolve();
+    },
+    { once: true }
+  );
+});
+var parseHyperliquidTradesMessage = (raw) => {
+  try {
+    const message = JSON.parse(raw);
+    return message.channel === "trades" && Array.isArray(message.data) ? message.data : [];
+  } catch {
+    return [];
+  }
+};
+var parseHyperliquidUserFillsMessage = (raw) => {
+  try {
+    const message = JSON.parse(raw);
+    if (message.channel !== "userFills" || !message.data || typeof message.data !== "object" || Array.isArray(message.data)) {
+      return null;
+    }
+    const data = message.data;
+    if (typeof data.user !== "string" || !Array.isArray(data.fills)) {
+      return null;
+    }
+    return {
+      address: data.user,
+      isSnapshot: data.isSnapshot === true,
+      fills: data.fills
+    };
+  } catch {
+    return null;
+  }
+};
+var runHyperliquidWhaleStream = async (params) => {
+  const universe = (0, import_strategies.getHyperliquidPerpUniverseSnapshot)();
+  const whales = (0, import_strategies.getHyperliquidWhaleRegistrySnapshot)();
+  const trackedSymbols = new Set(universe.symbols);
+  const identity = {
+    universeFingerprint: universe.fingerprint,
+    whaleRegistryFingerprint: whales.fingerprint
+  };
+  const buffer = [];
+  let writes = Promise.resolve();
+  let streamCoverageFromMs = null;
+  let streamCoverageToMs = 0;
+  const flush = () => {
+    if (!buffer.length) return writes;
+    const batch = buffer.splice(0, buffer.length);
+    writes = writes.then(() => (0, import_timescale.upsertHyperliquidWhaleTradeEvents)(batch));
+    return writes;
+  };
+  const recordStreamCoverage = (toMs) => {
+    if (streamCoverageFromMs == null) return writes;
+    const fromMs = Math.max(streamCoverageFromMs, streamCoverageToMs);
+    if (toMs <= fromMs) return writes;
+    const rows = Array.from(
+      { length: Math.floor((toMs - fromMs) / HYPERLIQUID_WHALE_BUCKET_MS) },
+      (_, index) => ({
+        ts: new Date(fromMs + index * HYPERLIQUID_WHALE_BUCKET_MS),
+        coveredWhales: whales.addresses.length,
+        expectedWhales: whales.addresses.length,
+        coveragePct: 1,
+        source: "hyperliquid_user_fills_ws",
+        ...identity
+      })
+    );
+    streamCoverageToMs = toMs;
+    writes = writes.then(() => (0, import_timescale.upsertHyperliquidWhaleCoverageRows)(rows));
+    return writes;
+  };
+  const finalize = () => {
+    const toMs = Math.floor((Date.now() - FINALIZE_LAG_MS) / HYPERLIQUID_WHALE_BUCKET_MS) * HYPERLIQUID_WHALE_BUCKET_MS;
+    const fromMs = Math.max(0, toMs - REBUILD_LOOKBACK_MS);
+    recordStreamCoverage(toMs);
+    writes = writes.then(
+      () => (0, import_timescale.rebuildHyperliquidWhaleFlowRows)({
+        fromMs,
+        toMs,
+        deleteEventsBeforeMs: toMs - RAW_EVENT_RETENTION_MS,
+        ...identity
+      }).then((buckets) => {
+        params.log?.(`Hyperliquid whale-flow finalized buckets=${buckets}`);
+      })
+    );
+    return writes;
+  };
+  const flushTimer = setInterval(() => void flush(), FLUSH_INTERVAL_MS);
+  const finalizeTimer = setInterval(
+    () => void flush().then(finalize),
+    FINALIZE_INTERVAL_MS
+  );
+  let reconnectDelayMs = 1e3;
+  try {
+    while (!params.signal.aborted) {
+      await new Promise((resolve) => {
+        const ws = new import_ws.WebSocket(
+          process.env.HYPERLIQUID_WS_URL?.trim() || DEFAULT_WS_URL
+        );
+        let settled = false;
+        const finish = () => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        };
+        const pingTimer = setInterval(() => {
+          if (ws.readyState === import_ws.WebSocket.OPEN) {
+            ws.send(JSON.stringify({ method: "ping" }));
+          }
+        }, 3e4);
+        const close = () => {
+          clearInterval(pingTimer);
+          if (ws.readyState === import_ws.WebSocket.OPEN) ws.close();
+          else if (ws.readyState === import_ws.WebSocket.CONNECTING) ws.terminate();
+          finish();
+        };
+        params.signal.addEventListener("abort", close, { once: true });
+        ws.on("open", () => {
+          reconnectDelayMs = 1e3;
+          streamCoverageFromMs = Math.ceil(Date.now() / HYPERLIQUID_WHALE_BUCKET_MS) * HYPERLIQUID_WHALE_BUCKET_MS;
+          streamCoverageToMs = streamCoverageFromMs;
+          for (const address of whales.addresses) {
+            ws.send(
+              JSON.stringify({
+                method: "subscribe",
+                subscription: { type: "userFills", user: address }
+              })
+            );
+          }
+          params.log?.(
+            `Hyperliquid whale stream connected userFills subscriptions=${whales.addresses.length}`
+          );
+        });
+        ws.on("message", (data) => {
+          const message = parseHyperliquidUserFillsMessage(data.toString());
+          if (!message) return;
+          for (const fill of message.fills) {
+            const event = normalizeHyperliquidUserFill({
+              fill,
+              address: message.address,
+              trackedSymbols,
+              identity
+            });
+            if (event) buffer.push(event);
+          }
+          if (buffer.length >= EVENT_BATCH_SIZE) void flush();
+        });
+        ws.on("error", (error) => {
+          params.log?.(`Hyperliquid whale stream error: ${String(error)}`);
+          close();
+        });
+        ws.on("close", () => {
+          recordStreamCoverage(
+            Math.floor(Date.now() / HYPERLIQUID_WHALE_BUCKET_MS) * HYPERLIQUID_WHALE_BUCKET_MS
+          );
+          streamCoverageFromMs = null;
+          clearInterval(pingTimer);
+          params.signal.removeEventListener("abort", close);
+          finish();
+        });
+      });
+      if (!params.signal.aborted) {
+        await sleep(reconnectDelayMs, params.signal);
+        reconnectDelayMs = Math.min(3e4, reconnectDelayMs * 2);
+      }
+    }
+  } finally {
+    clearInterval(flushTimer);
+    clearInterval(finalizeTimer);
+    await flush();
+    await finalize();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseHyperliquidTradesMessage,
+  parseHyperliquidUserFillsMessage,
+  runHyperliquidWhaleStream
+});