@tradejs/connectors 1.0.9 → 1.0.10

package/dist/index.mjs

@@ -1,11 +1,8 @@
 // src/ByBit/index.ts
 import _ from "lodash";
 import chalk from "chalk";
-import { delay } from "@tradejs/core/async";
-import {
-  MARKET_CATEGORY as MARKET_CATEGORY2,
-  PRELOAD_FALLBACK_DAYS as PRELOAD_FALLBACK_DAYS2
-} from "@tradejs/core/constants";
+import { delay as delay2 } from "@tradejs/core/async";
+import { PRELOAD_FALLBACK_DAYS as PRELOAD_FALLBACK_DAYS2 } from "@tradejs/core/constants";
 import { toJson } from "@tradejs/core/data";
 import { round } from "@tradejs/core/math";
 import { normalizeTickerData } from "@tradejs/core/tickers";
@@ -15,24 +12,43 @@ import { logger as logger3 } from "@tradejs/infra/logger";
 // 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 }, access = "private") => {
+import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
+var PRIVATE_RECV_WINDOW_MS = 1e4;
+var getClient = async (config, access = "private") => {
+  const account = access === "public" && !config.accountId ? null : await resolveTradingAccount({
+    userName: config.userName,
+    accountId: config.accountId,
+    provider: "bybit",
+    universe: config.universe
+  });
+  const useTestnet = account?.environment === "testnet";
   if (access === "public") {
     return new RestClientV5({
       parseAPIRateLimits: true,
       testnet: useTestnet
     });
   }
-  const user = await getData(redisKeys.user(userName));
-  if (!user) {
-    logger.log("error", "connection config not found: %s", userName);
+  if (!account?.apiKey || !account.apiSecret) {
+    if (config.accountId) {
+      logger.log(
+        "error",
+        "Bybit trading account config not found: user=%s account=%s",
+        config.userName,
+        config.accountId
+      );
+    } else {
+      logger.log("error", "connection config not found: %s", config.userName);
+    }
     return null;
   }
   const client = new RestClientV5({
-    key: user.BYBIT_API_KEY,
-    secret: user.BYBIT_API_SECRET,
+    key: account.apiKey,
+    secret: account.apiSecret,
     parseAPIRateLimits: true,
+    recv_window: PRIVATE_RECV_WINDOW_MS,
+    // Avoid noisy bybit-api console.error dumps when its internal
+    // /v5/market/time sync probe hits transient network resets.
+    syncTimeBeforePrivateRequests: false,
     testnet: useTestnet
   });
   return client;
@@ -42,6 +58,7 @@ var getClient = async ({ userName }, access = "private") => {
 import { PRELOAD_FALLBACK_DAYS } from "@tradejs/core/constants";
 import { mergeData } from "@tradejs/core/data";
 import { getItemTimestamp, getTimestamp } from "@tradejs/core/time";
+import { delay } from "@tradejs/core/async";
 import { logger as logger2 } from "@tradejs/infra/logger";
 import {
   getCandlesRange,
@@ -51,6 +68,23 @@ import {
 } from "@tradejs/infra/timescale";
 var DEFAULT_LIMIT = 1e3;
 var DEFAULT_CACHE_FALLBACK_WINDOW = 1e3;
+var DEFAULT_TIMESCALE_RETRIES = 2;
+var DEFAULT_TIMESCALE_RETRY_DELAY_MS = 1e3;
+var resolveNonNegativeInt = (value, fallback) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+  return Math.floor(parsed);
+};
+var getTimescaleRetryCount = () => resolveNonNegativeInt(
+  process.env.TIMESCALE_KLINE_RETRIES,
+  DEFAULT_TIMESCALE_RETRIES
+);
+var getTimescaleRetryDelayMs = () => resolveNonNegativeInt(
+  process.env.TIMESCALE_KLINE_RETRY_DELAY_MS,
+  DEFAULT_TIMESCALE_RETRY_DELAY_MS
+);
 var intervalMsOf = (interval) => interval * 6e4;
 var clampToClosedCandle = (value, intervalMs) => Math.floor(value / intervalMs) * intervalMs;
 var normalizeRangeToClosed = (intervalMs, start, end) => {
@@ -72,10 +106,29 @@ var createTimescaleCachedKline = ({
   cacheFallbackWindow = DEFAULT_CACHE_FALLBACK_WINDOW
 }) => {
   let isTimescaleFallbackMode = false;
-  const loadData = async (direction, pointer, limitBoundary, requestParams, intervalMs) => {
-    if (pointer === void 0) return [];
+  const runTimescaleOperation = async (operation) => {
+    const retries = getTimescaleRetryCount();
+    const retryDelayMs = getTimescaleRetryDelayMs();
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (attempt >= retries) {
+          throw error;
+        }
+        const waitMs = retryDelayMs * 2 ** attempt;
+        if (waitMs > 0) {
+          await delay(waitMs);
+        }
+      }
+    }
+  };
+  const loadData = async (direction, pointer, limitBoundary, requestParams, intervalMs, options = {}) => {
+    if (pointer === void 0) return { data: [], loaded: false };
     let accumulated = [];
     let fulfilled = false;
+    let loaded = false;
+    const shouldAccumulate = options.accumulate ?? true;
     while (!fulfilled) {
       const currentPointer = pointer;
       const params = {
@@ -96,7 +149,13 @@ var createTimescaleCachedKline = ({
         fulfilled = true;
         break;
       }
-      accumulated = direction === "older" ? mergeData(partData, accumulated) : mergeData(accumulated, partData);
+      loaded = true;
+      if (options.onPartData) {
+        await options.onPartData(partData);
+      }
+      if (shouldAccumulate) {
+        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;
@@ -109,7 +168,7 @@ var createTimescaleCachedKline = ({
       }
       pointer = nextPointer;
     }
-    return accumulated;
+    return { data: accumulated, loaded };
   };
   const refreshTail = async ({
     symbol,
@@ -134,7 +193,9 @@ var createTimescaleCachedKline = ({
       silent
     });
     if (part.length) {
-      await upsertCandles(toRows(provider, symbol, intMinutes, part));
+      await runTimescaleOperation(
+        () => upsertCandles(toRows(provider, symbol, intMinutes, part))
+      );
     }
   };
   return async ({
@@ -156,7 +217,9 @@ var createTimescaleCachedKline = ({
     }
     const intervalMs = intervalMsOf(intMinutes);
     try {
-      const edges = await getDataEdges(provider, symbol, intMinutes);
+      const edges = await runTimescaleOperation(
+        () => getDataEdges(provider, symbol, intMinutes)
+      );
       let dataStart = edges.min;
       let dataEnd = edges.max;
       const { normStart, normEnd } = normalizeRangeToClosed(
@@ -171,20 +234,18 @@ var createTimescaleCachedKline = ({
           0
         );
         const e = defaultEnd ?? base;
-        const dbData2 = await getCandlesRange(
-          provider,
-          symbol,
-          intMinutes,
-          s,
-          e
+        const dbData2 = await runTimescaleOperation(
+          () => 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);
+      const persistPartData = warmOnly ? (partData) => runTimescaleOperation(
+        () => upsertCandles(toRows(provider, symbol, intMinutes, partData))
+      ) : void 0;
       if (needOlderData) {
         const pointerForOlder = dataStart ?? normEnd ?? Date.now();
-        const olderData = await loadData(
+        const olderResult = await loadData(
           "older",
           pointerForOlder,
           normStart,
@@ -195,17 +256,34 @@ var createTimescaleCachedKline = ({
             start: normStart,
             end: pointerForOlder
           },
-          intervalMs
+          intervalMs,
+          {
+            accumulate: !warmOnly,
+            onPartData: persistPartData
+          }
         );
-        if (olderData.length) {
-          await upsertCandles(toRows(provider, symbol, intMinutes, olderData));
+        if (warmOnly && olderResult.loaded) {
           dataStart = normStart;
+          if (dataEnd === void 0) {
+            dataEnd = normEnd;
+          }
+        } else if (olderResult.data.length) {
+          await runTimescaleOperation(
+            () => upsertCandles(
+              toRows(provider, symbol, intMinutes, olderResult.data)
+            )
+          );
+          dataStart = normStart;
+          if (dataEnd === void 0) {
+            dataEnd = normEnd;
+          }
         }
       }
+      const needNewerData = defaultEnd !== void 0 && (dataEnd === void 0 || normEnd > dataEnd);
       if (needNewerData) {
         const fallbackStart = getTimestamp(PRELOAD_FALLBACK_DAYS);
         const pointerForNewer = dataEnd ?? (defaultStart !== void 0 ? normStart : fallbackStart) ?? 0;
-        const newerData = await loadData(
+        const newerResult = await loadData(
           "newer",
           pointerForNewer,
           normEnd,
@@ -216,10 +294,20 @@ var createTimescaleCachedKline = ({
             start: pointerForNewer,
             end: normEnd
           },
-          intervalMs
+          intervalMs,
+          {
+            accumulate: !warmOnly,
+            onPartData: persistPartData
+          }
         );
-        if (newerData.length) {
-          await upsertCandles(toRows(provider, symbol, intMinutes, newerData));
+        if (warmOnly && newerResult.loaded) {
+          dataEnd = normEnd;
+        } else if (newerResult.data.length) {
+          await runTimescaleOperation(
+            () => upsertCandles(
+              toRows(provider, symbol, intMinutes, newerResult.data)
+            )
+          );
           dataEnd = normEnd;
         }
       }
@@ -237,12 +325,8 @@ var createTimescaleCachedKline = ({
       const rangeStart = defaultStart ?? dataStart ?? 0;
       const rangeEnd = defaultEnd ?? dataEnd ?? Date.now();
       const { normStart: finalStart, normEnd: finalEnd } = normalizeRangeToClosed(intervalMs, rangeStart, rangeEnd);
-      const dbData = await getCandlesRange(
-        provider,
-        symbol,
-        intMinutes,
-        finalStart,
-        finalEnd
+      const dbData = await runTimescaleOperation(
+        () => getCandlesRange(provider, symbol, intMinutes, finalStart, finalEnd)
       );
       if (isTimescaleFallbackMode) {
         isTimescaleFallbackMode = false;
@@ -275,8 +359,8 @@ var createTimescaleCachedKline = ({
 };
 
 // src/ByBit/utils.ts
-import { MARKET_CATEGORY } from "@tradejs/core/constants";
 import { formatUnix } from "@tradejs/core/time";
+var BYBIT_CATEGORY = "linear";
 var parseKlineItem = (item) => ({
   dt: formatUnix(parseInt(item[0])),
   timestamp: parseInt(item[0]),
@@ -304,7 +388,7 @@ var getSymbolMeta = async (client, symbol) => {
   const cached = symbolMetaCache.get(symbol);
   if (cached) return cached;
   const res = await client.getInstrumentsInfo({
-    category: MARKET_CATEGORY,
+    category: BYBIT_CATEGORY,
     symbol
   });
   const item = res?.result?.list?.[0];
@@ -319,7 +403,10 @@ var getSymbolMeta = async (client, symbol) => {
     qtyStep: Number(qtyStepStr),
     minOrderQty: Number(minOrderQtyStr),
     pricePrecision: stepToPrecision(tickSizeStr),
-    qtyPrecision: stepToPrecision(qtyStepStr)
+    qtyPrecision: stepToPrecision(qtyStepStr),
+    maxLeverage: Number.isFinite(
+      Number(item.leverageFilter?.maxLeverage)
+    ) ? Number(item.leverageFilter.maxLeverage) : null
   };
   symbolMetaCache.set(symbol, meta);
   return meta;
@@ -366,13 +453,31 @@ var mapPositionData = (data) => {
 };
 
 // src/ByBit/index.ts
+import {
+  resolveConnectorUniverse
+} from "@tradejs/types";
 var LIMIT = 1e3;
+var BYBIT_CATEGORY2 = "linear";
+var BYBIT_CAPABILITIES = {
+  supportedUniverses: ["crypto", "tradfi"],
+  defaultUniverse: "crypto"
+};
+var BYBIT_TRADFI_SYMBOL_TYPES = ["stock", "commodity", "forex"];
+var FUNDING_HISTORY_LIMIT = 200;
 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 POSITION_SNAPSHOT_TIMEOUT_MS = Math.max(
+  1e3,
+  Number(process.env.TRADEJS_BYBIT_POSITION_TIMEOUT_MS ?? 1e4)
+);
+var POSITION_SNAPSHOT_CACHE_TTL_MS = Math.max(
+  250,
+  Number(process.env.TRADEJS_BYBIT_POSITION_CACHE_TTL_MS ?? 1500)
+);
 var INTERVAL_TO_MINUTES = {
   "1": 1,
   "3": 3,
@@ -392,6 +497,144 @@ 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 mapBybitAssetClass = (symbolType) => {
+  if (symbolType === "stock") return "equity";
+  if (symbolType === "commodity") return "commodity";
+  if (symbolType === "forex") return "forex";
+  return "crypto";
+};
+var mapBybitInstrument = (item) => {
+  const assetClass = mapBybitAssetClass(item.symbolType);
+  return {
+    provider: "bybit",
+    symbol: String(item.symbol ?? "").trim().toUpperCase(),
+    kind: "perpetual",
+    assetClass,
+    universe: assetClass === "crypto" ? "crypto" : "tradfi",
+    status: String(item.status ?? "").toLowerCase() === "trading" ? "trading" : "inactive",
+    baseAsset: String(item.baseCoin ?? "").trim() || void 0,
+    quoteAsset: String(item.quoteCoin ?? "").trim() || void 0,
+    settleAsset: String(item.settleCoin ?? "").trim() || void 0,
+    displayName: String(item.displayName ?? "").trim() || void 0,
+    venueMetadata: {
+      category: BYBIT_CATEGORY2,
+      symbolType: String(item.symbolType ?? ""),
+      contractType: String(item.contractType ?? ""),
+      fundingInterval: Number(item.fundingInterval ?? Number.NaN),
+      maxLeverage: Number(item.leverageFilter?.maxLeverage ?? Number.NaN)
+    }
+  };
+};
+var getOptionalStringField = (source, key) => {
+  if (!source || typeof source !== "object") {
+    return null;
+  }
+  const value = source[key];
+  return typeof value === "string" && value.trim() ? value : null;
+};
+var toFiniteNumberOrNull = (value) => {
+  const parsed = Number(value ?? Number.NaN);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var sumOptionalFees = (values) => {
+  const finiteValues = values.filter(
+    (value) => typeof value === "number" && Number.isFinite(value)
+  );
+  return finiteValues.length ? Number(finiteValues.reduce((sum, value) => sum + value, 0).toFixed(12)) : null;
+};
+var FUNDING_TRANSACTION_LOG_PAGE_LIMIT = 100;
+var FUNDING_TRANSACTION_LOG_MAX_PAGES = 20;
+var CLOSED_PNL_PAGE_LIMIT = 100;
+var CLOSED_PNL_MAX_PAGES = 20;
+var EXECUTION_PAGE_LIMIT = 100;
+var EXECUTION_MAX_PAGES = 20;
+var loadFundingFeeRows = async ({
+  client,
+  startTime,
+  endTime,
+  symbol
+}) => {
+  if (typeof client.getTransactionLog !== "function") {
+    return [];
+  }
+  try {
+    const rows = [];
+    let cursor;
+    for (let page = 0; page < FUNDING_TRANSACTION_LOG_MAX_PAGES; page += 1) {
+      const response = await client.getTransactionLog({
+        accountType: "UNIFIED",
+        category: BYBIT_CATEGORY2,
+        type: "SETTLEMENT",
+        startTime,
+        endTime,
+        limit: FUNDING_TRANSACTION_LOG_PAGE_LIMIT,
+        ...cursor ? { cursor } : {}
+      });
+      if (response?.retCode !== 0) {
+        logger3.log(
+          "debug",
+          "funding transaction log retCode: %s, %s",
+          response?.retCode,
+          response?.retMsg
+        );
+        return rows;
+      }
+      const pageRows = (response.result?.list ?? []).map((item) => {
+        const rowSymbol = String(item.symbol ?? "").trim();
+        const timestamp = Number(item.transactionTime ?? Number.NaN);
+        const fundingFee = Number(item.funding ?? Number.NaN);
+        if (!rowSymbol || !Number.isFinite(timestamp) || !Number.isFinite(fundingFee) || symbol && rowSymbol !== symbol) {
+          return null;
+        }
+        return {
+          symbol: rowSymbol,
+          timestamp,
+          fundingFee
+        };
+      });
+      rows.push(
+        ...pageRows.filter((item) => item != null)
+      );
+      const nextCursor = String(response.result?.nextPageCursor ?? "").trim();
+      if (!nextCursor || nextCursor === cursor) {
+        break;
+      }
+      cursor = nextCursor;
+    }
+    return rows;
+  } catch (error) {
+    logger3.log("debug", "funding transaction log failed: %s", error);
+    return [];
+  }
+};
+var sumFundingFeeForTrade = ({
+  rows,
+  symbol,
+  entryTimestamp,
+  closedAt
+}) => {
+  if (entryTimestamp == null || !Number.isFinite(entryTimestamp)) {
+    return null;
+  }
+  const matched = rows.filter(
+    (row) => row.symbol === symbol && row.timestamp >= entryTimestamp && row.timestamp <= closedAt
+  );
+  return matched.length ? Number(matched.reduce((sum, row) => sum + row.fundingFee, 0).toFixed(12)) : null;
+};
+var inferClosedPnlDirection = ({
+  entryPrice,
+  exitPrice,
+  closedPnl
+}) => {
+  const priceDelta = exitPrice - entryPrice;
+  if (!Number.isFinite(priceDelta) || priceDelta === 0) {
+    return null;
+  }
+  if (closedPnl === 0) {
+    return priceDelta > 0 ? "LONG" : "SHORT";
+  }
+  return priceDelta * closedPnl > 0 ? "LONG" : "SHORT";
+};
 var resolveKlineRetryDelayMs = (res, attempt) => {
   const resetAtRaw = Number(res?.rateLimitApi?.resetAtTimestamp);
   if (Number.isFinite(resetAtRaw) && resetAtRaw > 0) {
@@ -409,8 +652,14 @@ var resolveKlineRetryDelayMs = (res, attempt) => {
 };
 var ByBitConnectorCreator = async (config) => {
   let state = {};
+  const universe = resolveConnectorUniverse(
+    BYBIT_CAPABILITIES,
+    config.universe
+  );
   let publicClientPromise = null;
   let privateClientPromise = null;
+  const positionSnapshotCache = /* @__PURE__ */ new Map();
+  const inflightPositionSnapshots = /* @__PURE__ */ new Map();
   const getPublicClient = async () => {
     publicClientPromise ??= getClient(config, "public");
     return publicClientPromise;
@@ -419,6 +668,123 @@ var ByBitConnectorCreator = async (config) => {
     privateClientPromise ??= getClient(config, "private");
     return privateClientPromise;
   };
+  const instrumentCache = /* @__PURE__ */ new Map();
+  const fetchInstrumentGroup = async (symbolType) => {
+    const client = await getPublicClient();
+    if (!client) return [];
+    if (typeof client.getInstrumentsInfo !== "function") {
+      if (universe === "tradfi" || symbolType) {
+        throw new Error("Bybit instrument discovery is unavailable");
+      }
+      return [];
+    }
+    const instruments = [];
+    let cursor;
+    for (; ; ) {
+      const response = await client.getInstrumentsInfo({
+        category: BYBIT_CATEGORY2,
+        limit: LIMIT,
+        ...symbolType ? { symbolType } : {},
+        ...cursor ? { cursor } : {}
+      });
+      if (response.retCode !== 0) {
+        throw new Error(
+          `Bybit instruments failed: ${response.retCode} ${response.retMsg}`
+        );
+      }
+      for (const raw of response.result?.list ?? []) {
+        const instrument = mapBybitInstrument(raw);
+        if (instrument.symbol) instruments.push(instrument);
+      }
+      const nextCursor = String(response.result?.nextPageCursor ?? "").trim();
+      if (!nextCursor || nextCursor === cursor) break;
+      cursor = nextCursor;
+    }
+    return instruments;
+  };
+  const loadInstrumentUniverse = (requestedUniverse) => {
+    const cached = instrumentCache.get(requestedUniverse);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.promise;
+    }
+    const promise = requestedUniverse === "tradfi" ? Promise.all(
+      BYBIT_TRADFI_SYMBOL_TYPES.map(
+        (symbolType) => fetchInstrumentGroup(symbolType)
+      )
+    ).then((groups) => {
+      const bySymbol = /* @__PURE__ */ new Map();
+      for (const instrument of groups.flat()) {
+        bySymbol.set(instrument.symbol, instrument);
+      }
+      return [...bySymbol.values()];
+    }) : fetchInstrumentGroup().then(
+      (instruments) => instruments.filter(
+        (instrument) => instrument.universe === "crypto"
+      )
+    );
+    instrumentCache.set(requestedUniverse, {
+      expiresAt: Date.now() + 5 * 6e4,
+      promise
+    });
+    promise.catch(() => instrumentCache.delete(requestedUniverse));
+    return promise;
+  };
+  const listInstruments = async (query = {}) => {
+    const requestedUniverse = resolveConnectorUniverse(
+      BYBIT_CAPABILITIES,
+      query?.universe ?? universe
+    );
+    const [assetClasses, symbols] = [
+      query?.assetClasses?.length ? new Set(query.assetClasses) : null,
+      query?.symbols?.length ? new Set(query.symbols.map((symbol) => symbol.trim().toUpperCase())) : null
+    ];
+    return (await loadInstrumentUniverse(requestedUniverse)).filter(
+      (instrument) => (!assetClasses || assetClasses.has(instrument.assetClass)) && (!symbols || symbols.has(instrument.symbol))
+    );
+  };
+  const withTimeout = async (promise, timeoutMs, label) => {
+    let timeoutHandle = null;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise((_2, reject) => {
+          timeoutHandle = setTimeout(() => {
+            reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+  };
+  const setCachedPositionSnapshot = (symbol, value) => {
+    positionSnapshotCache.set(symbol, {
+      value,
+      expiresAt: Date.now() + POSITION_SNAPSHOT_CACHE_TTL_MS
+    });
+  };
+  const getCachedPositionSnapshot = (symbol) => {
+    const cached = positionSnapshotCache.get(symbol);
+    if (!cached) {
+      return void 0;
+    }
+    if (cached.expiresAt <= Date.now()) {
+      positionSnapshotCache.delete(symbol);
+      return void 0;
+    }
+    return cached.value;
+  };
+  const invalidatePositionSnapshot = (symbol) => {
+    if (typeof symbol === "string" && symbol.length > 0) {
+      positionSnapshotCache.delete(symbol);
+      inflightPositionSnapshots.delete(symbol);
+      return;
+    }
+    positionSnapshotCache.clear();
+    inflightPositionSnapshots.clear();
+  };
   const request = async ({
     symbol,
     interval,
@@ -439,7 +805,7 @@ var ByBitConnectorCreator = async (config) => {
       }
       for (let attempt = 1; attempt <= KLINE_RATE_LIMIT_MAX_ATTEMPTS; attempt += 1) {
         const kline = await client.getKline({
-          category: MARKET_CATEGORY2,
+          category: BYBIT_CATEGORY2,
           symbol,
           interval,
           start: normalizedStart,
@@ -458,7 +824,7 @@ var ByBitConnectorCreator = async (config) => {
               KLINE_RATE_LIMIT_MAX_ATTEMPTS,
               waitMs
             );
-            await delay(waitMs);
+            await delay2(waitMs);
             continue;
           }
         }
@@ -500,40 +866,67 @@ var ByBitConnectorCreator = async (config) => {
   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: MARKET_CATEGORY2
-    });
-    if (positionRes.retCode !== 0) {
+  const fetchPositionSnapshot = async (symbol) => {
+    try {
+      const client = await getPrivateClient();
+      if (!client) {
+        return null;
+      }
+      const positionRes = await withTimeout(
+        client.getPositionInfo({
+          symbol,
+          category: BYBIT_CATEGORY2
+        }),
+        POSITION_SNAPSHOT_TIMEOUT_MS,
+        `bybit getPositionInfo ${symbol}`
+      );
+      if (positionRes.retCode !== 0) {
+        logger3.log(
+          getLogLevel(positionRes),
+          "position retCode: %s, %s",
+          symbol,
+          positionRes.retCode
+        );
+        return null;
+      }
+      const positions = mapPositionData(positionRes.result.list);
+      if (!positions || _.isEmpty(positions)) {
+        return null;
+      }
+      const position = positions[0];
       logger3.log(
-        getLogLevel(positionRes),
-        "position retCode: %s, %s",
-        symbol,
-        positionRes.retCode
+        "debug",
+        "position: %s %s qty=%s price=%s",
+        position.symbol,
+        position.direction,
+        position.qty,
+        position.price
       );
+      return {
+        ...position
+      };
+    } catch (error) {
+      logger3.log("error", "getPositionSnapshot failed: %s %s", symbol, error);
       return null;
     }
-    const positions = mapPositionData(positionRes.result.list);
-    if (!positions || _.isEmpty(positions)) {
-      return null;
+  };
+  const getPositionSnapshot = async (symbol) => {
+    const cached = getCachedPositionSnapshot(symbol);
+    if (cached !== void 0) {
+      return cached;
     }
-    const position = positions[0];
-    logger3.log(
-      "debug",
-      "position: %s %s qty=%s price=%s",
-      position.symbol,
-      position.direction,
-      position.qty,
-      position.price
-    );
-    return {
-      ...position
-    };
+    const inflight = inflightPositionSnapshots.get(symbol);
+    if (inflight) {
+      return inflight;
+    }
+    const nextSnapshotPromise = fetchPositionSnapshot(symbol).then((position) => {
+      setCachedPositionSnapshot(symbol, position);
+      return position;
+    }).finally(() => {
+      inflightPositionSnapshots.delete(symbol);
+    });
+    inflightPositionSnapshots.set(symbol, nextSnapshotPromise);
+    return nextSnapshotPromise;
   };
   const setTakeProfits = async ({
     symbol,
@@ -584,7 +977,7 @@ var ByBitConnectorCreator = async (config) => {
       );
       const isFullMode = takeProfits.length === 1 && tp.rate === 1;
       const tpRes = await client.setTradingStop({
-        category: MARKET_CATEGORY2,
+        category: BYBIT_CATEGORY2,
         symbol,
         tpSize: isFullMode ? void 0 : tpSizeStr,
         tpslMode: isFullMode ? "Full" : "Partial",
@@ -649,7 +1042,7 @@ var ByBitConnectorCreator = async (config) => {
       meta
     );
     const slRes = await client.setTradingStop({
-      category: MARKET_CATEGORY2,
+      category: BYBIT_CATEGORY2,
       symbol,
       tpslMode: "Full",
       stopLoss: slNormalized.priceStr,
@@ -685,6 +1078,11 @@ var ByBitConnectorCreator = async (config) => {
     return isTradingStopAccepted(slRes);
   };
   return {
+    capabilities: BYBIT_CAPABILITIES,
+    universe,
+    accountId: config.accountId,
+    deploymentId: config.deploymentId,
+    listInstruments,
     getState: async () => state,
     setState: async (newState) => {
       state = { ...state, ...newState };
@@ -702,7 +1100,7 @@ var ByBitConnectorCreator = async (config) => {
         return [];
       }
       const positionRes = await client.getPositionInfo({
-        category: MARKET_CATEGORY2,
+        category: BYBIT_CATEGORY2,
         settleCoin: "USDT"
       });
       if (positionRes.retCode !== 0) {
@@ -725,7 +1123,7 @@ var ByBitConnectorCreator = async (config) => {
         return [];
       }
       const positionRes = await client.getPositionInfo({
-        category: MARKET_CATEGORY2,
+        category: BYBIT_CATEGORY2,
         settleCoin: "USDT"
       });
       if (positionRes.retCode !== 0) {
@@ -741,6 +1139,8 @@ var ByBitConnectorCreator = async (config) => {
         const entryPrice = Number(item.avgPrice ?? Number.NaN);
         const currentPrice = Number(item.markPrice ?? Number.NaN);
         const unrealizedPnl = Number(item.unrealisedPnl ?? Number.NaN);
+        const takeProfitPrice = toFiniteNumberOrNull(item.takeProfit);
+        const stopLossPrice = toFiniteNumberOrNull(item.stopLoss);
         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;
@@ -751,7 +1151,9 @@ var ByBitConnectorCreator = async (config) => {
           price: entryPrice,
           currentPrice,
           unrealizedPnl,
-          direction: side === "Buy" ? "LONG" : "SHORT"
+          direction: side === "Buy" ? "LONG" : "SHORT",
+          ...takeProfitPrice != null && takeProfitPrice > 0 ? { takeProfitPrice } : {},
+          ...stopLossPrice != null && stopLossPrice > 0 ? { stopLossPrice } : {}
         };
       }).filter(
         (item) => item != null && item.symbol.length > 0
@@ -767,23 +1169,47 @@ var ByBitConnectorCreator = async (config) => {
       if (!client) {
         return [];
       }
-      const response = await client.getClosedPnL({
-        category: MARKET_CATEGORY2,
+      const closedPnlRows = [];
+      let cursor;
+      const pageLimit = Math.min(
+        Math.max(1, Math.trunc(limit)),
+        CLOSED_PNL_PAGE_LIMIT
+      );
+      for (let page = 0; page < CLOSED_PNL_MAX_PAGES; page += 1) {
+        const response = await client.getClosedPnL({
+          category: BYBIT_CATEGORY2,
+          startTime,
+          endTime,
+          symbol,
+          limit: pageLimit,
+          ...cursor ? { cursor } : {}
+        });
+        if (response.retCode !== 0) {
+          logger3.log(
+            "error",
+            "closedPnl retCode: %s, %s",
+            response.retCode,
+            response.retMsg
+          );
+          return [];
+        }
+        closedPnlRows.push(...response.result?.list ?? []);
+        const nextCursor = String(response.result?.nextPageCursor ?? "").trim();
+        if (!nextCursor || nextCursor === cursor) {
+          break;
+        }
+        cursor = nextCursor;
+      }
+      if (!closedPnlRows.length) {
+        return [];
+      }
+      const fundingRows = await loadFundingFeeRows({
+        client,
         startTime,
         endTime,
-        symbol,
-        limit: Math.min(Math.max(1, Math.trunc(limit)), 100)
+        symbol
       });
-      if (response.retCode !== 0) {
-        logger3.log(
-          "error",
-          "closedPnl retCode: %s, %s",
-          response.retCode,
-          response.retMsg
-        );
-        return [];
-      }
-      return (response.result?.list ?? []).map((item) => {
+      return closedPnlRows.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);
@@ -791,7 +1217,23 @@ var ByBitConnectorCreator = async (config) => {
         const closedAt = Number(
           item.updatedTime ?? item.createdTime ?? Number.NaN
         );
+        const entryTimestamp = Number(item.createdTime ?? Number.NaN);
         const orderId = typeof item.orderId === "string" && item.orderId.trim() ? item.orderId : null;
+        const orderLinkId = getOptionalStringField(item, "orderLinkId");
+        const openFee = toFiniteNumberOrNull(item.openFee);
+        const closeFee = toFiniteNumberOrNull(item.closeFee);
+        const fundingFee = sumFundingFeeForTrade({
+          rows: fundingRows,
+          symbol: String(item.symbol ?? ""),
+          entryTimestamp: Number.isFinite(entryTimestamp) ? entryTimestamp : null,
+          closedAt
+        });
+        const totalFee = sumOptionalFees([openFee, closeFee, fundingFee]);
+        const direction = Number.isFinite(entryPrice) && Number.isFinite(exitPrice) ? inferClosedPnlDirection({
+          entryPrice,
+          exitPrice,
+          closedPnl
+        }) : null;
         if (!String(item.symbol ?? "").trim() || !Number.isFinite(qty) || !Number.isFinite(closedPnl) || !Number.isFinite(closedAt)) {
           return null;
         }
@@ -802,29 +1244,145 @@ var ByBitConnectorCreator = async (config) => {
           exitPrice: Number.isFinite(exitPrice) ? exitPrice : null,
           closedPnl,
           closedAt,
-          ...orderId ? { orderId } : {}
+          ...direction ? { direction } : {},
+          ...Number.isFinite(entryTimestamp) ? { entryTimestamp } : {},
+          ...orderId ? { orderId } : {},
+          ...orderLinkId ? { orderLinkId } : {},
+          ...openFee != null ? { openFee } : {},
+          ...closeFee != null ? { closeFee } : {},
+          ...fundingFee != null ? { fundingFee } : {},
+          ...totalFee != null ? { totalFee } : {}
         };
       }).filter((item) => item != null);
     },
-    placeOrder: async ({ symbol, price, qty, direction, isLimit, orderId }) => {
+    getEntryExecutions: async ({
+      startTime,
+      endTime,
+      symbol,
+      limit = 100
+    }) => {
+      const client = await getPrivateClient();
+      if (!client) {
+        return [];
+      }
+      const executionRows = [];
+      let cursor;
+      const pageLimit = Math.min(
+        Math.max(1, Math.trunc(limit)),
+        EXECUTION_PAGE_LIMIT
+      );
+      for (let page = 0; page < EXECUTION_MAX_PAGES; page += 1) {
+        const response = await client.getExecutionList({
+          category: BYBIT_CATEGORY2,
+          settleCoin: "USDT",
+          startTime,
+          endTime,
+          symbol,
+          limit: pageLimit,
+          ...cursor ? { cursor } : {}
+        });
+        if (response.retCode !== 0) {
+          logger3.log(
+            "error",
+            "entryExecutions retCode: %s, %s",
+            response.retCode,
+            response.retMsg
+          );
+          return [];
+        }
+        executionRows.push(...response.result?.list ?? []);
+        const nextCursor = String(response.result?.nextPageCursor ?? "").trim();
+        if (!nextCursor || nextCursor === cursor) {
+          break;
+        }
+        cursor = nextCursor;
+      }
+      if (!executionRows.length) {
+        return [];
+      }
+      const fundingRows = await loadFundingFeeRows({
+        client,
+        startTime,
+        endTime,
+        symbol
+      });
+      return executionRows.map((item) => {
+        const qty = Number(item.execQty ?? item.orderQty ?? Number.NaN);
+        const entryPrice = Number(item.execPrice ?? Number.NaN);
+        const entryTimestamp = Number(item.execTime ?? Number.NaN);
+        const side = String(item.side ?? "");
+        const orderId = typeof item.orderId === "string" && item.orderId.trim() ? item.orderId : null;
+        const orderLinkId = typeof item.orderLinkId === "string" && item.orderLinkId.trim() ? item.orderLinkId : null;
+        const openFee = toFiniteNumberOrNull(item.execFeeV2 ?? item.execFee);
+        const fundingFee = sumFundingFeeForTrade({
+          rows: fundingRows,
+          symbol: String(item.symbol ?? ""),
+          entryTimestamp,
+          closedAt: endTime
+        });
+        const totalFee = sumOptionalFees([openFee, fundingFee]);
+        if (!String(item.symbol ?? "").trim() || !Number.isFinite(qty) || !Number.isFinite(entryTimestamp) || !Number.isFinite(entryPrice) || side !== "Buy" && side !== "Sell" || !orderLinkId) {
+          return null;
+        }
+        return {
+          symbol: String(item.symbol),
+          qty,
+          entryPrice,
+          entryTimestamp,
+          direction: side === "Buy" ? "LONG" : "SHORT",
+          ...orderId ? { orderId } : {},
+          ...orderLinkId ? { orderLinkId } : {},
+          ...openFee != null ? { openFee } : {},
+          ...fundingFee != null ? { fundingFee } : {},
+          ...totalFee != null ? { totalFee } : {}
+        };
+      }).filter((item) => item != null).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+    },
+    placeOrder: async ({
+      symbol,
+      price,
+      qty,
+      direction,
+      isLimit,
+      orderId,
+      signal,
+      leverage
+    }) => {
+      invalidatePositionSnapshot(symbol);
       const client = await getPrivateClient();
       const marketDataClient = await getPublicClient();
       if (!client || !marketDataClient) {
+        if (signal) {
+          signal.orderFailureReason = "BYBIT_CLIENT_UNAVAILABLE";
+        }
         return false;
       }
       const isLong = direction === "LONG";
       const meta = await getSymbolMeta(marketDataClient, symbol);
-      const { qtyNum: orderQty, qtyStr: orderQtyStr } = normalizeQty(qty, meta);
-      if (orderQty < meta.minOrderQty) {
+      const normalizedQty = normalizeQty(qty, meta);
+      const minNormalizedQty = normalizeQty(meta.minOrderQty, meta);
+      const isQtyBelowMin = normalizedQty.qtyNum < meta.minOrderQty;
+      const orderQty = isQtyBelowMin ? Math.max(minNormalizedQty.qtyNum, meta.minOrderQty) : normalizedQty.qtyNum;
+      const orderQtyStr = isQtyBelowMin ? orderQty.toFixed(meta.qtyPrecision) : normalizedQty.qtyStr;
+      if (isQtyBelowMin) {
         logger3.log(
           "warn",
-          "placeOrder: qty too small: %s",
+          "placeOrder: qty below min, using minOrderQty: %s",
           toJson(
-            { symbol, qty, orderQty, minOrderQty: meta.minOrderQty },
+            {
+              symbol,
+              qty,
+              requestedOrderQty: normalizedQty.qtyNum,
+              orderQty,
+              minOrderQty: meta.minOrderQty
+            },
             true
           )
         );
-        return false;
+      }
+      if (signal) {
+        signal.orderQty = orderQty;
+        signal.orderValue = orderQty * price;
       }
       const entryNormalized = isLimit ? normalizePrice(price, "ENTRY", meta) : void 0;
       logger3.log(
@@ -842,14 +1400,16 @@ var ByBitConnectorCreator = async (config) => {
           true
         )
       );
+      const requestedLeverage = typeof leverage === "number" && Number.isFinite(leverage) ? Math.max(1, leverage) : 10;
+      const effectiveLeverage = meta.maxLeverage != null ? Math.min(requestedLeverage, meta.maxLeverage) : requestedLeverage;
       await client.setLeverage({
-        category: MARKET_CATEGORY2,
+        category: BYBIT_CATEGORY2,
         symbol,
-        buyLeverage: "10",
-        sellLeverage: "10"
+        buyLeverage: String(effectiveLeverage),
+        sellLeverage: String(effectiveLeverage)
       });
       const orderRes = await client.submitOrder({
-        category: MARKET_CATEGORY2,
+        category: BYBIT_CATEGORY2,
         symbol,
         price: entryNormalized?.priceStr || void 0,
         side: isLong ? "Buy" : "Sell",
@@ -864,19 +1424,27 @@ var ByBitConnectorCreator = async (config) => {
         toJson(orderRes, true)
       );
       if (orderRes.retCode !== 0) {
+        if (signal) {
+          signal.orderFailureReason = typeof orderRes.retMsg === "string" && orderRes.retMsg.trim() ? orderRes.retMsg.trim() : `BYBIT_RETCODE_${orderRes.retCode}`;
+        }
         return false;
       }
+      if (signal) {
+        signal.orderFailureReason = void 0;
+      }
+      invalidatePositionSnapshot(symbol);
       return true;
     },
     setTakeProfits,
     setStopLoss,
     closePosition: async ({ symbol, direction }) => {
+      invalidatePositionSnapshot(symbol);
       const client = await getPrivateClient();
       if (!client) {
         return false;
       }
       const closeRes = await client.submitOrder({
-        category: MARKET_CATEGORY2,
+        category: BYBIT_CATEGORY2,
         symbol,
         side: direction === "LONG" ? "Sell" : "Buy",
         orderType: "Market",
@@ -893,23 +1461,111 @@ var ByBitConnectorCreator = async (config) => {
       if (closeRes.retCode !== 0) {
         return false;
       }
+      invalidatePositionSnapshot(symbol);
       return true;
     },
-    getTickers: async () => {
+    getFundingRateHistory: async (rateRequest) => {
+      const client = await getPublicClient();
+      if (!client) return [];
+      const safeLimit = Math.min(
+        FUNDING_HISTORY_LIMIT,
+        Math.max(1, Math.trunc(rateRequest.limit ?? FUNDING_HISTORY_LIMIT))
+      );
+      const byTimestamp = /* @__PURE__ */ new Map();
+      let cursorEnd = Math.trunc(rateRequest.endTime);
+      while (Number.isFinite(cursorEnd) && cursorEnd >= (rateRequest.startTime ?? 0)) {
+        const response = await client.getFundingRateHistory({
+          category: BYBIT_CATEGORY2,
+          symbol: rateRequest.symbol.trim().toUpperCase(),
+          endTime: cursorEnd,
+          limit: safeLimit
+        });
+        if (response.retCode !== 0) {
+          throw new Error(
+            `Bybit funding history failed: ${response.retCode} ${response.retMsg}`
+          );
+        }
+        const page = response.result?.list ?? [];
+        if (!page.length) break;
+        let oldestTimestamp = Number.POSITIVE_INFINITY;
+        for (const item of page) {
+          const timestamp = Number(item.fundingRateTimestamp);
+          const rate = Number(item.fundingRate);
+          if (!Number.isFinite(timestamp) || !Number.isFinite(rate)) continue;
+          oldestTimestamp = Math.min(oldestTimestamp, timestamp);
+          if (timestamp >= (rateRequest.startTime ?? 0)) {
+            byTimestamp.set(timestamp, {
+              symbol: String(item.symbol ?? rateRequest.symbol),
+              timestamp,
+              rate
+            });
+          }
+        }
+        if (page.length < safeLimit || !Number.isFinite(oldestTimestamp) || oldestTimestamp <= (rateRequest.startTime ?? 0)) {
+          break;
+        }
+        const nextEnd = oldestTimestamp - 1;
+        if (nextEnd >= cursorEnd) break;
+        cursorEnd = nextEnd;
+      }
+      return [...byTimestamp.values()].sort(
+        (left, right) => left.timestamp - right.timestamp
+      );
+    },
+    getTradingFeeRate: async (symbol) => {
+      const client = await getPrivateClient();
+      if (!client) return null;
+      const normalizedSymbol = symbol.trim().toUpperCase();
+      const response = await client.getFeeRate({
+        category: BYBIT_CATEGORY2,
+        symbol: normalizedSymbol
+      });
+      if (response.retCode !== 0) return null;
+      const row = (response.result?.list ?? []).find(
+        (item) => String(item.symbol ?? "").toUpperCase() === normalizedSymbol
+      );
+      const makerRate = Number(row?.makerFeeRate);
+      const takerRate = Number(row?.takerFeeRate);
+      if (!Number.isFinite(makerRate) || !Number.isFinite(takerRate)) {
+        return null;
+      }
+      return {
+        symbol: normalizedSymbol,
+        makerRate,
+        takerRate,
+        source: "exchange-account",
+        capturedAt: Date.now()
+      };
+    },
+    getTickers: async (query = {}) => {
       const client = await getPublicClient();
       if (!client) {
         return [];
       }
+      const requestedUniverse = resolveConnectorUniverse(
+        BYBIT_CAPABILITIES,
+        query.universe ?? universe
+      );
+      const instruments = await listInstruments({
+        ...query,
+        universe: requestedUniverse
+      });
+      const allowedSymbols = instruments.length ? new Set(instruments.map((instrument) => instrument.symbol)) : null;
       const data = await client.getTickers({
-        category: MARKET_CATEGORY2
+        category: BYBIT_CATEGORY2
       });
-      return data.result.list.map((item) => normalizeTickerData(item));
+      return data.result.list.filter(
+        (item) => allowedSymbols == null || allowedSymbols.has(String(item.symbol ?? ""))
+      ).map((item) => normalizeTickerData(item));
     }
   };
 };
 
 // src/Binance/index.ts
 import { fetchWithRetry } from "@tradejs/infra/http";
+import {
+  resolveConnectorUniverse as resolveConnectorUniverse2
+} from "@tradejs/types";
 var INTERVAL_MAP = {
   "1": "1m",
   "3": "3m",
@@ -944,12 +1600,21 @@ var toNum = (value, fallback = 0) => {
   const num = Number(value);
   return Number.isFinite(num) ? num : fallback;
 };
+var toNullableNum = (value) => {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+};
 var intervalToMinutes = (interval) => {
   const intervalMs = INTERVAL_MS[String(interval)];
   return intervalMs ? Math.floor(intervalMs / 6e4) : null;
 };
-var BinanceConnectorCreator = async () => {
+var capabilities = {
+  supportedUniverses: ["crypto"],
+  defaultUniverse: "crypto"
+};
+var BinanceConnectorCreator = async (config) => {
   let state = {};
+  const universe = resolveConnectorUniverse2(capabilities, config.universe);
   const requestKline = async ({
     symbol,
     interval,
@@ -981,14 +1646,24 @@ var BinanceConnectorCreator = async () => {
         if (!Array.isArray(item)) continue;
         const ts = toNum(item[0], 0);
         if (!ts) continue;
+        const volume = toNum(item[5]);
+        const turnover = toNum(item[7]);
+        const trades = toNullableNum(item[8]);
+        const takerBuyBaseVolume = toNullableNum(item[9]);
+        const takerBuyQuoteVolume = toNullableNum(item[10]);
         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]),
+          volume,
+          turnover,
+          trades,
+          takerBuyBaseVolume,
+          takerBuyQuoteVolume,
+          takerSellBaseVolume: takerBuyBaseVolume == null ? null : Math.max(0, volume - takerBuyBaseVolume),
+          takerSellQuoteVolume: takerBuyQuoteVolume == null ? null : Math.max(0, turnover - takerBuyQuoteVolume),
           dt: new Date(ts).toISOString()
         });
         lastTs = ts;
@@ -999,7 +1674,64 @@ var BinanceConnectorCreator = async () => {
     rows.sort((a, b) => a.timestamp - b.timestamp);
     return rows;
   };
+  const loadTickers = 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: ""
+      };
+    });
+  };
   return {
+    capabilities,
+    universe,
+    accountId: config.accountId,
+    deploymentId: config.deploymentId,
+    listInstruments: async (query) => {
+      resolveConnectorUniverse2(capabilities, query?.universe ?? universe);
+      const symbols = query?.symbols?.length ? new Set(query.symbols.map((symbol) => symbol.trim().toUpperCase())) : null;
+      const tickers = await loadTickers();
+      return tickers.filter((ticker) => !symbols || symbols.has(ticker.symbol)).map((ticker) => ({
+        provider: "binance",
+        symbol: ticker.symbol,
+        kind: "spot",
+        assetClass: "crypto",
+        universe: "crypto",
+        status: "trading"
+      }));
+    },
     getState: async () => state,
     setState: async (newState) => {
       state = { ...state, ...newState };
@@ -1016,51 +1748,93 @@ var BinanceConnectorCreator = async () => {
     setTakeProfits: async () => false,
     setStopLoss: async () => false,
     closePosition: async () => false,
-    getTickers: async () => {
+    getTickers: async (query) => {
+      resolveConnectorUniverse2(capabilities, query?.universe ?? universe);
+      return loadTickers();
+    },
+    getTopOfBookTicker: async (symbol) => {
+      const normalizedSymbol = String(symbol || "").trim().toUpperCase();
+      if (!normalizedSymbol) return null;
+      const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
+      const url = new URL(`${baseUrl}/api/v3/ticker/bookTicker`);
+      url.searchParams.set("symbol", normalizedSymbol);
+      const response = await fetchWithRetry(url.toString(), {
+        headers: { "User-Agent": "tradejs/binance-connector" }
+      });
+      if (!response.ok) return null;
+      const row = await response.json();
+      return {
+        symbol: String(row.symbol ?? normalizedSymbol),
+        bidPrice: toNum(row.bidPrice),
+        bidQty: toNum(row.bidQty),
+        askPrice: toNum(row.askPrice),
+        askQty: toNum(row.askQty),
+        timestamp: Date.now()
+      };
+    },
+    getAggTrades: async ({ symbol, startTime, endTime, limit = 1e3 }) => {
+      const normalizedSymbol = String(symbol || "").trim().toUpperCase();
+      if (!normalizedSymbol) return [];
+      const safeLimit = Math.min(Math.max(Math.floor(limit), 1), 1e3);
       const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
-      const response = await fetchWithRetry(`${baseUrl}/api/v3/ticker/24hr`, {
+      const url = new URL(`${baseUrl}/api/v3/aggTrades`);
+      url.searchParams.set("symbol", normalizedSymbol);
+      url.searchParams.set("startTime", String(Math.floor(startTime)));
+      url.searchParams.set("endTime", String(Math.floor(endTime)));
+      url.searchParams.set("limit", String(safeLimit));
+      const response = await fetchWithRetry(url.toString(), {
         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: ""
-        };
+      return payload.map((row) => ({
+        aggregateTradeId: toNum(row.a, Number.NaN),
+        price: toNum(row.p, Number.NaN),
+        quantity: toNum(row.q, Number.NaN),
+        firstTradeId: toNum(row.f, Number.NaN),
+        lastTradeId: toNum(row.l, Number.NaN),
+        timestamp: toNum(row.T, Number.NaN),
+        isBuyerMaker: Boolean(row.m)
+      })).filter(
+        (row) => Number.isFinite(row.aggregateTradeId) && Number.isFinite(row.price) && Number.isFinite(row.quantity) && Number.isFinite(row.timestamp)
+      );
+    },
+    getOrderBookDepth: async ({ symbol, limit = 100 }) => {
+      const normalizedSymbol = String(symbol || "").trim().toUpperCase();
+      if (!normalizedSymbol) return null;
+      const allowedLimits = [5, 10, 20, 50, 100, 500, 1e3, 5e3];
+      const safeLimit = allowedLimits.includes(limit) ? limit : 100;
+      const baseUrl = process.env.BINANCE_BASE_URL?.trim() || "https://api.binance.com";
+      const url = new URL(`${baseUrl}/api/v3/depth`);
+      url.searchParams.set("symbol", normalizedSymbol);
+      url.searchParams.set("limit", String(safeLimit));
+      const response = await fetchWithRetry(url.toString(), {
+        headers: { "User-Agent": "tradejs/binance-connector" }
       });
+      if (!response.ok) return null;
+      const payload = await response.json();
+      const parseLevels = (levels) => (Array.isArray(levels) ? levels : []).map(
+        (level) => Array.isArray(level) ? [toNum(level[0], Number.NaN), toNum(level[1], Number.NaN)] : null
+      ).filter(
+        (level) => level != null && Number.isFinite(level[0]) && Number.isFinite(level[1])
+      );
+      return {
+        symbol: normalizedSymbol,
+        lastUpdateId: toNullableNum(payload.lastUpdateId),
+        bids: parseLevels(payload.bids),
+        asks: parseLevels(payload.asks),
+        timestamp: Date.now()
+      };
     }
   };
 };
 
 // src/Coinbase/index.ts
 import { fetchWithRetry as fetchWithRetry2 } from "@tradejs/infra/http";
+import {
+  resolveConnectorUniverse as resolveConnectorUniverse3
+} from "@tradejs/types";
 var INTERVAL_MS2 = {
   "1": 6e4,
   "3": 18e4,
@@ -1123,8 +1897,13 @@ var MAJOR_PRODUCTS = [
   "LINK-USD",
   "AVAX-USD"
 ];
-var CoinbaseConnectorCreator = async () => {
+var capabilities2 = {
+  supportedUniverses: ["crypto"],
+  defaultUniverse: "crypto"
+};
+var CoinbaseConnectorCreator = async (config) => {
   let state = {};
+  const universe = resolveConnectorUniverse3(capabilities2, config.universe);
   const requestKline = async ({
     symbol,
     interval,
@@ -1176,7 +1955,76 @@ var CoinbaseConnectorCreator = async () => {
     }
     return [...dedup.values()].sort((a, b) => a.timestamp - b.timestamp);
   };
+  const loadTickers = 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);
+  };
   return {
+    capabilities: capabilities2,
+    universe,
+    accountId: config.accountId,
+    deploymentId: config.deploymentId,
+    listInstruments: async (query) => {
+      resolveConnectorUniverse3(capabilities2, query?.universe ?? universe);
+      const symbols = query?.symbols?.length ? new Set(query.symbols.map((symbol) => symbol.trim().toUpperCase())) : null;
+      const tickers = await loadTickers();
+      return tickers.filter((ticker) => !symbols || symbols.has(ticker.symbol)).map((ticker) => ({
+        provider: "coinbase",
+        symbol: ticker.symbol,
+        kind: "spot",
+        assetClass: "crypto",
+        universe: "crypto",
+        status: "trading"
+      }));
+    },
     getState: async () => state,
     setState: async (newState) => {
       state = { ...state, ...newState };
@@ -1193,57 +2041,9 @@ var CoinbaseConnectorCreator = async () => {
     setTakeProfits: async () => false,
     setStopLoss: 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);
+    getTickers: async (query) => {
+      resolveConnectorUniverse3(capabilities2, query?.universe ?? universe);
+      return loadTickers();
     }
   };
 };
@@ -1263,18 +2063,26 @@ var mapBinanceKline = (payload) => payload.map((item) => {
   const low = Number(item[3]);
   const close = Number(item[4]);
   const volume = Number(item[5]);
+  const turnover = Number(item[7]) || 0;
+  const takerBuyBaseVolume = Number(item[9]);
+  const takerBuyQuoteVolume = Number(item[10]);
   if (![ts, open, high, low, close, volume].every(Number.isFinite))
     return null;
-  return {
+  const row = {
     timestamp: ts,
     open,
     high,
     low,
     close,
     volume,
-    turnover: Number(item[7]) || 0,
+    turnover,
+    takerBuyBaseVolume: Number.isFinite(takerBuyBaseVolume) ? takerBuyBaseVolume : null,
+    takerBuyQuoteVolume: Number.isFinite(takerBuyQuoteVolume) ? takerBuyQuoteVolume : null,
+    takerSellBaseVolume: Number.isFinite(takerBuyBaseVolume) ? Math.max(0, volume - takerBuyBaseVolume) : null,
+    takerSellQuoteVolume: Number.isFinite(takerBuyQuoteVolume) ? Math.max(0, turnover - takerBuyQuoteVolume) : null,
     dt: new Date(ts).toISOString()
   };
+  return row;
 }).filter((item) => item != null).sort((a, b) => a.timestamp - b.timestamp);
 var mapCoinbaseKline = (payload) => payload.map((item) => {
   if (!Array.isArray(item)) return null;
@@ -1347,6 +2155,144 @@ var spotKlineProviders = {
   }
 };
 
+// src/ByBit/klineStream.ts
+import { WebsocketClient } from "bybit-api";
+import { formatUnix as formatUnix3 } from "@tradejs/core/time";
+import { logger as logger4 } from "@tradejs/infra/logger";
+import { resolveTradingAccount as resolveTradingAccount2 } from "@tradejs/infra/tradingAccounts";
+var CATEGORY = "linear";
+var SUBSCRIPTION_BATCH_SIZE = 100;
+var KLINE_TOPIC_PATTERN = /^kline\.([^.]+)\.(.+)$/;
+var chunk = (items, size) => {
+  const result = [];
+  for (let index = 0; index < items.length; index += size) {
+    result.push(items.slice(index, index + size));
+  }
+  return result;
+};
+var normalizeSymbols = (symbols) => [...new Set(symbols.map((symbol) => symbol.trim().toUpperCase()))].filter(
+  Boolean
+);
+var buildBybitKlineTopic = (symbol, interval) => `kline.${interval}.${symbol.trim().toUpperCase()}`;
+var parseBybitKlineEvent = (value, receivedAt = Date.now()) => {
+  if (!value || typeof value !== "object") return [];
+  const event = value;
+  const match = String(event.topic ?? "").match(KLINE_TOPIC_PATTERN);
+  if (!match || !Array.isArray(event.data)) return [];
+  const [, interval, symbol] = match;
+  return event.data.flatMap((raw) => {
+    const row = raw;
+    const timestamp = Number(row.start);
+    const open = Number(row.open);
+    const high = Number(row.high);
+    const low = Number(row.low);
+    const close = Number(row.close);
+    const volume = Number(row.volume);
+    const turnover = Number(row.turnover);
+    if (![timestamp, open, high, low, close, volume, turnover].every(
+      Number.isFinite
+    ) || timestamp < 0 || high < Math.max(open, close) || low > Math.min(open, close)) {
+      return [];
+    }
+    return [
+      {
+        symbol: symbol.toUpperCase(),
+        interval,
+        candle: {
+          dt: formatUnix3(timestamp),
+          timestamp,
+          open,
+          high,
+          low,
+          close,
+          volume,
+          turnover
+        },
+        confirm: Boolean(row.confirm),
+        receivedAt
+      }
+    ];
+  });
+};
+var createBybitKlineStreamWithClient = ({
+  client,
+  onEvent
+}) => {
+  let topics = /* @__PURE__ */ new Set();
+  let closed = false;
+  client.on("update", (value) => {
+    for (const event of parseBybitKlineEvent(value)) {
+      void Promise.resolve(onEvent(event)).catch((error) => {
+        logger4.error("Bybit kline stream handler failed: %s", String(error));
+      });
+    }
+  });
+  client.on("reconnected", ({ wsKey }) => {
+    logger4.info("Bybit kline stream reconnected: %s", wsKey);
+  });
+  client.on("exception", (error) => {
+    logger4.error("Bybit kline stream exception: %s", String(error));
+  });
+  return {
+    setSubscriptions: (symbols, interval) => {
+      if (closed) return;
+      const nextTopics = new Set(
+        normalizeSymbols(symbols).map(
+          (symbol) => buildBybitKlineTopic(symbol, interval)
+        )
+      );
+      const added = [...nextTopics].filter((topic) => !topics.has(topic));
+      const removed = [...topics].filter((topic) => !nextTopics.has(topic));
+      for (const batch of chunk(removed, SUBSCRIPTION_BATCH_SIZE)) {
+        void Promise.all(client.unsubscribeV5(batch, CATEGORY)).catch(
+          (error) => logger4.error("Bybit kline unsubscribe failed: %s", String(error))
+        );
+      }
+      for (const batch of chunk(added, SUBSCRIPTION_BATCH_SIZE)) {
+        void Promise.all(client.subscribeV5(batch, CATEGORY)).catch(
+          (error) => logger4.error("Bybit kline subscribe failed: %s", String(error))
+        );
+      }
+      topics = nextTopics;
+      logger4.info(
+        "Bybit kline stream subscriptions: topics=%s added=%s removed=%s",
+        topics.size,
+        added.length,
+        removed.length
+      );
+    },
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      const currentTopics = [...topics];
+      topics.clear();
+      for (const batch of chunk(currentTopics, SUBSCRIPTION_BATCH_SIZE)) {
+        await Promise.allSettled(client.unsubscribeV5(batch, CATEGORY));
+      }
+      client.closeAll();
+    }
+  };
+};
+var createBybitKlineStream = async ({
+  config,
+  onEvent
+}) => {
+  const account = config.accountId ? await resolveTradingAccount2({
+    userName: config.userName,
+    accountId: config.accountId,
+    provider: "bybit",
+    universe: config.universe
+  }) : null;
+  const client = new WebsocketClient({
+    testnet: account?.environment === "testnet",
+    reconnectTimeout: Math.max(
+      500,
+      Number(process.env.BYBIT_WS_RECONNECT_TIMEOUT_MS ?? 1e3)
+    )
+  });
+  return createBybitKlineStreamWithClient({ client, onEvent });
+};
+
 // src/marketData/providers/binanceCoinbaseSpread.ts
 import {
   alignSpreadRows,
@@ -1407,7 +2353,7 @@ var binanceCoinbaseSpreadProvider = {
 };
 
 // src/marketData/providers/coinalyze.ts
-import { delay as delay2 } from "@tradejs/core/async";
+import { delay as delay3 } from "@tradejs/core/async";
 import {
   coinalyzePointsToRows,
   mergeCoinalyzeMetrics
@@ -1480,7 +2426,7 @@ var fetchCoinalyzeSeries = async (params) => {
       lastRequestTs + coinalyzeMinRequestDelayMs - now
     );
     if (waitMs > 0) {
-      await delay2(waitMs);
+      await delay3(waitMs);
     }
     lastRequestTs = Date.now();
     const response = await fetch(url.toString(), { headers });
@@ -1494,7 +2440,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 delay2(retryAfterMs ?? backoffMs);
+      await delay3(retryAfterMs ?? backoffMs);
       continue;
     }
     throw new Error(`Coinalyze ${endpoint} ${response.status}: ${text}`);
@@ -1622,12 +2568,16 @@ var index_default = { connectorEntries };
 export {
   ConnectorNames,
   ConnectorProviders,
+  buildBybitKlineTopic,
   connectorEntries,
   connectors,
+  createBybitKlineStream,
+  createBybitKlineStreamWithClient,
   index_default as default,
   getConnectorCreatorByProvider,
   getConnectorProviders,
   marketDataProviders,
+  parseBybitKlineEvent,
   providerToConnectorName,
   resolveConnectorNameByProvider,
   spotKlineProviders