@gbozee/ultimate 0.0.2-113 → 0.0.2-114

package/dist/index.js

@@ -54723,13 +54723,207 @@ class Strategy {
 
 // src/exchanges/binance.ts
 var import_binance = __toESM(require_lib2(), 1);
-
 // src/types/index.ts
 class BaseExchange {
   client;
+  getCredentials;
+  proxyAgent;
   constructor(client) {
     this.client = client;
   }
+  async rawCreateLimitPurchaseOrders(payload) {
+    const { symbol, orders, price_places, decimal_places } = payload;
+    return this._createLimitPurchaseOrders({
+      symbol,
+      price_places,
+      decimal_places,
+      orders
+    });
+  }
+  async placeStopOrders(payload) {
+    if (payload.place) {
+      const current_price = await this.getCurrentPrice(payload.symbol);
+      return this._placeStopOrder({
+        symbol: payload.symbol,
+        stop: payload.stop,
+        final_stop: payload.stop,
+        quantity: Math.abs(payload.quantity),
+        kind: payload.kind,
+        cancel: true,
+        is_limit: true,
+        price_places: payload.price_places,
+        decimal_places: payload.decimal_places,
+        current_price
+      });
+    }
+  }
+  async bulkPlaceLimitOrders(payload) {
+    const {
+      orders,
+      kind,
+      decimal_places = "%.3f",
+      price_places = "%.1f",
+      symbol,
+      place = false
+    } = payload;
+    const totalQuantity = orders.reduce((sum, order) => sum + (order.quantity || 0), 0);
+    let runningTotal = to_f2(totalQuantity, decimal_places);
+    let sortedOrders = [...orders].sort((a, b) => (a.entry || 0) - (b.entry || 0));
+    if (kind === "short") {
+      sortedOrders.reverse();
+    }
+    const withCumulative = [];
+    for (const order of sortedOrders) {
+      withCumulative.push({
+        ...order,
+        cumulative_quantity: runningTotal
+      });
+      runningTotal -= order.quantity;
+      runningTotal = to_f2(runningTotal, decimal_places);
+    }
+    const positions = await this.getPositionInfo(symbol);
+    const position2 = positions[kind] || {
+      kind,
+      size: 0,
+      entryPrice: 0,
+      symbol
+    };
+    const filteredOrders = withCumulative.filter((order) => (order.cumulative_quantity || 0) > position2.size).map((order) => ({
+      ...order,
+      price: order.entry,
+      kind,
+      side: kind.toLowerCase() === "long" ? "buy" : "sell"
+    }));
+    if (filteredOrders.length > 0 && place) {
+      await this.cancelAllOrders(symbol, {
+        type: "limit",
+        kind
+      });
+      await this._createLimitPurchaseOrders({
+        symbol,
+        orders: filteredOrders,
+        price_places,
+        decimal_places
+      });
+    }
+    return filteredOrders;
+  }
+  async get_current_price(symbol) {
+    return await this.getCurrentPrice(symbol);
+  }
+  async getExchangeAccountInfo(options) {
+    const {
+      price_places = "%.1f",
+      decimal_places = "%.3f",
+      account,
+      symbol
+    } = options;
+    return await this.getExchangeInfo({
+      price_places,
+      decimal_places,
+      account,
+      symbol
+    });
+  }
+  async cancelOrders(payload) {
+    return await this._cancelOrders({
+      symbol: payload.symbol,
+      orders: payload.orders.map((x) => ({ orderId: x }))
+    });
+  }
+  async placeTpOrder(payload) {
+    return await this._placeTpOrder({
+      symbol: payload.symbol,
+      tp: payload.take_profit,
+      kind: payload.kind,
+      quantity: payload.quantity,
+      cancel: true,
+      price_places: payload.price_places,
+      decimal_places: payload.decimal_places
+    });
+  }
+  async placeLimitOrder(payload) {
+    return await this.placeLimitOrders({
+      symbol: payload.symbol,
+      orders: [
+        {
+          entry: payload.price,
+          quantity: payload.quantity
+        }
+      ],
+      kind: payload.kind,
+      price_places: payload.price_places,
+      decimal_places: payload.decimal_places
+    });
+  }
+  async placeStopOrder(payload) {
+    const current_price = await this.getCurrentPrice(payload.symbol);
+    return await this._placeStopOrder({
+      symbol: payload.symbol,
+      stop: payload.stop,
+      final_stop: payload.stop,
+      quantity: Math.abs(payload.quantity),
+      kind: payload.kind,
+      cancel: true,
+      is_limit: true,
+      price_places: payload.price_places,
+      decimal_places: payload.decimal_places,
+      current_price
+    });
+  }
+  async closePosition(payload) {
+    const { symbol, kind, price_places, decimal_places } = payload;
+    const currentPrice = await this.getCurrentPrice(symbol);
+    return this.placeTpOrder({
+      price_places,
+      decimal_places,
+      symbol,
+      take_profit: currentPrice,
+      kind
+    });
+  }
+  async getAllOpenSymbols() {
+    const response = await this.getAllOpenOrders();
+    return Array.from(new Set(response.map((x) => x.symbol)));
+  }
+  async createLimitPurchaseOrders(payload) {
+    const {
+      orders,
+      kind,
+      decimal_places = "%.3f",
+      price_places = "%.1f",
+      symbol
+    } = payload;
+    return await this._createLimitPurchaseOrders({
+      symbol,
+      price_places,
+      decimal_places,
+      orders: orders.map((order) => ({
+        ...order,
+        price: order.entry,
+        kind,
+        side: kind.toLowerCase() === "long" ? "buy" : "sell"
+      }))
+    });
+  }
+  async placeMarketOrder(payload) {
+    const { symbol, kind, quantity, price_places, decimal_places } = payload;
+    const currentPrice = await this.get_current_price(symbol);
+    return this._createLimitPurchaseOrders({
+      symbol,
+      price_places,
+      decimal_places,
+      orders: [
+        {
+          force_market: true,
+          side: kind === "long" ? "buy" : "sell",
+          kind,
+          quantity,
+          price: currentPrice
+        }
+      ]
+    });
+  }
   async customStopLoss(payload) {
     const {
       symbol,
@@ -54768,6 +54962,33 @@ class BaseExchange {
       decimal_places
     });
   }
+  async placeBadStopEntry(payload) {
+    const { symbol, orders, price_places, decimal_places } = payload;
+    const openOrders = await this.getOpenOrders({ symbol });
+    const existingBadEntry = openOrders.filter((k) => {
+      if (k.stopPrice > 0) {
+        if (k.kind === "long" && k.price > k.stopPrice || k.kind === "short" && k.price < k.stopPrice) {
+          return true;
+        }
+        return false;
+      }
+      return false;
+    });
+    if (existingBadEntry.length > 0) {
+      console.log("Cancelling existing bad entry");
+      await this._cancelOrders({
+        symbol,
+        orders: existingBadEntry.map((x) => ({ orderId: x.orderId }))
+      });
+    }
+    console.log("Placing new order");
+    return this._createLimitPurchaseOrders({
+      symbol,
+      price_places,
+      decimal_places,
+      orders
+    });
+  }
   async analyzeCandlesticks(payload) {
     const { symbol } = payload;
     const arr = [
@@ -54818,6 +55039,10 @@ class BaseExchange {
       minimum_weekly: minimumWeekly
     };
   }
+  setAccountDetails(payload) {
+    this.getCredentials = payload.getCredentials;
+    this.proxyAgent = payload.proxyAgent;
+  }
 }
 
 // src/exchanges/binance.ts
@@ -55603,98 +55828,22 @@ async function getAllOpenOrders(payload) {
 class BinanceExchange extends BaseExchange {
   client;
   main_client;
-  getCredentials;
-  proxyAgent;
   constructor(client, main_client) {
     super(client);
     this.client = client;
     this.main_client = main_client;
   }
-  setAccountDetails(payload) {
-    this.getCredentials = payload.getCredentials;
-    this.proxyAgent = payload.proxyAgent;
+  async getPositionInfo(symbol) {
+    return await getPositionInfo(this.client, symbol);
   }
-  async placeStopOrders(payload) {
-    if (payload.place) {
-      const current_price = await this.get_current_price(payload.symbol);
-      return placeStopOrder(this.client, {
-        symbol: payload.symbol,
-        stop: payload.stop,
-        final_stop: payload.stop,
-        quantity: Math.abs(payload.quantity),
-        kind: payload.kind,
-        cancel: true,
-        is_limit: true,
-        price_places: payload.price_places,
-        decimal_places: payload.decimal_places,
-        current_price
-      });
-    }
+  async getCurrentPrice(symbol) {
+    return await getCurrentPrice(this.client, symbol);
   }
-  async createLimitPurchaseOrders(payload) {
-    const {
-      orders,
-      kind,
-      decimal_places = "%.3f",
-      price_places = "%.1f",
-      symbol
-    } = payload;
-    const _orders = orders.map((order) => ({
-      ...order,
-      price: order.entry,
-      kind,
-      side: kind.toLowerCase() === "long" ? "buy" : "sell"
-    }));
-    return await createLimitPurchaseOrders(this.client, symbol, price_places, decimal_places, _orders);
+  async cancelAllOrders(symbol, payload) {
+    return await cancelAllOrders(this.client, symbol, payload);
   }
-  async bulkPlaceLimitOrders(payload) {
-    const {
-      orders,
-      kind,
-      decimal_places = "%.3f",
-      price_places = "%.1f",
-      symbol,
-      place = false
-    } = payload;
-    const totalQuantity = orders.reduce((sum, order) => sum + (order.quantity || 0), 0);
-    let runningTotal = to_f2(totalQuantity, decimal_places);
-    let sortedOrders = [...orders].sort((a, b) => (a.entry || 0) - (b.entry || 0));
-    if (kind === "short") {
-      sortedOrders.reverse();
-    }
-    const withCumulative = [];
-    for (const order of sortedOrders) {
-      withCumulative.push({
-        ...order,
-        cumulative_quantity: runningTotal
-      });
-      runningTotal -= order.quantity;
-      runningTotal = to_f2(runningTotal, decimal_places);
-    }
-    const positions = await getPositionInfo(this.client, symbol);
-    const position2 = positions[kind] || {
-      kind,
-      size: 0,
-      entryPrice: 0,
-      symbol
-    };
-    const filteredOrders = withCumulative.filter((order) => (order.cumulative_quantity || 0) > position2.size).map((order) => ({
-      ...order,
-      price: order.entry,
-      kind,
-      side: kind.toLowerCase() === "long" ? "buy" : "sell"
-    }));
-    if (filteredOrders.length > 0 && place) {
-      await cancelAllOrders(this.client, symbol, {
-        type: "limit",
-        kind
-      });
-      await createLimitPurchaseOrders(this.client, symbol, price_places, decimal_places, filteredOrders);
-    }
-    return filteredOrders;
-  }
-  async get_current_price(symbol) {
-    return await getCurrentPrice(this.client, symbol);
+  async _createLimitPurchaseOrders(payload) {
+    return await createLimitPurchaseOrders(this.client, payload.symbol, payload.price_places, payload.decimal_places, payload.orders);
   }
   async analyzeCharts(payload) {
     return await analyzeCharts({
@@ -55705,67 +55854,30 @@ class BinanceExchange extends BaseExchange {
       raw: payload.raw
     });
   }
-  async getExchangeAccountInfo(options) {
-    const {
-      price_places = "%.1f",
-      decimal_places = "%.3f",
-      account,
-      symbol
-    } = options;
+  async getExchangeInfo(options) {
     return await fetchBinanceAccount(this.client, {
-      owner: account.owner,
-      symbol
+      owner: options.account.owner,
+      symbol: options.symbol
     }, {
-      price_places,
-      decimal_places
+      price_places: options.price_places,
+      decimal_places: options.decimal_places
     });
   }
-  async cancelOrders(payload) {
+  async _cancelOrders(payload) {
     return await cancelOrders({
       symbol: payload.symbol,
-      orders: payload.orders.map((x) => ({ orderId: x })),
+      orders: payload.orders,
       custom_client: this.client
     });
   }
-  async placeTpOrder(payload) {
-    return await placeTpOrder(this.client, {
-      symbol: payload.symbol,
-      tp: payload.take_profit,
-      kind: payload.kind,
-      quantity: payload.quantity,
-      cancel: true,
-      price_places: payload.price_places,
-      decimal_places: payload.decimal_places
-    });
+  async _placeTpOrder(payload) {
+    return await placeTpOrder(this.client, payload);
   }
-  async placeLimitOrder(payload) {
-    return await placeLimitOrders(this.client, {
-      symbol: payload.symbol,
-      orders: [
-        {
-          entry: payload.price,
-          quantity: payload.quantity
-        }
-      ],
-      kind: payload.kind,
-      price_places: payload.price_places,
-      decimal_places: payload.decimal_places
-    });
+  async placeLimitOrders(payload) {
+    return await placeLimitOrders(this.client, payload);
   }
-  async placeStopOrder(payload) {
-    const current_price = await this.get_current_price(payload.symbol);
-    return await placeStopOrder(this.client, {
-      symbol: payload.symbol,
-      stop: payload.stop,
-      final_stop: payload.stop,
-      quantity: Math.abs(payload.quantity),
-      kind: payload.kind,
-      cancel: true,
-      is_limit: true,
-      price_places: payload.price_places,
-      decimal_places: payload.decimal_places,
-      current_price
-    });
+  async _placeStopOrder(payload) {
+    return await placeStopOrder(this.client, payload);
   }
   async setLeverage(payload) {
     let maxLeverage = payload.leverage;
@@ -55859,20 +55971,8 @@ class BinanceExchange extends BaseExchange {
     const _movers = activeMovers.filter((m) => !toBeDelisted.includes(m.symbol));
     return { movers: _movers, delisted };
   }
-  async closePosition(payload) {
-    const { symbol, kind, price_places, decimal_places } = payload;
-    const currentPrice = await this.get_current_price(symbol);
-    return this.placeTpOrder({
-      price_places,
-      decimal_places,
-      symbol,
-      take_profit: currentPrice,
-      kind
-    });
-  }
-  async getAllOpenSymbols() {
-    const response = await getAllOpenOrders({ client: this.client });
-    return Array.from(new Set(response.map((x) => x.symbol)));
+  async getAllOpenOrders() {
+    return await getAllOpenOrders({ client: this.client });
   }
   async getDelistedSpotSymbols() {
     if (this.main_client) {
@@ -55905,49 +56005,9 @@ class BinanceExchange extends BaseExchange {
       return result;
     }
   }
-  async placeMarketOrder(payload) {
-    const { symbol, kind, quantity, price_places, decimal_places } = payload;
-    const currentPrice = await this.get_current_price(symbol);
-    return createLimitPurchaseOrders(this.client, symbol, price_places, decimal_places, [
-      {
-        force_market: true,
-        side: kind === "long" ? "buy" : "sell",
-        kind,
-        quantity,
-        price: currentPrice
-      }
-    ]);
-  }
-  async rawCreateLimitPurchaseOrders(payload) {
-    const { symbol, orders, price_places, decimal_places } = payload;
-    return createLimitPurchaseOrders(this.client, symbol, price_places, decimal_places, orders);
-  }
   async getOpenOrders(payload) {
     return await getOpenOrders(this.client, payload.symbol);
   }
-  async placeBadStopEntry(payload) {
-    const { symbol, orders, price_places, decimal_places } = payload;
-    const openOrders = await this.getOpenOrders({ symbol });
-    const existingBadEntry = openOrders.filter((k) => {
-      if (k.stopPrice > 0) {
-        if (k.kind === "long" && k.price > k.stopPrice || k.kind === "short" && k.price < k.stopPrice) {
-          return true;
-        }
-        return false;
-      }
-      return false;
-    });
-    if (existingBadEntry.length > 0) {
-      console.log("Cancelling existing bad entry");
-      await cancelOrders({
-        symbol,
-        orders: existingBadEntry.map((x) => ({ orderId: x.orderId })),
-        custom_client: this.client
-      });
-    }
-    console.log("Placing new order");
-    return createLimitPurchaseOrders(this.client, symbol, price_places, decimal_places, orders);
-  }
 }
 function getPricePlaces(target) {
   const numStr = target.toString();
@@ -56145,10 +56205,11 @@ async function placeStopOrder2(client, payload) {
       kind: payload.kind
     });
   }
+  const spread = 1.00005;
   const order = {
     kind: payload.kind,
     side: payload.kind === "long" ? "sell" : "buy",
-    price: payload.stop,
+    price: payload.kind === "long" ? payload.stop * spread ** -1 : payload.stop * spread,
     quantity: payload.quantity,
     stop: payload.final_stop,
     is_market: !payload.is_limit
@@ -56444,6 +56505,28 @@ async function analyzeCharts2(params) {
   }
   return finalPairs;
 }
+async function getAllOpenOrders2(payload) {
+  const { client, currency = "USDT" } = payload;
+  const response = await client.getActiveOrders({
+    category: "linear",
+    openOnly: 0,
+    settleCoin: currency
+  });
+  let cursor = response.result.nextPageCursor;
+  const orders = response.result.list || [];
+  while (Boolean(cursor)) {
+    const nextResponse = await client.getActiveOrders({
+      category: "linear",
+      openOnly: 0,
+      settleCoin: currency,
+      cursor
+    });
+    orders.push(...nextResponse.result.list);
+    cursor = nextResponse.result.nextPageCursor;
+    console.log("getAllOpenOrders cursor", cursor);
+  }
+  return orders;
+}
 
 class BybitExchange extends BaseExchange {
   client;
@@ -56453,68 +56536,16 @@ class BybitExchange extends BaseExchange {
     this.client = client;
     this.main_client = main_client;
   }
-  async placeStopOrders(payload) {
-    if (payload.place) {
-      return placeStopOrder2(this.client, {
-        symbol: payload.symbol,
-        stop: payload.stop,
-        final_stop: payload.stop,
-        quantity: Math.abs(payload.quantity),
-        kind: payload.kind,
-        cancel: true,
-        is_limit: true,
-        price_places: payload.price_places,
-        decimal_places: payload.decimal_places
-      });
-    }
+  async getPositionInfo(symbol) {
+    return await getPositionInfo2(this.client, symbol);
   }
-  async bulkPlaceLimitOrders(payload) {
-    const {
-      orders,
-      kind,
-      decimal_places = "%.3f",
-      price_places = "%.1f",
-      symbol,
-      place = false
-    } = payload;
-    const totalQuantity = orders.reduce((sum, order) => sum + (order.quantity || 0), 0);
-    let runningTotal = to_f2(totalQuantity, decimal_places);
-    let sortedOrders = [...orders].sort((a, b) => (a.entry || 0) - (b.entry || 0));
-    if (kind === "short") {
-      sortedOrders.reverse();
-    }
-    const withCumulative = [];
-    for (const order of sortedOrders) {
-      withCumulative.push({
-        ...order,
-        cumulative_quantity: runningTotal
-      });
-      runningTotal -= order.quantity;
-      runningTotal = to_f2(runningTotal, decimal_places);
-    }
-    const positions = await getPositionInfo2(this.client, symbol);
-    const position2 = positions[kind] || {
-      kind,
-      size: 0,
-      entryPrice: 0,
-      symbol
-    };
-    const filteredOrders = withCumulative.filter((order) => (order.cumulative_quantity || 0) > position2.size).map((order) => ({
-      ...order,
-      price: order.entry,
-      kind,
-      side: kind.toLowerCase() === "long" ? "buy" : "sell"
-    }));
-    if (filteredOrders.length > 0 && place) {
-      await cancelAllOrders2(this.client, symbol, {
-        type: "limit",
-        kind
-      });
-      await createLimitPurchaseOrders2(this.client, symbol, price_places, decimal_places, filteredOrders);
-    }
-    return filteredOrders;
+  async cancelAllOrders(symbol, payload) {
+    return await cancelAllOrders2(this.client, symbol, payload);
   }
-  async get_current_price(symbol) {
+  async _createLimitPurchaseOrders(payload) {
+    return await createLimitPurchaseOrders2(this.client, payload.symbol, payload.price_places, payload.decimal_places, payload.orders);
+  }
+  async getCurrentPrice(symbol) {
     return await getCurrentPrice2(this.client, symbol);
   }
   async analyzeCharts(payload) {
@@ -56526,60 +56557,30 @@ class BybitExchange extends BaseExchange {
       raw: payload.raw || false
     });
   }
-  async getExchangeAccountInfo(options) {
-    const {
-      price_places = "%.1f",
-      decimal_places = "%.3f",
-      account,
-      symbol
-    } = options;
+  async getExchangeInfo(options) {
     return await fetchBybitAccount(this.client, {
-      owner: account.owner,
-      symbol
+      owner: options.account.owner,
+      symbol: options.symbol
     }, {
-      price_places,
-      decimal_places
+      price_places: options.price_places,
+      decimal_places: options.decimal_places
     });
   }
-  async cancelOrders(payload) {
+  async _cancelOrders(payload) {
     return await cancelOrders2({
       symbol: payload.symbol,
-      orders: payload.orders.map((x) => ({ orderId: x })),
+      orders: payload.orders,
       custom_client: this.client
     });
   }
-  async placeTpOrder(payload) {
-    return await placeTpOrder2(this.client, {
-      symbol: payload.symbol,
-      tp: payload.take_profit,
-      kind: payload.kind,
-      cancel: true
-    });
+  async _placeTpOrder(payload) {
+    return await placeTpOrder2(this.client, payload);
   }
-  async placeLimitOrder(payload) {
-    return await placeLimitOrders2(this.client, {
-      symbol: payload.symbol,
-      orders: [
-        {
-          entry: payload.price,
-          quantity: payload.quantity
-        }
-      ],
-      kind: payload.kind
-    });
+  async placeLimitOrders(payload) {
+    return await placeLimitOrders2(this.client, payload);
   }
-  async placeStopOrder(payload) {
-    return await placeStopOrder2(this.client, {
-      symbol: payload.symbol,
-      stop: payload.stop,
-      final_stop: payload.stop,
-      quantity: Math.abs(payload.quantity),
-      kind: payload.kind,
-      cancel: true,
-      is_limit: true,
-      price_places: payload.price_places,
-      decimal_places: payload.decimal_places
-    });
+  async _placeStopOrder(payload) {
+    return await placeStopOrder2(this.client, payload);
   }
   async setLeverage(payload) {
     return await this.client.setLeverage({
@@ -56593,40 +56594,18 @@ class BybitExchange extends BaseExchange {
   }
   async checkDelistedMovers(payload) {
   }
-  async closePosition(payload) {
-  }
-  async getAllOpenSymbols() {
-    return [];
+  async getAllOpenOrders() {
+    const result = await getAllOpenOrders2({ client: this.client });
+    return result;
   }
   async getOpenPositions() {
     return [];
   }
-  async createLimitPurchaseOrders(payload) {
-    const {
-      orders,
-      kind,
-      decimal_places = "%.3f",
-      price_places = "%.1f",
-      symbol
-    } = payload;
-    return await createLimitPurchaseOrders2(this.client, symbol, price_places, decimal_places, orders.map((order) => ({
-      ...order,
-      price: order.entry,
-      kind,
-      side: kind.toLowerCase() === "long" ? "buy" : "sell"
-    })));
-  }
   async getDelistedSpotSymbols() {
     return [];
   }
   async crossAccountTransfer(payload) {
   }
-  async placeMarketOrder(payload) {
-  }
-  async rawCreateLimitPurchaseOrders(payload) {
-    const { symbol, orders, price_places, decimal_places } = payload;
-    return createLimitPurchaseOrders2(this.client, symbol, price_places, decimal_places, orders);
-  }
   getOpenOrders(payload) {
     return getOpenOrders2(this.client, payload.symbol);
   }
@@ -58062,6 +58041,9 @@ class ExchangeAccount {
       long_config,
       short_config
     });
+    if (!long_config || !short_config) {
+      return null;
+    }
     let long_target_pnl = payload.kind == "long" ? payload.target_pnl : 0;
     let short_target_pnl = payload.kind == "short" ? payload.target_pnl : 0;
     const long_sell_ratio = long_config.sell_ratio || long_position?.sell_ratio;
@@ -58186,7 +58168,7 @@ class ExchangeAccount {
     });
     const long_pause_tp = long_config?.pause_tp;
     const short_pause_tp = short_config?.pause_tp;
-    if (payload.trigger && !long_pause_tp && !short_pause_tp) {
+    if (payload.trigger && !long_pause_tp && !short_pause_tp && config2) {
       return await this.reduceMajorPositionEntry({
         symbol,
         long: config2.long,
@@ -58750,15 +58732,15 @@ class ExchangeAccount {
   }
   async buildOppositeTrades(payload) {
     const { symbol, kind, place, place_symbol } = payload;
-    const strategy = await this.runSimulation({
+    const strategy2 = await this.runSimulation({
       symbol,
       kind,
       raw: true
     });
     try {
-      const result = strategy.generateOppositeTrades({
+      const result = strategy2.generateOppositeTrades({
         kind,
-        avg_entry: strategy.position[kind].avg_price
+        avg_entry: strategy2.position[kind].avg_price
       });
       if (place && result?.kind) {
         const _symbol = place_symbol || symbol;
@@ -58809,7 +58791,7 @@ class ExchangeAccount {
       reduce_ratio,
       global_config: symbol_config
     };
-    const strategy = new Strategy({
+    const strategy2 = new Strategy({
       long: {
         entry: long_position.entry,
         quantity: long_position.quantity,
@@ -58825,9 +58807,9 @@ class ExchangeAccount {
       config: strategy_config
     });
     if (raw) {
-      return strategy;
+      return strategy2;
     }
-    return strategy.runIterations({
+    return strategy2.runIterations({
       iterations,
       kind
     });
@@ -59516,31 +59498,31 @@ class ExchangeAccount {
     if (!focus_position) {
       return;
     }
-    const strategy = focus_position?.expand?.account_strategy;
-    if (!strategy) {
+    const strategy2 = focus_position?.expand?.account_strategy;
+    if (!strategy2) {
       return;
     }
-    const risk = strategy.risk;
-    const kind = strategy.kind;
-    const support = strategy.support;
-    const resistance = strategy.resistance;
+    const risk = strategy2.risk;
+    const kind = strategy2.kind;
+    const support = strategy2.support;
+    const resistance = strategy2.resistance;
     console.log("Getting long and short positions for ", symbol);
     const long_position = positions.find((k) => k.kind === "long");
     const short_position = positions.find((k) => k.kind === "short");
     console.log("Getting focus position for ", symbol, kind);
     const reverse_position = kind === "long" ? short_position : long_position;
-    if (strategy.max_reward_factor === 0) {
-      reward_factor = strategy.reward_factor;
+    if (strategy2.max_reward_factor === 0) {
+      reward_factor = strategy2.reward_factor;
     }
-    if (focus_position.avg_qty >= focus_position.quantity && strategy.max_reward_factor) {
-      if (strategy.dynamic) {
+    if (focus_position.avg_qty >= focus_position.quantity && strategy2.max_reward_factor) {
+      if (strategy2.dynamic) {
         const quantity_ratio = focus_position.quantity / focus_position.avg_qty;
-        reward_factor = to_f2(quantity_ratio ** 2 * strategy.max_reward_factor, "%.2f");
+        reward_factor = to_f2(quantity_ratio ** 2 * strategy2.max_reward_factor, "%.2f");
       } else {
-        reward_factor = to_f2(focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty, "%.4f");
+        reward_factor = to_f2(focus_position.quantity * strategy2.max_reward_factor / focus_position.avg_qty, "%.4f");
       }
     } else {
-      reward_factor = strategy.reward_factor;
+      reward_factor = strategy2.reward_factor;
     }
     console.log("Getting entry and stop for ", symbol, kind);
     const entry = kind === "long" ? resistance : support;
@@ -59554,7 +59536,7 @@ class ExchangeAccount {
       symbol
     });
     console.log("Computing risk reward for ", symbol, kind);
-    const risk_reward = strategy.risk_reward || computeRiskReward({
+    const risk_reward = strategy2.risk_reward || computeRiskReward({
       app_config: initial_app_config,
       entry: initial_app_config.entry,
       stop: initial_app_config.stop,
@@ -59687,7 +59669,7 @@ class ExchangeAccount {
         const max_size = app_config.max_size * 0.98;
         if (reverse_config.threshold_qty !== max_size) {
           await this.app_db.updateScheduledTrade(reverse_config.id, {
-            follow: strategy.follow,
+            follow: strategy2.follow,
             threshold_qty: max_size
           });
         }
@@ -59761,8 +59743,8 @@ class ExchangeAccount {
     }
     const reverse_kind = focus_position.kind === "long" ? "short" : "long";
     const reverse_position = positions.find((k) => k.kind === reverse_kind);
-    const strategy = focus_position?.expand?.account_strategy;
-    if (!strategy) {
+    const strategy2 = focus_position?.expand?.account_strategy;
+    if (!strategy2) {
       return;
     }
     return computeProfitDetail({
@@ -59775,9 +59757,9 @@ class ExchangeAccount {
       },
       pnl: focus_position.target_pnl,
       strategy: {
-        reward_factor: strategy.reward_factor,
-        risk: strategy.risk,
-        max_reward_factor: strategy.max_reward_factor
+        reward_factor: strategy2.reward_factor,
+        risk: strategy2.risk,
+        max_reward_factor: strategy2.max_reward_factor
       },
       reduce_position: {
         kind: reduce_position.kind,
@@ -60023,6 +60005,9 @@ class App {
         owner: exchange.owner,
         exchange: exchange.exchange
       });
+      if (exchange.exchange === "bybit" && symbol === "BTCUSDC") {
+        continue;
+      }
       await exchange_account.placeProfitAndStop({
         symbol,
         trigger: true,
@@ -60117,11 +60102,11 @@ class App {
   }
   async runDbStrategyAccounts(callback) {
     const strategies = await this.app_db.getRunningAccountStrategies();
-    for (const strategy of strategies) {
-      console.log("Running strategy for ", strategy.symbol, "for account", strategy.expand.account.owner, strategy.expand.account.exchange);
+    for (const strategy2 of strategies) {
+      console.log("Running strategy for ", strategy2.symbol, "for account", strategy2.expand.account.owner, strategy2.expand.account.exchange);
       await callback({
-        symbol: strategy.symbol,
-        account: strategy.expand.account
+        symbol: strategy2.symbol,
+        account: strategy2.expand.account
       });
     }
   }