@tradejs/cli 2.0.13 → 2.0.15

package/dist/lib/hyperliquidWhaleData.js

@@ -0,0 +1,307 @@
+"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/hyperliquidWhaleData.ts
+var hyperliquidWhaleData_exports = {};
+__export(hyperliquidWhaleData_exports, {
+  HYPERLIQUID_WHALE_BUCKET_MS: () => HYPERLIQUID_WHALE_BUCKET_MS,
+  aggregateHyperliquidWhaleEvents: () => aggregateHyperliquidWhaleEvents,
+  classifyHyperliquidPositionChange: () => classifyHyperliquidPositionChange,
+  normalizeHyperliquidUserFill: () => normalizeHyperliquidUserFill,
+  normalizeHyperliquidWsTrade: () => normalizeHyperliquidWsTrade
+});
+module.exports = __toCommonJS(hyperliquidWhaleData_exports);
+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 normalizeHyperliquidWsTrade = (params) => {
+  const normalized = normalizeTradeFields(params.trade);
+  if (!normalized || !params.trackedSymbols.has(normalized.symbol)) return null;
+  const users = Array.isArray(params.trade.users) ? params.trade.users : [];
+  const buyerAddress = normalizeAddress(users[0]);
+  const sellerAddress = normalizeAddress(users[1]);
+  const buyerTracked = buyerAddress != null && params.trackedWhales.has(buyerAddress);
+  const sellerTracked = sellerAddress != null && params.trackedWhales.has(sellerAddress);
+  if (!buyerTracked && !sellerTracked) return null;
+  return {
+    symbol: normalized.symbol,
+    ts: new Date(normalized.timestamp),
+    tid: normalized.tid,
+    price: normalized.price,
+    size: normalized.size,
+    notionalUsd: normalized.notionalUsd,
+    buyerAddress,
+    sellerAddress,
+    buyerTracked,
+    sellerTracked,
+    ...params.identity,
+    source: "hyperliquid_trades"
+  };
+};
+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"
+  };
+};
+var eventKey = (event) => `${event.universeFingerprint}:${event.whaleRegistryFingerprint}:${event.symbol}:${event.ts.getTime()}:${event.tid}`;
+var mergeEvent = (left, right) => ({
+  ...left,
+  buyerAddress: left.buyerAddress ?? right.buyerAddress,
+  sellerAddress: left.sellerAddress ?? right.sellerAddress,
+  buyerTracked: left.buyerTracked || right.buyerTracked,
+  sellerTracked: left.sellerTracked || right.sellerTracked,
+  buyerStartPosition: left.buyerStartPosition ?? right.buyerStartPosition,
+  buyerEndPosition: left.buyerEndPosition ?? right.buyerEndPosition,
+  buyerPositionAction: left.buyerPositionAction ?? right.buyerPositionAction,
+  buyerClosedPnl: left.buyerClosedPnl ?? right.buyerClosedPnl,
+  buyerLiquidation: left.buyerLiquidation ?? right.buyerLiquidation,
+  sellerStartPosition: left.sellerStartPosition ?? right.sellerStartPosition,
+  sellerEndPosition: left.sellerEndPosition ?? right.sellerEndPosition,
+  sellerPositionAction: left.sellerPositionAction ?? right.sellerPositionAction,
+  sellerClosedPnl: left.sellerClosedPnl ?? right.sellerClosedPnl,
+  sellerLiquidation: left.sellerLiquidation ?? right.sellerLiquidation
+});
+var aggregateHyperliquidWhaleEvents = (events) => {
+  const deduplicated = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const key = eventKey(event);
+    const previous = deduplicated.get(key);
+    deduplicated.set(key, previous ? mergeEvent(previous, event) : event);
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  for (const event of deduplicated.values()) {
+    const bucketTs = Math.floor(event.ts.getTime() / HYPERLIQUID_WHALE_BUCKET_MS) * HYPERLIQUID_WHALE_BUCKET_MS;
+    const key = `${event.universeFingerprint}:${event.whaleRegistryFingerprint}:${event.symbol}:${bucketTs}`;
+    const row = buckets.get(key) ?? {
+      symbol: event.symbol,
+      interval: "1m",
+      ts: new Date(bucketTs),
+      trades: 0,
+      whaleSides: 0,
+      uniqueWhales: 0,
+      buyNotionalUsd: 0,
+      sellNotionalUsd: 0,
+      netNotionalUsd: 0,
+      buySharePct: null,
+      positionAwareWhaleSides: 0,
+      longEntryWhaleAddresses: /* @__PURE__ */ new Set(),
+      shortEntryWhaleAddresses: /* @__PURE__ */ new Set(),
+      longExitWhaleAddresses: /* @__PURE__ */ new Set(),
+      shortExitWhaleAddresses: /* @__PURE__ */ new Set(),
+      longEntryNotionalUsd: 0,
+      shortEntryNotionalUsd: 0,
+      longExitNotionalUsd: 0,
+      shortExitNotionalUsd: 0,
+      entryNetNotionalUsd: 0,
+      entryLongSharePct: null,
+      universeFingerprint: event.universeFingerprint,
+      whaleRegistryFingerprint: event.whaleRegistryFingerprint,
+      source: "hyperliquid_trades",
+      whaleAddresses: /* @__PURE__ */ new Set()
+    };
+    row.trades += 1;
+    if (event.buyerTracked) {
+      row.whaleSides += 1;
+      row.buyNotionalUsd += event.notionalUsd;
+      if (event.buyerAddress) row.whaleAddresses.add(event.buyerAddress);
+    }
+    if (event.sellerTracked) {
+      row.whaleSides += 1;
+      row.sellNotionalUsd += event.notionalUsd;
+      if (event.sellerAddress) row.whaleAddresses.add(event.sellerAddress);
+    }
+    const applyPositionLeg = (params) => {
+      if (!params.address || !Number.isFinite(params.startPosition) || !Number.isFinite(params.endPosition)) {
+        return;
+      }
+      const startPosition = Number(params.startPosition);
+      const endPosition = Number(params.endPosition);
+      const longEntrySize = Math.max(
+        0,
+        Math.max(endPosition, 0) - Math.max(startPosition, 0)
+      );
+      const shortEntrySize = Math.max(
+        0,
+        Math.max(-endPosition, 0) - Math.max(-startPosition, 0)
+      );
+      const longExitSize = Math.max(
+        0,
+        Math.max(startPosition, 0) - Math.max(endPosition, 0)
+      );
+      const shortExitSize = Math.max(
+        0,
+        Math.max(-startPosition, 0) - Math.max(-endPosition, 0)
+      );
+      row.positionAwareWhaleSides += 1;
+      row.longEntryNotionalUsd += longEntrySize * event.price;
+      row.shortEntryNotionalUsd += shortEntrySize * event.price;
+      row.longExitNotionalUsd += longExitSize * event.price;
+      row.shortExitNotionalUsd += shortExitSize * event.price;
+      if (longEntrySize > 0) row.longEntryWhaleAddresses.add(params.address);
+      if (shortEntrySize > 0) row.shortEntryWhaleAddresses.add(params.address);
+      if (longExitSize > 0) row.longExitWhaleAddresses.add(params.address);
+      if (shortExitSize > 0) row.shortExitWhaleAddresses.add(params.address);
+    };
+    if (event.buyerTracked) {
+      applyPositionLeg({
+        address: event.buyerAddress,
+        startPosition: event.buyerStartPosition,
+        endPosition: event.buyerEndPosition
+      });
+    }
+    if (event.sellerTracked) {
+      applyPositionLeg({
+        address: event.sellerAddress,
+        startPosition: event.sellerStartPosition,
+        endPosition: event.sellerEndPosition
+      });
+    }
+    row.uniqueWhales = row.whaleAddresses.size;
+    row.netNotionalUsd = row.buyNotionalUsd - row.sellNotionalUsd;
+    const total = row.buyNotionalUsd + row.sellNotionalUsd;
+    row.buySharePct = total > 0 ? row.buyNotionalUsd / total : null;
+    row.entryNetNotionalUsd = row.longEntryNotionalUsd - row.shortEntryNotionalUsd;
+    const entryTotal = row.longEntryNotionalUsd + row.shortEntryNotionalUsd;
+    row.entryLongSharePct = entryTotal > 0 ? row.longEntryNotionalUsd / entryTotal : null;
+    if (row.positionAwareWhaleSides > 0) {
+      row.source = "hyperliquid_user_fills";
+    }
+    buckets.set(key, row);
+  }
+  return [...buckets.values()].map(
+    ({
+      whaleAddresses,
+      longEntryWhaleAddresses,
+      shortEntryWhaleAddresses,
+      longExitWhaleAddresses,
+      shortExitWhaleAddresses,
+      ...row
+    }) => ({
+      ...row,
+      whaleAddresses: [...whaleAddresses].sort(),
+      longEntryWhaleAddresses: [...longEntryWhaleAddresses].sort(),
+      shortEntryWhaleAddresses: [...shortEntryWhaleAddresses].sort(),
+      longExitWhaleAddresses: [...longExitWhaleAddresses].sort(),
+      shortExitWhaleAddresses: [...shortExitWhaleAddresses].sort()
+    })
+  ).sort(
+    (left, right) => left.ts.getTime() - right.ts.getTime() || left.symbol.localeCompare(right.symbol)
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HYPERLIQUID_WHALE_BUCKET_MS,
+  aggregateHyperliquidWhaleEvents,
+  classifyHyperliquidPositionChange,
+  normalizeHyperliquidUserFill,
+  normalizeHyperliquidWsTrade
+});

package/dist/lib/hyperliquidWhaleSelection.js

@@ -0,0 +1,116 @@
+"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/hyperliquidWhaleSelection.ts
+var hyperliquidWhaleSelection_exports = {};
+__export(hyperliquidWhaleSelection_exports, {
+  HYPERLIQUID_WHALE_SELECTION: () => HYPERLIQUID_WHALE_SELECTION,
+  evaluateHyperliquidWhaleStructure: () => evaluateHyperliquidWhaleStructure,
+  rankHyperliquidStructuralWhales: () => rankHyperliquidStructuralWhales
+});
+module.exports = __toCommonJS(hyperliquidWhaleSelection_exports);
+var HYPERLIQUID_WHALE_SELECTION = {
+  minimumAccountValueUsd: 5e5,
+  minimumActiveDays: 1,
+  maximumRawFillsPerDay: 20,
+  maximumDirectionalExecutionsPerDay: 10,
+  minimumMedianNotionalUsd: 0,
+  minimumMedianInterExecutionMinutes: 0,
+  minimumTop30NotionalShare: 1e-3,
+  minimumTurnoverToEquity: 0.05,
+  maximumTurnoverToEquity: 5
+};
+var finiteNumber = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var median = (values) => {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+var evaluateHyperliquidWhaleStructure = (params) => {
+  const fills = params.fills.filter((fill) => {
+    const time = finiteNumber(fill.time);
+    return time >= params.calibrationFromMs && time < params.calibrationToMs;
+  }).sort((left, right) => finiteNumber(left.time) - finiteNumber(right.time));
+  const days = Math.max(
+    1,
+    (params.calibrationToMs - params.calibrationFromMs) / 864e5
+  );
+  const executions = fills.reduce((clusters, fill) => {
+    const coin = String(fill.coin);
+    const side = String(fill.side);
+    const time = finiteNumber(fill.time);
+    const notionalUsd = Math.abs(finiteNumber(fill.px) * finiteNumber(fill.sz));
+    const previous = clusters.at(-1);
+    if (previous && previous.coin === coin && previous.side === side && time - previous.time <= 6e4) {
+      previous.time = time;
+      previous.notionalUsd += notionalUsd;
+    } else {
+      clusters.push({ coin, side, time, notionalUsd });
+    }
+    return clusters;
+  }, []);
+  const notionals = executions.map((execution) => execution.notionalUsd);
+  const totalNotional = notionals.reduce((sum, value) => sum + value, 0);
+  const top30Notional = executions.reduce(
+    (sum, execution) => sum + (params.top30Symbols.has(execution.coin) ? execution.notionalUsd : 0),
+    0
+  );
+  const interExecutionMinutes = executions.slice(1).map(
+    (execution, index) => (execution.time - executions[index].time) / 6e4
+  ).filter((value) => value >= 0);
+  const activeDays = new Set(
+    fills.map(
+      (fill) => new Date(finiteNumber(fill.time)).toISOString().slice(0, 10)
+    )
+  ).size;
+  const rawFillsPerDay = fills.length / days;
+  const directionalExecutionsPerDay = executions.length / days;
+  const medianNotionalUsd = median(notionals);
+  const medianInterExecutionMinutes = median(interExecutionMinutes);
+  const top30NotionalShare = totalNotional > 0 ? top30Notional / totalNotional : 0;
+  const eligible = params.accountValueUsd >= HYPERLIQUID_WHALE_SELECTION.minimumAccountValueUsd && activeDays >= HYPERLIQUID_WHALE_SELECTION.minimumActiveDays && rawFillsPerDay <= HYPERLIQUID_WHALE_SELECTION.maximumRawFillsPerDay && directionalExecutionsPerDay <= HYPERLIQUID_WHALE_SELECTION.maximumDirectionalExecutionsPerDay && medianNotionalUsd >= HYPERLIQUID_WHALE_SELECTION.minimumMedianNotionalUsd && medianInterExecutionMinutes >= HYPERLIQUID_WHALE_SELECTION.minimumMedianInterExecutionMinutes && top30NotionalShare >= HYPERLIQUID_WHALE_SELECTION.minimumTop30NotionalShare;
+  const score = Math.log1p(params.accountValueUsd) * Math.log1p(medianNotionalUsd) * Math.log1p(Math.max(1, medianInterExecutionMinutes)) * Math.sqrt(Math.max(0, activeDays)) * top30NotionalShare / Math.sqrt(1 + rawFillsPerDay);
+  return {
+    address: params.address.toLowerCase(),
+    accountValueUsd: params.accountValueUsd,
+    rawFills: fills.length,
+    rawFillsPerDay,
+    directionalExecutions: executions.length,
+    directionalExecutionsPerDay,
+    activeDays,
+    medianNotionalUsd,
+    medianInterExecutionMinutes,
+    top30NotionalShare,
+    score,
+    eligible
+  };
+};
+var rankHyperliquidStructuralWhales = (metrics, limit = 100) => metrics.filter((row) => row.eligible).sort(
+  (left, right) => right.score - left.score || left.address.localeCompare(right.address)
+).slice(0, limit);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HYPERLIQUID_WHALE_SELECTION,
+  evaluateHyperliquidWhaleStructure,
+  rankHyperliquidStructuralWhales
+});