@tradejs/node 2.0.13 → 2.0.14

package/dist/strategies.js

@@ -5556,6 +5556,7 @@ __export(strategies_exports, {
   enrichSignalWithAi: () => enrichSignalWithAi,
   enrichSignalWithBinanceMarketContext: () => enrichSignalWithBinanceMarketContext,
   enrichSignalWithCoinMarketCapContext: () => enrichSignalWithCoinMarketCapContext,
+  enrichSignalWithHyperliquidWhaleContext: () => enrichSignalWithHyperliquidWhaleContext,
   enrichSignalWithMl: () => enrichSignalWithMl,
   enrichSignalWithMlAi: () => enrichSignalWithMlAi,
   ensureAiStrategyPluginsLoaded: () => ensureAiStrategyPluginsLoaded,
@@ -5566,6 +5567,10 @@ __export(strategies_exports, {
   getBinanceBreadthUniverseSnapshot: () => getBinanceBreadthUniverseSnapshot,
   getBinanceBreadthUniverses: () => getBinanceBreadthUniverses,
   getDeterministicAiGateContext: () => getDeterministicAiGateContext,
+  getHyperliquidPerpSymbols: () => getHyperliquidPerpSymbols,
+  getHyperliquidPerpUniverseSnapshot: () => getHyperliquidPerpUniverseSnapshot,
+  getHyperliquidWhaleAddresses: () => getHyperliquidWhaleAddresses,
+  getHyperliquidWhaleRegistrySnapshot: () => getHyperliquidWhaleRegistrySnapshot,
   getOpenRouterModelKwargs: () => getOpenRouterModelKwargs,
   getOrderArrivalSnapshot: () => getOrderArrivalSnapshot,
   getPrimaryBinanceBreadthUniverse: () => getPrimaryBinanceBreadthUniverse,
@@ -5574,9 +5579,12 @@ __export(strategies_exports, {
   getStrategyCreator: () => getStrategyCreator,
   getStrategyManifest: () => getStrategyManifest,
   isKnownStrategy: () => isKnownStrategy,
+  isTrackedHyperliquidPerp: () => isTrackedHyperliquidPerp,
+  isTrackedHyperliquidWhale: () => isTrackedHyperliquidWhale,
   registerStrategyEntries: () => registerStrategyEntries,
   resetAiRuntimeCache: () => resetAiRuntimeCache,
   resetStrategyRegistryCache: () => resetStrategyRegistryCache,
+  resolveHyperliquidPerpFromSignalSymbol: () => resolveHyperliquidPerpFromSignalSymbol,
   resolveStrategyConfig: () => resolveStrategyConfig,
   runAiPrompt: () => runAiPrompt,
   runAiPromptLocal: () => runAiPromptLocal,
@@ -6932,7 +6940,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.
@@ -7253,12 +7261,12 @@ var askAI = async (signal, options = {}) => {
 // src/strategyRuntime.ts
 var import_node_path2 = __toESM(require("path"));
 var import_constants4 = require("@tradejs/core/constants");
-var import_data2 = require("@tradejs/core/data");
-var import_strategies4 = require("@tradejs/core/strategies");
-var import_logger8 = require("@tradejs/infra/logger");
+var import_data3 = require("@tradejs/core/data");
+var import_strategies5 = require("@tradejs/core/strategies");
+var import_logger9 = require("@tradejs/infra/logger");
 
 // src/strategyHelpers/runtime.ts
-var import_logger7 = require("@tradejs/infra/logger");
+var import_logger8 = require("@tradejs/infra/logger");
 var import_constants3 = require("@tradejs/core/constants");
 var import_ml2 = require("@tradejs/infra/ml");
 
@@ -8856,6 +8864,562 @@ var enrichSignalWithCoinMarketCapContext = async (params) => {
   }
 };
 
+// src/strategyHelpers/hyperliquidWhaleContext.ts
+var import_data2 = require("@tradejs/core/data");
+var import_strategies4 = require("@tradejs/core/strategies");
+var import_timescale4 = require("@tradejs/infra/timescale");
+var import_logger7 = require("@tradejs/infra/logger");
+
+// src/hyperliquidWhaleUniverse.ts
+var import_node_crypto3 = require("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) => (0, import_node_crypto3.createHash)("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
+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 parseEnabledFlag4 = (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 = (0, import_timescale4.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 = (0, import_timescale4.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) => parseEnabledFlag4(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 + (0, import_data2.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 = (0, import_timescale4.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;
+    import_logger7.logger.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
+      }
+    }
+  };
+  (0, import_strategies4.refreshSignalBaseContextGateFeatures)(signal);
+  return true;
+};
+
 // src/strategyHelpers/runtime.ts
 var formatAiError = (err) => {
   const error = err;
@@ -8972,7 +9536,7 @@ var enrichSignalWithAi = async ({
     signal.aiAnalysis = analysis;
     return resolveAiQuality(analysis, direction);
   } catch (err) {
-    import_logger7.logger.error("AI analysis error: %s %s", symbol, formatAiError(err));
+    import_logger8.logger.error("AI analysis error: %s %s", symbol, formatAiError(err));
   }
   return void 0;
 };
@@ -8988,6 +9552,7 @@ var enrichSignalWithMlAi = async ({
   await enrichSignalWithBinanceMarketContext({ signal, env });
   await enrichSignalWithCoinMarketCapContext({ signal, env });
   await enrichSignalWithDerivativesContext({ signal, env });
+  await enrichSignalWithHyperliquidWhaleContext({ signal, env });
   await enrichSignalWithMl({ signal, env, ml });
   return enrichSignalWithAi({ signal, userName, symbol, direction, env, ai });
 };
@@ -9022,7 +9587,7 @@ var getOrderArrivalSnapshot = async ({
       spreadBps
     };
   } catch (error) {
-    import_logger7.logger.warn(
+    import_logger8.logger.warn(
       "runtime order arrival snapshot failed: %s %s",
       symbol,
       error?.message || String(error)
@@ -9526,7 +10091,7 @@ var resolveBacktestExecutionDelayMs = (value, fallbackDelayMs) => {
 };
 var safeIntervalToMs = (interval) => {
   try {
-    return (0, import_data2.intervalToMs)(interval);
+    return (0, import_data3.intervalToMs)(interval);
   } catch {
     return null;
   }
@@ -9608,14 +10173,14 @@ var applyBacktestDelayedEntryExecution = ({
       btcExecutionCandle: null
     };
   }
-  const executionPrice = (0, import_strategies4.resolveBacktestExecutionPrice)(
+  const executionPrice = (0, import_strategies5.resolveBacktestExecutionPrice)(
     candle,
     backtestPriceMode ?? "open"
   );
   const executionTimestamp = candle.timestamp;
   const takeProfitPrice = decision.entryContext.prices.takeProfitPrice;
   const stopLossPrice = decision.orderPlan.stopLossPrice;
-  const riskRatio = (0, import_strategies4.calculateRiskRatio)({
+  const riskRatio = (0, import_strategies5.calculateRiskRatio)({
     direction: decision.entryContext.direction,
     currentPrice: executionPrice,
     takeProfitPrice,
@@ -9643,7 +10208,7 @@ var applyBacktestDelayedEntryExecution = ({
     executionCandle: buildBacktestExecutionOnlyCandle(candle, executionPrice),
     btcExecutionCandle: buildBacktestExecutionOnlyCandle(
       btcCandle,
-      (0, import_strategies4.resolveBacktestExecutionPrice)(btcCandle, backtestPriceMode ?? "open")
+      (0, import_strategies5.resolveBacktestExecutionPrice)(btcCandle, backtestPriceMode ?? "open")
     )
   };
   if (!decision.signal) {
@@ -9888,7 +10453,7 @@ var handleExitDecision = async ({
         deploymentId: connector.deploymentId
       });
       if (!activeTrade) {
-        import_logger8.logger.warn(
+        import_logger9.logger.warn(
           "[%s] blocked closePosition for untracked runtime position: %s",
           strategyName ?? "unknown",
           symbol
@@ -9896,7 +10461,7 @@ var handleExitDecision = async ({
         return "CLOSE_BLOCKED_BY_UNTRACKED_POSITION";
       }
       if (!strategyName || activeTrade.strategy !== strategyName) {
-        import_logger8.logger.warn(
+        import_logger9.logger.warn(
           "[%s] blocked closePosition for foreign runtime position: %s ownedBy=%s",
           strategyName ?? "unknown",
           symbol,
@@ -9948,7 +10513,7 @@ var handleExitDecision = async ({
           exitType: closedTrade?.exitType ?? "exit"
         });
       } catch (notificationError) {
-        import_logger8.logger.error(
+        import_logger9.logger.error(
           "runtime close notification error: %s %s",
           symbol,
           notificationError
@@ -9962,7 +10527,7 @@ var handleExitDecision = async ({
       decision,
       market
     });
-    import_logger8.logger.error("close order error: %s %s", symbol, err);
+    import_logger9.logger.error("close order error: %s %s", symbol, err);
     return "ORDER_ERROR";
   }
   return decision.code;
@@ -9989,7 +10554,7 @@ var handleProtectDecision = async ({
       decision,
       market
     });
-    import_logger8.logger.error("protect position error: %s %s", symbol, err);
+    import_logger9.logger.error("protect position error: %s %s", symbol, err);
     return "ORDER_ERROR";
   }
   return decision.code;
@@ -10152,9 +10717,9 @@ var executeEntryDecision = async ({
       market
     });
     if (err?.message === import_types.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
-      import_logger8.logger.warn("order warning: %s %s", symbol, err);
+      import_logger9.logger.warn("order warning: %s %s", symbol, err);
     } else {
-      import_logger8.logger.error("order error: %s %s", symbol, err);
+      import_logger9.logger.error("order error: %s %s", symbol, err);
     }
     return signal ?? "ORDER_ERROR";
   }
@@ -10251,7 +10816,7 @@ var createStrategyRuntime = ({
       assetClass
     });
     const strategyPolicyProfile = getPolicyProfile();
-    const indicatorPeriods = (0, import_strategies4.buildDefaultIndicatorPeriods)(config);
+    const indicatorPeriods = (0, import_strategies5.buildDefaultIndicatorPeriods)(config);
     const hookBase = {
       connector,
       strategyName,
@@ -10309,7 +10874,7 @@ var createStrategyRuntime = ({
         try {
           await projectHook(errorParams);
         } catch (hookError) {
-          import_logger8.logger.error(
+          import_logger9.logger.error(
             "project hook onRuntimeError failed: %s %s",
             strategyName,
             hookError
@@ -10323,7 +10888,7 @@ var createStrategyRuntime = ({
       try {
         await onRuntimeError(errorParams);
       } catch (hookError) {
-        import_logger8.logger.error(
+        import_logger9.logger.error(
           "runtime hook onRuntimeError failed: %s %s",
           strategyName,
           hookError
@@ -10337,7 +10902,7 @@ var createStrategyRuntime = ({
       try {
         return await hook(params);
       } catch (error) {
-        import_logger8.logger.error(
+        import_logger9.logger.error(
           'strategy hook "%s" failed for %s: %s',
           stage,
           strategyName,
@@ -10473,7 +11038,7 @@ var createStrategyRuntime = ({
       }
       return void 0;
     };
-    const indicatorsState = (0, import_strategies4.createStrategyIndicatorsState)({
+    const indicatorsState = (0, import_strategies5.createStrategyIndicatorsState)({
       env,
       data,
       btcData,
@@ -10485,7 +11050,7 @@ var createStrategyRuntime = ({
       sharedReplayKey: indicatorSharedReplayKey,
       useBtcReference: universe === "crypto"
     });
-    const strategyApi = (0, import_strategies4.createStrategyAPI)({
+    const strategyApi = (0, import_strategies5.createStrategyAPI)({
       strategy: strategyName,
       symbol,
       interval: config.INTERVAL ?? "15",
@@ -10495,7 +11060,30 @@ var createStrategyRuntime = ({
       indicatorsState,
       isConfigFromBacktest,
       sharedReplayKey: strategySharedReplayKey,
-      getSharedReplayState: import_strategies4.getSharedStrategyReplayState
+      getSharedReplayState: import_strategies5.getSharedStrategyReplayState,
+      loadDecisionBaseContext: async ({
+        baseContext,
+        candle,
+        symbol: decisionSymbol,
+        interval: decisionInterval
+      }) => {
+        if (!baseContext) return void 0;
+        const hyperliquidWhales = await loadHyperliquidWhaleFlowContext({
+          symbol: decisionSymbol,
+          interval: decisionInterval,
+          timestamp: candle.timestamp,
+          env,
+          useSeriesCache: env === "BACKTEST" || env === "PARITY"
+        });
+        if (!hyperliquidWhales) return baseContext;
+        return {
+          ...baseContext,
+          participation: {
+            ...baseContext.participation,
+            hyperliquidWhales
+          }
+        };
+      }
     });
     const core = await createCore({
       userName,
@@ -10510,7 +11098,7 @@ var createStrategyRuntime = ({
       strategyApi,
       indicatorsState,
       sharedReplayKey: strategySharedReplayKey,
-      getSharedReplayState: import_strategies4.getSharedStrategyReplayState
+      getSharedReplayState: import_strategies5.getSharedStrategyReplayState
     });
     await invokeStageHooks("onInit", strategyManifest?.hooks?.onInit, {
       ctx: getHookCtx(),
@@ -11056,7 +11644,7 @@ var createStrategyRuntime = ({
 
 // src/strategyHooks/closeOppositePositionsBeforeOpen.ts
 var import_lodash2 = __toESM(require_lodash());
-var import_logger9 = require("@tradejs/infra/logger");
+var import_logger10 = require("@tradejs/infra/logger");
 var closeOppositePositionsBeforeOpen = async ({
   connector,
   entryContext
@@ -11070,7 +11658,7 @@ var closeOppositePositionsBeforeOpen = async ({
   } = entryContext;
   const price = prices.currentPrice;
   try {
-    import_logger9.logger.log(
+    import_logger10.logger.log(
       "info",
       "[%s] checking open positions before open: %s %s",
       strategyName,
@@ -11081,7 +11669,7 @@ var closeOppositePositionsBeforeOpen = async ({
     const openPositions = (positions || []).filter(
       (item) => item && Number(item.qty) > 0
     );
-    import_logger9.logger.log(
+    import_logger10.logger.log(
       "info",
       "[%s] open positions found: %s",
       strategyName,
@@ -11091,7 +11679,7 @@ var closeOppositePositionsBeforeOpen = async ({
       (item) => item.symbol !== currentSymbol && item.direction !== currentDirection
     );
     if (import_lodash2.default.isEmpty(oppositePositions)) {
-      import_logger9.logger.log(
+      import_logger10.logger.log(
         "info",
         "[%s] no opposite positions to close before open: %s",
         strategyName,
@@ -11100,7 +11688,7 @@ var closeOppositePositionsBeforeOpen = async ({
       return;
     }
     for (const position of oppositePositions) {
-      import_logger9.logger.log(
+      import_logger10.logger.log(
         "info",
         "[%s] closing opposite position: %s %s qty=%s",
         strategyName,
@@ -11115,14 +11703,14 @@ var closeOppositePositionsBeforeOpen = async ({
           timestamp,
           direction: position.direction
         });
-        import_logger9.logger.log(
+        import_logger10.logger.log(
           "info",
           "[%s] opposite position closed: %s",
           strategyName,
           position.symbol
         );
       } catch (err) {
-        import_logger9.logger.log(
+        import_logger10.logger.log(
           "error",
           "[%s] failed to close opposite position: %s %s",
           strategyName,
@@ -11132,7 +11720,7 @@ var closeOppositePositionsBeforeOpen = async ({
       }
     }
   } catch (err) {
-    import_logger9.logger.log(
+    import_logger10.logger.log(
       "error",
       "[%s] failed to load open positions before open: %s %s",
       strategyName,
@@ -11344,7 +11932,7 @@ var createMoveStopToBreakEvenOnBarHook = ({
 var createMoveStopToBreakEvenAfterCoreDecisionHook = createMoveStopToBreakEvenOnBarHook;
 
 // src/signalsHooks/closeAllPositionsOnGlobalProfitBeforeSignals.ts
-var import_logger10 = require("@tradejs/infra/logger");
+var import_logger11 = require("@tradejs/infra/logger");
 var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   getStrategyDefaultConfig = () => void 0,
   profitRiskMultiplier = DEFAULT_GLOBAL_UNREALIZED_PNL_TRIGGER_RISK_MULTIPLIER
@@ -11383,7 +11971,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
     if (!Number.isFinite(unrealizedPnlThreshold) || unrealizedPnlThreshold <= 0 || totalUnrealizedPnl < unrealizedPnlThreshold) {
       return;
     }
-    import_logger10.logger.info(
+    import_logger11.logger.info(
       "closing all positions before signals by global unrealized pnl threshold: totalPnl=%s threshold=%s positions=%s",
       totalUnrealizedPnl,
       unrealizedPnlThreshold,
@@ -11409,7 +11997,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
       ];
     });
     if (failedClosures.length) {
-      import_logger10.logger.warn(
+      import_logger11.logger.warn(
         "close-all before signals hook could not confirm closures for %s",
         failedClosures.join(", ")
       );
@@ -11441,6 +12029,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   enrichSignalWithAi,
   enrichSignalWithBinanceMarketContext,
   enrichSignalWithCoinMarketCapContext,
+  enrichSignalWithHyperliquidWhaleContext,
   enrichSignalWithMl,
   enrichSignalWithMlAi,
   ensureAiStrategyPluginsLoaded,
@@ -11451,6 +12040,10 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   getBinanceBreadthUniverseSnapshot,
   getBinanceBreadthUniverses,
   getDeterministicAiGateContext,
+  getHyperliquidPerpSymbols,
+  getHyperliquidPerpUniverseSnapshot,
+  getHyperliquidWhaleAddresses,
+  getHyperliquidWhaleRegistrySnapshot,
   getOpenRouterModelKwargs,
   getOrderArrivalSnapshot,
   getPrimaryBinanceBreadthUniverse,
@@ -11459,9 +12052,12 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   getStrategyCreator,
   getStrategyManifest,
   isKnownStrategy,
+  isTrackedHyperliquidPerp,
+  isTrackedHyperliquidWhale,
   registerStrategyEntries,
   resetAiRuntimeCache,
   resetStrategyRegistryCache,
+  resolveHyperliquidPerpFromSignalSymbol,
   resolveStrategyConfig,
   runAiPrompt,
   runAiPromptLocal,