@tradejs/cli 1.0.9 → 1.0.10

package/dist/scripts/binanceMarketIngest.js

@@ -0,0 +1,565 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/binanceMarketIngest.ts
+var binanceMarketIngest_exports = {};
+__export(binanceMarketIngest_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(binanceMarketIngest_exports);
+var import_config = require("dotenv/config");
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+var import_connectors = require("@tradejs/connectors");
+var import_timescale = require("@tradejs/infra/timescale");
+
+// src/lib/binanceMarketData.ts
+var MARKET_FEATURE_INTERVAL_MS = {
+  "1m": 6e4,
+  "5m": 3e5,
+  "15m": 9e5,
+  "1h": 36e5
+};
+var STABLE_QUOTE_SYMBOLS = /* @__PURE__ */ new Set([
+  "USDCUSDT",
+  "FDUSDUSDT",
+  "TUSDUSDT",
+  "BUSDUSDT",
+  "USDPUSDT",
+  "DAIUSDT"
+]);
+var safeDivide = (num, den) => Number.isFinite(num) && Number.isFinite(den) && den !== 0 ? num / den : null;
+var mean = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
+var standardDeviation = (values) => {
+  const avg = mean(values);
+  if (avg == null || values.length < 2) return null;
+  const variance = values.reduce((sum, value) => sum + (value - avg) ** 2, 0) / values.length;
+  return Math.sqrt(variance);
+};
+var buildPrefixSum = (values) => {
+  const prefix = [0];
+  for (const value of values) prefix.push(prefix[prefix.length - 1] + value);
+  return prefix;
+};
+var sumPrefixRange = (prefix, startIndex, endIndexInclusive) => {
+  if (endIndexInclusive < startIndex) return 0;
+  const start = Math.max(0, startIndex);
+  const end = Math.min(prefix.length - 2, endIndexInclusive);
+  if (end < start) return 0;
+  return prefix[end + 1] - prefix[start];
+};
+var windowReturn = (candles, index, lookbackBars) => {
+  const previous = candles[index - lookbackBars];
+  const current = candles[index];
+  return previous && previous.close > 0 ? (current.close - previous.close) / previous.close : null;
+};
+var classifyBtcAltRegime = ({
+  btcReturn24h,
+  altBasketReturn24h,
+  btcVsAltReturn24h
+}) => {
+  if (btcReturn24h == null || altBasketReturn24h == null || btcVsAltReturn24h == null) {
+    return "unknown";
+  }
+  if (btcReturn24h < -0.015 && altBasketReturn24h < -0.025) {
+    return "risk_off";
+  }
+  if (btcReturn24h > 5e-3 && altBasketReturn24h > 5e-3 && altBasketReturn24h > btcReturn24h) {
+    return "risk_on";
+  }
+  if (btcVsAltReturn24h > 5e-3) return "btc_lead";
+  if (btcVsAltReturn24h < -5e-3) return "alt_lead";
+  return "neutral";
+};
+var normalizeMarketFeatureInterval = (value) => {
+  const normalized = String(value || "15m").trim().toLowerCase();
+  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "5" || normalized === "5m") return "5m";
+  if (normalized === "15" || normalized === "15m") return "15m";
+  if (normalized === "60" || normalized === "1h") return "1h";
+  return "15m";
+};
+var normalizeBinanceSymbols = (value) => String(value || "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+var selectBreadthUniverseFromTickers = (tickers, limit) => tickers.filter(
+  (ticker) => ticker.symbol.endsWith("USDT") && ticker.symbol !== "BTCUSDT" && !STABLE_QUOTE_SYMBOLS.has(ticker.symbol) && Number.isFinite(ticker.turnover24h) && ticker.turnover24h > 0
+).sort((a, b) => b.turnover24h - a.turnover24h).slice(0, Math.max(0, limit)).map((ticker) => ticker.symbol);
+var estimateBinanceMarketDataVolume = ({
+  symbols,
+  days,
+  interval,
+  includeAggTrades,
+  includeBreadth,
+  breadthLimit
+}) => {
+  const intervalMs = MARKET_FEATURE_INTERVAL_MS[interval];
+  const bucketRowsPerSymbol = Math.ceil(days * 864e5 / intervalMs);
+  const aggTradeBucketRows = includeAggTrades ? symbols.length * bucketRowsPerSymbol : 0;
+  const breadthSymbols = includeBreadth ? Math.max(0, breadthLimit) : 0;
+  const breadthCandleRows = breadthSymbols * bucketRowsPerSymbol;
+  const breadthRows = includeBreadth ? bucketRowsPerSymbol : 0;
+  return {
+    interval,
+    days,
+    symbols: symbols.length,
+    bucketRowsPerSymbol,
+    aggTradeBucketRows,
+    breadthSymbols,
+    breadthCandleRows,
+    breadthRows,
+    estimatedStoredRows: aggTradeBucketRows + breadthRows
+  };
+};
+var aggregateAggTradesToRows = ({
+  symbol,
+  interval,
+  trades,
+  source = "binance_agg_trades"
+}) => {
+  const intervalMs = MARKET_FEATURE_INTERVAL_MS[interval];
+  const buckets = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const bucketTs = Math.floor(trade.timestamp / intervalMs) * intervalMs;
+    const row = buckets.get(bucketTs) ?? {
+      symbol,
+      interval,
+      ts: new Date(bucketTs),
+      trades: 0,
+      buyBaseVolume: 0,
+      sellBaseVolume: 0,
+      buyQuoteVolume: 0,
+      sellQuoteVolume: 0,
+      netBaseDelta: 0,
+      netQuoteDelta: 0,
+      buyPressurePct: null,
+      source
+    };
+    const quote = trade.price * trade.quantity;
+    const isAggressiveSell = trade.isBuyerMaker;
+    row.trades += 1;
+    if (isAggressiveSell) {
+      row.sellBaseVolume = (row.sellBaseVolume ?? 0) + trade.quantity;
+      row.sellQuoteVolume = (row.sellQuoteVolume ?? 0) + quote;
+    } else {
+      row.buyBaseVolume = (row.buyBaseVolume ?? 0) + trade.quantity;
+      row.buyQuoteVolume = (row.buyQuoteVolume ?? 0) + quote;
+    }
+    row.netBaseDelta = (row.buyBaseVolume ?? 0) - (row.sellBaseVolume ?? 0);
+    row.netQuoteDelta = (row.buyQuoteVolume ?? 0) - (row.sellQuoteVolume ?? 0);
+    row.buyPressurePct = safeDivide(
+      row.buyBaseVolume ?? 0,
+      (row.buyBaseVolume ?? 0) + (row.sellBaseVolume ?? 0)
+    );
+    buckets.set(bucketTs, row);
+  }
+  return [...buckets.values()].sort((a, b) => a.ts.getTime() - b.ts.getTime());
+};
+var buildMarketBreadthRows = ({
+  universe,
+  interval,
+  candlesBySymbol,
+  btcCandles,
+  source = "binance_klines"
+}) => {
+  const timestamps = /* @__PURE__ */ new Set();
+  const indexedSymbols = Object.values(candlesBySymbol).map((candles) => ({
+    candles,
+    byTimestamp: new Map(
+      candles.map((candle, index) => [candle.timestamp, index])
+    ),
+    turnoverPrefix: buildPrefixSum(
+      candles.map((candle) => Math.max(0, candle.turnover ?? 0))
+    ),
+    closePrefix: buildPrefixSum(candles.map((candle) => candle.close))
+  }));
+  const btcIndexed = btcCandles ? {
+    candles: btcCandles,
+    byTimestamp: new Map(
+      btcCandles.map((candle, index) => [candle.timestamp, index])
+    ),
+    turnoverPrefix: buildPrefixSum(
+      btcCandles.map((candle) => Math.max(0, candle.turnover ?? 0))
+    )
+  } : null;
+  const intervalMs = MARKET_FEATURE_INTERVAL_MS[interval];
+  const bars1h = Math.max(1, Math.round(36e5 / intervalMs));
+  const bars4h = Math.max(1, Math.round(144e5 / intervalMs));
+  const bars24h = Math.max(1, Math.round(864e5 / intervalMs));
+  for (const candles of Object.values(candlesBySymbol)) {
+    for (const candle of candles) timestamps.add(candle.timestamp);
+  }
+  return [...timestamps].sort((a, b) => a - b).map((timestamp) => {
+    const returns = [];
+    const weightedReturns = [];
+    let advancers = 0;
+    let decliners = 0;
+    let unchanged = 0;
+    let aboveMa20 = 0;
+    let aboveMa20Eligible = 0;
+    let aboveMa50 = 0;
+    let aboveMa50Eligible = 0;
+    const altReturns1h = [];
+    const altReturns4h = [];
+    const altReturns24h = [];
+    let altTurnover1h = 0;
+    let altTurnover24h = 0;
+    let previousAltTurnover24h = 0;
+    for (const indexed of indexedSymbols) {
+      const { candles, byTimestamp, turnoverPrefix, closePrefix } = indexed;
+      const index = byTimestamp.get(timestamp);
+      if (index == null) continue;
+      const candle = candles[index];
+      const previous = candles[index - 1];
+      const ret = previous && previous.close > 0 ? (candle.close - previous.close) / previous.close : 0;
+      if (ret > 0) advancers += 1;
+      else if (ret < 0) decliners += 1;
+      else unchanged += 1;
+      returns.push(ret);
+      weightedReturns.push({
+        value: ret,
+        weight: Math.max(0, candle.turnover ?? 0)
+      });
+      const ma20Start = index - 19;
+      if (ma20Start >= 0) {
+        aboveMa20Eligible += 1;
+        const ma20 = sumPrefixRange(closePrefix, ma20Start, index) / 20;
+        if (candle.close > ma20) aboveMa20 += 1;
+      }
+      const ma50Start = index - 49;
+      if (ma50Start >= 0) {
+        aboveMa50Eligible += 1;
+        const ma50 = sumPrefixRange(closePrefix, ma50Start, index) / 50;
+        if (candle.close > ma50) aboveMa50 += 1;
+      }
+      const altReturn1h = windowReturn(candles, index, bars1h);
+      const altReturn4h = windowReturn(candles, index, bars4h);
+      const altReturn24h = windowReturn(candles, index, bars24h);
+      if (altReturn1h != null) altReturns1h.push(altReturn1h);
+      if (altReturn4h != null) altReturns4h.push(altReturn4h);
+      if (altReturn24h != null) altReturns24h.push(altReturn24h);
+      altTurnover1h += sumPrefixRange(
+        turnoverPrefix,
+        index - bars1h + 1,
+        index
+      );
+      altTurnover24h += sumPrefixRange(
+        turnoverPrefix,
+        index - bars24h + 1,
+        index
+      );
+      previousAltTurnover24h += sumPrefixRange(
+        turnoverPrefix,
+        index - bars24h * 2 + 1,
+        index - bars24h
+      );
+    }
+    const weightSum = weightedReturns.reduce(
+      (sum, item) => sum + item.weight,
+      0
+    );
+    const volumeWeightedReturn = weightSum > 0 ? weightedReturns.reduce(
+      (sum, item) => sum + item.value * item.weight,
+      0
+    ) / weightSum : null;
+    const btcIndex = btcIndexed?.byTimestamp.get(timestamp);
+    const btcReturn1h = btcIndexed && btcIndex != null ? windowReturn(btcIndexed.candles, btcIndex, bars1h) : null;
+    const btcReturn4h = btcIndexed && btcIndex != null ? windowReturn(btcIndexed.candles, btcIndex, bars4h) : null;
+    const btcReturn24h = btcIndexed && btcIndex != null ? windowReturn(btcIndexed.candles, btcIndex, bars24h) : null;
+    const btcTurnover1h = btcIndexed && btcIndex != null ? sumPrefixRange(
+      btcIndexed.turnoverPrefix,
+      btcIndex - bars1h + 1,
+      btcIndex
+    ) : null;
+    const btcTurnover24h = btcIndexed && btcIndex != null ? sumPrefixRange(
+      btcIndexed.turnoverPrefix,
+      btcIndex - bars24h + 1,
+      btcIndex
+    ) : null;
+    const previousBtcTurnover24h = btcIndexed && btcIndex != null ? sumPrefixRange(
+      btcIndexed.turnoverPrefix,
+      btcIndex - bars24h * 2 + 1,
+      btcIndex - bars24h
+    ) : null;
+    const altBasketReturn1h = mean(altReturns1h);
+    const altBasketReturn4h = mean(altReturns4h);
+    const altBasketReturn24h = mean(altReturns24h);
+    const btcVsAltReturn1h = btcReturn1h == null || altBasketReturn1h == null ? null : btcReturn1h - altBasketReturn1h;
+    const btcVsAltReturn4h = btcReturn4h == null || altBasketReturn4h == null ? null : btcReturn4h - altBasketReturn4h;
+    const btcVsAltReturn24h = btcReturn24h == null || altBasketReturn24h == null ? null : btcReturn24h - altBasketReturn24h;
+    const btcTurnoverShare1h = btcTurnover1h == null ? null : safeDivide(btcTurnover1h, btcTurnover1h + altTurnover1h);
+    const btcTurnoverShare24h = btcTurnover24h == null ? null : safeDivide(btcTurnover24h, btcTurnover24h + altTurnover24h);
+    const previousBtcTurnoverShare24h = previousBtcTurnover24h == null ? null : safeDivide(
+      previousBtcTurnover24h,
+      previousBtcTurnover24h + previousAltTurnover24h
+    );
+    const btcTurnoverShareChange24h = btcTurnoverShare24h == null || previousBtcTurnoverShare24h == null ? null : btcTurnoverShare24h - previousBtcTurnoverShare24h;
+    return {
+      universe,
+      interval,
+      ts: new Date(timestamp),
+      symbolsCount: returns.length,
+      advancers,
+      decliners,
+      unchanged,
+      advanceDeclineRatio: safeDivide(advancers, decliners || 1),
+      pctAboveMa20: safeDivide(aboveMa20, aboveMa20Eligible),
+      pctAboveMa50: safeDivide(aboveMa50, aboveMa50Eligible),
+      equalWeightedReturn: mean(returns),
+      volumeWeightedReturn,
+      dispersion: standardDeviation(returns),
+      btcReturn1h,
+      btcReturn4h,
+      btcReturn24h,
+      altBasketReturn1h,
+      altBasketReturn4h,
+      altBasketReturn24h,
+      btcVsAltReturn1h,
+      btcVsAltReturn4h,
+      btcVsAltReturn24h,
+      btcTurnoverShare1h,
+      btcTurnoverShare24h,
+      btcTurnoverShareChange24h,
+      altVolToBtcVol24h: btcTurnover24h == null ? null : safeDivide(altTurnover24h, btcTurnover24h),
+      altDispersion24h: standardDeviation(altReturns24h),
+      btcAltRegime: classifyBtcAltRegime({
+        btcReturn24h,
+        altBasketReturn24h,
+        btcVsAltReturn24h
+      }),
+      source
+    };
+  }).filter((row) => row.symbolsCount > 0);
+};
+
+// src/scripts/binanceMarketIngest.ts
+import_args.default.example(
+  "yarn cli:node8g binance:market-ingest --all --symbols BTCUSDT,ETHUSDT --days 0.05 --interval 1m --write",
+  "Ingest Binance public market breadth and historical aggTrades buckets"
+);
+import_args.default.option(
+  ["s", "symbols"],
+  "Comma-separated target symbols",
+  "BTCUSDT,ETHUSDT"
+);
+import_args.default.option(["i", "interval"], "Aggregation interval: 1m,5m,15m,1h", "1m");
+import_args.default.option(["d", "days"], "Lookback window in days", "1");
+import_args.default.option(["h", "hours"], "Lookback window in hours; overrides --days");
+import_args.default.option(["a", "aggTrades"], "Fetch and bucket Binance aggTrades");
+import_args.default.option(
+  ["b", "breadth"],
+  "Build alt-basket market breadth from Binance klines"
+);
+import_args.default.option(["A", "all"], "Enable aggTrades and breadth");
+import_args.default.option(
+  ["w", "write"],
+  "Write rows to Timescale; without this flag only estimate"
+);
+import_args.default.option(
+  ["B", "breadthLimit"],
+  "Top USDT symbols used for breadth universe",
+  30
+);
+import_args.default.option(
+  ["M", "batchMinutes"],
+  "aggTrades request window size in minutes",
+  15
+);
+import_args.default.option(
+  ["r", "requestDelayMs"],
+  "Delay between Binance aggTrades requests",
+  75
+);
+var flags = import_args.default.parse(process.argv);
+var asFloat = (value, fallback) => {
+  const parsed = Number.parseFloat(String(value ?? ""));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+var intervalToConnectorInterval = (interval) => {
+  if (interval === "1m") return "1";
+  if (interval === "5m") return "5";
+  if (interval === "15m") return "15";
+  return "60";
+};
+var fetchAggTradesForWindow = async ({
+  connector,
+  symbol,
+  fromMs,
+  toMs,
+  batchMinutes,
+  requestDelayMs
+}) => {
+  if (!connector.getAggTrades) return [];
+  const rows = [];
+  const batchMs = Math.max(1, batchMinutes) * 6e4;
+  let cursor = fromMs;
+  while (cursor <= toMs) {
+    const endTime = Math.min(toMs, cursor + batchMs - 1);
+    let pageCursor = cursor;
+    while (pageCursor <= endTime) {
+      const page = await connector.getAggTrades({
+        symbol,
+        startTime: pageCursor,
+        endTime,
+        limit: 1e3
+      });
+      if (!page.length) break;
+      rows.push(...page);
+      const lastTs = page[page.length - 1]?.timestamp;
+      if (page.length < 1e3 || !Number.isFinite(lastTs)) break;
+      const nextCursor = Math.max(pageCursor + 1, Number(lastTs) + 1);
+      if (nextCursor > endTime) break;
+      pageCursor = nextCursor;
+      await sleep(requestDelayMs);
+    }
+    cursor = endTime + 1;
+    await sleep(requestDelayMs);
+  }
+  return rows;
+};
+var printEstimate = (estimate) => {
+  console.log(import_chalk.default.cyan("Binance market ingest estimate"));
+  console.log(`interval: ${estimate.interval}`);
+  console.log(`days: ${estimate.days}`);
+  console.log(`target symbols: ${estimate.symbols}`);
+  console.log(`bucket rows/symbol: ${estimate.bucketRowsPerSymbol}`);
+  console.log(`aggTrades bucket rows: ${estimate.aggTradeBucketRows}`);
+  console.log(`breadth symbols: ${estimate.breadthSymbols}`);
+  console.log(`breadth candle reads: ${estimate.breadthCandleRows}`);
+  console.log(`breadth rows: ${estimate.breadthRows}`);
+  console.log(`estimated stored rows: ${estimate.estimatedStoredRows}`);
+};
+var main = async () => {
+  const symbols = normalizeBinanceSymbols(flags.symbols);
+  const interval = normalizeMarketFeatureInterval(flags.interval);
+  const hours = flags.hours == null ? null : asFloat(flags.hours, 0);
+  const days = hours != null && hours > 0 ? hours / 24 : asFloat(flags.days, 1);
+  const breadthLimit = asInt(flags.breadthLimit, 30);
+  const batchMinutes = asInt(flags.batchMinutes, 15);
+  const requestDelayMs = asInt(flags.requestDelayMs, 75);
+  const includeAll = Boolean(flags.all);
+  const includeAggTrades = includeAll || Boolean(flags.aggTrades);
+  const includeBreadth = includeAll || Boolean(flags.breadth);
+  const anyMode = includeAggTrades || includeBreadth;
+  const modes = {
+    includeAggTrades: anyMode ? includeAggTrades : true,
+    includeBreadth: anyMode ? includeBreadth : true
+  };
+  if (!symbols.length) throw new Error("No symbols provided");
+  const estimate = estimateBinanceMarketDataVolume({
+    symbols,
+    days,
+    interval,
+    includeAggTrades: modes.includeAggTrades,
+    includeBreadth: modes.includeBreadth,
+    breadthLimit
+  });
+  printEstimate(estimate);
+  if (!flags.write) {
+    console.log(import_chalk.default.yellow("Dry run only. Pass --write to ingest."));
+    return;
+  }
+  await (0, import_timescale.waitForDbReady)();
+  const connector = await import_connectors.connectors[import_connectors.ConnectorNames.Binance]({
+    userName: "root"
+  });
+  const toMs = Math.floor(Date.now() / MARKET_FEATURE_INTERVAL_MS[interval]) * MARKET_FEATURE_INTERVAL_MS[interval];
+  const fromMs = toMs - days * 864e5;
+  let aggTradesRaw = 0;
+  let tradeFlowRows = 0;
+  let breadthRows = 0;
+  let breadthCandleRows = 0;
+  if (modes.includeAggTrades) {
+    for (const symbol of symbols) {
+      process.stdout.write(import_chalk.default.cyan(`aggTrades ${symbol}... `));
+      const trades = await fetchAggTradesForWindow({
+        connector,
+        symbol,
+        fromMs,
+        toMs,
+        batchMinutes,
+        requestDelayMs
+      });
+      const rows = aggregateAggTradesToRows({ symbol, interval, trades });
+      await (0, import_timescale.upsertMarketTradeFlowRows)(rows);
+      aggTradesRaw += trades.length;
+      tradeFlowRows += rows.length;
+      process.stdout.write(
+        `${trades.length} trades -> ${rows.length} buckets
+`
+      );
+    }
+  }
+  if (modes.includeBreadth) {
+    const tickers = await connector.getTickers();
+    const breadthSymbols = selectBreadthUniverseFromTickers(
+      tickers,
+      breadthLimit
+    );
+    const connectorInterval = intervalToConnectorInterval(interval);
+    const candlesBySymbol = {};
+    for (const symbol of breadthSymbols) {
+      process.stdout.write(import_chalk.default.cyan(`breadth candles ${symbol}... `));
+      const candles = await connector.kline({
+        symbol,
+        interval: connectorInterval,
+        start: fromMs,
+        end: toMs,
+        silent: true
+      });
+      candlesBySymbol[symbol] = candles;
+      breadthCandleRows += candles.length;
+      process.stdout.write(`${candles.length}
+`);
+    }
+    const universe = `binance_top${breadthSymbols.length}_usdt`;
+    const rows = buildMarketBreadthRows({
+      universe,
+      interval,
+      candlesBySymbol
+    });
+    await (0, import_timescale.upsertMarketBreadthRows)(rows);
+    breadthRows += rows.length;
+  }
+  console.log(import_chalk.default.green("Binance market ingest done"));
+  console.log(`aggTrades raw rows: ${aggTradesRaw}`);
+  console.log(`trade-flow bucket rows: ${tradeFlowRows}`);
+  console.log(`breadth candle rows read: ${breadthCandleRows}`);
+  console.log(`breadth rows: ${breadthRows}`);
+  console.log(
+    `stored rows: ${tradeFlowRows + breadthRows} (raw aggTrades are not stored)`
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/dist/scripts/bot.js

@@ -5,6 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -21,8 +25,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/scripts/bot.ts
+var bot_exports = {};
+__export(bot_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(bot_exports);
 var import_config = require("dotenv/config");
 
 // src/lib/runBot.ts
@@ -128,6 +138,7 @@ var runBot = async () => {
         const btcCandle = btcData.pop();
         const strategy = await strategyCreator({
           userName,
+          connectorName,
           config: strategyConfig,
           symbol,
           data,
@@ -155,8 +166,11 @@ var runBot = async () => {
 };
 
 // src/scripts/bot.ts
-var run = async () => {
+var main = async () => {
   await runBot();
   process.exit();
 };
-run();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/dist/scripts/candlesMigrateProvider.js

@@ -8,6 +8,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -24,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/postgres-array/index.js
 var require_postgres_array = __commonJS({
@@ -4957,6 +4962,11 @@ var require_lib2 = __commonJS({
 });
 
 // src/scripts/candlesMigrateProvider.ts
+var candlesMigrateProvider_exports = {};
+__export(candlesMigrateProvider_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(candlesMigrateProvider_exports);
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -5276,27 +5286,27 @@ var printProgress = (message) => {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
   console.log(import_chalk.default.gray(`[${timestamp}] ${message}`));
 };
-var run = async () => {
-  printProgress(
-    `Start candles provider migration for ${String(flags.schema || "public")}.${String(
-      flags.table || "candles"
-    )}${flags["dry-run"] ? " (dry-run)" : ""}`
-  );
-  const summary = await runCandlesProviderMigration(pool, {
-    schema: String(flags.schema || "public"),
-    table: String(flags.table || "candles"),
-    dryRun: Boolean(flags["dry-run"]),
-    recompress: !Boolean(flags["skip-recompress"]),
-    keepPolicyPaused: Boolean(flags["keep-policy-paused"]),
-    onProgress: printProgress
-  });
-  printSummary(summary);
+var main = async () => {
+  try {
+    printProgress(
+      `Start candles provider migration for ${String(flags.schema || "public")}.${String(
+        flags.table || "candles"
+      )}${flags["dry-run"] ? " (dry-run)" : ""}`
+    );
+    const summary = await runCandlesProviderMigration(pool, {
+      schema: String(flags.schema || "public"),
+      table: String(flags.table || "candles"),
+      dryRun: Boolean(flags["dry-run"]),
+      recompress: !Boolean(flags["skip-recompress"]),
+      keepPolicyPaused: Boolean(flags["keep-policy-paused"]),
+      onProgress: printProgress
+    });
+    printSummary(summary);
+  } finally {
+    await pool.end().catch(() => void 0);
+  }
 };
-run().catch((error) => {
-  console.error(
-    import_chalk.default.red(`candles:migrate-provider failed: ${String(error)}`)
-  );
-  process.exitCode = 1;
-}).finally(async () => {
-  await pool.end().catch(() => void 0);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
 });