@tradejs/node 2.0.12 → 2.0.14

package/dist/backtest.js

@@ -46,11 +46,11 @@ __reExport(backtest_exports, require("@tradejs/core/backtest"), module.exports);
 var import_types = require("@tradejs/types");
 var import_indicators3 = require("@tradejs/core/indicators");
 var import_constants4 = require("@tradejs/core/constants");
-var import_strategies4 = require("@tradejs/core/strategies");
+var import_strategies5 = require("@tradejs/core/strategies");
 var import_time = require("@tradejs/core/time");
 var import_ai2 = require("@tradejs/infra/ai");
 var import_ml2 = require("@tradejs/infra/ml");
-var import_logger7 = require("@tradejs/infra/logger");
+var import_logger8 = require("@tradejs/infra/logger");
 
 // src/ai.ts
 var import_aiLanguages = require("@tradejs/infra/aiLanguages");
@@ -2457,6 +2457,558 @@ var enrichSignalWithDerivativesContext = 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_logger6 = require("@tradejs/infra/logger");
+
+// src/hyperliquidWhaleUniverse.ts
+var import_node_crypto2 = 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_crypto2.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 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_logger6.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/strategyAdapters/ml.ts
 var defaultMlAdapter = {
   normalizeStrategyConfig: (strategyConfig) => strategyConfig
@@ -2506,7 +3058,7 @@ var buildMlPayload = (payload) => {
 };
 
 // src/connectorsRegistry.ts
-var import_logger6 = require("@tradejs/infra/logger");
+var import_logger7 = require("@tradejs/infra/logger");
 var createConnectorRegistryState = () => ({
   connectorCreators: /* @__PURE__ */ new Map(),
   providerToConnectorName: /* @__PURE__ */ new Map(),
@@ -2558,7 +3110,7 @@ var normalizeProviders = (providers, connectorName) => {
 var registerProvider = (provider, connectorName, source, providerToConnectorName) => {
   const existing = providerToConnectorName.get(provider);
   if (existing && existing !== connectorName) {
-    import_logger6.logger.warn(
+    import_logger7.logger.warn(
       'Skip duplicate connector provider "%s" from %s: already mapped to %s',
       provider,
       source,
@@ -2571,11 +3123,11 @@ var registerProvider = (provider, connectorName, source, providerToConnectorName
 var registerEntry = (entry, source, state) => {
   const connectorName = String(entry?.name ?? "").trim();
   if (!connectorName) {
-    import_logger6.logger.warn("Skip connector entry without name from %s", source);
+    import_logger7.logger.warn("Skip connector entry without name from %s", source);
     return;
   }
   if (typeof entry.creator !== "function") {
-    import_logger6.logger.warn(
+    import_logger7.logger.warn(
       'Skip connector entry "%s" from %s: creator must be a function',
       connectorName,
       source
@@ -2587,7 +3139,7 @@ var registerEntry = (entry, source, state) => {
     state.connectorCreators
   );
   if (existingByName) {
-    import_logger6.logger.warn(
+    import_logger7.logger.warn(
       'Skip duplicate connector "%s" from %s: already registered as %s',
       connectorName,
       source,
@@ -2659,7 +3211,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           );
           const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
           if (!pluginDefinition) {
-            import_logger6.logger.warn(
+            import_logger7.logger.warn(
               'Skip connector plugin "%s": export { connectorEntries } is missing',
               moduleName
             );
@@ -2667,7 +3219,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           }
           registerEntries2(pluginDefinition.connectorEntries, moduleName, state);
         } catch (error) {
-          import_logger6.logger.warn(
+          import_logger7.logger.warn(
             'Failed to load connector plugin "%s": %s',
             moduleName,
             String(error)
@@ -2698,7 +3250,7 @@ var getConnectorCreatorByName = async (connectorName, cwd = getTradejsProjectCwd
 var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
 
 // src/testConnector.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_constants2 = require("@tradejs/core/constants");
 var import_backtest = require("@tradejs/core/backtest");
 var import_trade = require("@tradejs/core/trade");
@@ -3166,7 +3718,7 @@ var createTestConnector = (connector, context) => {
     },
     kline: async (options) => connector.kline(options),
     getResult: async () => {
-      const orderLogId = (0, import_node_crypto2.randomUUID)().slice(-12);
+      const orderLogId = (0, import_node_crypto3.randomUUID)().slice(-12);
       const fullStat = fastMode ? (0, import_backtest.calculateStatsFull)(positionLog) : null;
       return {
         stat: fullStat ? {
@@ -4140,7 +4692,7 @@ var prepareTestingData = async (params) => {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
   if (!binanceConnector || !coinbaseConnector) {
-    import_logger7.logger.warn(
+    import_logger8.logger.warn(
       "Binance/Coinbase connectors are unavailable. Reusing %s for BTC references.",
       connectorName
     );
@@ -4727,6 +5279,13 @@ var testing = async ({
           env: "BACKTEST"
         })
       );
+      await withTimeout(
+        "hyperliquid whale context",
+        enrichSignalWithHyperliquidWhaleContext({
+          signal,
+          env: "BACKTEST"
+        })
+      );
     }
     if (ml && signal && typeof signal !== "string" && signal.signalId) {
       const payload = buildMlPayload({
@@ -5152,6 +5711,13 @@ var testingGroupInSharedCandleLoop = async (tests) => {
             env: "BACKTEST"
           })
         );
+        await withTimeout(
+          "hyperliquid whale context",
+          enrichSignalWithHyperliquidWhaleContext({
+            signal,
+            env: "BACKTEST"
+          })
+        );
       }
       if (test.ml && signal && typeof signal !== "string" && signal.signalId) {
         const payload = buildMlPayload({
@@ -5262,8 +5828,8 @@ var testingGroupInSharedCandleLoop = async (tests) => {
     }
     return results;
   } finally {
-    (0, import_strategies4.releaseStrategyIndicatorsReplayCache)(sharedIndicatorsReplayKey);
-    (0, import_strategies4.releaseStrategyReplayCache)(sharedIndicatorsReplayKey);
+    (0, import_strategies5.releaseStrategyIndicatorsReplayCache)(sharedIndicatorsReplayKey);
+    (0, import_strategies5.releaseStrategyReplayCache)(sharedIndicatorsReplayKey);
   }
 };
 // Annotate the CommonJS export names for ESM import in node: