@tradejs/cli 2.0.12 → 2.0.14

package/dist/scripts/hyperliquidWhaleIngest.js

@@ -0,0 +1,333 @@
+"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/scripts/hyperliquidWhaleIngest.ts
+var hyperliquidWhaleIngest_exports = {};
+__export(hyperliquidWhaleIngest_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(hyperliquidWhaleIngest_exports);
+
+// src/lib/hyperliquidWhaleStream.ts
+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 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();
+  }
+};
+
+// src/scripts/hyperliquidWhaleIngest.ts
+var main = async () => {
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  try {
+    await runHyperliquidWhaleStream({
+      signal: controller.signal,
+      log: console.log
+    });
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/dist/scripts/hyperliquidWhalesUpdate.js

@@ -0,0 +1,369 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/hyperliquidWhalesUpdate.ts
+var hyperliquidWhalesUpdate_exports = {};
+__export(hyperliquidWhalesUpdate_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(hyperliquidWhalesUpdate_exports);
+var import_config = require("dotenv/config");
+var import_args = __toESM(require("args"));
+var import_node_crypto = require("crypto");
+var import_strategies2 = require("@tradejs/node/strategies");
+
+// src/lib/hyperliquidWhaleBackfill.ts
+var import_timescale = require("@tradejs/infra/timescale");
+var import_strategies = require("@tradejs/node/strategies");
+
+// src/lib/hyperliquidWhaleData.ts
+var HYPERLIQUID_WHALE_BUCKET_MS = 6e4;
+
+// src/lib/hyperliquidRateLimiter.ts
+var DEFAULT_WEIGHT_PER_MINUTE = 1e3;
+var WINDOW_MS = 6e4;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+var HyperliquidInfoRateLimiter = class {
+  constructor(capacity = DEFAULT_WEIGHT_PER_MINUTE, now = Date.now, wait = sleep) {
+    this.capacity = capacity;
+    this.now = now;
+    this.wait = wait;
+    this.reservations = [];
+    this.queue = Promise.resolve();
+  }
+  reserve(weight) {
+    const normalizedWeight = Math.max(1, Math.ceil(weight));
+    const pending = this.queue.then(
+      () => this.reserveInternal(normalizedWeight)
+    );
+    this.queue = pending.catch(() => void 0);
+    return pending;
+  }
+  async reserveInternal(weight) {
+    if (weight > this.capacity) {
+      throw new Error(
+        `Hyperliquid request weight ${weight} exceeds limiter capacity ${this.capacity}`
+      );
+    }
+    for (; ; ) {
+      const nowMs = this.now();
+      this.reservations = this.reservations.filter(
+        (reservation) => reservation.atMs > nowMs - WINDOW_MS
+      );
+      const used = this.reservations.reduce(
+        (sum, reservation) => sum + reservation.weight,
+        0
+      );
+      if (used + weight <= this.capacity) {
+        this.reservations.push({ atMs: nowMs, weight });
+        return;
+      }
+      const oldest = this.reservations[0];
+      await this.wait(Math.max(1, oldest.atMs + WINDOW_MS - nowMs));
+    }
+  }
+};
+var hyperliquidInfoResponseWeight = (rows) => Math.max(0, Math.ceil(Math.max(0, rows) / 20));
+
+// src/lib/hyperliquidWhaleBackfill.ts
+var DEFAULT_BASE_URL = "https://api.hyperliquid.xyz";
+var DEFAULT_RATE_LIMIT_WEIGHT = 1e3;
+var MAX_PAGE_SIZE = 2e3;
+var MAX_PAGES_PER_WHALE = 5;
+var REQUEST_WEIGHT = 20;
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+var positiveInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var nextMinute = (value) => (Math.floor(value / HYPERLIQUID_WHALE_BUCKET_MS) + 1) * HYPERLIQUID_WHALE_BUCKET_MS;
+var fetchHyperliquidUserFillsByTime = async (params) => {
+  const fetchImpl = params.fetchImpl ?? fetch;
+  const limiter = params.rateLimiter ?? new HyperliquidInfoRateLimiter(
+    positiveInt(
+      process.env.HYPERLIQUID_WHALE_RATE_LIMIT_WEIGHT,
+      DEFAULT_RATE_LIMIT_WEIGHT
+    ),
+    Date.now,
+    params.wait ?? sleep2
+  );
+  const fills = [];
+  let cursor = params.startTime;
+  for (let page = 0; page < (params.maxPages ?? MAX_PAGES_PER_WHALE) && cursor <= params.endTime; page += 1) {
+    await limiter.reserve(REQUEST_WEIGHT);
+    const response = await fetchImpl(
+      `${process.env.HYPERLIQUID_API_BASE_URL?.trim() || DEFAULT_BASE_URL}/info`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          type: "userFillsByTime",
+          user: params.address,
+          startTime: cursor,
+          endTime: params.endTime,
+          aggregateByTime: true
+        })
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Hyperliquid userFillsByTime ${response.status}: ${await response.text()}`
+      );
+    }
+    const raw = await response.json();
+    const pageRows = Array.isArray(raw) ? raw : [];
+    const responseWeight = hyperliquidInfoResponseWeight(pageRows.length);
+    if (responseWeight > 0) await limiter.reserve(responseWeight);
+    fills.push(...pageRows);
+    if (pageRows.length < MAX_PAGE_SIZE) {
+      return { fills, truncated: false, coveredFromMs: params.startTime };
+    }
+    const lastTime = Math.max(
+      ...pageRows.map((row) => Number(row.time)).filter(Number.isFinite)
+    );
+    if (!Number.isFinite(lastTime) || lastTime < cursor) {
+      throw new Error(
+        `Hyperliquid fills pagination stalled for ${params.address}`
+      );
+    }
+    cursor = lastTime + 1;
+  }
+  if (cursor > params.endTime) {
+    return { fills, truncated: false, coveredFromMs: params.startTime };
+  }
+  const firstAvailableTime = Math.min(
+    ...fills.map((fill) => Number(fill.time)).filter(Number.isFinite)
+  );
+  return {
+    fills,
+    truncated: true,
+    coveredFromMs: Math.min(params.endTime + 1, nextMinute(firstAvailableTime))
+  };
+};
+
+// src/lib/hyperliquidWhaleSelection.ts
+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);
+
+// src/scripts/hyperliquidWhalesUpdate.ts
+var LEADERBOARD_URL = "https://stats-data.hyperliquid.xyz/Mainnet/leaderboard";
+var DAY_MS = 864e5;
+var CANDIDATE_LIMIT = 400;
+import_args.default.option(
+  ["t", "to"],
+  "Exclusive calibration end (ISO); defaults to the current UTC day"
+);
+import_args.default.option(["d", "days"], "Calibration window in days", 7);
+var flags = import_args.default.parse(process.argv);
+var fingerprint = (addresses) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(addresses)).digest("hex").slice(0, 16);
+var runConcurrent = async (params) => {
+  let nextIndex = 0;
+  await Promise.all(
+    Array.from({ length: params.concurrency }, async () => {
+      for (; ; ) {
+        const index = nextIndex;
+        nextIndex += 1;
+        if (index >= params.items.length) return;
+        await params.worker(params.items[index]);
+      }
+    })
+  );
+};
+var main = async () => {
+  const explicitTo = flags.to == null ? Number.NaN : Date.parse(String(flags.to));
+  const calibrationToMs = Number.isFinite(explicitTo) ? explicitTo : Math.floor(Date.now() / DAY_MS) * DAY_MS;
+  const calibrationDays = Math.max(1, Number(flags.days) || 7);
+  const calibrationFromMs = calibrationToMs - calibrationDays * DAY_MS;
+  const response = await fetch(LEADERBOARD_URL);
+  if (!response.ok) {
+    throw new Error(`Hyperliquid leaderboard ${response.status}`);
+  }
+  const payload = await response.json();
+  const candidates = (payload.leaderboardRows ?? []).map((row) => {
+    const address = String(row.ethAddress ?? "").toLowerCase();
+    const accountValueUsd = Number(row.accountValue);
+    const weeklyVolumeUsd = Number(
+      row.windowPerformances?.find(([window]) => window === "week")?.[1].vlm
+    );
+    return {
+      address,
+      accountValueUsd,
+      turnoverToEquity: accountValueUsd > 0 ? weeklyVolumeUsd / accountValueUsd : 0
+    };
+  }).filter(
+    (row) => /^0x[0-9a-f]{40}$/.test(row.address) && row.accountValueUsd >= HYPERLIQUID_WHALE_SELECTION.minimumAccountValueUsd && row.turnoverToEquity >= HYPERLIQUID_WHALE_SELECTION.minimumTurnoverToEquity && row.turnoverToEquity <= HYPERLIQUID_WHALE_SELECTION.maximumTurnoverToEquity
+  ).sort(
+    (left, right) => left.turnoverToEquity - right.turnoverToEquity || right.accountValueUsd - left.accountValueUsd || left.address.localeCompare(right.address)
+  ).slice(0, CANDIDATE_LIMIT);
+  const top30Symbols = new Set((0, import_strategies2.getHyperliquidPerpUniverseSnapshot)().symbols);
+  const limiter = new HyperliquidInfoRateLimiter();
+  const metrics = [];
+  let completed = 0;
+  await runConcurrent({
+    items: candidates,
+    concurrency: 2,
+    worker: async (candidate) => {
+      const result = await fetchHyperliquidUserFillsByTime({
+        address: candidate.address,
+        startTime: calibrationFromMs,
+        endTime: calibrationToMs - 1,
+        rateLimiter: limiter,
+        maxPages: 1
+      });
+      metrics.push(
+        evaluateHyperliquidWhaleStructure({
+          address: candidate.address,
+          accountValueUsd: candidate.accountValueUsd,
+          fills: result.fills,
+          calibrationFromMs,
+          calibrationToMs,
+          top30Symbols
+        })
+      );
+      completed += 1;
+      if (completed % 10 === 0 || completed === candidates.length) {
+        console.log(
+          `Hyperliquid whale selection ${completed}/${candidates.length}; eligible=${metrics.filter((row) => row.eligible).length}`
+        );
+      }
+    }
+  });
+  const selected = rankHyperliquidStructuralWhales(metrics, 100);
+  if (selected.length !== 100) {
+    throw new Error(
+      `Only ${selected.length} structural whales passed selection from ${candidates.length} candidates`
+    );
+  }
+  const addresses = selected.map((row) => row.address);
+  const timestamp = new Date(calibrationToMs).toISOString();
+  const snapshot = {
+    schemaVersion: 2,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "hyperliquid_structural_fills_snapshot",
+    selection: {
+      calibrationFrom: new Date(calibrationFromMs).toISOString(),
+      calibrationTo: timestamp,
+      effectiveFrom: timestamp,
+      candidateLimit: CANDIDATE_LIMIT,
+      ...HYPERLIQUID_WHALE_SELECTION,
+      score: "log1p(accountValue)*log1p(medianExecutionNotional)*log1p(max(1,medianInterExecutionMinutes))*sqrt(activeDays)*top30Share/sqrt(1+rawFillsPerDay)",
+      forbiddenSelectionMetrics: ["pnl", "roi", "winRate", "closedPnl"]
+    },
+    fingerprint: fingerprint(addresses),
+    size: 100,
+    addresses
+  };
+  console.log(JSON.stringify(snapshot, null, 2));
+  return snapshot;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});