bandkit 1.0.1 → 1.0.3

package/scripts/test-decision-stream.cjs

@@ -0,0 +1,417 @@
+/* eslint-disable */
+//
+// test-decision-stream.cjs
+//
+// Standalone Node script that streams live Binance ETH/USDT order book + trades
+// and Coinbase ETH-USD ticker, and runs the same decision logic as
+// src/decisionEngine.ts. Prints live decisions; after the run window,
+// prints a summary tally and a diagnostic signal-vs-forward-price comparison.
+//
+// IMPORTANT — what this proves and does NOT prove:
+//   - It DOES verify the decision logic responds to live data without crashing.
+//   - It DOES show the cadence and balance of signals.
+//   - It DOES report a crude correlation between BUY/SELL signals and the
+//     next minute's price change.
+//   - It DOES NOT prove the strategy is profitable.
+//     Real validation needs months of historical data, realistic slippage and
+//     gas modelling, out-of-sample windows, and statistical significance tests.
+//
+// Usage:
+//   node scripts/test-decision-stream.cjs [durationMinutes]
+//   default duration: 7 minutes
+//
+
+const WebSocket = require("ws");
+
+const DURATION_MIN = Number(process.argv[2] ?? 7);
+const BINANCE_DEPTH_URL = "wss://stream.binance.com:9443/ws/ethusdt@depth20@100ms";
+const BINANCE_TRADE_URL = "wss://stream.binance.com:9443/ws/ethusdt@trade";
+const COINBASE_URL = "wss://ws-feed.exchange.coinbase.com";
+
+// ---- State ----------------------------------------------------------------
+const state = {
+  binanceBook: { bids: [], asks: [], midPrice: null, spreadPct: null, ts: 0 },
+  coinbaseMid: null,
+  recentTrades: [], // { price, size, side, ts }
+  priceTicks: [], // for volatility regime
+  decisions: [], // { at, decision, confidence, midPrice, reasons }
+  startedAt: Date.now()
+};
+
+const PRICE_TICK_WINDOW = 60;
+const FLOW_WINDOW_MS = 60_000;
+const EVAL_INTERVAL_MS = 2000;
+const FORWARD_PRICE_DELAY_MS = 60_000;
+
+// ---- Decision logic (mirrors src/decisionEngine.ts) ----------------------
+function computeBookImbalance(bids, asks, mid, withinPct = 0.005) {
+  const lo = mid * (1 - withinPct);
+  const hi = mid * (1 + withinPct);
+  let bidSum = 0;
+  let askSum = 0;
+  for (const b of bids) if (b.price >= lo) bidSum += b.size;
+  for (const a of asks) if (a.price <= hi) askSum += a.size;
+  const total = bidSum + askSum;
+  return total > 0 ? (bidSum - askSum) / total : 0;
+}
+
+function computeBookDepth(bids, asks, mid, withinPct = 0.005) {
+  const lo = mid * (1 - withinPct);
+  const hi = mid * (1 + withinPct);
+  let total = 0;
+  for (const b of bids) if (b.price >= lo) total += b.size;
+  for (const a of asks) if (a.price <= hi) total += a.size;
+  return total;
+}
+
+function computeTradeImbalance(trades, windowMs, nowMs) {
+  const cutoff = nowMs - windowMs;
+  let buyVol = 0;
+  let sellVol = 0;
+  for (const t of trades) {
+    if (t.ts < cutoff) continue;
+    if (t.side === "buy") buyVol += t.size;
+    else sellVol += t.size;
+  }
+  const total = buyVol + sellVol;
+  return total > 0 ? (buyVol - sellVol) / total : 0;
+}
+
+function classifyRegime(prices) {
+  if (prices.length < Math.max(8, Math.floor(PRICE_TICK_WINDOW / 4))) {
+    return { regime: "UNKNOWN", stddevPct: null, driftPct: null };
+  }
+  const mean = prices.reduce((s, v) => s + v, 0) / prices.length;
+  const variance = prices.reduce((s, v) => s + (v - mean) ** 2, 0) / prices.length;
+  const stddev = Math.sqrt(variance);
+  const stddevPct = mean > 0 ? (stddev / mean) * 100 : null;
+  const drift = prices[prices.length - 1] - prices[0];
+  const driftPct = mean > 0 ? (drift / mean) * 100 : null;
+  const absDriftPct = driftPct === null ? null : Math.abs(driftPct);
+
+  let regime = "MIXED";
+  if (stddevPct !== null && absDriftPct !== null) {
+    if (absDriftPct >= 0.45) regime = "TRENDING";
+    else if (stddevPct <= 0.15 && absDriftPct < 0.45) regime = "RANGING";
+  }
+  return { regime, stddevPct, driftPct };
+}
+
+function computeDecision(inputs) {
+  const reasons = [];
+  if (inputs.regime === "UNKNOWN") {
+    return { decision: "WAIT", confidence: 0, reasons: ["Warming up"] };
+  }
+  if (inputs.regime === "TRENDING") {
+    return {
+      decision: "STAND DOWN",
+      confidence: 90,
+      reasons: ["TRENDING regime — bot sits out"]
+    };
+  }
+
+  let scoreBuy = 0;
+  let scoreSell = 0;
+  let confidence = inputs.regime === "RANGING" ? 45 : 30;
+  reasons.push(`Regime: ${inputs.regime}`);
+
+  if (inputs.bookImbalance >= 0.15) {
+    scoreBuy += 25;
+    reasons.push(`Book +${(inputs.bookImbalance * 100).toFixed(0)}% bid`);
+  } else if (inputs.bookImbalance <= -0.15) {
+    scoreSell += 25;
+    reasons.push(`Book ${(inputs.bookImbalance * 100).toFixed(0)}% ask`);
+  } else {
+    reasons.push(`Book ${(inputs.bookImbalance * 100).toFixed(0)}%`);
+  }
+
+  if (inputs.tradeImbalance >= 0.10) {
+    scoreBuy += 20;
+    reasons.push(`Flow ${((0.5 + inputs.tradeImbalance / 2) * 100).toFixed(0)}% buys`);
+  } else if (inputs.tradeImbalance <= -0.10) {
+    scoreSell += 20;
+    reasons.push(`Flow ${((0.5 - inputs.tradeImbalance / 2) * 100).toFixed(0)}% sells`);
+  } else {
+    reasons.push("Flow balanced");
+  }
+
+  if (inputs.spreadPct > 0.05) {
+    confidence -= 10;
+    reasons.push(`Spread wide ${inputs.spreadPct.toFixed(3)}%`);
+  } else {
+    confidence += 5;
+  }
+
+  if (inputs.venueDivergenceBps !== null && Number.isFinite(inputs.venueDivergenceBps)) {
+    if (inputs.venueDivergenceBps > 5) {
+      scoreBuy += 12;
+      reasons.push(`BIN +${inputs.venueDivergenceBps.toFixed(1)}bps`);
+    } else if (inputs.venueDivergenceBps < -5) {
+      scoreSell += 12;
+      reasons.push(`BIN ${inputs.venueDivergenceBps.toFixed(1)}bps`);
+    }
+  }
+
+  if (inputs.bookDepth < 50) {
+    confidence -= 15;
+    reasons.push(`Thin book (${inputs.bookDepth.toFixed(0)} ETH)`);
+  } else {
+    confidence += 5;
+  }
+
+  let decision = "WAIT";
+  if (scoreBuy > scoreSell + 12) {
+    decision = "BUY";
+    confidence = Math.min(100, Math.max(0, confidence + scoreBuy));
+  } else if (scoreSell > scoreBuy + 12) {
+    decision = "SELL";
+    confidence = Math.min(100, Math.max(0, confidence + scoreSell));
+  } else {
+    confidence = Math.min(100, Math.max(0, confidence + Math.max(scoreBuy, scoreSell) / 2));
+  }
+
+  return { decision, confidence: Math.round(confidence), reasons };
+}
+
+// ---- WebSocket setup -----------------------------------------------------
+function connectBinanceDepth() {
+  const ws = new WebSocket(BINANCE_DEPTH_URL);
+  ws.on("message", (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+      const bids = (msg.bids || [])
+        .map(([p, q]) => ({ price: Number(p), size: Number(q) }))
+        .filter((l) => l.size > 0);
+      const asks = (msg.asks || [])
+        .map(([p, q]) => ({ price: Number(p), size: Number(q) }))
+        .filter((l) => l.size > 0);
+      const bestBid = bids[0]?.price ?? null;
+      const bestAsk = asks[0]?.price ?? null;
+      if (bestBid && bestAsk) {
+        const mid = (bestBid + bestAsk) / 2;
+        state.binanceBook = {
+          bids,
+          asks,
+          midPrice: mid,
+          spreadPct: ((bestAsk - bestBid) / mid) * 100,
+          ts: Date.now()
+        };
+        // Sample price tick (rate-limited)
+        if (
+          state.priceTicks.length === 0 ||
+          Date.now() - (state.priceTicks._lastSampleAt || 0) > 1000
+        ) {
+          state.priceTicks.push(mid);
+          if (state.priceTicks.length > PRICE_TICK_WINDOW) state.priceTicks.shift();
+          state.priceTicks._lastSampleAt = Date.now();
+        }
+      }
+    } catch (err) {
+      /* swallow parse */
+    }
+  });
+  ws.on("error", () => {});
+  ws.on("close", () => setTimeout(connectBinanceDepth, 3000));
+  return ws;
+}
+
+function connectBinanceTrades() {
+  const ws = new WebSocket(BINANCE_TRADE_URL);
+  ws.on("message", (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+      const trade = {
+        price: Number(msg.p),
+        size: Number(msg.q),
+        side: msg.m ? "sell" : "buy",
+        ts: Number(msg.T)
+      };
+      if (Number.isFinite(trade.price) && Number.isFinite(trade.size)) {
+        state.recentTrades.push(trade);
+        // Prune
+        const cutoff = Date.now() - FLOW_WINDOW_MS * 2;
+        while (state.recentTrades.length > 0 && state.recentTrades[0].ts < cutoff) {
+          state.recentTrades.shift();
+        }
+      }
+    } catch (err) {
+      /* swallow */
+    }
+  });
+  ws.on("error", () => {});
+  ws.on("close", () => setTimeout(connectBinanceTrades, 3000));
+  return ws;
+}
+
+function connectCoinbase() {
+  const ws = new WebSocket(COINBASE_URL);
+  ws.on("open", () => {
+    ws.send(
+      JSON.stringify({
+        type: "subscribe",
+        product_ids: ["ETH-USD"],
+        channels: ["ticker"]
+      })
+    );
+  });
+  ws.on("message", (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+      if (msg.type === "ticker" && msg.product_id === "ETH-USD") {
+        const bid = Number(msg.best_bid);
+        const ask = Number(msg.best_ask);
+        if (Number.isFinite(bid) && Number.isFinite(ask)) {
+          state.coinbaseMid = (bid + ask) / 2;
+        }
+      }
+    } catch (err) {
+      /* swallow */
+    }
+  });
+  ws.on("error", () => {});
+  ws.on("close", () => setTimeout(connectCoinbase, 3000));
+  return ws;
+}
+
+// ---- Main loop -----------------------------------------------------------
+function pad(s, n) {
+  s = String(s);
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+
+function evaluate() {
+  const mid = state.binanceBook.midPrice;
+  if (!mid) return;
+
+  const bookImbalance = computeBookImbalance(state.binanceBook.bids, state.binanceBook.asks, mid);
+  const bookDepth = computeBookDepth(state.binanceBook.bids, state.binanceBook.asks, mid);
+  const tradeImbalance = computeTradeImbalance(state.recentTrades, FLOW_WINDOW_MS, Date.now());
+  const { regime, stddevPct, driftPct } = classifyRegime(state.priceTicks);
+  const venueDivergenceBps =
+    state.coinbaseMid && state.coinbaseMid > 0
+      ? ((mid - state.coinbaseMid) / state.coinbaseMid) * 10000
+      : null;
+
+  const result = computeDecision({
+    regime,
+    bookImbalance,
+    tradeImbalance,
+    spreadPct: state.binanceBook.spreadPct ?? 0,
+    venueDivergenceBps,
+    bookDepth
+  });
+
+  const entry = {
+    at: Date.now(),
+    decision: result.decision,
+    confidence: result.confidence,
+    midPrice: mid,
+    reasons: result.reasons,
+    regime,
+    bookImbalance,
+    tradeImbalance,
+    venueDivergenceBps,
+    stddevPct,
+    driftPct
+  };
+  state.decisions.push(entry);
+
+  const elapsedSec = ((Date.now() - state.startedAt) / 1000).toFixed(0);
+  console.log(
+    `[t+${pad(elapsedSec, 4)}s] ${pad(result.decision, 11)} conf=${pad(result.confidence, 3)}` +
+      ` mid=${mid.toFixed(2)} regime=${pad(regime, 8)}` +
+      ` book=${pad((bookImbalance * 100).toFixed(0) + "%", 5)}` +
+      ` flow=${pad((tradeImbalance * 100).toFixed(0) + "%", 5)}` +
+      ` div=${venueDivergenceBps === null ? " — " : (venueDivergenceBps.toFixed(1) + "bps")}` +
+      `  ${result.reasons.slice(0, 3).join(", ")}`
+  );
+}
+
+function printSummary() {
+  console.log("\n" + "=".repeat(80));
+  console.log(`SUMMARY  (duration ${DURATION_MIN} min, ${state.decisions.length} evaluations)`);
+  console.log("=".repeat(80));
+
+  const tally = { BUY: 0, SELL: 0, WAIT: 0, "STAND DOWN": 0 };
+  const regimeTally = { RANGING: 0, MIXED: 0, TRENDING: 0, UNKNOWN: 0 };
+  for (const d of state.decisions) {
+    tally[d.decision]++;
+    regimeTally[d.regime]++;
+  }
+
+  console.log("\nDecision tally:");
+  for (const [k, v] of Object.entries(tally)) {
+    const pct = state.decisions.length > 0 ? ((v / state.decisions.length) * 100).toFixed(1) : "0.0";
+    console.log(`  ${pad(k, 12)}  ${pad(v, 5)}  (${pct}%)`);
+  }
+
+  console.log("\nRegime time-in-state:");
+  for (const [k, v] of Object.entries(regimeTally)) {
+    const pct = state.decisions.length > 0 ? ((v / state.decisions.length) * 100).toFixed(1) : "0.0";
+    console.log(`  ${pad(k, 12)}  ${pad(v, 5)}  (${pct}%)`);
+  }
+
+  // Forward-price diagnostic: for each BUY/SELL signal, look at the price
+  // ~60s later and tally whether it moved in the signal's favor.
+  const directional = state.decisions.filter((d) => d.decision === "BUY" || d.decision === "SELL");
+  let evaluated = 0;
+  let correct = 0;
+  let totalForwardBps = 0;
+  for (const d of directional) {
+    const targetTs = d.at + FORWARD_PRICE_DELAY_MS;
+    // find first decision at or after target
+    const futureIdx = state.decisions.findIndex((x) => x.at >= targetTs);
+    if (futureIdx === -1) continue;
+    const futurePrice = state.decisions[futureIdx].midPrice;
+    const moveBps = ((futurePrice - d.midPrice) / d.midPrice) * 10000;
+    evaluated++;
+    const signedMove = d.decision === "BUY" ? moveBps : -moveBps;
+    totalForwardBps += signedMove;
+    if (signedMove > 0) correct++;
+  }
+  console.log("\nDirectional diagnostic (60s-forward, NOT a profitability test):");
+  if (evaluated === 0) {
+    console.log("  no eligible directional signals with forward window");
+  } else {
+    const hitRate = ((correct / evaluated) * 100).toFixed(1);
+    const avgSignedBps = (totalForwardBps / evaluated).toFixed(2);
+    console.log(`  signals scored:        ${evaluated}`);
+    console.log(`  moved in our favour:   ${correct}  (${hitRate}%)`);
+    console.log(`  avg signed move:       ${avgSignedBps} bps`);
+    console.log(
+      `  ↳ baseline ~50% means no edge; small samples (<50) are noise; gas + slippage`
+    );
+    console.log(`     would eat anything below ~10 bps on Uniswap mainnet.`);
+  }
+
+  console.log("\nReminders:");
+  console.log("  - This verifies the logic responds. It does NOT prove profitability.");
+  console.log("  - Binance signals ≠ Uniswap fills. Cross-venue + AMM curves differ.");
+  console.log("  - Real validation needs months of historical data + walk-forward.\n");
+}
+
+// ---- Run ------------------------------------------------------------------
+console.log(`Starting decision stream test for ${DURATION_MIN} minutes…`);
+console.log(`Streams: Binance depth + trade (ETHUSDT), Coinbase ticker (ETH-USD)`);
+console.log(`Evaluating every ${EVAL_INTERVAL_MS}ms. Press Ctrl-C to abort.\n`);
+
+connectBinanceDepth();
+connectBinanceTrades();
+connectCoinbase();
+
+const evalTimer = setInterval(evaluate, EVAL_INTERVAL_MS);
+const stopAt = Date.now() + DURATION_MIN * 60_000;
+const stopTimer = setInterval(() => {
+  if (Date.now() >= stopAt) {
+    clearInterval(evalTimer);
+    clearInterval(stopTimer);
+    printSummary();
+    process.exit(0);
+  }
+}, 1000);
+
+process.on("SIGINT", () => {
+  console.log("\n\nAborted by user. Printing partial summary…");
+  printSummary();
+  process.exit(0);
+});