@tradejs/connectors 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1293 @@
+// src/ByBit/index.ts
+import _ from "lodash";
+import chalk from "chalk";
+import {
+  MARKET_CATEGORY as MARKET_CATEGORY2,
+  PRELOAD_FALLBACK_DAYS
+} from "@tradejs/core/constants";
+import { mergeData } from "@tradejs/core/data";
+import { toJson } from "@tradejs/core/json";
+import { round } from "@tradejs/core/math";
+import { normalizeTickerData } from "@tradejs/core/tickers";
+import { formatUnix as formatUnix2, getItemTimestamp, getTimestamp } from "@tradejs/core/time";
+import { logger as logger2 } from "@tradejs/infra/logger";
+import {
+  getCandlesRange,
+  getDataEdges,
+  upsertCandles,
+  toRows
+} from "@tradejs/infra/timescale";
+
+// src/ByBit/client.ts
+import { RestClientV5 } from "bybit-api";
+import { logger } from "@tradejs/infra/logger";
+import { getData, redisKeys } from "@tradejs/infra/redis";
+var useTestnet = false;
+var getClient = async ({ userName }) => {
+  const user = await getData(redisKeys.user(userName));
+  if (!user) {
+    logger.log("error", "connection config not found: %s", userName);
+    return null;
+  }
+  const client = new RestClientV5({
+    key: user.BYBIT_API_KEY,
+    secret: user.BYBIT_API_SECRET,
+    testnet: useTestnet
+  });
+  return client;
+};
+
+// src/ByBit/utils.ts
+import { MARKET_CATEGORY } from "@tradejs/core/constants";
+import { formatUnix } from "@tradejs/core/time";
+var parseKlineItem = (item) => ({
+  dt: formatUnix(parseInt(item[0])),
+  timestamp: parseInt(item[0]),
+  open: parseFloat(item[1]),
+  high: parseFloat(item[2]),
+  low: parseFloat(item[3]),
+  close: parseFloat(item[4]),
+  volume: parseFloat(item[5]),
+  turnover: parseFloat(item[6])
+});
+var mapKlineToChartData = (data) => data.map(parseKlineItem);
+var symbolMetaCache = /* @__PURE__ */ new Map();
+var roundByStep = (value, step, mode = "floor") => {
+  if (!step || !Number.isFinite(value)) return value;
+  const ratio = value / step;
+  const fn = mode === "ceil" ? Math.ceil : mode === "round" ? Math.round : Math.floor;
+  const res = fn(ratio) * step;
+  return Number(res.toFixed(12));
+};
+var stepToPrecision = (raw) => {
+  const [, decimals = ""] = raw.split(".");
+  return decimals.length;
+};
+var getSymbolMeta = async (client, symbol) => {
+  const cached = symbolMetaCache.get(symbol);
+  if (cached) return cached;
+  const res = await client.getInstrumentsInfo({
+    category: MARKET_CATEGORY,
+    symbol
+  });
+  const item = res?.result?.list?.[0];
+  if (!item) {
+    throw new Error(`No instrument info for symbol ${symbol}`);
+  }
+  const tickSizeStr = item.priceFilter?.tickSize ?? "0.01";
+  const qtyStepStr = item.lotSizeFilter?.qtyStep ?? "0.001";
+  const minOrderQtyStr = item.lotSizeFilter?.minOrderQty ?? "0.001";
+  const meta = {
+    tickSize: Number(tickSizeStr),
+    qtyStep: Number(qtyStepStr),
+    minOrderQty: Number(minOrderQtyStr),
+    pricePrecision: stepToPrecision(tickSizeStr),
+    qtyPrecision: stepToPrecision(qtyStepStr)
+  };
+  symbolMetaCache.set(symbol, meta);
+  return meta;
+};
+var normalizeQty = (rawQty, meta) => {
+  const qtyNum = roundByStep(rawQty, meta.qtyStep, "floor");
+  const qtyStr = qtyNum.toFixed(meta.qtyPrecision);
+  return { qtyNum, qtyStr };
+};
+var normalizePrice = (rawPrice, role, meta) => {
+  let mode = "floor";
+  switch (role) {
+    case "TP_LONG":
+      mode = "ceil";
+      break;
+    case "TP_SHORT":
+      mode = "floor";
+      break;
+    case "SL_LONG":
+      mode = "floor";
+      break;
+    case "SL_SHORT":
+      mode = "ceil";
+      break;
+    case "ENTRY":
+    default:
+      mode = "floor";
+  }
+  const priceNum = roundByStep(rawPrice, meta.tickSize, mode);
+  const priceStr = priceNum.toFixed(meta.pricePrecision);
+  return { priceNum, priceStr };
+};
+var mapPositionData = (data) => {
+  if (!data) {
+    return [];
+  }
+  return data.filter((item) => parseFloat(item.size) > 0).map((item) => ({
+    symbol: item.symbol,
+    price: parseFloat(item.avgPrice),
+    slPrice: parseFloat(item.stopLoss || ""),
+    qty: parseFloat(item.size),
+    direction: item.side === "Buy" ? "LONG" : "SHORT"
+  }));
+};
+
+// src/ByBit/index.ts
+var LIMIT = 1e3;
+var CACHE_FALLBACK_WINDOW = 1e3;
+var INTERVAL_TO_MINUTES = {
+  "1": 1,
+  "3": 3,
+  "5": 5,
+  "15": 15,
+  "30": 30,
+  "60": 60,
+  "120": 120,
+  "240": 240,
+  "360": 360,
+  "720": 720,
+  D: 1440,
+  W: 10080,
+  M: 43200
+};
+var getLogLevel = (res) => res.retCode === 0 ? "info" : "error";
+var ByBitConnectorCreator = async (config) => {
+  let state = {};
+  let isTimescaleFallbackMode = false;
+  const request = async ({
+    symbol,
+    interval,
+    start,
+    end,
+    silent
+  }) => {
+    const normalizedStart = round(
+      start || getTimestamp(PRELOAD_FALLBACK_DAYS),
+      0
+    );
+    const normalizedEnd = round(end || Date.now());
+    try {
+      const client = await getClient(config);
+      if (!client) return [];
+      if (normalizedEnd <= normalizedStart) {
+        return [];
+      }
+      const kline = await client.getKline({
+        category: MARKET_CATEGORY2,
+        symbol,
+        interval,
+        start: normalizedStart,
+        end: normalizedEnd,
+        limit: LIMIT
+      });
+      if (!kline?.result?.list) {
+        logger2.log("error", "empty kline.list for %s %s", symbol, interval);
+        return [];
+      }
+      if (!silent) {
+        logger2.log(
+          "info",
+          "%s %s %s %s",
+          chalk.yellow(formatUnix2(normalizedEnd)),
+          chalk.cyan(symbol),
+          chalk.cyan(interval),
+          chalk.yellow(kline.result.list.length)
+        );
+      }
+      return mapKlineToChartData(kline.result.list.reverse());
+    } catch (error) {
+      logger2.log(
+        "error",
+        "request kline: %s %s %s",
+        normalizedStart,
+        normalizedEnd,
+        error
+      );
+      return [];
+    }
+  };
+  const loadData = async (direction, pointer, limitBoundary, requestParams, intervalMs) => {
+    if (pointer === void 0) return [];
+    let accumulated = [];
+    let fulfilled = false;
+    while (!fulfilled) {
+      const currentPointer = pointer;
+      const params = {
+        symbol: requestParams.symbol,
+        interval: requestParams.interval,
+        silent: requestParams.silent
+      };
+      if (direction === "older") {
+        params.end = pointer;
+        if (limitBoundary !== void 0) params.start = limitBoundary;
+      } else {
+        params.start = pointer;
+        if (limitBoundary !== void 0) params.end = limitBoundary;
+      }
+      const partData = await request(params);
+      if (_.isEmpty(partData)) {
+        fulfilled = true;
+        break;
+      }
+      accumulated = direction === "older" ? mergeData(partData, accumulated) : mergeData(accumulated, partData);
+      const boundaryReached = limitBoundary !== void 0 && (direction === "older" && currentPointer <= limitBoundary || direction === "newer" && currentPointer >= limitBoundary);
+      if (partData.length < LIMIT || boundaryReached) {
+        fulfilled = true;
+        break;
+      }
+      const nextPointer = direction === "older" ? getItemTimestamp(partData[0]) - intervalMs : getItemTimestamp(partData[partData.length - 1]) + intervalMs;
+      if (!Number.isFinite(nextPointer) || nextPointer === currentPointer) {
+        fulfilled = true;
+        break;
+      }
+      pointer = nextPointer;
+    }
+    return accumulated;
+  };
+  const intervalMsOf = (interval) => interval * 6e4;
+  const intervalToMinutes = (interval) => {
+    return INTERVAL_TO_MINUTES[String(interval)] ?? null;
+  };
+  const clampToClosedCandle = (value, intervalMs) => Math.floor(value / intervalMs) * intervalMs;
+  const normalizeRangeToClosed = (intervalMs, start, end) => {
+    const lastClosed = Math.floor(Date.now() / intervalMs) * intervalMs;
+    const normStart = start !== void 0 ? clampToClosedCandle(start, intervalMs) : 0;
+    const cappedEnd = Math.min(end ?? Date.now(), lastClosed);
+    const normEnd = clampToClosedCandle(cappedEnd, intervalMs);
+    return { normStart, normEnd, lastClosed };
+  };
+  const rowsToKline = (rows) => rows.map(({ ts, ...data }) => ({
+    timestamp: new Date(ts).getTime(),
+    ...data
+  }));
+  const refreshTail = async ({
+    symbol,
+    interval,
+    silent,
+    tailCount = 2
+  }) => {
+    const intMinutes = intervalToMinutes(interval);
+    if (!intMinutes) {
+      logger2.log("error", "refreshTail: invalid interval %s", interval);
+      return;
+    }
+    const intervalMs = intervalMsOf(intMinutes);
+    const lastClosed = Math.floor(Date.now() / intervalMs) * intervalMs;
+    const tailEnd = lastClosed + intervalMs;
+    const tailStart = tailEnd - tailCount * intervalMs;
+    const part = await request({
+      symbol,
+      interval,
+      start: tailStart,
+      end: tailEnd,
+      silent
+    });
+    if (part.length) {
+      await upsertCandles(toRows(symbol, intMinutes, part));
+    }
+  };
+  return {
+    getState: async () => state,
+    setState: async (newState) => {
+      state = { ...state, ...newState };
+    },
+    kline: async ({
+      symbol,
+      interval,
+      start: defaultStart,
+      end: defaultEnd,
+      silent = false,
+      cacheOnly = false
+    }) => {
+      const intMinutes = intervalToMinutes(interval);
+      if (!intMinutes) {
+        logger2.log("error", "kline: invalid interval %s", interval);
+        return [];
+      }
+      if (defaultStart !== void 0 && defaultEnd !== void 0 && defaultEnd <= defaultStart) {
+        return [];
+      }
+      const intervalMs = intervalMsOf(intMinutes);
+      try {
+        const edges = await getDataEdges(symbol, intMinutes);
+        let dataStart = edges.min;
+        let dataEnd = edges.max;
+        const { normStart, normEnd } = normalizeRangeToClosed(
+          intervalMs,
+          defaultStart,
+          defaultEnd
+        );
+        if (cacheOnly) {
+          const base = edges.max ?? Date.now();
+          const s = Math.max(
+            defaultStart ?? base - CACHE_FALLBACK_WINDOW * intervalMs,
+            0
+          );
+          const e = defaultEnd ?? base;
+          const dbData2 = await getCandlesRange(symbol, intMinutes, s, e);
+          return rowsToKline(dbData2);
+        }
+        const needOlderData = defaultStart !== void 0 && (dataStart === void 0 || normStart < dataStart);
+        const needNewerData = defaultEnd !== void 0 && (dataEnd === void 0 || normEnd > dataEnd);
+        if (needOlderData) {
+          const pointerForOlder = dataStart ?? normEnd ?? Date.now();
+          const olderData = await loadData(
+            "older",
+            pointerForOlder,
+            normStart,
+            {
+              symbol,
+              interval,
+              silent,
+              start: normStart,
+              end: pointerForOlder
+            },
+            intervalMs
+          );
+          if (olderData.length) {
+            await upsertCandles(toRows(symbol, intMinutes, olderData));
+            dataStart = normStart;
+          }
+        }
+        if (needNewerData) {
+          const pointerForNewer = dataEnd ?? normStart ?? 0;
+          const newerData = await loadData(
+            "newer",
+            pointerForNewer,
+            normEnd,
+            {
+              symbol,
+              interval,
+              silent,
+              start: pointerForNewer,
+              end: normEnd
+            },
+            intervalMs
+          );
+          if (newerData.length) {
+            await upsertCandles(toRows(symbol, intMinutes, newerData));
+            dataEnd = normEnd;
+          }
+        }
+        const isRightEdgeQuery = defaultEnd === void 0 || defaultEnd && defaultEnd >= Date.now() - intervalMs;
+        if (!cacheOnly && isRightEdgeQuery) {
+          await refreshTail({ symbol, interval, silent });
+        }
+        const rangeStart = defaultStart ?? dataStart ?? 0;
+        const rangeEnd = defaultEnd ?? dataEnd ?? Date.now();
+        const { normStart: finalStart, normEnd: finalEnd } = normalizeRangeToClosed(intervalMs, rangeStart, rangeEnd);
+        const dbData = await getCandlesRange(
+          symbol,
+          intMinutes,
+          finalStart,
+          finalEnd
+        );
+        if (isTimescaleFallbackMode) {
+          isTimescaleFallbackMode = false;
+          logger2.log("info", "TimescaleDB connection restored for kline cache");
+        }
+        return rowsToKline(dbData);
+      } catch (error) {
+        if (!isTimescaleFallbackMode) {
+          isTimescaleFallbackMode = true;
+          logger2.log(
+            "warn",
+            "TimescaleDB unavailable for %s %s: %s. Falling back to exchange API.",
+            symbol,
+            interval,
+            String(error)
+          );
+        }
+        if (cacheOnly) {
+          return [];
+        }
+        return request({
+          symbol,
+          interval,
+          start: defaultStart,
+          end: defaultEnd,
+          silent
+        });
+      }
+    },
+    getPosition: async (symbol) => {
+      const client = await getClient(config);
+      if (!client) {
+        return null;
+      }
+      const positionRes = await client.getPositionInfo({
+        symbol,
+        category: MARKET_CATEGORY2
+      });
+      logger2.log(
+        getLogLevel(positionRes),
+        "position retCode: %s, %s",
+        symbol,
+        positionRes.retCode
+      );
+      if (positionRes.retCode !== 0) {
+        return null;
+      }
+      const positions = mapPositionData(positionRes.result.list);
+      if (!positions || _.isEmpty(positions)) {
+        return null;
+      }
+      const position = positions[0];
+      logger2.log(
+        getLogLevel(positionRes),
+        "position: %s, %s",
+        symbol,
+        toJson(positionRes, true)
+      );
+      return {
+        ...position
+      };
+    },
+    getPositions: async () => {
+      const client = await getClient(config);
+      if (!client) {
+        return [];
+      }
+      const positionRes = await client.getPositionInfo({
+        category: MARKET_CATEGORY2,
+        settleCoin: "USDT"
+      });
+      logger2.log(
+        getLogLevel(positionRes),
+        "positions retCode: %s, %s",
+        positionRes.retCode
+      );
+      if (positionRes.retCode !== 0) {
+        return [];
+      }
+      const positions = mapPositionData(positionRes.result.list);
+      if (!positions || _.isEmpty(positions)) {
+        return [];
+      }
+      return positions;
+    },
+    placeOrder: async ({ symbol, price, qty, direction, isLimit }, TP = [], slPrice) => {
+      const client = await getClient(config);
+      if (!client) {
+        return false;
+      }
+      const isLong = direction === "LONG";
+      const meta = await getSymbolMeta(client, symbol);
+      const { qtyNum: orderQty, qtyStr: orderQtyStr } = normalizeQty(qty, meta);
+      if (orderQty < meta.minOrderQty) {
+        logger2.log(
+          "warn",
+          "placeOrder: qty too small: %s",
+          toJson(
+            { symbol, qty, orderQty, minOrderQty: meta.minOrderQty },
+            true
+          )
+        );
+        return false;
+      }
+      const entryNormalized = isLimit ? normalizePrice(price, "ENTRY", meta) : void 0;
+      const slNormalized = slPrice ? normalizePrice(slPrice, isLong ? "SL_LONG" : "SL_SHORT", meta) : void 0;
+      const firstTP = TP?.[0];
+      const tpNormalized = firstTP && firstTP.rate === 1 ? normalizePrice(firstTP.price, isLong ? "TP_LONG" : "TP_SHORT", meta) : void 0;
+      logger2.log(
+        "info",
+        "placeOrder: %s",
+        toJson(
+          {
+            symbol,
+            price,
+            qty,
+            direction,
+            orderQty,
+            orderQtyStr,
+            slPrice,
+            slPriceNorm: slNormalized?.priceStr,
+            TP
+          },
+          true
+        )
+      );
+      await client.setLeverage({
+        category: MARKET_CATEGORY2,
+        symbol,
+        buyLeverage: "10",
+        sellLeverage: "10"
+      });
+      const orderRes = await client.submitOrder({
+        category: MARKET_CATEGORY2,
+        symbol,
+        price: entryNormalized?.priceStr || void 0,
+        takeProfit: tpNormalized?.priceStr || void 0,
+        tpTriggerBy: "MarkPrice",
+        stopLoss: slNormalized?.priceStr || void 0,
+        slTriggerBy: "LastPrice",
+        side: isLong ? "Buy" : "Sell",
+        orderType: isLimit ? "Limit" : "Market",
+        qty: orderQtyStr,
+        orderFilter: "Order"
+      });
+      logger2.log(
+        getLogLevel(orderRes),
+        "placeOrder:response: %s",
+        toJson(orderRes, true)
+      );
+      if (orderRes.retCode !== 0) {
+        return false;
+      }
+      if (!isLimit) {
+        for (const tp of TP) {
+          const tpSizeRaw = orderQty * tp.rate;
+          const { qtyNum: tpSizeNum, qtyStr: tpSizeStr } = normalizeQty(
+            tpSizeRaw,
+            meta
+          );
+          if (!tpSizeNum || tpSizeNum < meta.minOrderQty) {
+            logger2.log(
+              "warn",
+              "tp skipped: size too small %s",
+              toJson(
+                { symbol, tp, tpSizeNum, minOrderQty: meta.minOrderQty },
+                true
+              )
+            );
+            continue;
+          }
+          const tpPriceNorm = normalizePrice(
+            tp.price,
+            isLong ? "TP_LONG" : "TP_SHORT",
+            meta
+          );
+          const isFullMode = TP.length === 1 && tp.rate === 1;
+          const tpRes = await client.setTradingStop({
+            category: MARKET_CATEGORY2,
+            symbol,
+            tpSize: isFullMode ? void 0 : tpSizeStr,
+            tpslMode: isFullMode ? "Full" : "Partial",
+            takeProfit: tpPriceNorm.priceStr,
+            stopLoss: isFullMode && slNormalized ? slNormalized.priceStr : void 0,
+            slTriggerBy: "LastPrice",
+            tpOrderType: "Market",
+            positionIdx: 0
+          });
+          logger2.log(
+            getLogLevel(tpRes),
+            "tp: %s %s",
+            toJson(tp, true),
+            toJson(tpRes, true)
+          );
+        }
+      }
+      return true;
+    },
+    closePosition: async ({ symbol, direction }) => {
+      const client = await getClient(config);
+      if (!client) {
+        return false;
+      }
+      const closeRes = await client.submitOrder({
+        category: MARKET_CATEGORY2,
+        symbol,
+        side: direction === "LONG" ? "Sell" : "Buy",
+        orderType: "Market",
+        qty: "0",
+        reduceOnly: true
+      });
+      logger2.log(
+        getLogLevel(closeRes),
+        "closePosition: %s, %s, %s",
+        symbol,
+        direction,
+        toJson(closeRes, true)
+      );
+      if (closeRes.retCode !== 0) {
+        return false;
+      }
+      return true;
+    },
+    getTickers: async () => {
+      const client = await getClient(config);
+      if (!client) {
+        return [];
+      }
+      const data = await client.getTickers({
+        category: MARKET_CATEGORY2
+      });
+      return data.result.list.map((item) => normalizeTickerData(item));
+    }
+  };
+};
+
+// src/Binance/index.ts
+import { fetchWithRetry } from "@tradejs/infra/http";
+var INTERVAL_MAP = {
+  "1": "1m",
+  "3": "3m",
+  "5": "5m",
+  "15": "15m",
+  "30": "30m",
+  "60": "1h",
+  "120": "2h",
+  "240": "4h",
+  "360": "6h",
+  "720": "12h",
+  D: "1d",
+  W: "1w",
+  M: "1M"
+};
+var INTERVAL_MS = {
+  "1": 6e4,
+  "3": 18e4,
+  "5": 3e5,
+  "15": 9e5,
+  "30": 18e5,
+  "60": 36e5,
+  "120": 72e5,
+  "240": 144e5,
+  "360": 216e5,
+  "720": 432e5,
+  D: 864e5,
+  W: 6048e5,
+  M: 2592e6
+};
+var toNum = (value, fallback = 0) => {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback;
+};
+var BinanceConnectorCreator = async () => {
+  let state = {};
+  return {
+    getState: async () => state,
+    setState: async (newState) => {
+      state = { ...state, ...newState };
+    },
+    kline: async ({ symbol, interval, start, end }) => {
+      const intervalToken = INTERVAL_MAP[String(interval)];
+      if (!intervalToken) return [];
+      const intervalMs = INTERVAL_MS[String(interval)] ?? 9e5;
+      const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
+      let cursor = start ?? Math.max(0, end - intervalMs * 1e3);
+      const rows = [];
+      while (cursor <= end) {
+        const url = new URL(`${baseUrl}/api/v3/klines`);
+        url.searchParams.set("symbol", symbol);
+        url.searchParams.set("interval", intervalToken);
+        url.searchParams.set("startTime", String(cursor));
+        url.searchParams.set("endTime", String(end));
+        url.searchParams.set("limit", "1000");
+        const response = await fetchWithRetry(url.toString(), {
+          headers: { "User-Agent": "tradejs/binance-connector" }
+        });
+        if (!response.ok) break;
+        const payload = await response.json();
+        if (!Array.isArray(payload) || !payload.length) break;
+        let lastTs = cursor;
+        for (const item of payload) {
+          if (!Array.isArray(item)) continue;
+          const ts = toNum(item[0], 0);
+          if (!ts) continue;
+          rows.push({
+            timestamp: ts,
+            open: toNum(item[1]),
+            high: toNum(item[2]),
+            low: toNum(item[3]),
+            close: toNum(item[4]),
+            volume: toNum(item[5]),
+            turnover: toNum(item[7]),
+            dt: new Date(ts).toISOString()
+          });
+          lastTs = ts;
+        }
+        if (payload.length < 1e3) break;
+        cursor = lastTs + intervalMs;
+      }
+      rows.sort((a, b) => a.timestamp - b.timestamp);
+      return rows;
+    },
+    getPosition: async () => null,
+    getPositions: async () => [],
+    placeOrder: async () => false,
+    closePosition: async () => false,
+    getTickers: async () => {
+      const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
+      const response = await fetchWithRetry(`${baseUrl}/api/v3/ticker/24hr`, {
+        headers: { "User-Agent": "tradejs/binance-connector" }
+      });
+      if (!response.ok) return [];
+      const payload = await response.json();
+      if (!Array.isArray(payload)) return [];
+      return payload.map((row) => {
+        const symbol = String(row.symbol ?? "");
+        return {
+          symbol,
+          lastPrice: toNum(row.lastPrice),
+          indexPrice: toNum(row.lastPrice),
+          markPrice: toNum(row.lastPrice),
+          prevPrice24h: toNum(row.openPrice),
+          price24hPcnt: toNum(row.priceChangePercent) / 100,
+          highPrice24h: toNum(row.highPrice),
+          lowPrice24h: toNum(row.lowPrice),
+          prevPrice1h: 0,
+          openInterest: 0,
+          openInterestValue: 0,
+          turnover24h: toNum(row.quoteVolume),
+          volume24h: toNum(row.volume),
+          fundingRate: 0,
+          nextFundingTime: 0,
+          predictedDeliveryPrice: "",
+          basisRate: "",
+          deliveryFeeRate: "",
+          deliveryTime: 0,
+          ask1Size: toNum(row.askQty),
+          bid1Price: toNum(row.bidPrice),
+          ask1Price: toNum(row.askPrice),
+          bid1Size: toNum(row.bidQty),
+          basis: "",
+          preOpenPrice: "",
+          preQty: ""
+        };
+      });
+    }
+  };
+};
+
+// src/Coinbase/index.ts
+import { fetchWithRetry as fetchWithRetry2 } from "@tradejs/infra/http";
+var INTERVAL_MS2 = {
+  "1": 6e4,
+  "3": 18e4,
+  "5": 3e5,
+  "15": 9e5,
+  "30": 18e5,
+  "60": 36e5,
+  "120": 72e5,
+  "240": 144e5,
+  "360": 216e5,
+  "720": 432e5,
+  D: 864e5,
+  W: 6048e5,
+  M: 2592e6
+};
+var GRANULARITY_MAP = {
+  "1": 60,
+  "3": 300,
+  "5": 300,
+  "15": 900,
+  "30": 1800,
+  "60": 3600,
+  "120": 21600,
+  "240": 21600,
+  "360": 21600,
+  "720": 21600,
+  D: 86400,
+  W: 86400,
+  M: 86400
+};
+var toNum2 = (value, fallback = 0) => {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback;
+};
+var toCoinbaseProduct = (symbol) => {
+  const upper = symbol.toUpperCase();
+  const quoteSuffixes = ["USDT", "USDC", "BUSD", "USD"];
+  for (const quote of quoteSuffixes) {
+    if (upper.endsWith(quote)) {
+      const base = upper.slice(0, -quote.length);
+      if (!base) return null;
+      return `${base}-USD`;
+    }
+  }
+  return null;
+};
+var MAJOR_PRODUCTS = [
+  "BTC-USD",
+  "ETH-USD",
+  "SOL-USD",
+  "XRP-USD",
+  "ADA-USD",
+  "DOGE-USD",
+  "LTC-USD",
+  "BCH-USD",
+  "LINK-USD",
+  "AVAX-USD"
+];
+var CoinbaseConnectorCreator = async () => {
+  let state = {};
+  return {
+    getState: async () => state,
+    setState: async (newState) => {
+      state = { ...state, ...newState };
+    },
+    kline: async ({ symbol, interval, start, end }) => {
+      const granularity = GRANULARITY_MAP[String(interval)];
+      if (!granularity) return [];
+      const product = toCoinbaseProduct(symbol);
+      if (!product) return [];
+      const baseUrl = process.env.COINBASE_BASE_URL?.trim() || "https://api.exchange.coinbase.com";
+      const stepMs = granularity * 1e3 * 300;
+      const fromMs = start ?? Math.max(0, end - INTERVAL_MS2[String(interval)] * 1e3);
+      let cursorEnd = end;
+      const rows = [];
+      while (cursorEnd >= fromMs) {
+        const chunkStart = Math.max(fromMs, cursorEnd - stepMs);
+        const url = new URL(`${baseUrl}/products/${product}/candles`);
+        url.searchParams.set("granularity", String(granularity));
+        url.searchParams.set("start", new Date(chunkStart).toISOString());
+        url.searchParams.set("end", new Date(cursorEnd).toISOString());
+        const response = await fetchWithRetry2(url.toString(), {
+          headers: { "User-Agent": "tradejs/coinbase-connector" }
+        });
+        if (!response.ok) break;
+        const payload = await response.json();
+        if (Array.isArray(payload)) {
+          for (const item of payload) {
+            if (!Array.isArray(item)) continue;
+            const ts = toNum2(item[0]) * 1e3;
+            rows.push({
+              timestamp: ts,
+              low: toNum2(item[1]),
+              high: toNum2(item[2]),
+              open: toNum2(item[3]),
+              close: toNum2(item[4]),
+              volume: toNum2(item[5]),
+              turnover: 0,
+              dt: new Date(ts).toISOString()
+            });
+          }
+        }
+        cursorEnd = chunkStart - 1;
+      }
+      const dedup = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        dedup.set(row.timestamp, row);
+      }
+      return [...dedup.values()].sort((a, b) => a.timestamp - b.timestamp);
+    },
+    getPosition: async () => null,
+    getPositions: async () => [],
+    placeOrder: async () => false,
+    closePosition: async () => false,
+    getTickers: async () => {
+      const baseUrl = process.env.COINBASE_BASE_URL?.trim() || "https://api.exchange.coinbase.com";
+      const entries = await Promise.all(
+        MAJOR_PRODUCTS.map(async (product) => {
+          const [tickerRes, statsRes] = await Promise.all([
+            fetchWithRetry2(`${baseUrl}/products/${product}/ticker`, {
+              headers: { "User-Agent": "tradejs/coinbase-connector" }
+            }),
+            fetchWithRetry2(`${baseUrl}/products/${product}/stats`, {
+              headers: { "User-Agent": "tradejs/coinbase-connector" }
+            })
+          ]);
+          if (!tickerRes.ok || !statsRes.ok) return null;
+          const ticker = await tickerRes.json();
+          const stats = await statsRes.json();
+          const base = product.replace("-USD", "");
+          const symbol = `${base}USDT`;
+          const open = toNum2(stats.open);
+          const last = toNum2(ticker.price);
+          const pct = open > 0 ? (last - open) / open : 0;
+          return {
+            symbol,
+            lastPrice: last,
+            indexPrice: last,
+            markPrice: last,
+            prevPrice24h: open,
+            price24hPcnt: pct,
+            highPrice24h: toNum2(stats.high),
+            lowPrice24h: toNum2(stats.low),
+            prevPrice1h: 0,
+            openInterest: 0,
+            openInterestValue: 0,
+            turnover24h: 0,
+            volume24h: toNum2(stats.volume),
+            fundingRate: 0,
+            nextFundingTime: 0,
+            predictedDeliveryPrice: "",
+            basisRate: "",
+            deliveryFeeRate: "",
+            deliveryTime: 0,
+            ask1Size: toNum2(ticker.ask_size),
+            bid1Price: toNum2(ticker.bid),
+            ask1Price: toNum2(ticker.ask),
+            bid1Size: toNum2(ticker.bid_size),
+            basis: "",
+            preOpenPrice: "",
+            preQty: ""
+          };
+        })
+      );
+      return entries.filter((item) => item != null);
+    }
+  };
+};
+
+// src/Test/index.ts
+import { createTestConnector } from "@tradejs/node/backtest";
+var TestConnectorCreator = (connector, context) => createTestConnector(connector, context);
+
+// src/marketData/spotKlineProviders.ts
+import { fetchWithRetry as fetchWithRetry3 } from "@tradejs/infra/http";
+var toIntervalToken = (interval) => interval === "1h" ? "1h" : "15m";
+var mapBinanceKline = (payload) => payload.map((item) => {
+  if (!Array.isArray(item)) return null;
+  const ts = Number(item[0]);
+  const open = Number(item[1]);
+  const high = Number(item[2]);
+  const low = Number(item[3]);
+  const close = Number(item[4]);
+  const volume = Number(item[5]);
+  if (![ts, open, high, low, close, volume].every(Number.isFinite))
+    return null;
+  return {
+    timestamp: ts,
+    open,
+    high,
+    low,
+    close,
+    volume,
+    turnover: Number(item[7]) || 0,
+    dt: new Date(ts).toISOString()
+  };
+}).filter((item) => item != null).sort((a, b) => a.timestamp - b.timestamp);
+var mapCoinbaseKline = (payload) => payload.map((item) => {
+  if (!Array.isArray(item)) return null;
+  const tsSec = Number(item[0]);
+  const low = Number(item[1]);
+  const high = Number(item[2]);
+  const open = Number(item[3]);
+  const close = Number(item[4]);
+  const volume = Number(item[5]);
+  const ts = tsSec * 1e3;
+  if (![ts, open, high, low, close, volume].every(Number.isFinite))
+    return null;
+  return {
+    timestamp: ts,
+    open,
+    high,
+    low,
+    close,
+    volume,
+    turnover: 0,
+    dt: new Date(ts).toISOString()
+  };
+}).filter((item) => item != null).sort((a, b) => a.timestamp - b.timestamp);
+var spotKlineProviders = {
+  binance: {
+    kline: async ({ symbol, interval, start, end }) => {
+      const token = toIntervalToken(interval);
+      const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
+      const url = new URL(`${baseUrl}/api/v3/klines`);
+      url.searchParams.set("symbol", symbol);
+      url.searchParams.set("interval", token);
+      url.searchParams.set("startTime", String(start));
+      url.searchParams.set("endTime", String(end));
+      url.searchParams.set("limit", "1000");
+      const response = await fetchWithRetry3(url.toString(), {
+        headers: { "User-Agent": "tradejs/market-data-ingest" }
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Binance kline ${response.status}: ${await response.text()}`
+        );
+      }
+      const payload = await response.json();
+      return Array.isArray(payload) ? mapBinanceKline(payload) : [];
+    }
+  },
+  coinbase: {
+    kline: async ({ symbol, interval, start, end }) => {
+      const baseUrl = process.env.COINBASE_BASE_URL?.trim() || "https://api.exchange.coinbase.com";
+      const granularity = interval === "1h" ? 3600 : 900;
+      const url = new URL(`${baseUrl}/products/${symbol}/candles`);
+      url.searchParams.set("granularity", String(granularity));
+      url.searchParams.set("start", new Date(start).toISOString());
+      url.searchParams.set("end", new Date(end).toISOString());
+      const response = await fetchWithRetry3(url.toString(), {
+        headers: {
+          "User-Agent": "tradejs/market-data-ingest",
+          Accept: "application/json"
+        }
+      });
+      if (response.status === 404) return [];
+      if (!response.ok) {
+        throw new Error(
+          `Coinbase kline ${response.status}: ${await response.text()}`
+        );
+      }
+      const payload = await response.json();
+      return Array.isArray(payload) ? mapCoinbaseKline(payload) : [];
+    }
+  }
+};
+
+// src/marketData/providers/binanceCoinbaseSpread.ts
+import {
+  alignSpreadRows,
+  coinbaseProductFromSymbol,
+  intervalToMs
+} from "@tradejs/core/indicators";
+var fetchBinanceKlines = async (params) => {
+  const { symbol, interval, fromMs, toMs } = params;
+  const rows = await spotKlineProviders.binance.kline({
+    symbol,
+    interval,
+    start: fromMs,
+    end: toMs
+  });
+  return rows.map((row) => ({ ts: row.timestamp, close: row.close }));
+};
+var fetchCoinbaseCandles = async (params) => {
+  const { symbol, interval, fromMs, toMs } = params;
+  const product = coinbaseProductFromSymbol(symbol);
+  if (!product) return [];
+  const stepMs = intervalToMs(interval) * 250;
+  const rows = [];
+  let cursor = fromMs;
+  while (cursor <= toMs) {
+    const endMs = Math.min(toMs, cursor + stepMs);
+    const klineRows = await spotKlineProviders.coinbase.kline({
+      symbol: product,
+      interval,
+      start: cursor,
+      end: endMs
+    });
+    for (const row of klineRows) {
+      rows.push({ ts: row.timestamp, close: row.close });
+    }
+    cursor = endMs + 1;
+  }
+  rows.sort((a, b) => a.ts - b.ts);
+  const dedup = /* @__PURE__ */ new Map();
+  for (const row of rows) dedup.set(row.ts, row);
+  return [...dedup.values()].sort((a, b) => a.ts - b.ts);
+};
+var binanceCoinbaseSpreadProvider = {
+  name: "binance_coinbase_spread",
+  fetchWindow: async ({ symbol, interval, fromMs, toMs }) => {
+    const [binance, coinbase] = await Promise.all([
+      fetchBinanceKlines({ symbol, interval, fromMs, toMs }),
+      fetchCoinbaseCandles({ symbol, interval, fromMs, toMs })
+    ]);
+    const spreadRows = alignSpreadRows({
+      symbol,
+      interval,
+      binance,
+      coinbase,
+      source: "binance_coinbase_spread"
+    });
+    return { spreadRows };
+  }
+};
+
+// src/marketData/providers/coinalyze.ts
+import { delay } from "@tradejs/core/async";
+import {
+  coinalyzePointsToRows,
+  mergeCoinalyzeMetrics
+} from "@tradejs/core/indicators";
+var coinalyzeIntervalMap = {
+  "15m": "15min",
+  "1h": "1hour"
+};
+var coinalyzeMinRequestDelayMs = Number(
+  process.env.COINALYZE_MIN_REQUEST_DELAY_MS ?? 300
+);
+var coinalyzeMaxRetries = Number(process.env.COINALYZE_MAX_RETRIES ?? 4);
+var lastRequestTs = 0;
+var flattenCoinalyzeHistory = (raw) => {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const history = item.history;
+    if (Array.isArray(history)) {
+      for (const point of history) {
+        if (point && typeof point === "object") {
+          out.push(point);
+        }
+      }
+      continue;
+    }
+    out.push(item);
+  }
+  return out;
+};
+var normalizeMetricPayload = (metric, raw) => {
+  const points = flattenCoinalyzeHistory(raw);
+  if (!points.length) return [];
+  if (metric === "oi") {
+    return points.map((point) => ({
+      ...point,
+      open_interest: point.open_interest ?? point.openInterest ?? point.oi ?? point.c
+    }));
+  }
+  if (metric === "funding") {
+    return points.map((point) => ({
+      ...point,
+      funding_rate: point.funding_rate ?? point.fundingRate ?? point.rate ?? point.c
+    }));
+  }
+  return points.map((point) => ({
+    ...point,
+    liq_long: point.liq_long ?? point.long_liq ?? point.long ?? point.l,
+    liq_short: point.liq_short ?? point.short_liq ?? point.short ?? point.s
+  }));
+};
+var fetchCoinalyzeSeries = async (params) => {
+  const { endpoint, metric, symbol, interval, fromMs, toMs } = params;
+  const baseUrl = process.env.COINALYZE_BASE_URL?.trim() || "https://api.coinalyze.net/v1";
+  const apiKey = process.env.COINALYZE_API_KEY?.trim();
+  if (!apiKey) {
+    throw new Error("Missing COINALYZE_API_KEY");
+  }
+  const url = new URL(`${baseUrl}${endpoint}`);
+  url.searchParams.set("symbols", symbol);
+  url.searchParams.set("interval", coinalyzeIntervalMap[interval] || interval);
+  url.searchParams.set("from", String(Math.floor(fromMs / 1e3)));
+  url.searchParams.set("to", String(Math.floor(toMs / 1e3)));
+  const headers = {
+    api_key: apiKey,
+    "x-api-key": apiKey,
+    Authorization: `Bearer ${apiKey}`
+  };
+  for (let attempt = 0; attempt <= coinalyzeMaxRetries; attempt += 1) {
+    const now = Date.now();
+    const waitMs = Math.max(
+      0,
+      lastRequestTs + coinalyzeMinRequestDelayMs - now
+    );
+    if (waitMs > 0) {
+      await delay(waitMs);
+    }
+    lastRequestTs = Date.now();
+    const response = await fetch(url.toString(), { headers });
+    if (response.ok) {
+      const raw = await response.json();
+      return normalizeMetricPayload(metric, raw);
+    }
+    const text = await response.text();
+    const retryAfterRaw = Number(response.headers.get("retry-after") ?? "");
+    const retryAfterMs = Number.isFinite(retryAfterRaw) && retryAfterRaw > 0 ? retryAfterRaw * 1e3 : null;
+    const transient = response.status === 429 || response.status >= 500;
+    if (attempt < coinalyzeMaxRetries && transient) {
+      const backoffMs = Math.min(1e4, 750 * 2 ** attempt);
+      await delay(retryAfterMs ?? backoffMs);
+      continue;
+    }
+    throw new Error(`Coinalyze ${endpoint} ${response.status}: ${text}`);
+  }
+  return [];
+};
+var coinalyzeProvider = {
+  name: "coinalyze",
+  fetchWindow: async ({ symbol, marketSymbol, interval, fromMs, toMs }) => {
+    const oiPath = process.env.COINALYZE_OI_PATH?.trim() || "/open-interest-history";
+    const fundingPath = process.env.COINALYZE_FUNDING_PATH?.trim() || "/funding-rate-history";
+    const liqPath = process.env.COINALYZE_LIQ_PATH?.trim() || "/liquidation-history";
+    const requestSymbol = (marketSymbol || symbol).trim().toUpperCase();
+    const oiRaw = await fetchCoinalyzeSeries({
+      endpoint: oiPath,
+      metric: "oi",
+      symbol: requestSymbol,
+      interval,
+      fromMs,
+      toMs
+    });
+    const fundingRaw = await fetchCoinalyzeSeries({
+      endpoint: fundingPath,
+      metric: "funding",
+      symbol: requestSymbol,
+      interval,
+      fromMs,
+      toMs
+    });
+    const liqRaw = await fetchCoinalyzeSeries({
+      endpoint: liqPath,
+      metric: "liq",
+      symbol: requestSymbol,
+      interval,
+      fromMs,
+      toMs
+    });
+    const points = mergeCoinalyzeMetrics({
+      symbol,
+      oiRaw,
+      fundingRaw,
+      liqRaw
+    });
+    return {
+      derivativesRows: coinalyzePointsToRows(points, interval, "coinalyze")
+    };
+  }
+};
+
+// src/marketData/providers/index.ts
+var marketDataProviders = {
+  coinalyze: coinalyzeProvider,
+  binance_coinbase_spread: binanceCoinbaseSpreadProvider
+};
+
+// src/index.ts
+var ConnectorNames = /* @__PURE__ */ ((ConnectorNames2) => {
+  ConnectorNames2["ByBit"] = "ByBit";
+  ConnectorNames2["Binance"] = "Binance";
+  ConnectorNames2["Coinbase"] = "Coinbase";
+  ConnectorNames2["Test"] = "Test";
+  return ConnectorNames2;
+})(ConnectorNames || {});
+var ConnectorProviders = /* @__PURE__ */ ((ConnectorProviders2) => {
+  ConnectorProviders2["bybit"] = "bybit";
+  ConnectorProviders2["binance"] = "binance";
+  ConnectorProviders2["coinbase"] = "coinbase";
+  return ConnectorProviders2;
+})(ConnectorProviders || {});
+var providerToConnectorName = {
+  ["bybit" /* bybit */]: "ByBit" /* ByBit */,
+  ["binance" /* binance */]: "Binance" /* Binance */,
+  ["coinbase" /* coinbase */]: "Coinbase" /* Coinbase */
+};
+var getConnectorProviders = () => Object.keys(providerToConnectorName);
+var resolveConnectorNameByProvider = (provider) => {
+  const normalized = String(provider || "").trim().toLowerCase();
+  return providerToConnectorName[normalized] || null;
+};
+var connectors = {
+  ["ByBit" /* ByBit */]: ByBitConnectorCreator,
+  ["Binance" /* Binance */]: BinanceConnectorCreator,
+  ["Coinbase" /* Coinbase */]: CoinbaseConnectorCreator,
+  ["Test" /* Test */]: TestConnectorCreator
+};
+var connectorEntries = [
+  {
+    name: "ByBit" /* ByBit */,
+    creator: ByBitConnectorCreator,
+    providers: ["bybit" /* bybit */]
+  },
+  {
+    name: "Binance" /* Binance */,
+    creator: BinanceConnectorCreator,
+    providers: ["binance" /* binance */]
+  },
+  {
+    name: "Coinbase" /* Coinbase */,
+    creator: CoinbaseConnectorCreator,
+    providers: ["coinbase" /* coinbase */]
+  }
+];
+var getConnectorCreatorByProvider = (provider) => {
+  const connectorName = resolveConnectorNameByProvider(provider);
+  if (!connectorName) {
+    return null;
+  }
+  return connectors[connectorName];
+};
+var index_default = { connectorEntries };
+export {
+  ConnectorNames,
+  ConnectorProviders,
+  connectorEntries,
+  connectors,
+  index_default as default,
+  getConnectorCreatorByProvider,
+  getConnectorProviders,
+  marketDataProviders,
+  providerToConnectorName,
+  resolveConnectorNameByProvider,
+  spotKlineProviders
+};