@tradejs/connectors 1.0.5 → 1.0.8

package/dist/index.js

@@ -47,21 +47,26 @@ module.exports = __toCommonJS(index_exports);
 // src/ByBit/index.ts
 var import_lodash = __toESM(require("lodash"));
 var import_chalk = __toESM(require("chalk"));
-var import_constants2 = require("@tradejs/core/constants");
-var import_data = require("@tradejs/core/data");
+var import_async = require("@tradejs/core/async");
+var import_constants3 = require("@tradejs/core/constants");
 var import_data2 = require("@tradejs/core/data");
 var import_math = require("@tradejs/core/math");
 var import_tickers = require("@tradejs/core/tickers");
-var import_time2 = require("@tradejs/core/time");
-var import_logger2 = require("@tradejs/infra/logger");
-var import_timescale = require("@tradejs/infra/timescale");
+var import_time3 = require("@tradejs/core/time");
+var import_logger3 = require("@tradejs/infra/logger");
 
 // src/ByBit/client.ts
 var import_bybit_api = require("bybit-api");
 var import_logger = require("@tradejs/infra/logger");
 var import_redis = require("@tradejs/infra/redis");
 var useTestnet = false;
-var getClient = async ({ userName }) => {
+var getClient = async ({ userName }, access = "private") => {
+  if (access === "public") {
+    return new import_bybit_api.RestClientV5({
+      parseAPIRateLimits: true,
+      testnet: useTestnet
+    });
+  }
   const user = await (0, import_redis.getData)(import_redis.redisKeys.user(userName));
   if (!user) {
     import_logger.logger.log("error", "connection config not found: %s", userName);
@@ -70,16 +75,248 @@ var getClient = async ({ userName }) => {
   const client = new import_bybit_api.RestClientV5({
     key: user.BYBIT_API_KEY,
     secret: user.BYBIT_API_SECRET,
+    parseAPIRateLimits: true,
     testnet: useTestnet
   });
   return client;
 };
 
-// src/ByBit/utils.ts
+// src/shared/timescaleKlineCache.ts
 var import_constants = require("@tradejs/core/constants");
+var import_data = require("@tradejs/core/data");
 var import_time = require("@tradejs/core/time");
+var import_logger2 = require("@tradejs/infra/logger");
+var import_timescale = require("@tradejs/infra/timescale");
+var DEFAULT_LIMIT = 1e3;
+var DEFAULT_CACHE_FALLBACK_WINDOW = 1e3;
+var intervalMsOf = (interval) => interval * 6e4;
+var clampToClosedCandle = (value, intervalMs) => Math.floor(value / intervalMs) * intervalMs;
+var 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 };
+};
+var rowsToKline = (rows) => rows.map(({ ts, ...data }) => ({
+  timestamp: new Date(ts).getTime(),
+  ...data
+}));
+var createTimescaleCachedKline = ({
+  provider,
+  request,
+  intervalToMinutes: intervalToMinutes3,
+  limit = DEFAULT_LIMIT,
+  cacheFallbackWindow = DEFAULT_CACHE_FALLBACK_WINDOW
+}) => {
+  let isTimescaleFallbackMode = false;
+  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,
+        end: requestParams.end
+      };
+      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 (!partData.length) {
+        fulfilled = true;
+        break;
+      }
+      accumulated = direction === "older" ? (0, import_data.mergeData)(partData, accumulated) : (0, import_data.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" ? (0, import_time.getItemTimestamp)(partData[0]) - intervalMs : (0, import_time.getItemTimestamp)(partData[partData.length - 1]) + intervalMs;
+      if (!Number.isFinite(nextPointer) || nextPointer === currentPointer) {
+        fulfilled = true;
+        break;
+      }
+      pointer = nextPointer;
+    }
+    return accumulated;
+  };
+  const refreshTail = async ({
+    symbol,
+    interval,
+    silent,
+    tailCount = 2
+  }) => {
+    const intMinutes = intervalToMinutes3(interval);
+    if (!intMinutes) {
+      import_logger2.logger.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 (0, import_timescale.upsertCandles)((0, import_timescale.toRows)(provider, symbol, intMinutes, part));
+    }
+  };
+  return async ({
+    symbol,
+    interval,
+    start: defaultStart,
+    end: defaultEnd,
+    silent = false,
+    cacheOnly = false,
+    warmOnly = false
+  }) => {
+    const intMinutes = intervalToMinutes3(interval);
+    if (!intMinutes) {
+      import_logger2.logger.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 (0, import_timescale.getDataEdges)(provider, 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 - cacheFallbackWindow * intervalMs,
+          0
+        );
+        const e = defaultEnd ?? base;
+        const dbData2 = await (0, import_timescale.getCandlesRange)(
+          provider,
+          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 (0, import_timescale.upsertCandles)((0, import_timescale.toRows)(provider, symbol, intMinutes, olderData));
+          dataStart = normStart;
+        }
+      }
+      if (needNewerData) {
+        const fallbackStart = (0, import_time.getTimestamp)(import_constants.PRELOAD_FALLBACK_DAYS);
+        const pointerForNewer = dataEnd ?? (defaultStart !== void 0 ? normStart : fallbackStart) ?? 0;
+        const newerData = await loadData(
+          "newer",
+          pointerForNewer,
+          normEnd,
+          {
+            symbol,
+            interval,
+            silent,
+            start: pointerForNewer,
+            end: normEnd
+          },
+          intervalMs
+        );
+        if (newerData.length) {
+          await (0, import_timescale.upsertCandles)((0, import_timescale.toRows)(provider, symbol, intMinutes, newerData));
+          dataEnd = normEnd;
+        }
+      }
+      const isRightEdgeQuery = defaultEnd === void 0 || defaultEnd && defaultEnd >= Date.now() - intervalMs;
+      if (!cacheOnly && isRightEdgeQuery) {
+        await refreshTail({ symbol, interval, silent });
+      }
+      if (warmOnly) {
+        if (isTimescaleFallbackMode) {
+          isTimescaleFallbackMode = false;
+          import_logger2.logger.log("info", "TimescaleDB connection restored for kline cache");
+        }
+        return [];
+      }
+      const rangeStart = defaultStart ?? dataStart ?? 0;
+      const rangeEnd = defaultEnd ?? dataEnd ?? Date.now();
+      const { normStart: finalStart, normEnd: finalEnd } = normalizeRangeToClosed(intervalMs, rangeStart, rangeEnd);
+      const dbData = await (0, import_timescale.getCandlesRange)(
+        provider,
+        symbol,
+        intMinutes,
+        finalStart,
+        finalEnd
+      );
+      if (isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = false;
+        import_logger2.logger.log("info", "TimescaleDB connection restored for kline cache");
+      }
+      return rowsToKline(dbData);
+    } catch (error) {
+      if (!isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = true;
+        import_logger2.logger.log(
+          "warn",
+          "TimescaleDB unavailable for %s %s: %s. Falling back to exchange API.",
+          symbol,
+          interval,
+          String(error)
+        );
+      }
+      if (cacheOnly || warmOnly) {
+        return [];
+      }
+      return request({
+        symbol,
+        interval,
+        start: defaultStart,
+        end: defaultEnd,
+        silent
+      });
+    }
+  };
+};
+
+// src/ByBit/utils.ts
+var import_constants2 = require("@tradejs/core/constants");
+var import_time2 = require("@tradejs/core/time");
 var parseKlineItem = (item) => ({
-  dt: (0, import_time.formatUnix)(parseInt(item[0])),
+  dt: (0, import_time2.formatUnix)(parseInt(item[0])),
   timestamp: parseInt(item[0]),
   open: parseFloat(item[1]),
   high: parseFloat(item[2]),
@@ -105,7 +342,7 @@ var getSymbolMeta = async (client, symbol) => {
   const cached = symbolMetaCache.get(symbol);
   if (cached) return cached;
   const res = await client.getInstrumentsInfo({
-    category: import_constants.MARKET_CATEGORY,
+    category: import_constants2.MARKET_CATEGORY,
     symbol
   });
   const item = res?.result?.list?.[0];
@@ -168,7 +405,12 @@ var mapPositionData = (data) => {
 
 // src/ByBit/index.ts
 var LIMIT = 1e3;
-var CACHE_FALLBACK_WINDOW = 1e3;
+var BYBIT_RATE_LIMIT_RETCODE = 10006;
+var BYBIT_TRADING_STOP_NOT_MODIFIED_RETCODE = 34040;
+var KLINE_RATE_LIMIT_MAX_ATTEMPTS = 3;
+var KLINE_RATE_LIMIT_BASE_DELAY_MS = 800;
+var KLINE_RATE_LIMIT_MAX_DELAY_MS = 1e4;
+var KLINE_RATE_LIMIT_RESET_BUFFER_MS = 50;
 var INTERVAL_TO_MINUTES = {
   "1": 1,
   "3": 3,
@@ -185,9 +427,36 @@ var INTERVAL_TO_MINUTES = {
   M: 43200
 };
 var getLogLevel = (res) => res.retCode === 0 ? "info" : "error";
+var isTradingStopNotModified = (res) => res?.retCode === BYBIT_TRADING_STOP_NOT_MODIFIED_RETCODE;
+var isTradingStopAccepted = (res) => res?.retCode === 0 || isTradingStopNotModified(res);
+var isKlineRateLimited = (res) => res?.retCode === BYBIT_RATE_LIMIT_RETCODE;
+var resolveKlineRetryDelayMs = (res, attempt) => {
+  const resetAtRaw = Number(res?.rateLimitApi?.resetAtTimestamp);
+  if (Number.isFinite(resetAtRaw) && resetAtRaw > 0) {
+    return Math.max(
+      KLINE_RATE_LIMIT_RESET_BUFFER_MS,
+      resetAtRaw - Date.now() + KLINE_RATE_LIMIT_RESET_BUFFER_MS
+    );
+  }
+  const jitterMs = Math.round(Math.random() * 250);
+  const backoffMs = Math.min(
+    KLINE_RATE_LIMIT_MAX_DELAY_MS,
+    KLINE_RATE_LIMIT_BASE_DELAY_MS * 2 ** (attempt - 1)
+  );
+  return backoffMs + jitterMs;
+};
 var ByBitConnectorCreator = async (config) => {
   let state = {};
-  let isTimescaleFallbackMode = false;
+  let publicClientPromise = null;
+  let privateClientPromise = null;
+  const getPublicClient = async () => {
+    publicClientPromise ??= getClient(config, "public");
+    return publicClientPromise;
+  };
+  const getPrivateClient = async () => {
+    privateClientPromise ??= getClient(config, "private");
+    return privateClientPromise;
+  };
   const request = async ({
     symbol,
     interval,
@@ -196,48 +465,67 @@ var ByBitConnectorCreator = async (config) => {
     silent
   }) => {
     const normalizedStart = (0, import_math.round)(
-      start || (0, import_time2.getTimestamp)(import_constants2.PRELOAD_FALLBACK_DAYS),
+      start || (0, import_time3.getTimestamp)(import_constants3.PRELOAD_FALLBACK_DAYS),
       0
     );
     const normalizedEnd = (0, import_math.round)(end || Date.now());
     try {
-      const client = await getClient(config);
+      const client = await getPublicClient();
       if (!client) return [];
       if (normalizedEnd <= normalizedStart) {
         return [];
       }
-      const kline = await client.getKline({
-        category: import_constants2.MARKET_CATEGORY,
-        symbol,
-        interval,
-        start: normalizedStart,
-        end: normalizedEnd,
-        limit: LIMIT
-      });
-      if (!kline?.result?.list) {
-        const responseError = typeof kline?.retMsg === "string" && kline.retMsg !== "OK" ? `${kline.retMsg}${typeof kline?.retCode === "number" ? ` (retCode: ${kline.retCode})` : ""}` : typeof kline?.retCode === "number" && kline.retCode !== 0 ? `retCode: ${kline.retCode}` : "";
-        import_logger2.logger.log(
-          "error",
-          "empty kline.list for %s %s%s",
+      for (let attempt = 1; attempt <= KLINE_RATE_LIMIT_MAX_ATTEMPTS; attempt += 1) {
+        const kline = await client.getKline({
+          category: import_constants3.MARKET_CATEGORY,
           symbol,
           interval,
-          responseError ? `: ${responseError}` : ""
-        );
-        return [];
-      }
-      if (!silent) {
-        import_logger2.logger.log(
-          "info",
-          "%s %s %s %s",
-          import_chalk.default.yellow((0, import_time2.formatUnix)(normalizedEnd)),
-          import_chalk.default.cyan(symbol),
-          import_chalk.default.cyan(interval),
-          import_chalk.default.yellow(kline.result.list.length)
-        );
+          start: normalizedStart,
+          end: normalizedEnd,
+          limit: LIMIT
+        });
+        if (isKlineRateLimited(kline)) {
+          if (attempt < KLINE_RATE_LIMIT_MAX_ATTEMPTS) {
+            const waitMs = resolveKlineRetryDelayMs(kline, attempt);
+            import_logger3.logger.log(
+              "warn",
+              "kline rate limited for %s %s: attempt=%s/%s waitMs=%s",
+              symbol,
+              interval,
+              attempt,
+              KLINE_RATE_LIMIT_MAX_ATTEMPTS,
+              waitMs
+            );
+            await (0, import_async.delay)(waitMs);
+            continue;
+          }
+        }
+        if (!kline?.result?.list) {
+          const responseError = typeof kline?.retMsg === "string" && kline.retMsg !== "OK" ? `${kline.retMsg}${typeof kline?.retCode === "number" ? ` (retCode: ${kline.retCode})` : ""}` : typeof kline?.retCode === "number" && kline.retCode !== 0 ? `retCode: ${kline.retCode}` : "";
+          import_logger3.logger.log(
+            "error",
+            "empty kline.list for %s %s%s",
+            symbol,
+            interval,
+            responseError ? `: ${responseError}` : ""
+          );
+          return [];
+        }
+        if (!silent && (process.stdout.isTTY || process.env.TRADEJS_LOG_KLINE_REQUESTS === "1")) {
+          import_logger3.logger.log(
+            "info",
+            "%s %s %s %s",
+            import_chalk.default.yellow((0, import_time3.formatUnix)(normalizedEnd)),
+            import_chalk.default.cyan(symbol),
+            import_chalk.default.cyan(interval),
+            import_chalk.default.yellow(kline.result.list.length)
+          );
+        }
+        return mapKlineToChartData(kline.result.list.reverse());
       }
-      return mapKlineToChartData(kline.result.list.reverse());
+      return [];
     } catch (error) {
-      import_logger2.logger.log(
+      import_logger3.logger.log(
         "error",
         "request kline: %s %s %s",
         normalizedStart,
@@ -247,276 +535,326 @@ var ByBitConnectorCreator = async (config) => {
       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 (import_lodash.default.isEmpty(partData)) {
-        fulfilled = true;
-        break;
+  const intervalToMinutes3 = (interval) => {
+    return INTERVAL_TO_MINUTES[String(interval)] ?? null;
+  };
+  const getPositionSnapshot = async (symbol) => {
+    const client = await getPrivateClient();
+    if (!client) {
+      return null;
+    }
+    const positionRes = await client.getPositionInfo({
+      symbol,
+      category: import_constants3.MARKET_CATEGORY
+    });
+    if (positionRes.retCode !== 0) {
+      import_logger3.logger.log(
+        getLogLevel(positionRes),
+        "position retCode: %s, %s",
+        symbol,
+        positionRes.retCode
+      );
+      return null;
+    }
+    const positions = mapPositionData(positionRes.result.list);
+    if (!positions || import_lodash.default.isEmpty(positions)) {
+      return null;
+    }
+    const position = positions[0];
+    import_logger3.logger.log(
+      "debug",
+      "position: %s %s qty=%s price=%s",
+      position.symbol,
+      position.direction,
+      position.qty,
+      position.price
+    );
+    return {
+      ...position
+    };
+  };
+  const setTakeProfits = async ({
+    symbol,
+    direction,
+    qty,
+    takeProfits
+  }) => {
+    const client = await getPrivateClient();
+    const marketDataClient = await getPublicClient();
+    if (!client || !marketDataClient) {
+      return false;
+    }
+    if (!Array.isArray(takeProfits) || takeProfits.length === 0) {
+      return true;
+    }
+    const meta = await getSymbolMeta(marketDataClient, symbol);
+    const positionQty = qty ?? (await getPositionSnapshot(symbol))?.qty ?? 0;
+    if (!Number.isFinite(positionQty) || positionQty <= 0) {
+      import_logger3.logger.log(
+        "warn",
+        "setTakeProfits: missing position qty: %s",
+        (0, import_data2.toJson)({ symbol, qty, positionQty, takeProfits }, true)
+      );
+      return false;
+    }
+    const isLong = direction === "LONG";
+    for (const tp of takeProfits) {
+      const tpSizeRaw = positionQty * tp.rate;
+      const { qtyNum: tpSizeNum, qtyStr: tpSizeStr } = normalizeQty(
+        tpSizeRaw,
+        meta
+      );
+      if (!tpSizeNum || tpSizeNum < meta.minOrderQty) {
+        import_logger3.logger.log(
+          "warn",
+          "tp skipped: size too small %s",
+          (0, import_data2.toJson)(
+            { symbol, tp, tpSizeNum, minOrderQty: meta.minOrderQty },
+            true
+          )
+        );
+        continue;
       }
-      accumulated = direction === "older" ? (0, import_data.mergeData)(partData, accumulated) : (0, import_data.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 tpPriceNorm = normalizePrice(
+        tp.price,
+        isLong ? "TP_LONG" : "TP_SHORT",
+        meta
+      );
+      const isFullMode = takeProfits.length === 1 && tp.rate === 1;
+      const tpRes = await client.setTradingStop({
+        category: import_constants3.MARKET_CATEGORY,
+        symbol,
+        tpSize: isFullMode ? void 0 : tpSizeStr,
+        tpslMode: isFullMode ? "Full" : "Partial",
+        takeProfit: tpPriceNorm.priceStr,
+        tpTriggerBy: "MarkPrice",
+        tpOrderType: "Market",
+        positionIdx: 0
+      });
+      if (isTradingStopNotModified(tpRes)) {
+        import_logger3.logger.log(
+          "debug",
+          "tp unchanged: %s %s price=%s rate=%s",
+          symbol,
+          direction,
+          tpPriceNorm.priceStr,
+          tp.rate
+        );
+      } else if (tpRes.retCode === 0) {
+        import_logger3.logger.log(
+          "info",
+          "tp updated: %s %s price=%s rate=%s",
+          symbol,
+          direction,
+          tpPriceNorm.priceStr,
+          tp.rate
+        );
+      } else {
+        import_logger3.logger.log(
+          "error",
+          "tp failed: %s %s price=%s rate=%s %s",
+          symbol,
+          direction,
+          tpPriceNorm.priceStr,
+          tp.rate,
+          (0, import_data2.toJson)(tpRes, true)
+        );
       }
-      const nextPointer = direction === "older" ? (0, import_time2.getItemTimestamp)(partData[0]) - intervalMs : (0, import_time2.getItemTimestamp)(partData[partData.length - 1]) + intervalMs;
-      if (!Number.isFinite(nextPointer) || nextPointer === currentPointer) {
-        fulfilled = true;
-        break;
+      if (!isTradingStopAccepted(tpRes)) {
+        return false;
       }
-      pointer = nextPointer;
     }
-    return accumulated;
-  };
-  const intervalMsOf = (interval) => interval * 6e4;
-  const intervalToMinutes = (interval) => {
-    return INTERVAL_TO_MINUTES[String(interval)] ?? null;
+    return true;
   };
-  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 ({
+  const setStopLoss = async ({
     symbol,
-    interval,
-    silent,
-    tailCount = 2
+    direction,
+    stopLossPrice
   }) => {
-    const intMinutes = intervalToMinutes(interval);
-    if (!intMinutes) {
-      import_logger2.logger.log("error", "refreshTail: invalid interval %s", interval);
-      return;
+    const client = await getPrivateClient();
+    const marketDataClient = await getPublicClient();
+    if (!client || !marketDataClient) {
+      return false;
     }
-    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({
+    if (typeof stopLossPrice !== "number" || !Number.isFinite(stopLossPrice)) {
+      return true;
+    }
+    const meta = await getSymbolMeta(marketDataClient, symbol);
+    const isLong = direction === "LONG";
+    const slNormalized = normalizePrice(
+      stopLossPrice,
+      isLong ? "SL_LONG" : "SL_SHORT",
+      meta
+    );
+    const slRes = await client.setTradingStop({
+      category: import_constants3.MARKET_CATEGORY,
       symbol,
-      interval,
-      start: tailStart,
-      end: tailEnd,
-      silent
+      tpslMode: "Full",
+      stopLoss: slNormalized.priceStr,
+      slTriggerBy: "LastPrice",
+      positionIdx: 0
     });
-    if (part.length) {
-      await (0, import_timescale.upsertCandles)((0, import_timescale.toRows)(symbol, intMinutes, part));
+    if (isTradingStopNotModified(slRes)) {
+      import_logger3.logger.log(
+        "debug",
+        "sl unchanged: %s %s stopLoss=%s",
+        symbol,
+        direction,
+        slNormalized.priceStr
+      );
+    } else if (slRes.retCode === 0) {
+      import_logger3.logger.log(
+        "info",
+        "sl updated: %s %s stopLoss=%s",
+        symbol,
+        direction,
+        slNormalized.priceStr
+      );
+    } else {
+      import_logger3.logger.log(
+        "error",
+        "sl failed: %s %s stopLoss=%s %s",
+        symbol,
+        direction,
+        slNormalized.priceStr,
+        (0, import_data2.toJson)(slRes, true)
+      );
     }
+    return isTradingStopAccepted(slRes);
   };
   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) {
-        import_logger2.logger.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 (0, import_timescale.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 (0, import_timescale.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 (0, import_timescale.upsertCandles)((0, import_timescale.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 (0, import_timescale.upsertCandles)((0, import_timescale.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 (0, import_timescale.getCandlesRange)(
-          symbol,
-          intMinutes,
-          finalStart,
-          finalEnd
-        );
-        if (isTimescaleFallbackMode) {
-          isTimescaleFallbackMode = false;
-          import_logger2.logger.log("info", "TimescaleDB connection restored for kline cache");
-        }
-        return rowsToKline(dbData);
-      } catch (error) {
-        if (!isTimescaleFallbackMode) {
-          isTimescaleFallbackMode = true;
-          import_logger2.logger.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);
+    kline: createTimescaleCachedKline({
+      provider: "bybit",
+      request,
+      intervalToMinutes: intervalToMinutes3,
+      limit: LIMIT
+    }),
+    getPosition: async (symbol) => getPositionSnapshot(symbol),
+    getPositions: async () => {
+      const client = await getPrivateClient();
       if (!client) {
-        return null;
+        return [];
       }
       const positionRes = await client.getPositionInfo({
-        symbol,
-        category: import_constants2.MARKET_CATEGORY
+        category: import_constants3.MARKET_CATEGORY,
+        settleCoin: "USDT"
       });
-      import_logger2.logger.log(
-        getLogLevel(positionRes),
-        "position retCode: %s, %s",
-        symbol,
-        positionRes.retCode
-      );
       if (positionRes.retCode !== 0) {
-        return null;
+        import_logger3.logger.log(
+          getLogLevel(positionRes),
+          "positions retCode: %s, %s",
+          positionRes.retCode
+        );
+        return [];
       }
       const positions = mapPositionData(positionRes.result.list);
       if (!positions || import_lodash.default.isEmpty(positions)) {
-        return null;
+        return [];
       }
-      const position = positions[0];
-      import_logger2.logger.log(
-        getLogLevel(positionRes),
-        "position: %s, %s",
-        symbol,
-        (0, import_data2.toJson)(positionRes, true)
-      );
-      return {
-        ...position
-      };
+      return positions;
     },
-    getPositions: async () => {
-      const client = await getClient(config);
+    getOpenPositionPnl: async () => {
+      const client = await getPrivateClient();
       if (!client) {
         return [];
       }
       const positionRes = await client.getPositionInfo({
-        category: import_constants2.MARKET_CATEGORY,
+        category: import_constants3.MARKET_CATEGORY,
         settleCoin: "USDT"
       });
-      import_logger2.logger.log(
-        getLogLevel(positionRes),
-        "positions retCode: %s, %s",
-        positionRes.retCode
-      );
       if (positionRes.retCode !== 0) {
+        import_logger3.logger.log(
+          getLogLevel(positionRes),
+          "positions pnl retCode: %s, %s",
+          positionRes.retCode
+        );
         return [];
       }
-      const positions = mapPositionData(positionRes.result.list);
-      if (!positions || import_lodash.default.isEmpty(positions)) {
+      return (positionRes.result?.list ?? []).map((item) => {
+        const qty = Number(item.size ?? Number.NaN);
+        const entryPrice = Number(item.avgPrice ?? Number.NaN);
+        const currentPrice = Number(item.markPrice ?? Number.NaN);
+        const unrealizedPnl = Number(item.unrealisedPnl ?? Number.NaN);
+        const side = String(item.side ?? "");
+        if (!Number.isFinite(qty) || qty <= 0 || !Number.isFinite(entryPrice) || !Number.isFinite(currentPrice) || !Number.isFinite(unrealizedPnl) || side !== "Buy" && side !== "Sell") {
+          return null;
+        }
+        return {
+          symbol: String(item.symbol ?? ""),
+          qty,
+          price: entryPrice,
+          currentPrice,
+          unrealizedPnl,
+          direction: side === "Buy" ? "LONG" : "SHORT"
+        };
+      }).filter(
+        (item) => item != null && item.symbol.length > 0
+      );
+    },
+    getClosedPnl: async ({
+      startTime,
+      endTime,
+      symbol,
+      limit = 100
+    }) => {
+      const client = await getPrivateClient();
+      if (!client) {
         return [];
       }
-      return positions;
+      const response = await client.getClosedPnL({
+        category: import_constants3.MARKET_CATEGORY,
+        startTime,
+        endTime,
+        symbol,
+        limit: Math.min(Math.max(1, Math.trunc(limit)), 100)
+      });
+      if (response.retCode !== 0) {
+        import_logger3.logger.log(
+          "error",
+          "closedPnl retCode: %s, %s",
+          response.retCode,
+          response.retMsg
+        );
+        return [];
+      }
+      return (response.result?.list ?? []).map((item) => {
+        const qty = Number(item.qty ?? item.closedSize ?? Number.NaN);
+        const entryPrice = Number(item.avgEntryPrice ?? Number.NaN);
+        const exitPrice = Number(item.avgExitPrice ?? Number.NaN);
+        const closedPnl = Number(item.closedPnl ?? Number.NaN);
+        const closedAt = Number(
+          item.updatedTime ?? item.createdTime ?? Number.NaN
+        );
+        const orderId = typeof item.orderId === "string" && item.orderId.trim() ? item.orderId : null;
+        if (!String(item.symbol ?? "").trim() || !Number.isFinite(qty) || !Number.isFinite(closedPnl) || !Number.isFinite(closedAt)) {
+          return null;
+        }
+        return {
+          symbol: String(item.symbol),
+          qty,
+          entryPrice: Number.isFinite(entryPrice) ? entryPrice : null,
+          exitPrice: Number.isFinite(exitPrice) ? exitPrice : null,
+          closedPnl,
+          closedAt,
+          ...orderId ? { orderId } : {}
+        };
+      }).filter((item) => item != null);
     },
-    placeOrder: async ({ symbol, price, qty, direction, isLimit }, TP = [], slPrice) => {
-      const client = await getClient(config);
-      if (!client) {
+    placeOrder: async ({ symbol, price, qty, direction, isLimit, orderId }) => {
+      const client = await getPrivateClient();
+      const marketDataClient = await getPublicClient();
+      if (!client || !marketDataClient) {
         return false;
       }
       const isLong = direction === "LONG";
-      const meta = await getSymbolMeta(client, symbol);
+      const meta = await getSymbolMeta(marketDataClient, symbol);
       const { qtyNum: orderQty, qtyStr: orderQtyStr } = normalizeQty(qty, meta);
       if (orderQty < meta.minOrderQty) {
-        import_logger2.logger.log(
+        import_logger3.logger.log(
           "warn",
           "placeOrder: qty too small: %s",
           (0, import_data2.toJson)(
@@ -527,10 +865,7 @@ var ByBitConnectorCreator = async (config) => {
         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;
-      import_logger2.logger.log(
+      import_logger3.logger.log(
         "info",
         "placeOrder: %s",
         (0, import_data2.toJson)(
@@ -540,34 +875,28 @@ var ByBitConnectorCreator = async (config) => {
             qty,
             direction,
             orderQty,
-            orderQtyStr,
-            slPrice,
-            slPriceNorm: slNormalized?.priceStr,
-            TP
+            orderQtyStr
           },
           true
         )
       );
       await client.setLeverage({
-        category: import_constants2.MARKET_CATEGORY,
+        category: import_constants3.MARKET_CATEGORY,
         symbol,
         buyLeverage: "10",
         sellLeverage: "10"
       });
       const orderRes = await client.submitOrder({
-        category: import_constants2.MARKET_CATEGORY,
+        category: import_constants3.MARKET_CATEGORY,
         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"
+        orderFilter: "Order",
+        orderLinkId: typeof orderId === "string" && orderId.trim() ? orderId : void 0
       });
-      import_logger2.logger.log(
+      import_logger3.logger.log(
         getLogLevel(orderRes),
         "placeOrder:response: %s",
         (0, import_data2.toJson)(orderRes, true)
@@ -575,65 +904,24 @@ var ByBitConnectorCreator = async (config) => {
       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) {
-            import_logger2.logger.log(
-              "warn",
-              "tp skipped: size too small %s",
-              (0, import_data2.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: import_constants2.MARKET_CATEGORY,
-            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
-          });
-          import_logger2.logger.log(
-            getLogLevel(tpRes),
-            "tp: %s %s",
-            (0, import_data2.toJson)(tp, true),
-            (0, import_data2.toJson)(tpRes, true)
-          );
-        }
-      }
       return true;
     },
+    setTakeProfits,
+    setStopLoss,
     closePosition: async ({ symbol, direction }) => {
-      const client = await getClient(config);
+      const client = await getPrivateClient();
       if (!client) {
         return false;
       }
       const closeRes = await client.submitOrder({
-        category: import_constants2.MARKET_CATEGORY,
+        category: import_constants3.MARKET_CATEGORY,
         symbol,
         side: direction === "LONG" ? "Sell" : "Buy",
         orderType: "Market",
         qty: "0",
         reduceOnly: true
       });
-      import_logger2.logger.log(
+      import_logger3.logger.log(
         getLogLevel(closeRes),
         "closePosition: %s, %s, %s",
         symbol,
@@ -646,12 +934,12 @@ var ByBitConnectorCreator = async (config) => {
       return true;
     },
     getTickers: async () => {
-      const client = await getClient(config);
+      const client = await getPublicClient();
       if (!client) {
         return [];
       }
       const data = await client.getTickers({
-        category: import_constants2.MARKET_CATEGORY
+        category: import_constants3.MARKET_CATEGORY
       });
       return data.result.list.map((item) => (0, import_tickers.normalizeTickerData)(item));
     }
@@ -694,59 +982,77 @@ var toNum = (value, fallback = 0) => {
   const num = Number(value);
   return Number.isFinite(num) ? num : fallback;
 };
+var intervalToMinutes = (interval) => {
+  const intervalMs = INTERVAL_MS[String(interval)];
+  return intervalMs ? Math.floor(intervalMs / 6e4) : null;
+};
 var BinanceConnectorCreator = async () => {
   let state = {};
+  const requestKline = async ({
+    symbol,
+    interval,
+    start,
+    end
+  }) => {
+    const intervalToken = INTERVAL_MAP[String(interval)];
+    if (!intervalToken) return [];
+    const intervalMs = INTERVAL_MS[String(interval)] ?? 9e5;
+    const normalizedEnd = end ?? Date.now();
+    const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
+    let cursor = start ?? Math.max(0, normalizedEnd - intervalMs * 1e3);
+    const rows = [];
+    while (cursor <= normalizedEnd) {
+      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(normalizedEnd));
+      url.searchParams.set("limit", "1000");
+      const response = await (0, import_http.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;
+  };
   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 (0, import_http.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;
-    },
+    kline: createTimescaleCachedKline({
+      provider: "binance",
+      request: requestKline,
+      intervalToMinutes
+    }),
     getPosition: async () => null,
     getPositions: async () => [],
+    getOpenPositionPnl: async () => [],
     placeOrder: async () => false,
+    setTakeProfits: async () => false,
+    setStopLoss: async () => false,
     closePosition: async () => false,
     getTickers: async () => {
       const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
@@ -827,6 +1133,10 @@ var toNum2 = (value, fallback = 0) => {
   const num = Number(value);
   return Number.isFinite(num) ? num : fallback;
 };
+var intervalToMinutes2 = (interval) => {
+  const intervalMs = INTERVAL_MS2[String(interval)];
+  return intervalMs ? Math.floor(intervalMs / 6e4) : null;
+};
 var toCoinbaseProduct = (symbol) => {
   const upper = symbol.toUpperCase();
   const quoteSuffixes = ["USDT", "USDC", "BUSD", "USD"];
@@ -853,59 +1163,73 @@ var MAJOR_PRODUCTS = [
 ];
 var CoinbaseConnectorCreator = async () => {
   let state = {};
+  const requestKline = 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 normalizedEnd = end ?? Date.now();
+    const stepMs = granularity * 1e3 * 300;
+    const fromMs = start ?? Math.max(0, normalizedEnd - INTERVAL_MS2[String(interval)] * 1e3);
+    let cursorEnd = normalizedEnd;
+    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 (0, import_http2.fetchWithRetry)(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);
+  };
   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 (0, import_http2.fetchWithRetry)(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);
-    },
+    kline: createTimescaleCachedKline({
+      provider: "coinbase",
+      request: requestKline,
+      intervalToMinutes: intervalToMinutes2
+    }),
     getPosition: async () => null,
     getPositions: async () => [],
+    getOpenPositionPnl: async () => [],
     placeOrder: async () => false,
+    setTakeProfits: async () => false,
+    setStopLoss: async () => false,
     closePosition: async () => false,
     getTickers: async () => {
       const baseUrl = process.env.COINBASE_BASE_URL?.trim() || "https://api.exchange.coinbase.com";
@@ -1117,7 +1441,7 @@ var binanceCoinbaseSpreadProvider = {
 };
 
 // src/marketData/providers/coinalyze.ts
-var import_async = require("@tradejs/core/async");
+var import_async2 = require("@tradejs/core/async");
 var import_indicators2 = require("@tradejs/core/indicators");
 var coinalyzeIntervalMap = {
   "15m": "15min",
@@ -1168,12 +1492,8 @@ var normalizeMetricPayload = (metric, raw) => {
   }));
 };
 var fetchCoinalyzeSeries = async (params) => {
-  const { endpoint, metric, symbol, interval, fromMs, toMs } = params;
+  const { endpoint, metric, symbol, apiKey, 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);
@@ -1191,7 +1511,7 @@ var fetchCoinalyzeSeries = async (params) => {
       lastRequestTs + coinalyzeMinRequestDelayMs - now
     );
     if (waitMs > 0) {
-      await (0, import_async.delay)(waitMs);
+      await (0, import_async2.delay)(waitMs);
     }
     lastRequestTs = Date.now();
     const response = await fetch(url.toString(), { headers });
@@ -1205,7 +1525,7 @@ var fetchCoinalyzeSeries = async (params) => {
     const transient = response.status === 429 || response.status >= 500;
     if (attempt < coinalyzeMaxRetries && transient) {
       const backoffMs = Math.min(1e4, 750 * 2 ** attempt);
-      await (0, import_async.delay)(retryAfterMs ?? backoffMs);
+      await (0, import_async2.delay)(retryAfterMs ?? backoffMs);
       continue;
     }
     throw new Error(`Coinalyze ${endpoint} ${response.status}: ${text}`);
@@ -1214,15 +1534,27 @@ var fetchCoinalyzeSeries = async (params) => {
 };
 var coinalyzeProvider = {
   name: "coinalyze",
-  fetchWindow: async ({ symbol, marketSymbol, interval, fromMs, toMs }) => {
+  fetchWindow: async ({
+    symbol,
+    marketSymbol,
+    apiKey,
+    interval,
+    fromMs,
+    toMs
+  }) => {
+    if (!apiKey?.trim()) {
+      throw new Error("Missing COINALYZE_API_KEY in user settings");
+    }
     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 normalizedApiKey = apiKey.trim();
     const oiRaw = await fetchCoinalyzeSeries({
       endpoint: oiPath,
       metric: "oi",
       symbol: requestSymbol,
+      apiKey: normalizedApiKey,
       interval,
       fromMs,
       toMs
@@ -1231,6 +1563,7 @@ var coinalyzeProvider = {
       endpoint: fundingPath,
       metric: "funding",
       symbol: requestSymbol,
+      apiKey: normalizedApiKey,
       interval,
       fromMs,
       toMs
@@ -1239,6 +1572,7 @@ var coinalyzeProvider = {
       endpoint: liqPath,
       metric: "liq",
       symbol: requestSymbol,
+      apiKey: normalizedApiKey,
       interval,
       fromMs,
       toMs