@tradejs/node 2.0.13 → 2.0.15

package/dist/{chunk-76TEMQKX.mjs → chunk-FEQR4XGR.mjs}

@@ -1,6 +1,6 @@
 import {
   getStrategyProfileMlAdapter
-} from "./chunk-PD25CABK.mjs";
+} from "./chunk-DPHKRDD5.mjs";
 import {
   getStrategyManifest
 } from "./chunk-QVSMINLG.mjs";
@@ -1077,27 +1077,585 @@ var enrichSignalWithCoinMarketCapContext = async (params) => {
   }
 };
 
+// src/hyperliquidWhaleUniverse.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/config/hyperliquidPerpUniverse.json
+var hyperliquidPerpUniverse_default = {
+  schemaVersion: 1,
+  updatedAt: "2026-08-04T11:46:43.476Z",
+  source: "hyperliquid_main_perp_day_notional_volume",
+  fingerprint: "58f7e024b19158dc",
+  size: 30,
+  symbols: [
+    "BTC",
+    "ETH",
+    "HYPE",
+    "SOL",
+    "ZEC",
+    "PUMP",
+    "XRP",
+    "CASHCAT",
+    "WLD",
+    "GRAM",
+    "UNI",
+    "ADA",
+    "LIT",
+    "ENA",
+    "NEAR",
+    "kPEPE",
+    "FARTCOIN",
+    "KAITO",
+    "AAVE",
+    "SUI",
+    "ONDO",
+    "AVAX",
+    "DOGE",
+    "VVV",
+    "BNB",
+    "ALGO",
+    "XMR",
+    "MEGA",
+    "LINK",
+    "TAO"
+  ]
+};
+
+// src/config/hyperliquidWhales.json
+var hyperliquidWhales_default = {
+  schemaVersion: 2,
+  updatedAt: "2026-08-04T15:10:21.316Z",
+  source: "hyperliquid_structural_fills_snapshot",
+  selection: {
+    calibrationFrom: "2026-07-28T00:00:00.000Z",
+    calibrationTo: "2026-08-04T00:00:00.000Z",
+    effectiveFrom: "2026-08-04T00:00:00.000Z",
+    candidateLimit: 400,
+    minimumAccountValueUsd: 5e5,
+    minimumActiveDays: 1,
+    maximumRawFillsPerDay: 20,
+    maximumDirectionalExecutionsPerDay: 10,
+    minimumMedianNotionalUsd: 0,
+    minimumMedianInterExecutionMinutes: 0,
+    minimumTop30NotionalShare: 1e-3,
+    minimumTurnoverToEquity: 0.05,
+    maximumTurnoverToEquity: 5,
+    score: "log1p(accountValue)*log1p(medianExecutionNotional)*log1p(max(1,medianInterExecutionMinutes))*sqrt(activeDays)*top30Share/sqrt(1+rawFillsPerDay)",
+    forbiddenSelectionMetrics: ["pnl", "roi", "winRate", "closedPnl"]
+  },
+  fingerprint: "77a6e9d41222efdb",
+  size: 100,
+  addresses: [
+    "0xacb66d1996501bcc82a0e7819c9e041599f5efbd",
+    "0x90dbb196cacf24bd212b377a0dd62eaad5e8151b",
+    "0xde5b8c8e713f7c29ec72c22a326d61e5ac76e402",
+    "0x22edc38749b59c31c9319eae7fc62143ac2fcc6c",
+    "0x4bc9a771cd2c96cb2a4501f2c049402b4e7e11b3",
+    "0x9a0825ca6c4c577a1202a8fae3b8f044c1d5711d",
+    "0xb6ca5d1ed0ca4bf8444c9dee2d068a9f4c5e2e92",
+    "0xc3610d02548cdb1a30ede87c5dc0d2ffe5b9b99f",
+    "0x48c6aaa647ad5197e85797f8eb95d7b9ce1ec5b6",
+    "0x8c1ab015da7e5319649afca4a551924f89eff883",
+    "0x64bddab5f13a99576fca6747f0aa205422c5f708",
+    "0x98785f2a43fe32f972476b86ed5a5cfaf5240f00",
+    "0x9836e286fbf4f71998827d4bd6ea3b470c26457e",
+    "0x8f8d2d2565bfb10608a7ce64b48e2aea7875a344",
+    "0xe6df4ed7a6ccb8426cbc87bdcdd3cc6d0e6c0690",
+    "0xab04d040dec929a204298d44701476968b238b69",
+    "0x870f718a84843abc3e22412a9b4dc2924466d448",
+    "0x12c206d3e2f0d0059420c54d33fe604ebbecc230",
+    "0x7d9e91a8a47eb553cbfd323e7633c0c213327124",
+    "0x2057d4f2b6ea957b63371980775b0a5505a438f0",
+    "0xead5b7d86c681c036c59cd00a0390541061c69f2",
+    "0x3005fade4c0df5e1cd187d7062da359416f0eb8e",
+    "0xe83b5e3644b50e802a25b34b38b91a061a0d3ca8",
+    "0x525232cb6ed5030d2b052b36bfc0baec96986ee3",
+    "0xa251520154ca342f0b1d702bf5a56f78c982405b",
+    "0xa9184bb57fd75c7c63e4c074d6319eceac6be53b",
+    "0xa20fb0c9e04063eec5be286e9269028d966646fa",
+    "0x169ba96d963e77a87dbe58922ecdcdd0f0cf3315",
+    "0x115849ce84370f25cadcf0d348510d73837e1aa5",
+    "0x37b81ab9e3ab04b9e3738e4891621205aaa31fd5",
+    "0x90f57d90a7dd3114312d4c31803ad5732baf5935",
+    "0xad227f63d34e7251c1d0ab65e64eeea07aee4e44",
+    "0xd38e2b0b3c85ae138532f9fe1a1d5f5455866b82",
+    "0xf5f4c3aa62a0f903a8529905031b1536d1cf16f8",
+    "0x75632aaf83120eae9b0618f8f50773ce347de2ad",
+    "0x3927af597c09774f91ef84bf765ded4109e9f8ea",
+    "0xf1863bd6d60a8f4b5f583ec54009af6a044877bf",
+    "0xe7b34f28c54f85533896f8827edc92edac28b17f",
+    "0x1cda20f9f6a23c209d54940af3ef63b96c9b2c31",
+    "0x9e55b0e43b7f7f3909af841d326b2dadfda9392e",
+    "0x610b8dd6b392d010c2b6ad8d121dfc09524cb613",
+    "0x1d639a688b78f3d7e57166e59d9a8886b1bfb5a5",
+    "0x34d3a17095ef7def39a489d63c7c916e673c9ca2",
+    "0x5d0bde4017530ed43370e332a5d30194941f73c6",
+    "0xaa7afc250041e2c56a06d3b7a5295bd01929e11b",
+    "0x325edd95bb016c36027ce3b9f7595af7094a9564",
+    "0x47f5a6397b79deaaca5c456503e7c1a49357b942",
+    "0xf5e7ffe523d0491709958490b4877e1d9de6c6f7",
+    "0x64702807a1f0f9888ea22b858099d7f481227b55",
+    "0xd08a4557671ca465e7bba41110a93148c90f9931",
+    "0x0423b4b2acb4f219ae4a270abd5dde2360e455bb",
+    "0x7b29f8c0ea709b96b72214b3de5d85c3d9570794",
+    "0xeb8ebad162a9ce4cb7e2325c92b960b9df63365c",
+    "0x939f95036d2e7b6d7419ec072bf9d967352204d2",
+    "0x2490aa2b48022e857d44e738911787c8e2296aed",
+    "0x7622f628135378f1b8d1876952de9bab80245f1c",
+    "0x9d677028e0e592d48fc8a8ddc910693301a4a450",
+    "0x85e410e4c535cb1709dbd36468f132037a5b2087",
+    "0xd6f52e2ab58a678eced4a4d1693757b0677631c8",
+    "0x24d8969e2bd6aabb6c4dfe042ef8b2cd8085217e",
+    "0xda51323fe9800c8365646ad5c7ade0dd17fdc167",
+    "0x53f8f390fd4f70941c5d160a964f6893c8dbceff",
+    "0x72dae3560e7f4c59a305e2e739d6bd6777f738b5",
+    "0x36f5e448c9cf0032551e58919cf4eabefcd742c1",
+    "0x5b43b7162694de766c164202df0f0c716e4292ab",
+    "0xae551d73161bac3315c5ade0e2d499a44ebe2236",
+    "0x4eca8d62e07b3f3e78a8ae8725d4666da324c5a8",
+    "0x40a632026febd007b0e4431a29170507f7aa3896",
+    "0xd453e91f692eb5437cf345e09545827576e3225d",
+    "0xbe2c69eb3d7b8ee35cbe3a28293472be31179d75",
+    "0xfdf891f2b214a4c9374d26595ec6d4080262e381",
+    "0xfd97600ac44b3c4e20ac1a5f23e3b18d10fa5912",
+    "0x98e073b579fd483eac8f10d5bd0b32c8c3bbd7e0",
+    "0xb56f19e917546a60d658110a611cf62a6877b517",
+    "0xbd334a55db91617545e8d1b09941e036ad8e4200",
+    "0x9f1920d0cbb63ed03376a1e09fd2851d601234c8",
+    "0xe9cef9fd872a03cedf9d3e6e90309782b3724ea6",
+    "0xa43682a1f129e4faf0152175cc03c44e4957e8cf",
+    "0x6fbb33de5f39c690d2decb95b9ab46ed0c83e3bc",
+    "0x81d4163289cf61a0eaaac4862cb88ef0f4215c29",
+    "0xd248d2f09bfbe04e67fc7fea08828d6ad6d95b6d",
+    "0x01ffcc7285866e5cee14c8e807cb2e8d5f61079f",
+    "0xc69ae428f6049e78d445f053d2c1df879c59b34c",
+    "0xaab4dfe6d735c4ac46217216fe883a39fbfe8284",
+    "0xe912cac1a6641004a8803687ee7699227fdb0550",
+    "0x5fdbf83c3d95d525704f61401db68cbec1b2a775",
+    "0xebd7c4b3677a4480fb5f69ac2f51c51d66a19990",
+    "0xe4d1fa7e6141f9131345117bdb8b5701bca67662",
+    "0x685feceec46dd4e5c9b5b726f5d7550fd0eda526",
+    "0x3ea8b09da72972e953541500721803a187526da6",
+    "0xdbe0780a5c5a0e3b345101bbc01ac2218196d6d5",
+    "0x18cd4597e06b7fe0a8cd33dda499121b3a145a8b",
+    "0xb8243756956e722bff5c763971b562ac551bfbd2",
+    "0xe0bf8c96795d2df0b61b3b17e7cfd7d3ba13d4be",
+    "0x218a65e21eddeece7a9df38c6bbdd89f692b7da2",
+    "0x53b63a30a688beb53b5dc7bd731c661d678c555c",
+    "0xfce053a5e461683454bf37ad66d20344c0e3f4c0",
+    "0x3e516cf3c9d4f29fae6c1324c2414dc872fc9c09",
+    "0xe5f1486dc84706d2509885fe6bbc46d21ba81286",
+    "0x38042d713af713f0275b00640a83654db91ea543"
+  ]
+};
+
+// src/hyperliquidWhaleUniverse.ts
+var fingerprint2 = (value) => createHash2("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
+var validateUnique = (values, label) => {
+  if (new Set(values).size !== values.length) {
+    throw new Error(`Hyperliquid ${label} snapshot contains duplicates`);
+  }
+};
+var validatePerpSnapshot = (value) => {
+  const symbols = value.symbols.map((symbol) => symbol.trim()).filter(Boolean);
+  validateUnique(symbols, "perp universe");
+  if (value.schemaVersion !== 1 || value.source !== "hyperliquid_main_perp_day_notional_volume" || value.size !== 30 || symbols.length !== 30 || value.fingerprint !== fingerprint2(symbols)) {
+    throw new Error("Invalid Hyperliquid perp universe snapshot");
+  }
+  return value;
+};
+var validateWhaleSnapshot = (value) => {
+  const addresses = value.addresses.map((address) => address.toLowerCase());
+  validateUnique(addresses, "whale registry");
+  if (value.schemaVersion !== 2 || value.source !== "hyperliquid_structural_fills_snapshot" || value.size !== 100 || addresses.length !== 100 || addresses.some((address) => !/^0x[0-9a-f]{40}$/.test(address)) || value.fingerprint !== fingerprint2(addresses)) {
+    throw new Error("Invalid Hyperliquid whale registry snapshot");
+  }
+  return value;
+};
+var perpSnapshot = validatePerpSnapshot(hyperliquidPerpUniverse_default);
+var whaleSnapshot = validateWhaleSnapshot(hyperliquidWhales_default);
+var perpSymbolSet = new Set(perpSnapshot.symbols);
+var whaleAddressSet = new Set(whaleSnapshot.addresses);
+var getHyperliquidPerpUniverseSnapshot = () => perpSnapshot;
+var getHyperliquidWhaleRegistrySnapshot = () => whaleSnapshot;
+var getHyperliquidPerpSymbols = () => [...perpSnapshot.symbols];
+var getHyperliquidWhaleAddresses = () => [...whaleSnapshot.addresses];
+var isTrackedHyperliquidPerp = (symbol) => perpSymbolSet.has(symbol.trim());
+var isTrackedHyperliquidWhale = (address) => whaleAddressSet.has(address.trim().toLowerCase());
+var SIGNAL_TO_HYPERLIQUID_ALIASES = {
+  PEPE: "kPEPE",
+  "1000PEPE": "kPEPE",
+  PUMPFUN: "PUMP",
+  SHIB: "kSHIB",
+  BONK: "kBONK"
+};
+var resolveHyperliquidPerpFromSignalSymbol = (symbol) => {
+  const normalized = symbol.trim().toUpperCase().replace(/(?:USDT|USDC)$/, "");
+  const candidate = SIGNAL_TO_HYPERLIQUID_ALIASES[normalized] ?? normalized;
+  return perpSymbolSet.has(candidate) ? candidate : null;
+};
+
+// src/strategyHelpers/hyperliquidWhaleContext.ts
+import { intervalToMs } from "@tradejs/core/data";
+import { refreshSignalBaseContextGateFeatures as refreshSignalBaseContextGateFeatures3 } from "@tradejs/core/strategies";
+import {
+  getHyperliquidWhaleCoverageSeriesRows,
+  getHyperliquidWhaleFlowAggregate,
+  getHyperliquidWhaleFlowSeriesRows
+} from "@tradejs/infra/timescale";
+import { logger as logger3 } from "@tradejs/infra/logger";
+var MAX_CACHE_ENTRIES = 2048;
+var MAX_COVERAGE_SERIES_CACHE_ENTRIES = 20;
+var MAX_FLOW_SERIES_CACHE_ENTRIES = 64;
+var SERIES_CHUNK_MS = 30 * 24 * 60 * 6e4;
+var MAX_SERIES_LOOKBACK_MS = 60 * 6e4;
+var DEFAULT_MIN_COVERAGE_PCT = 0.8;
+var INTERVAL_MS = {
+  "1m": 6e4,
+  "5m": 5 * 6e4,
+  "15m": 15 * 6e4,
+  "1h": 60 * 6e4
+};
+var DEFAULT_MAX_AGE_BY_INTERVAL2 = {
+  "1m": 2 * 6e4,
+  "5m": 10 * 6e4,
+  "15m": 30 * 6e4,
+  "1h": 2 * 60 * 6e4
+};
+var hyperliquidWhaleContextUnavailable = false;
+var contextCache = /* @__PURE__ */ new Map();
+var coverageSeriesCache = /* @__PURE__ */ new Map();
+var flowSeriesCache = /* @__PURE__ */ new Map();
+var parseEnabledFlag3 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return env !== "TEST";
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var getMinimumCoveragePct = () => {
+  const parsed = Number(process.env.HYPERLIQUID_WHALE_MIN_COVERAGE_PCT);
+  return Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : DEFAULT_MIN_COVERAGE_PCT;
+};
+var signalIntervalToMarketInterval2 = (value) => {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "5" || normalized === "5m") return "5m";
+  if (normalized === "60" || normalized === "1h") return "1h";
+  return "15m";
+};
+var hasBaseContext3 = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var setBoundedCache = (key, value) => {
+  if (contextCache.size >= MAX_CACHE_ENTRIES) {
+    const oldestKey = contextCache.keys().next().value;
+    if (oldestKey != null) contextCache.delete(oldestKey);
+  }
+  contextCache.set(key, value);
+};
+var setBoundedSeriesCache = (cache, maxEntries, key, value) => {
+  if (cache.size >= maxEntries) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey != null) cache.delete(oldestKey);
+  }
+  cache.set(key, value);
+};
+var uniqueAddressCount = (rows, field) => {
+  const addresses = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const address of row[field]) addresses.add(address);
+  }
+  return addresses.size;
+};
+var sumFlowField = (rows, field) => rows.reduce((sum, row) => sum + row[field], 0);
+var sliceSeriesWindow = (rows, fromMs, toMs) => {
+  const lowerBound = (timestamp) => {
+    let low = 0;
+    let high = rows.length;
+    while (low < high) {
+      const middle = low + Math.floor((high - low) / 2);
+      if (rows[middle].ts.getTime() < timestamp) low = middle + 1;
+      else high = middle;
+    }
+    return low;
+  };
+  return rows.slice(lowerBound(fromMs), lowerBound(toMs));
+};
+var aggregateHyperliquidWhaleFlowSeries = (params) => {
+  const intervalMs = INTERVAL_MS[params.interval];
+  const windowStartMs = params.decisionTimeMs - intervalMs;
+  const coverageRows = sliceSeriesWindow(
+    params.coverageRows,
+    windowStartMs,
+    params.decisionTimeMs
+  );
+  const expectedBuckets = Math.ceil(intervalMs / 6e4);
+  if (coverageRows.length !== expectedBuckets || coverageRows.some((row) => row.coveredWhales <= 0)) {
+    return null;
+  }
+  const flowRows = sliceSeriesWindow(
+    params.flowRows,
+    windowStartMs,
+    params.decisionTimeMs
+  );
+  const asOfTs = new Date(
+    Math.max(...coverageRows.map((row) => row.ts.getTime()))
+  );
+  const coveredWhales = Math.min(
+    ...coverageRows.map((row) => row.coveredWhales)
+  );
+  const expectedWhales = Math.max(
+    ...coverageRows.map((row) => row.expectedWhales)
+  );
+  const coveragePct = Math.min(...coverageRows.map((row) => row.coveragePct));
+  const trades = sumFlowField(flowRows, "trades");
+  const whaleSides = sumFlowField(flowRows, "whaleSides");
+  const buyNotionalUsd = sumFlowField(flowRows, "buyNotionalUsd");
+  const sellNotionalUsd = sumFlowField(flowRows, "sellNotionalUsd");
+  const positionAwareWhaleSides = sumFlowField(
+    flowRows,
+    "positionAwareWhaleSides"
+  );
+  const longEntryNotionalUsd = sumFlowField(flowRows, "longEntryNotionalUsd");
+  const shortEntryNotionalUsd = sumFlowField(flowRows, "shortEntryNotionalUsd");
+  const longExitNotionalUsd = sumFlowField(flowRows, "longExitNotionalUsd");
+  const shortExitNotionalUsd = sumFlowField(flowRows, "shortExitNotionalUsd");
+  const totalNotionalUsd = buyNotionalUsd + sellNotionalUsd;
+  const totalEntryNotionalUsd = longEntryNotionalUsd + shortEntryNotionalUsd;
+  const ageMs = params.decisionTimeMs - (asOfTs.getTime() + 6e4);
+  return {
+    symbol: params.symbol,
+    interval: params.interval,
+    asOfTs,
+    windowEndTs: new Date(params.decisionTimeMs),
+    trades,
+    whaleSides,
+    uniqueWhales: uniqueAddressCount(flowRows, "whaleAddresses"),
+    coveredWhales,
+    expectedWhales,
+    coveragePct,
+    buyNotionalUsd,
+    sellNotionalUsd,
+    netNotionalUsd: buyNotionalUsd - sellNotionalUsd,
+    buySharePct: totalNotionalUsd > 0 ? buyNotionalUsd / totalNotionalUsd : null,
+    positionAwareWhaleSides,
+    positionAwarePct: whaleSides > 0 ? positionAwareWhaleSides / whaleSides : 0,
+    longEntryWhales: uniqueAddressCount(flowRows, "longEntryWhaleAddresses"),
+    shortEntryWhales: uniqueAddressCount(flowRows, "shortEntryWhaleAddresses"),
+    longExitWhales: uniqueAddressCount(flowRows, "longExitWhaleAddresses"),
+    shortExitWhales: uniqueAddressCount(flowRows, "shortExitWhaleAddresses"),
+    longEntryNotionalUsd,
+    shortEntryNotionalUsd,
+    longExitNotionalUsd,
+    shortExitNotionalUsd,
+    entryNetNotionalUsd: longEntryNotionalUsd - shortEntryNotionalUsd,
+    entryLongSharePct: totalEntryNotionalUsd > 0 ? longEntryNotionalUsd / totalEntryNotionalUsd : null,
+    universeFingerprint: params.universeFingerprint,
+    whaleRegistryFingerprint: params.whaleRegistryFingerprint,
+    source: positionAwareWhaleSides > 0 ? "hyperliquid_user_fills" : null,
+    ageMs,
+    stale: ageMs < 0 || (params.maxAgeMs != null && Number.isFinite(params.maxAgeMs) ? ageMs > params.maxAgeMs : false)
+  };
+};
+var loadHyperliquidWhaleFlowAggregateFromSeries = async (params) => {
+  const chunkStartMs = Math.floor(params.decisionTimeMs / SERIES_CHUNK_MS) * SERIES_CHUNK_MS;
+  const fromMs = chunkStartMs - MAX_SERIES_LOOKBACK_MS;
+  const toMs = chunkStartMs + SERIES_CHUNK_MS;
+  const sharedKey = [
+    fromMs,
+    toMs,
+    params.universeFingerprint,
+    params.whaleRegistryFingerprint
+  ].join(":");
+  let pendingCoverage = coverageSeriesCache.get(sharedKey);
+  if (!pendingCoverage) {
+    pendingCoverage = getHyperliquidWhaleCoverageSeriesRows({
+      fromMs,
+      toMs,
+      universeFingerprint: params.universeFingerprint,
+      whaleRegistryFingerprint: params.whaleRegistryFingerprint
+    });
+    setBoundedSeriesCache(
+      coverageSeriesCache,
+      MAX_COVERAGE_SERIES_CACHE_ENTRIES,
+      sharedKey,
+      pendingCoverage
+    );
+  }
+  const flowKey = `${params.symbol}:${sharedKey}`;
+  let pendingFlow = flowSeriesCache.get(flowKey);
+  if (!pendingFlow) {
+    pendingFlow = getHyperliquidWhaleFlowSeriesRows({
+      symbol: params.symbol,
+      fromMs,
+      toMs,
+      universeFingerprint: params.universeFingerprint,
+      whaleRegistryFingerprint: params.whaleRegistryFingerprint
+    });
+    setBoundedSeriesCache(
+      flowSeriesCache,
+      MAX_FLOW_SERIES_CACHE_ENTRIES,
+      flowKey,
+      pendingFlow
+    );
+  }
+  const [coverageRows, flowRows] = await Promise.all([
+    pendingCoverage,
+    pendingFlow
+  ]);
+  return aggregateHyperliquidWhaleFlowSeries({
+    ...params,
+    coverageRows,
+    flowRows
+  });
+};
+var toBaseHyperliquidWhaleFlowContext = (row, minimumCoveragePct) => ({
+  source: row.positionAwareWhaleSides > 0 ? "hyperliquid_user_fills" : "hyperliquid_trades",
+  interval: row.interval,
+  asOfTs: row.asOfTs.getTime(),
+  windowEndTs: row.windowEndTs.getTime(),
+  ageMs: row.ageMs,
+  stale: row.stale,
+  symbol: row.symbol,
+  trades: row.trades,
+  whaleSides: row.whaleSides,
+  uniqueWhales: row.uniqueWhales,
+  coveredWhales: row.coveredWhales,
+  expectedWhales: row.expectedWhales,
+  coveragePct: row.coveragePct,
+  coverageSufficient: row.coveragePct >= minimumCoveragePct,
+  buyNotionalUsd: row.buyNotionalUsd,
+  sellNotionalUsd: row.sellNotionalUsd,
+  netNotionalUsd: row.netNotionalUsd,
+  buySharePct: row.buySharePct,
+  positionAwareWhaleSides: row.positionAwareWhaleSides,
+  positionAwarePct: row.positionAwarePct,
+  longEntryWhales: row.longEntryWhales,
+  shortEntryWhales: row.shortEntryWhales,
+  longExitWhales: row.longExitWhales,
+  shortExitWhales: row.shortExitWhales,
+  longEntryNotionalUsd: row.longEntryNotionalUsd,
+  shortEntryNotionalUsd: row.shortEntryNotionalUsd,
+  longExitNotionalUsd: row.longExitNotionalUsd,
+  shortExitNotionalUsd: row.shortExitNotionalUsd,
+  entryNetNotionalUsd: row.entryNetNotionalUsd,
+  entryLongSharePct: row.entryLongSharePct,
+  universeFingerprint: row.universeFingerprint,
+  whaleRegistryFingerprint: row.whaleRegistryFingerprint
+});
+var isHyperliquidWhaleContextEnabled = (env) => parseEnabledFlag3(process.env.HYPERLIQUID_WHALE_CONTEXT_ENABLED, env);
+var loadHyperliquidWhaleFlowContext = async (params) => {
+  if (!(params.enabled ?? isHyperliquidWhaleContextEnabled(params.env)) || hyperliquidWhaleContextUnavailable || params.interval == null) {
+    return null;
+  }
+  const symbol = resolveHyperliquidPerpFromSignalSymbol(params.symbol);
+  if (!symbol) return null;
+  const interval = params.marketInterval ?? signalIntervalToMarketInterval2(params.interval);
+  const decisionTimeMs = params.timestamp + intervalToMs(params.interval);
+  const maxAgeMs = params.maxAgeMs ?? DEFAULT_MAX_AGE_BY_INTERVAL2[interval];
+  const universe = getHyperliquidPerpUniverseSnapshot();
+  const whales = getHyperliquidWhaleRegistrySnapshot();
+  const minimumCoveragePct = getMinimumCoveragePct();
+  const cacheKey = [
+    symbol,
+    interval,
+    decisionTimeMs,
+    maxAgeMs,
+    universe.fingerprint,
+    whales.fingerprint,
+    minimumCoveragePct
+  ].join(":");
+  try {
+    let row;
+    if (params.useSeriesCache) {
+      row = await loadHyperliquidWhaleFlowAggregateFromSeries({
+        symbol,
+        interval,
+        decisionTimeMs,
+        maxAgeMs,
+        universeFingerprint: universe.fingerprint,
+        whaleRegistryFingerprint: whales.fingerprint
+      });
+    } else {
+      let pending = contextCache.get(cacheKey);
+      if (!pending) {
+        pending = getHyperliquidWhaleFlowAggregate({
+          symbol,
+          interval,
+          decisionTimeMs,
+          maxAgeMs,
+          universeFingerprint: universe.fingerprint,
+          whaleRegistryFingerprint: whales.fingerprint
+        });
+        setBoundedCache(cacheKey, pending);
+      }
+      row = await pending;
+    }
+    if (!row) return null;
+    return toBaseHyperliquidWhaleFlowContext(row, minimumCoveragePct);
+  } catch (error) {
+    hyperliquidWhaleContextUnavailable = true;
+    logger3.warn(
+      "Hyperliquid whale context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return null;
+  }
+};
+var enrichSignalWithHyperliquidWhaleContext = async (params) => {
+  const { signal, env } = params;
+  if (signal.universe === "tradfi" || signal.interval == null || !hasBaseContext3(signal)) {
+    return false;
+  }
+  const hyperliquidWhales = await loadHyperliquidWhaleFlowContext({
+    symbol: signal.symbol,
+    interval: signal.interval,
+    timestamp: signal.timestamp,
+    env,
+    enabled: params.enabled,
+    marketInterval: params.interval,
+    maxAgeMs: params.maxAgeMs
+  });
+  if (!hyperliquidWhales) return false;
+  const baseContext = signal.additionalIndicators.baseContext;
+  signal.additionalIndicators = {
+    ...signal.additionalIndicators,
+    baseContext: {
+      ...baseContext,
+      participation: {
+        ...baseContext.participation,
+        hyperliquidWhales
+      }
+    }
+  };
+  refreshSignalBaseContextGateFeatures3(signal);
+  return true;
+};
+
 // src/strategyHelpers/derivativesContext.ts
 import {
   buildDerivativesContext,
   buildCoinalyzeHourlyRowsWithFallback,
   getLastClosedDerivativesBarStartMs
 } from "@tradejs/core/indicators";
-import { intervalToMs } from "@tradejs/core/data";
-import { refreshSignalBaseContextGateFeatures as refreshSignalBaseContextGateFeatures3 } from "@tradejs/core/strategies";
+import { intervalToMs as intervalToMs2 } from "@tradejs/core/data";
+import { refreshSignalBaseContextGateFeatures as refreshSignalBaseContextGateFeatures4 } from "@tradejs/core/strategies";
 import {
   DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS,
   resolveDerivativesContextReferenceSymbols
 } from "@tradejs/core/constants";
 import { getDerivativesWindow } from "@tradejs/infra/timescale";
-import { logger as logger3 } from "@tradejs/infra/logger";
+import { logger as logger4 } from "@tradejs/infra/logger";
 var STORED_INTERVALS = ["15m", "1h"];
 var CONTEXT_INTERVALS = ["15m", "1h"];
 var DEFAULT_LOOKBACK_HOURS = 48;
 var PRIMARY_DERIVATIVES_REFERENCE_SYMBOL = DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[0];
 var SECONDARY_DERIVATIVES_REFERENCE_SYMBOL = DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[1];
 var derivativesContextUnavailable = false;
-var parseEnabledFlag3 = (value, env) => {
+var parseEnabledFlag4 = (value, env) => {
   const normalized = String(value ?? "").trim().toLowerCase();
   if (!normalized) return true;
   if (["1", "true", "yes", "on"].includes(normalized)) return true;
@@ -1235,7 +1793,7 @@ var buildReferenceDerivativesContext = (params) => {
     } : {}
   };
 };
-var isDerivativesContextEnabled = (env) => parseEnabledFlag3(process.env.DERIVATIVES_CONTEXT_ENABLED, env);
+var isDerivativesContextEnabled = (env) => parseEnabledFlag4(process.env.DERIVATIVES_CONTEXT_ENABLED, env);
 var isDerivativesTargetContextEnabled = () => parseBooleanFlag(process.env.DERIVATIVES_CONTEXT_TARGET_ENABLED, false);
 var enrichSignalWithDerivativesContext = async (params) => {
   const { signal, env, enabled = isDerivativesContextEnabled(env) } = params;
@@ -1246,7 +1804,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
     const referenceSymbols = getDerivativesContextReferenceSymbols();
     const targetSymbol = normalizeSymbol(signal.symbol);
     const lookbackMs = parseLookbackMs();
-    const decisionTimeMs = signal.timestamp + intervalToMs(signal.interval);
+    const decisionTimeMs = signal.timestamp + intervalToMs2(signal.interval);
     const derivativesEndMs = getLastClosedDerivativesBarStartMs(
       decisionTimeMs,
       "15m"
@@ -1313,11 +1871,11 @@ var enrichSignalWithDerivativesContext = async (params) => {
         derivatives: derivativesContext
       } : signal.additionalIndicators?.baseContext
     };
-    refreshSignalBaseContextGateFeatures3(signal);
+    refreshSignalBaseContextGateFeatures4(signal);
     return true;
   } catch (error) {
     derivativesContextUnavailable = true;
-    logger3.warn(
+    logger4.warn(
       "Derivatives context disabled after Timescale read failure: %s",
       String(error)
     );
@@ -1382,5 +1940,14 @@ export {
   enrichSignalWithBinanceMarketContext,
   enrichSignalWithCoinMarketCapContext,
   enrichSignalWithDerivativesContext,
+  getHyperliquidPerpUniverseSnapshot,
+  getHyperliquidWhaleRegistrySnapshot,
+  getHyperliquidPerpSymbols,
+  getHyperliquidWhaleAddresses,
+  isTrackedHyperliquidPerp,
+  isTrackedHyperliquidWhale,
+  resolveHyperliquidPerpFromSignalSymbol,
+  loadHyperliquidWhaleFlowContext,
+  enrichSignalWithHyperliquidWhaleContext,
   buildMlPayload
 };

package/dist/cli.js

@@ -6810,7 +6810,7 @@ Input payload structure:
   \u2022 \`baseContext.raw\`: current MA, ATR, BB, OBV, price stats, levels, BTC correlation.
   \u2022 \`baseContext.regime\`: derived trend / volatility / momentum / session regime fields.
   \u2022 \`baseContext.structure\`: local range position, breakout freshness/quality, level-touch counts, rejection wick context.
-  \u2022 \`baseContext.participation\`: volume/turnover participation, effort-vs-result context, and Binance aggTrades trade-flow when available.
+  \u2022 \`baseContext.participation\`: volume/turnover participation, effort-vs-result context, Binance aggTrades, and fingerprinted Hyperliquid whale-flow when available.
   \u2022 \`baseContext.relative\`: BTC/ETH relative-strength, benchmark MA bias context, Binance alt-basket breadth, and CoinMarketCap historical global/exchange/index context when available.
   \u2022 \`baseContext.derivatives\`: Coinalyze-aligned derivatives summary when available.
   \u2022 \`baseContext.mtf\`: compact multi-timeframe summary plus only the latest few candles for each timeframe.

package/dist/cli.mjs

@@ -8,7 +8,7 @@ import {
 } from "./chunk-GPR56UYQ.mjs";
 import {
   askAI
-} from "./chunk-PD25CABK.mjs";
+} from "./chunk-DPHKRDD5.mjs";
 import "./chunk-QVSMINLG.mjs";
 import {
   getTradejsProjectCwd,