@tradejs/core 1.0.0

package/dist/strategies.mjs

@@ -0,0 +1,390 @@
+import {
+  uuid
+} from "./chunk-NQ7D3T4E.mjs";
+import {
+  createIndicators
+} from "./chunk-LIGD3WWX.mjs";
+import "./chunk-AYC2QVKI.mjs";
+import {
+  getTimestamp
+} from "./chunk-PXLXXXLA.mjs";
+import {
+  FEE_PERCENT
+} from "./chunk-JG2QPVAV.mjs";
+import "./chunk-M7QGVZ3J.mjs";
+
+// src/utils/strategyHelpers/indicators.ts
+var buildDefaultIndicatorPeriods = (config) => ({
+  maFast: config.MA_FAST,
+  maMedium: config.MA_MEDIUM,
+  maSlow: config.MA_SLOW,
+  obvSma: config.OBV_SMA,
+  atr: config.ATR,
+  atrPctShort: config.ATR_PCT_SHORT,
+  atrPctLong: config.ATR_PCT_LONG,
+  bb: config.BB,
+  bbStd: config.BB_STD,
+  macdFast: config.MACD_FAST,
+  macdSlow: config.MACD_SLOW,
+  macdSignal: config.MACD_SIGNAL,
+  levelLookback: config.LEVEL_LOOKBACK,
+  levelDelay: config.LEVEL_DELAY
+});
+var createStrategyIndicatorsState = ({
+  env,
+  data,
+  btcData,
+  btcBinanceData,
+  btcCoinbaseData,
+  periods
+}) => {
+  let controller = env === "BACKTEST" ? createIndicators(data, btcData, {
+    periods,
+    btcBinanceData,
+    btcCoinbaseData
+  }) : null;
+  let currentBarPair;
+  const withSnapshot = (value) => Object.assign(value, {
+    snapshot: () => value.result()
+  });
+  const applyBar = (candle, btcCandle) => {
+    if (!controller) return;
+    controller.next(candle, btcCandle);
+  };
+  const ensureControllerInitialized = () => {
+    if (controller) return withSnapshot(controller);
+    controller = createIndicators(data.slice(0, -1), btcData.slice(0, -1), {
+      periods,
+      btcBinanceData,
+      btcCoinbaseData
+    });
+    const lastCandle = data[data.length - 1];
+    const lastBtcCandle = btcData[btcData.length - 1];
+    if (lastCandle && lastBtcCandle) {
+      controller.next(lastCandle, lastBtcCandle);
+    }
+    return withSnapshot(controller);
+  };
+  return {
+    isInitialized: () => controller != null,
+    setCurrentBar: (candle, btcCandle) => {
+      currentBarPair = { candle, btcCandle };
+    },
+    onBar: (candle, btcCandle) => {
+      const resolvedCandle = candle ?? currentBarPair?.candle;
+      const resolvedBtcCandle = btcCandle ?? currentBarPair?.btcCandle;
+      if (!resolvedCandle || !resolvedBtcCandle) return;
+      applyBar(resolvedCandle, resolvedBtcCandle);
+    },
+    next: (candle, btcCandle) => {
+      if (!controller) return void 0;
+      return controller.next(candle, btcCandle);
+    },
+    // Lazy bootstrap for live mode: initialize on history before current bar and then apply current bar once.
+    ensureInitializedWithCurrentBar: ensureControllerInitialized,
+    snapshot: () => ensureControllerInitialized().snapshot(),
+    latestNumber: (key) => {
+      const snapshot = ensureControllerInitialized().snapshot();
+      const value = snapshot?.[key];
+      if (!Array.isArray(value) || value.length === 0) {
+        return void 0;
+      }
+      const last = value[value.length - 1];
+      return typeof last === "number" ? last : void 0;
+    }
+  };
+};
+
+// src/utils/strategyHelpers/market.ts
+var getStrategyMarketSnapshot = async ({
+  env,
+  connector,
+  symbol,
+  interval,
+  cachedData,
+  preloadStart,
+  backtestPriceMode = "mid"
+}) => {
+  const fullData = env === "BACKTEST" ? cachedData : await connector.kline({
+    symbol,
+    start: preloadStart,
+    end: getTimestamp(),
+    cacheOnly: false,
+    interval
+  });
+  const lastCandle = fullData[fullData.length - 1];
+  let currentPrice = lastCandle.close;
+  if (env === "BACKTEST") {
+    if (backtestPriceMode === "mid") {
+      currentPrice = (lastCandle.open + lastCandle.close) / 2;
+    } else if (backtestPriceMode === "open") {
+      currentPrice = lastCandle.open;
+    } else if (backtestPriceMode === "rand") {
+      const min = Math.min(lastCandle.low, lastCandle.high);
+      const max = Math.max(lastCandle.low, lastCandle.high);
+      currentPrice = min + Math.random() * (max - min);
+    }
+  }
+  return {
+    fullData,
+    lastCandle,
+    timestamp: lastCandle.timestamp,
+    currentPrice
+  };
+};
+var calculateRiskRatio = ({
+  direction,
+  currentPrice,
+  takeProfitPrice,
+  stopLossPrice
+}) => {
+  const isLong = direction === "LONG";
+  const reward = isLong ? takeProfitPrice - currentPrice : currentPrice - takeProfitPrice;
+  const risk = isLong ? currentPrice - stopLossPrice : stopLossPrice - currentPrice;
+  return risk > 0 ? reward / risk : 0;
+};
+var getDirectionalTpSlPrices = ({
+  price,
+  direction,
+  takeProfitDelta,
+  stopLossDelta,
+  unit = "percent",
+  maxLossValue,
+  feePercent = FEE_PERCENT
+}) => {
+  const deltaFactor = unit === "percent" ? 100 : 1;
+  const tp = takeProfitDelta / deltaFactor;
+  const sl = stopLossDelta / deltaFactor;
+  const isLong = direction === "LONG";
+  const stopLossPrice = isLong ? price * (1 - sl) : price * (1 + sl);
+  const takeProfitPrice = isLong ? price * (1 + tp) : price * (1 - tp);
+  const riskRatio = calculateRiskRatio({
+    direction,
+    currentPrice: price,
+    takeProfitPrice,
+    stopLossPrice
+  });
+  const slPercent = unit === "percent" ? stopLossDelta : stopLossDelta * 100;
+  const qty = typeof maxLossValue === "number" && Number.isFinite(maxLossValue) && maxLossValue > 0 ? maxLossValue / (price * (slPercent + feePercent) / 100) : void 0;
+  return {
+    stopLossPrice,
+    takeProfitPrice,
+    riskRatio,
+    qty
+  };
+};
+
+// src/utils/strategyHelpers/state.ts
+var createLastTradeController = ({
+  env,
+  enabled = env ? env === "BACKTEST" : true,
+  cooldownMs = 864e5
+}) => {
+  let lastTradeTimestamp = null;
+  return {
+    isInCooldown: (timestamp) => Boolean(
+      enabled && lastTradeTimestamp != null && timestamp <= lastTradeTimestamp + cooldownMs
+    ),
+    markTrade: (timestamp) => {
+      if (!enabled) return;
+      lastTradeTimestamp = timestamp;
+    },
+    getLastTradeTimestamp: () => lastTradeTimestamp
+  };
+};
+
+// src/utils/strategyHelpers/signalBuilders.ts
+var mapAiRuntimeFromConfig = (config, overrides = {}) => ({
+  enabled: Boolean(config.AI_ENABLED ?? true),
+  minQuality: Number(config.MIN_AI_QUALITY ?? 4),
+  ...overrides
+});
+var mapMlRuntimeFromConfig = (config, overrides = {}) => ({
+  enabled: Boolean(config.ML_ENABLED ?? true),
+  mlThreshold: Number(config.ML_THRESHOLD ?? 0),
+  ...overrides
+});
+var buildStrategySignal = ({
+  signalId,
+  strategy,
+  symbol,
+  interval,
+  direction,
+  timestamp,
+  prices,
+  figures = {},
+  indicators = {},
+  additionalIndicators,
+  isConfigFromBacktest
+}) => ({
+  signalId,
+  strategy,
+  symbol,
+  interval,
+  direction,
+  timestamp,
+  figures,
+  prices,
+  indicators,
+  additionalIndicators,
+  isConfigFromBacktest
+});
+var buildEntrySignalDecision = ({
+  code,
+  entryContext,
+  figures,
+  indicators,
+  additionalIndicators,
+  signalId,
+  orderPlan,
+  runtime
+}) => ({
+  kind: "entry",
+  code,
+  entryContext,
+  signal: buildStrategySignal({
+    signalId: signalId ?? uuid(),
+    strategy: entryContext.strategy,
+    symbol: entryContext.symbol,
+    interval: entryContext.interval,
+    direction: entryContext.direction,
+    timestamp: entryContext.timestamp,
+    prices: entryContext.prices,
+    figures,
+    indicators,
+    additionalIndicators,
+    isConfigFromBacktest: entryContext.isConfigFromBacktest
+  }),
+  orderPlan,
+  runtime
+});
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var toDefaultEntryCode = (strategy, direction) => `${strategy.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_${direction}_ENTRY`;
+var resolveTakeProfitPrice = ({
+  direction,
+  takeProfits
+}) => {
+  if (!Array.isArray(takeProfits) || takeProfits.length === 0) {
+    throw new Error("strategyApi.entry requires at least one takeProfit");
+  }
+  const prices = takeProfits.map((tp) => tp?.price).filter((price) => isFiniteNumber(price));
+  if (prices.length === 0) {
+    throw new Error("strategyApi.entry requires finite takeProfit prices");
+  }
+  return direction === "LONG" ? Math.max(...prices) : Math.min(...prices);
+};
+var createStrategyAPI = ({
+  strategy,
+  symbol,
+  interval,
+  env,
+  connector,
+  cachedData,
+  indicatorsState,
+  preloadStart,
+  backtestPriceMode,
+  isConfigFromBacktest
+}) => {
+  const getCurrentPosition = () => connector.getPosition(symbol);
+  const isPositionExists = async () => {
+    const position = await getCurrentPosition();
+    return Boolean(
+      position && typeof position.qty === "number" && position.qty > 0
+    );
+  };
+  const getMarketData = async (params = {}) => {
+    const resolvedPreloadStart = params.preloadStart ?? preloadStart;
+    if (typeof resolvedPreloadStart !== "number") {
+      throw new Error("strategyApi.getMarketData requires preloadStart");
+    }
+    const snapshot = await getStrategyMarketSnapshot({
+      env,
+      connector,
+      symbol,
+      interval,
+      cachedData,
+      preloadStart: resolvedPreloadStart,
+      backtestPriceMode: params.backtestPriceMode ?? backtestPriceMode
+    });
+    return snapshot;
+  };
+  return {
+    skip: (code) => ({ kind: "skip", code }),
+    entry: async ({
+      code,
+      direction,
+      figures,
+      indicators,
+      additionalIndicators,
+      signalId,
+      orderPlan,
+      runtime
+    }) => {
+      const marketData = await getMarketData();
+      const currentPrice = marketData.currentPrice;
+      const timestamp = marketData.timestamp;
+      const stopLossPrice = orderPlan.stopLossPrice;
+      const takeProfitPrice = resolveTakeProfitPrice({
+        direction,
+        takeProfits: orderPlan.takeProfits
+      });
+      if (!isFiniteNumber(stopLossPrice)) {
+        throw new Error(
+          "strategyApi.entry requires finite orderPlan.stopLossPrice"
+        );
+      }
+      const resolvedCode = code ?? toDefaultEntryCode(String(strategy), direction);
+      const riskRatio = calculateRiskRatio({
+        direction,
+        currentPrice,
+        takeProfitPrice,
+        stopLossPrice
+      });
+      return buildEntrySignalDecision({
+        code: resolvedCode,
+        entryContext: {
+          strategy,
+          symbol,
+          interval,
+          direction,
+          timestamp,
+          prices: {
+            currentPrice,
+            takeProfitPrice,
+            stopLossPrice,
+            riskRatio
+          },
+          isConfigFromBacktest
+        },
+        figures,
+        indicators,
+        additionalIndicators,
+        signalId,
+        orderPlan,
+        runtime
+      });
+    },
+    getMarketData,
+    nextIndicators: (candle, btcCandle) => indicatorsState?.next(candle, btcCandle),
+    getCurrentPosition,
+    isCurrentPositionExists: isPositionExists,
+    getDirectionalTpSlPrices: (params) => getDirectionalTpSlPrices(params),
+    createLastTradeController: (params) => createLastTradeController({
+      env,
+      ...params
+    })
+  };
+};
+export {
+  buildDefaultIndicatorPeriods,
+  buildEntrySignalDecision,
+  buildStrategySignal,
+  calculateRiskRatio,
+  createLastTradeController,
+  createStrategyAPI,
+  createStrategyIndicatorsState,
+  getDirectionalTpSlPrices,
+  getStrategyMarketSnapshot,
+  mapAiRuntimeFromConfig,
+  mapMlRuntimeFromConfig
+};

package/dist/tickers.d.mts

@@ -0,0 +1,7 @@
+import { Ticker, Item } from '@tradejs/types';
+
+declare const getVolatilityTickers: (data: Ticker[]) => Item[];
+declare const getTopTickers: (data: Ticker[], topN?: number) => Item<Ticker>[];
+declare const normalizeTickerData: (raw: Record<string, string>) => Ticker;
+
+export { getTopTickers, getVolatilityTickers, normalizeTickerData };

package/dist/tickers.d.ts

@@ -0,0 +1,7 @@
+import { Ticker, Item } from '@tradejs/types';
+
+declare const getVolatilityTickers: (data: Ticker[]) => Item[];
+declare const getTopTickers: (data: Ticker[], topN?: number) => Item<Ticker>[];
+declare const normalizeTickerData: (raw: Record<string, string>) => Ticker;
+
+export { getTopTickers, getVolatilityTickers, normalizeTickerData };

package/dist/tickers.js

@@ -0,0 +1,166 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tickers.ts
+var tickers_exports = {};
+__export(tickers_exports, {
+  getTopTickers: () => getTopTickers,
+  getVolatilityTickers: () => getVolatilityTickers,
+  normalizeTickerData: () => normalizeTickerData
+});
+module.exports = __toCommonJS(tickers_exports);
+
+// src/utils/tickers.ts
+var import_lodash2 = __toESM(require("lodash"));
+
+// src/utils/math.ts
+var import_lodash = __toESM(require("lodash"));
+var round = (value, precision = 2) => precision > 0 ? Math.round(value * 10 ** precision) / 10 ** precision : Math.round(value);
+
+// src/utils/tickers.ts
+var EXCLUDE_TICKERS = [
+  "USDEUSDT",
+  "USDCUSDT",
+  "USDTUSDT",
+  "RLUSDUSDT",
+  "PAXGUSDT",
+  "XAUTUSDT"
+];
+var getVolatilityTickers = (data) => {
+  const result = [];
+  const selected = /* @__PURE__ */ new Set();
+  const getBaseSymbol = (symbol) => symbol.replace(/(USDT)$/i, "");
+  const byVol24h = [...data].map((coin) => ({
+    ...coin,
+    volatility24h: Math.abs(coin.price24hPcnt)
+  })).sort((a, b) => b.volatility24h - a.volatility24h);
+  const byVol1h = [...data].map((coin) => {
+    const prev1h = coin.prevPrice1h;
+    const last = coin.lastPrice;
+    const volatility1h = prev1h ? Math.abs((last - prev1h) / prev1h) : 0;
+    return {
+      ...coin,
+      volatility1h
+    };
+  }).sort((a, b) => b.volatility1h - a.volatility1h);
+  const byVolume = [...data].map((coin) => ({
+    ...coin,
+    volume24hNum: coin.volume24h
+  })).sort((a, b) => b.volume24hNum - a.volume24hNum);
+  const addTop = (list, category, limit) => {
+    for (const coin of list) {
+      if (!selected.has(coin.symbol)) {
+        selected.add(coin.symbol);
+        result.push({
+          label: `${getBaseSymbol(coin.symbol)}`,
+          value: coin.symbol,
+          category
+        });
+        if (result.length >= limit) break;
+      }
+    }
+  };
+  addTop(byVol24h, "volatility24h", 10);
+  addTop(byVol1h, "volatility1h", 20);
+  addTop(byVolume, "volume", 30);
+  return result.slice(0, 30).sort(
+    (a, b) => a.category === b.category ? a.value.localeCompare(b.value) : a.category.localeCompare(b.category)
+  ).map(({ value, label, category }) => ({
+    label,
+    value,
+    description: category
+  }));
+};
+var getTopTickers = (data, topN) => {
+  const scores = data.filter(({ symbol }) => {
+    if (symbol.includes("BTC") && symbol !== "BTCUSDT") {
+      return false;
+    }
+    if (symbol.startsWith("USD") || !symbol.endsWith("USDT")) {
+      return false;
+    }
+    if (EXCLUDE_TICKERS.includes(symbol)) {
+      return false;
+    }
+    return true;
+  }).map((coin) => {
+    const volumeMln = coin.volume24h / 1e6;
+    return {
+      ...coin,
+      symbol: coin.symbol,
+      volume24h: volumeMln
+    };
+  });
+  const sortedByVlolume = import_lodash2.default.sortBy(scores, (item) => -item.volume24h);
+  const items = sortedByVlolume.map(({ symbol, volume24h, ...coin }, i) => ({
+    label: symbol.replace(/(USDT)$/i, ""),
+    value: symbol,
+    description: `volume: ${round(volume24h, 2)}m (#${i + 1})`,
+    data: {
+      ...coin,
+      symbol,
+      volume24h
+    }
+  }));
+  return import_lodash2.default.sortBy(topN ? items.slice(0, topN) : items, "label");
+};
+var normalizeTickerData = (raw) => ({
+  symbol: raw.symbol,
+  lastPrice: parseFloat(raw.lastPrice),
+  indexPrice: parseFloat(raw.indexPrice),
+  markPrice: parseFloat(raw.markPrice),
+  prevPrice24h: parseFloat(raw.prevPrice24h),
+  price24hPcnt: parseFloat(raw.price24hPcnt),
+  highPrice24h: parseFloat(raw.highPrice24h),
+  lowPrice24h: parseFloat(raw.lowPrice24h),
+  prevPrice1h: parseFloat(raw.prevPrice1h),
+  openInterest: parseFloat(raw.openInterest),
+  openInterestValue: parseFloat(raw.openInterestValue),
+  turnover24h: parseFloat(raw.turnover24h),
+  volume24h: parseFloat(raw.volume24h),
+  fundingRate: parseFloat(raw.fundingRate),
+  nextFundingTime: parseInt(raw.nextFundingTime),
+  predictedDeliveryPrice: raw.predictedDeliveryPrice,
+  basisRate: raw.basisRate,
+  deliveryFeeRate: raw.deliveryFeeRate,
+  deliveryTime: parseInt(raw.deliveryTime),
+  ask1Size: parseFloat(raw.ask1Size),
+  bid1Price: parseFloat(raw.bid1Price),
+  ask1Price: parseFloat(raw.ask1Price),
+  bid1Size: parseFloat(raw.bid1Size),
+  basis: raw.basis,
+  preOpenPrice: raw.preOpenPrice,
+  preQty: raw.preQty
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTopTickers,
+  getVolatilityTickers,
+  normalizeTickerData
+});

package/dist/tickers.mjs

@@ -0,0 +1,125 @@
+import {
+  round
+} from "./chunk-AYC2QVKI.mjs";
+
+// src/utils/tickers.ts
+import _ from "lodash";
+var EXCLUDE_TICKERS = [
+  "USDEUSDT",
+  "USDCUSDT",
+  "USDTUSDT",
+  "RLUSDUSDT",
+  "PAXGUSDT",
+  "XAUTUSDT"
+];
+var getVolatilityTickers = (data) => {
+  const result = [];
+  const selected = /* @__PURE__ */ new Set();
+  const getBaseSymbol = (symbol) => symbol.replace(/(USDT)$/i, "");
+  const byVol24h = [...data].map((coin) => ({
+    ...coin,
+    volatility24h: Math.abs(coin.price24hPcnt)
+  })).sort((a, b) => b.volatility24h - a.volatility24h);
+  const byVol1h = [...data].map((coin) => {
+    const prev1h = coin.prevPrice1h;
+    const last = coin.lastPrice;
+    const volatility1h = prev1h ? Math.abs((last - prev1h) / prev1h) : 0;
+    return {
+      ...coin,
+      volatility1h
+    };
+  }).sort((a, b) => b.volatility1h - a.volatility1h);
+  const byVolume = [...data].map((coin) => ({
+    ...coin,
+    volume24hNum: coin.volume24h
+  })).sort((a, b) => b.volume24hNum - a.volume24hNum);
+  const addTop = (list, category, limit) => {
+    for (const coin of list) {
+      if (!selected.has(coin.symbol)) {
+        selected.add(coin.symbol);
+        result.push({
+          label: `${getBaseSymbol(coin.symbol)}`,
+          value: coin.symbol,
+          category
+        });
+        if (result.length >= limit) break;
+      }
+    }
+  };
+  addTop(byVol24h, "volatility24h", 10);
+  addTop(byVol1h, "volatility1h", 20);
+  addTop(byVolume, "volume", 30);
+  return result.slice(0, 30).sort(
+    (a, b) => a.category === b.category ? a.value.localeCompare(b.value) : a.category.localeCompare(b.category)
+  ).map(({ value, label, category }) => ({
+    label,
+    value,
+    description: category
+  }));
+};
+var getTopTickers = (data, topN) => {
+  const scores = data.filter(({ symbol }) => {
+    if (symbol.includes("BTC") && symbol !== "BTCUSDT") {
+      return false;
+    }
+    if (symbol.startsWith("USD") || !symbol.endsWith("USDT")) {
+      return false;
+    }
+    if (EXCLUDE_TICKERS.includes(symbol)) {
+      return false;
+    }
+    return true;
+  }).map((coin) => {
+    const volumeMln = coin.volume24h / 1e6;
+    return {
+      ...coin,
+      symbol: coin.symbol,
+      volume24h: volumeMln
+    };
+  });
+  const sortedByVlolume = _.sortBy(scores, (item) => -item.volume24h);
+  const items = sortedByVlolume.map(({ symbol, volume24h, ...coin }, i) => ({
+    label: symbol.replace(/(USDT)$/i, ""),
+    value: symbol,
+    description: `volume: ${round(volume24h, 2)}m (#${i + 1})`,
+    data: {
+      ...coin,
+      symbol,
+      volume24h
+    }
+  }));
+  return _.sortBy(topN ? items.slice(0, topN) : items, "label");
+};
+var normalizeTickerData = (raw) => ({
+  symbol: raw.symbol,
+  lastPrice: parseFloat(raw.lastPrice),
+  indexPrice: parseFloat(raw.indexPrice),
+  markPrice: parseFloat(raw.markPrice),
+  prevPrice24h: parseFloat(raw.prevPrice24h),
+  price24hPcnt: parseFloat(raw.price24hPcnt),
+  highPrice24h: parseFloat(raw.highPrice24h),
+  lowPrice24h: parseFloat(raw.lowPrice24h),
+  prevPrice1h: parseFloat(raw.prevPrice1h),
+  openInterest: parseFloat(raw.openInterest),
+  openInterestValue: parseFloat(raw.openInterestValue),
+  turnover24h: parseFloat(raw.turnover24h),
+  volume24h: parseFloat(raw.volume24h),
+  fundingRate: parseFloat(raw.fundingRate),
+  nextFundingTime: parseInt(raw.nextFundingTime),
+  predictedDeliveryPrice: raw.predictedDeliveryPrice,
+  basisRate: raw.basisRate,
+  deliveryFeeRate: raw.deliveryFeeRate,
+  deliveryTime: parseInt(raw.deliveryTime),
+  ask1Size: parseFloat(raw.ask1Size),
+  bid1Price: parseFloat(raw.bid1Price),
+  ask1Price: parseFloat(raw.ask1Price),
+  bid1Size: parseFloat(raw.bid1Size),
+  basis: raw.basis,
+  preOpenPrice: raw.preOpenPrice,
+  preQty: raw.preQty
+});
+export {
+  getTopTickers,
+  getVolatilityTickers,
+  normalizeTickerData
+};

package/dist/time-DEyFa2vI.d.mts

@@ -0,0 +1,11 @@
+import { OrderLogData, SimpleOrderLogData, KlineChartData, KlineChartItem } from '@tradejs/types';
+
+declare const toMs: (ts: number) => number;
+declare const getTimestamp: (days?: number) => number;
+declare const getItemTimestamp: (item: KlineChartItem) => number;
+declare const getDataTimestamp: (data: KlineChartData) => number | null;
+declare const formatUnix: (dt: number) => string;
+declare const getTimeline: (start?: number, end?: number, step?: number) => number[];
+declare const compactOrderLog: (timeline: number[], orderLog: OrderLogData) => SimpleOrderLogData;
+
+export { getDataTimestamp as a, getItemTimestamp as b, compactOrderLog as c, getTimestamp as d, formatUnix as f, getTimeline as g, toMs as t };