@gbozee/ultimate 0.0.2-19 → 0.0.2-21

package/dist/index.js

@@ -32115,6 +32115,18 @@ class AppDatabase {
   constructor(pb) {
     this.pb = pb;
   }
+  async getAllSymbolsFromPositions(options) {
+    const { no_position = false, kind = "long", custom_filter } = options || {};
+    let filter = custom_filter || (no_position ? `quantity = 0` : undefined);
+    if (kind && filter && !custom_filter) {
+      filter = `${filter} && kind = "${kind}"`;
+    }
+    const positions = await this.pb.collection("positions").getFullList({
+      fields: `symbol`,
+      filter
+    });
+    return Array.from(new Set(positions.map((p) => p.symbol)));
+  }
   async createOrUpdateLiveExchangeInstance(payload) {
     const result = await this.getLiveExchangeInstance(payload);
     if (result) {
@@ -32157,18 +32169,21 @@ class AppDatabase {
   async getAccounts() {
     return await this.pb.collection("exchange_accounts").getFullList();
   }
-  async getAllSymbolConfigs(with_positions) {
+  async getAllSymbolConfigs(payload) {
+    const { with_positions = false, custom_filter } = payload || {
+      with_positions: false
+    };
+    let filter = custom_filter || undefined;
     if (with_positions) {
       const positions = await this.pb.collection("positions").getFullList({
         fields: `symbol`
       });
       const symbol_set = new Set(positions.map((p) => p.symbol));
-      const filter = Array.from(symbol_set).map((s2) => `symbol:lower="${s2.toLowerCase()}"`).join(" || ");
-      return await this.pb.collection("symbol_configs").getFullList({
-        filter
-      });
+      filter = Array.from(symbol_set).map((s2) => `symbol:lower="${s2.toLowerCase()}"`).join(" || ");
     }
-    return await this.pb.collection("symbol_configs").getFullList();
+    return await this.pb.collection("symbol_configs").getFullList({
+      filter
+    });
   }
   async get_exchange_db_instance(account) {
     const result = await this.pb.collection("exchange_accounts").getFirstListItem(`owner="${account.owner}" && exchange="${account.exchange}"`, {
@@ -32176,9 +32191,9 @@ class AppDatabase {
     });
     return result;
   }
-  async getPositions(account, options) {
-    const { symbol, as_view = false } = options;
-    const default_params = as_view ? {
+  async getPositions(options) {
+    const { symbol, as_view = false, account, custom_filter } = options;
+    let default_params = as_view ? {
       table: "positions_view",
       params: {
         filter: `symbol:lower="${symbol.toLowerCase()}" && account:lower="${account.owner.toLowerCase()} ${account.exchange.toLowerCase()}"`,
@@ -32191,6 +32206,9 @@ class AppDatabase {
         expand: "account,config"
       }
     };
+    if (custom_filter) {
+      default_params.params.filter = custom_filter;
+    }
     return await this.pb.collection(default_params.table).getFullList(default_params.params);
   }
   async _createOrUpdatePosition(db_position, params) {
@@ -32208,7 +32226,8 @@ class AppDatabase {
   }
   async createOrUpdatePositions(account, options) {
     const { symbol, long_position, usd_balance, short_position } = options;
-    const db_positions = await this.getPositions(account, {
+    const db_positions = await this.getPositions({
+      account,
       symbol
     });
     const exchange_db_instance = await this.get_exchange_db_instance(account);
@@ -32236,7 +32255,13 @@ class AppDatabase {
     return await this.pb.collection("positions").update(position.id, payload);
   }
   async getSymbolConfigFromDB(symbol) {
-    return await this.pb.collection("symbol_configs").getFirstListItem(`symbol:lower="${symbol.toLowerCase()}"`);
+    const item = await this.pb.collection("symbol_configs").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}"`
+    });
+    if (item.length > 0) {
+      return item[0];
+    }
+    return null;
   }
   async getRunningInstanceFromDB(account, symbol, options) {
     const { delay = 60 * 1000 } = options || {
@@ -32385,31 +32410,74 @@ class AppDatabase {
       return { success: false, error: error.message };
     }
   }
+  async getMoverExchangeInstances() {
+    const result = await this.pb.collection("exchange_accounts").getFullList({
+      filter: `totalRisk > 0 && movePercent > 0 && profit_percent > 0 && risk_reward > 0 && max_non_essential > 0`
+    });
+    return result;
+  }
+  async updateScheduledTrade(id, payload) {
+    return await this.pb.collection("scheduled_trades").update(id, payload);
+  }
   async createOrUpdatePositionConfig(db_position, payload) {
     let config = null;
     if (db_position.config) {
-      await this.pb.collection("scheduled_trades").update(db_position.config, {
+      const obj = {
         entry: payload.entry,
         stop: payload.stop,
         risk_reward: payload.risk_reward,
         risk: payload.risk
-      });
+      };
+      if (payload.profit_percent !== undefined) {
+        obj.profit_percent = payload.profit_percent;
+      }
+      if (payload.place_tp !== undefined) {
+        obj.place_tp = payload.place_tp;
+      }
+      if (payload.profit !== undefined) {
+        obj.profit = payload.profit;
+      }
+      return await this.pb.collection("scheduled_trades").update(db_position.config, obj);
     } else {
-      config = await this.pb.collection("scheduled_trades").create({
-        symbol: db_position.symbol,
-        account: db_position.account,
-        profit: payload.risk,
-        kind: payload.entry > payload.stop ? "long" : "short",
-        entry: payload.entry,
-        stop: payload.stop,
-        risk_reward: payload.risk_reward,
-        risk: payload.risk,
-        profit_percent: payload.profit_percent,
-        place_tp: true
+      const kind = payload.entry > payload.stop ? "long" : "short";
+      const account = db_position.expand?.account;
+      const configs = await this.pb.collection("scheduled_trades").getFullList({
+        filter: `symbol:lower="${db_position.symbol.toLowerCase()}" && kind="${kind}" && account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}"`
       });
+      if (configs.length > 0) {
+        config = configs[0];
+        await this.pb.collection("scheduled_trades").update(config.id, {
+          entry: payload.entry,
+          stop: payload.stop,
+          risk_reward: payload.risk_reward,
+          risk: payload.risk,
+          profit_percent: payload.profit_percent,
+          place_tp: payload.place_tp !== undefined ? payload.place_tp : true,
+          profit: payload.profit !== undefined ? payload.profit : config.profit
+        });
+        for (const _config of configs) {
+          if (_config.id !== config.id) {
+            await this.pb.collection("scheduled_trades").delete(_config.id);
+          }
+        }
+      } else {
+        config = await this.pb.collection("scheduled_trades").create({
+          symbol: db_position.symbol,
+          account: db_position.account,
+          profit: payload.profit || payload.risk,
+          kind,
+          entry: payload.entry,
+          stop: payload.stop,
+          risk_reward: payload.risk_reward,
+          risk: payload.risk,
+          profit_percent: payload.profit_percent,
+          place_tp: payload.place_tp !== undefined ? payload.place_tp : true
+        });
+      }
       await this.pb.collection("positions").update(db_position.id, {
         config: config?.id
       });
+      return config;
     }
   }
   async getPositionConfig(payload) {
@@ -32458,7 +32526,7 @@ class AppDatabase {
         moved_to_winding: []
       };
     }
-    const { new_markets, totalRisk } = options;
+    const { new_markets, totalRisk, max_count: _max_count } = options;
     const newMarketSymbols = new Set(new_markets.map((m) => m.symbol));
     console.log(`Processing ${new_markets.length} new top movers with total risk ${totalRisk}`);
     let currentBullish = [];
@@ -32649,6 +32717,12 @@ class AppDatabase {
     });
     return result;
   }
+  async hasExistingOrders(symbol) {
+    const result = await this.pb.collection("orders").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}"`
+    });
+    return result;
+  }
   async removeSymbolFromUnwindingMarkets(symbol) {
     const result = await this.pb.collection("winding_down_markets").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}"`
@@ -33192,6 +33266,10 @@ class Signal {
         limit_orders = trade_zones.slice(1).filter((x) => x >= this.to_f(current_price));
         market_orders = trade_zones.slice(1).filter((x) => x < this.to_f(current_price));
       }
+      if (market_orders.length === 1) {
+        limit_orders = limit_orders.concat(market_orders);
+        market_orders = [];
+      }
       const increase_position = Boolean(this.support) && this.increase_position;
       const market_trades = limit_orders.length > 0 ? market_orders.map((x, i2) => {
         const defaultStopLoss = i2 === 0 ? limit_orders[limit_orders.length - 1] : market_orders[i2 - 1];
@@ -33338,6 +33416,8 @@ class Signal {
     });
     const multiplier = start - index;
     const incurred_fees = fees.reduce((a, b) => a + b, 0) + previous_risks.reduce((a, b) => a + b, 0);
+    if (index === 0) {
+    }
     let quantity = determine_position_size({
       entry,
       stop,
@@ -33819,7 +33899,11 @@ async function placeTpOrder(client, payload) {
       price: payload.tp,
       quantity: _quantity
     };
-    return createLimitPurchaseOrders(client, symbol, price_places, decimal_places, [order]);
+    const rr = await createLimitPurchaseOrders(client, symbol, price_places, decimal_places, [order]);
+    if (payload.kind == "long") {
+      console.log("rr", { rr, price_places, decimal_places });
+    }
+    return rr;
   }
   return { error: "No quantity" };
 }
@@ -33935,17 +34019,21 @@ async function allWalletBalances(client) {
     balance: to_f(x.balance, "%.8f")
   }));
 }
-function buildPosition(position2, orders) {
+function buildPosition(position2, orders, options) {
+  const { price_places = "%.1f", decimal_places = "%.3f" } = options;
   const entry = position2.entryPrice;
-  const quantity = Math.abs(position2.positionAmt);
+  let quantity = Math.abs(position2.positionAmt);
   const kind = position2.kind;
+  if (Number.isNaN(quantity)) {
+    quantity = 0;
+  }
   const limitOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((o) => {
     return kind === "long" ? o.side === "buy" : o.side === "sell";
   });
   const avg = determine_average_entry_and_size([
     { price: entry, quantity },
     ...limitOrders.map((o) => ({ price: o.price, quantity: o.qty }))
-  ], "%.3f", "%.1f");
+  ], decimal_places, price_places);
   const stopOrders = orders.filter((x) => x.kind === kind && x.isStop)[0];
   const tpOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((x) => x.kind === "long" ? x.side === "sell" : x.side === "buy")[0];
   const avg_entry = avg.entry;
@@ -33980,7 +34068,7 @@ var emptyPosition = {
   tp_quantity: 0,
   stop_quantity: 0
 };
-async function fetchBinanceAccount(client, json) {
+async function fetchBinanceAccount(client, json, options) {
   const [position2, balance, orders, current_price, all_balances] = await Promise.all([
     getPositionInfo(client, json.symbol),
     getWalletBalance(client, json.symbol.toLowerCase().endsWith("usdt") ? "USDT" : "USDC"),
@@ -33995,19 +34083,19 @@ async function fetchBinanceAccount(client, json) {
   const long_position = buildPosition(position2.long || {
     ...emptyPosition,
     kind: "long"
-  }, orders);
+  }, orders, options);
   const short_position = buildPosition(position2.short || {
     ...emptyPosition,
     kind: "short"
-  }, orders);
+  }, orders, options);
   const result = {
     id: `${json.owner}-${json.symbol}-binance`,
     owner: json.owner,
     config: {
       symbol: json.symbol,
       id: 0,
-      price_places: "%.1f",
-      decimal_places: "%.3f",
+      price_places: options.price_places,
+      decimal_places: options.decimal_places,
       trades: {}
     },
     exchange: "binance",
@@ -34103,10 +34191,10 @@ async function analyzeCharts(params) {
   return finalPairs;
 }
 async function getWeeklyKlines(payload) {
-  const { client, symbol, limit = 20 } = payload;
+  const { client, symbol, limit = 20, interval = "1w" } = payload;
   const requestParams = {
     symbol: symbol.toUpperCase(),
-    interval: "1w"
+    interval
   };
   if (limit) {
     requestParams.limit = limit;
@@ -34163,11 +34251,18 @@ async function getActiveSymbols(payload) {
   const response = await client.getExchangeInfo();
   return response.symbols;
 }
+async function getAllOpenOrders(payload) {
+  const { client } = payload;
+  const response = await client.getAllOpenOrders();
+  return response;
+}
 
 class BinanceExchange {
   client;
-  constructor(client) {
+  main_client;
+  constructor(client, main_client) {
     this.client = client;
+    this.main_client = main_client;
   }
   async placeStopOrders(payload) {
     if (payload.place) {
@@ -34184,6 +34279,22 @@ class BinanceExchange {
       });
     }
   }
+  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 bulkPlaceLimitOrders(payload) {
     const {
       orders,
@@ -34242,10 +34353,19 @@ class BinanceExchange {
       raw: payload.raw || false
     });
   }
-  async getExchangeAccountInfo(account, symbol) {
+  async getExchangeAccountInfo(options) {
+    const {
+      price_places = "%.1f",
+      decimal_places = "%.3f",
+      account,
+      symbol
+    } = options;
     return await fetchBinanceAccount(this.client, {
       owner: account.owner,
       symbol
+    }, {
+      price_places,
+      decimal_places
     });
   }
   async cancelOrders(payload) {
@@ -34304,20 +34424,25 @@ class BinanceExchange {
       }
       maxLeverage = Math.max(...brackets.brackets.map((b) => b.initialLeverage));
     }
-    await this.client.setLeverage({
-      symbol: payload.symbol,
-      leverage: payload.leverage || maxLeverage
-    });
+    try {
+      await this.client.setLeverage({
+        symbol: payload.symbol,
+        leverage: payload.leverage || maxLeverage
+      });
+    } catch (error) {
+      console.log("error", error);
+    }
     return maxLeverage;
   }
   async generateConfig(payload) {
     const symbols = await getActiveSymbols({ client: this.client });
     console.log("symbols", symbols);
-    const { symbol, limit = 5 } = payload;
+    const { symbol, limit = 5, interval = "1w" } = payload;
     const klines = await getWeeklyKlines({
       client: this.client,
       symbol,
-      limit
+      limit,
+      interval
     });
     const { support, resistance } = calculateSupportResistance(klines);
     const target = symbols.find((s2) => s2.symbol === symbol);
@@ -34328,14 +34453,19 @@ class BinanceExchange {
       if (f.filterType === "MIN_NOTIONAL")
         minNotional = parseFloat(f.notional);
     });
+    if (["BTCUSDT", "BTCUSDC"].includes(symbol)) {
+      minNotional = 105;
+    }
+    const isBTC = ["BTCUSDT", "BTCUSDC"].includes(symbol);
     const currentPrice = await getCurrentPrice(this.client, symbol);
-    const price_places = `%.${getPricePlaces(currentPrice)}f`;
+    const price_places = isBTC ? "%.1f" : `%.${getPricePlaces(currentPrice)}f`;
     const decimal_places = `%.${target.quantityPrecision}f`;
+    const min_size = to_f((minNotional || 0) / support, decimal_places);
     const configObj = {
       support,
       resistance,
       minNotional,
-      min_size: to_f((minNotional || 0) / support, decimal_places),
+      min_size: isBTC ? 0.002 : min_size,
       price_places,
       decimal_places,
       leverage: await this.setLeverage({ symbol }),
@@ -34353,18 +34483,49 @@ class BinanceExchange {
     const delisted = movers.map((x) => x.symbol).filter((symbol) => !activeSymbols.includes(symbol));
     const validMovers = movers.filter((m) => !delisted.includes(m.symbol)).filter((m) => activeSymbols.includes(m.symbol));
     const activeMovers = [];
-    for (const m of validMovers) {
-      const isActive = await isSymbolActive({
+    const isActivePromises = validMovers.map(async (m) => {
+      return await isSymbolActive({
         client: this.client,
         symbol: m.symbol
       });
-      if (isActive) {
-        activeMovers.push(m);
+    });
+    const isActiveResults = await Promise.all(isActivePromises);
+    for (let i2 = 0;i2 < validMovers.length; i2++) {
+      if (isActiveResults[i2]) {
+        activeMovers.push(validMovers[i2]);
       }
     }
     console.log(`Top movers:`, movers);
     console.log(`Delisted movers:`, delisted);
-    return { movers: activeMovers, delisted };
+    const toBeDelisted = await this.getDelistedSpotSymbols();
+    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 getDelistedSpotSymbols() {
+    if (this.main_client) {
+      const client = this.main_client;
+      const response = await client.getDelistSchedule();
+      if (response.length > 0) {
+        return response[0].symbols;
+      }
+      return [];
+    }
+    return [];
   }
 }
 function getPricePlaces(target) {
@@ -34681,7 +34842,8 @@ async function allWalletBalances2(client) {
     balance: to_f(x.walletBalance, "%.8f")
   }));
 }
-function buildPosition2(position2, orders) {
+function buildPosition2(position2, orders, options) {
+  const { price_places = "%.1f", decimal_places = "%.3f" } = options;
   const entry = parseFloat(position2.avgPrice || "0");
   const quantity = parseFloat(position2.size || "0");
   const kind = position2.positionIdx === 1 ? "long" : "short";
@@ -34691,7 +34853,7 @@ function buildPosition2(position2, orders) {
   const avg = determine_average_entry_and_size([
     { price: entry, quantity },
     ...limitOrders.map((o) => ({ price: o.price, quantity: o.qty }))
-  ], "%.3f", "%.1f");
+  ], decimal_places, price_places);
   const stopOrders = orders.filter((x) => x.kind === kind && x.isStop)[0];
   const tpOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((x) => x.kind === "long" ? x.side === "sell" : x.side === "buy")[0];
   const avg_entry = avg.entry;
@@ -34726,7 +34888,8 @@ var emptyPosition2 = {
   tp_quantity: 0,
   stop_quantity: 0
 };
-async function fetchBybitAccount(client, json) {
+async function fetchBybitAccount(client, json, options) {
+  const { price_places = "%.1f", decimal_places = "%.3f" } = options;
   const [position2, balance, orders, current_price, all_balances] = await Promise.all([
     getPositionInfo2(client, json.symbol),
     getWalletBalance2(client, "USDT"),
@@ -34744,8 +34907,8 @@ async function fetchBybitAccount(client, json) {
     config: {
       symbol: json.symbol,
       id: 0,
-      price_places: "%.1f",
-      decimal_places: "%.3f",
+      price_places,
+      decimal_places,
       trades: {}
     },
     exchange: "bybit",
@@ -34758,12 +34921,18 @@ async function fetchBybitAccount(client, json) {
       ...emptyPosition2,
       positionIdx: 1,
       kind: "long"
-    }, orders),
+    }, orders, {
+      price_places,
+      decimal_places
+    }),
     short_position: buildPosition2(position2.short || {
       ...emptyPosition2,
       positionIdx: 2,
       kind: "short"
-    }, orders),
+    }, orders, {
+      price_places,
+      decimal_places
+    }),
     current_price,
     orders: limitOrders,
     entries: [],
@@ -34856,8 +35025,10 @@ async function analyzeCharts2(params) {
 
 class BybitExchange {
   client;
-  constructor(client) {
+  main_client;
+  constructor(client, main_client) {
     this.client = client;
+    this.main_client = main_client;
   }
   async placeStopOrders(payload) {
     if (payload.place) {
@@ -34932,10 +35103,19 @@ class BybitExchange {
       raw: payload.raw || false
     });
   }
-  async getExchangeAccountInfo(account, symbol) {
+  async getExchangeAccountInfo(options) {
+    const {
+      price_places = "%.1f",
+      decimal_places = "%.3f",
+      account,
+      symbol
+    } = options;
     return await fetchBybitAccount(this.client, {
       owner: account.owner,
       symbol
+    }, {
+      price_places,
+      decimal_places
     });
   }
   async cancelOrders(payload) {
@@ -34990,6 +35170,29 @@ class BybitExchange {
   }
   async checkDelistedMovers(payload) {
   }
+  async closePosition(payload) {
+  }
+  async getAllOpenSymbols() {
+    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 [];
+  }
 }
 
 // src/helpers/accounts.ts
@@ -35145,12 +35348,12 @@ function calculateHedge(kind, active_account, targetPnl = 100, ratio = 0.9, use_
   return {
     [kind]: {
       price: to_f(takeProfitPrice, active_account.price_places),
-      quantity: to_f(position2.quantity, active_account.decimal_places),
+      quantity: to_f(position2.quantity || 0, active_account.decimal_places),
       type: "TAKE_PROFIT"
     },
     [oppositeKind]: {
       stop_price: to_f(stopLossPrice, active_account.price_places),
-      quantity: to_f(stopLossQuantity, active_account.decimal_places),
+      quantity: to_f(stopLossQuantity || 0, active_account.decimal_places),
       type: "STOP_LOSS"
     }
   };
@@ -35219,7 +35422,9 @@ function processPosition(codeNode, input, kind) {
     owner: active_account.owner,
     risk: codeNode.profit || 150,
     increase: codeNode.increase,
-    not_reduce: codeNode.not_reduce
+    not_reduce: codeNode.not_reduce,
+    price_places: active_account.price_places,
+    decimal_places: active_account.decimal_places
   };
 }
 async function reduceMajorPositionCalculation(input, exchange_instance) {
@@ -35242,11 +35447,13 @@ async function reduceMajorPositionCalculation(input, exchange_instance) {
     });
     if (conditionsCheck) {
       const async_tp = async () => {
-        if (input.stop) {
+        if (input.stop && input.stop !== Infinity) {
           await exchange_instance.placeTpOrder({
             symbol: input.position.symbol,
             kind: input.kind,
-            take_profit: input.stop
+            take_profit: input.stop,
+            price_places: input.price_places,
+            decimal_places: input.decimal_places
           });
         }
       };
@@ -35256,7 +35463,9 @@ async function reduceMajorPositionCalculation(input, exchange_instance) {
             symbol: input.position.symbol,
             kind: input.to_place.kind,
             price: input.to_place.stop_price,
-            quantity: input.to_place.quantity
+            quantity: input.to_place.quantity,
+            price_places: input.price_places,
+            decimal_places: input.decimal_places
           }).then((r2) => {
             console.log("placeNewOrderData", r2);
           });
@@ -35264,12 +35473,14 @@ async function reduceMajorPositionCalculation(input, exchange_instance) {
       };
       let placeNewOrderData = null;
       const async_place_stop = async () => {
-        if (!input.not_reduce && input.to_place.stop_price) {
+        if (!input.not_reduce && input.to_place.stop_price && input.to_place.quantity) {
           await exchange_instance.placeStopOrder({
             symbol: input.position.symbol,
             kind: input.to_place.kind,
             stop: input.to_place.stop_price,
-            quantity: Math.abs(input.to_place.quantity)
+            quantity: Math.abs(input.to_place.quantity),
+            price_places: input.price_places,
+            decimal_places: input.decimal_places
           });
         }
       };
@@ -35385,6 +35596,7 @@ function buildConfig(app_config, {
   if (kind === "short") {
     console.log("condition", condition, entry === stop);
   }
+  console.log({ entry, support: app_config.support, stop });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -35418,8 +35630,8 @@ function get_app_config_and_max_size(config, payload) {
     stop: payload.stop,
     risk_per_trade: config.risk,
     risk_reward: config.risk_reward || 199,
-    support: config.support,
-    resistance: config.resistance,
+    support: to_f(config.support, config.price_places),
+    resistance: to_f(config.resistance, config.price_places),
     focus: payload.entry,
     fee: 0,
     percent_change: config.stop_percent / 100,
@@ -35443,13 +35655,23 @@ function get_app_config_and_max_size(config, payload) {
     decimal_places: app_config.decimal_places
   });
   const max_size = initialResult[0]?.avg_size;
+  const last_value = initialResult[0];
+  const entries = initialResult.map((x) => ({
+    entry: x.entry,
+    avg_entry: x.avg_entry,
+    avg_size: x.avg_size,
+    neg_pnl: x.neg_pnl,
+    quantity: x.quantity
+  }));
   return {
     app_config,
-    max_size
+    max_size,
+    last_value,
+    entries
   };
 }
 function buildAppConfig(config, payload) {
-  const { app_config, max_size } = get_app_config_and_max_size({
+  const { app_config, max_size, last_value, entries } = get_app_config_and_max_size({
     ...config,
     risk: payload.risk,
     profit: payload.profit || 500,
@@ -35468,6 +35690,8 @@ function buildAppConfig(config, payload) {
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
   app_config.stop = payload.stop || app_config.stop;
+  app_config.last_value = last_value;
+  app_config.entries = entries;
   return app_config;
 }
 function getOptimumStopAndRisk(app_config, params) {
@@ -35641,24 +35865,35 @@ function generate_config_params(app_config, payload) {
 class ExchangeAccount {
   instance;
   exchange;
+  main_exchange;
   app_db;
   constructor(payload, options) {
     this.instance = payload;
     this.exchange = options.exchange;
     this.app_db = options.app_db;
+    this.main_exchange = options.main_exchange;
   }
   async getLiveExchangeInstance(payload) {
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol: payload.symbol,
+      refresh: payload.refresh_symbol_config
+    });
     const result = await this.app_db.getLiveExchangeInstance({
       account: this.instance,
       symbol: payload.symbol
     });
     if (payload.refresh || !result) {
-      const data = await this.exchange.getExchangeAccountInfo(this.instance, payload.symbol);
-      if (payload.price_places) {
-        data.config.price_places = payload.price_places;
+      const data = await this.exchange.getExchangeAccountInfo({
+        account: this.instance,
+        symbol: payload.symbol,
+        price_places: symbol_config?.price_places,
+        decimal_places: symbol_config?.decimal_places
+      });
+      if (symbol_config?.price_places) {
+        data.config.price_places = symbol_config.price_places;
       }
-      if (payload.decimal_places) {
-        data.config.decimal_places = payload.decimal_places;
+      if (symbol_config?.decimal_places) {
+        data.config.decimal_places = symbol_config.decimal_places;
       }
       return await this.app_db.createOrUpdateLiveExchangeInstance({
         account: this.instance,
@@ -35668,11 +35903,15 @@ class ExchangeAccount {
     }
     return result;
   }
-  async getActiveAccount(symbol, full) {
-    const symbol_config = await this.app_db.getSymbolConfigFromDB(symbol);
-    const live_exchange_instance = await this.getLiveExchangeInstance({
+  async getActiveAccount(payload) {
+    const { symbol, full = false, refresh = false } = payload;
+    const symbol_config = await this.recomputeSymbolConfig({
       symbol
     });
+    const live_exchange_instance = await this.getLiveExchangeInstance({
+      symbol,
+      refresh
+    });
     const raw_active_account = live_exchange_instance.data;
     const _all = get_active_accounts({
       active_account: raw_active_account,
@@ -35684,9 +35923,10 @@ class ExchangeAccount {
     return _all.active_account;
   }
   async syncAccount(options) {
-    const { symbol, update = false } = options;
+    const { symbol, update = false, live_refresh = false } = options;
     if (!update) {
-      const db_positions2 = await this.app_db.getPositions(this.instance, {
+      const db_positions2 = await this.app_db.getPositions({
+        account: this.instance,
         symbol: options.symbol,
         as_view: options.as_view
       });
@@ -35696,7 +35936,10 @@ class ExchangeAccount {
       }
       return db_positions2;
     }
-    const active_account = await this.getActiveAccount(symbol);
+    const active_account = await this.getActiveAccount({
+      refresh: live_refresh,
+      symbol
+    });
     if (options.leverage) {
       await this.exchange.setLeverage({ symbol, leverage: options.leverage });
     }
@@ -35723,7 +35966,9 @@ class ExchangeAccount {
       });
       return db_orders;
     }
-    const active_account = await this.getActiveAccount(symbol);
+    const active_account = await this.getActiveAccount({
+      symbol
+    });
     const orders = kind === "long" ? active_account.orders.long.entries : active_account.orders.short.entries;
     const stop_orders = kind === "long" ? active_account.orders.long.stop_orders : active_account.orders.short.stop_orders;
     const tp_orders = kind === "long" ? active_account.orders.long.tp_orders : active_account.orders.short.tp_orders;
@@ -35851,7 +36096,8 @@ class ExchangeAccount {
       final_stop: solution.stop,
       kind: app_config.kind,
       quantity: trades[0]?.avg_size,
-      is_limit: true
+      is_limit: true,
+      neg_pnl: trades[0]?.neg_pnl
     };
     if (place) {
       let arr = [
@@ -35886,6 +36132,59 @@ class ExchangeAccount {
       trades
     };
   }
+  async determineAmountToBuy(payload) {
+    const {
+      orders,
+      kind,
+      decimal_places = "%.3f",
+      symbol
+    } = payload;
+    const totalQuantity = orders.reduce((sum, order) => sum + (order.quantity || 0), 0);
+    let runningTotal = to_f(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_f(runningTotal, decimal_places);
+    }
+    const position2 = await this.syncAccount({
+      symbol,
+      kind,
+      live_refresh: true,
+      update: true
+    });
+    let existingOrders = await this.syncOrders({
+      symbol,
+      kind,
+      update: true
+    });
+    let filteredOrders = withCumulative.filter((order) => (order.cumulative_quantity || 0) > position2?.quantity).map((order) => ({
+      ...order,
+      price: order.entry,
+      kind,
+      side: kind.toLowerCase() === "long" ? "buy" : "sell"
+    }));
+    filteredOrders = filteredOrders.filter((k) => !existingOrders.map((j) => j.price).includes(k.price));
+    const side = kind.toLowerCase() === "long" ? "buy" : "sell";
+    const shouldCancel = existingOrders.filter((k) => !orders.map((j) => j.entry).includes(k.price) && k.side === side).map((u) => u.price);
+    if (shouldCancel.length > 0) {
+      const pp = kind === "long" ? Math.max(...shouldCancel) : Math.min(...shouldCancel);
+      const cancel_orders = await this.cancelOrders({
+        symbol,
+        kind,
+        price: pp
+      });
+      console.log("cancel_orders", cancel_orders);
+    }
+    return filteredOrders;
+  }
   async placeSharedOrder(action, payload) {
     const app_config = await this.buildAppConfig({
       entry: payload.entry,
@@ -35906,6 +36205,29 @@ class ExchangeAccount {
       min_size: app_config.min_size,
       symbol: payload.symbol
     }, false);
+    if (payload.raw) {
+      let actual_orders_to_buy = await this.determineAmountToBuy({
+        orders: trades,
+        kind: app_config.kind,
+        decimal_places: app_config.decimal_places,
+        price_places: app_config.price_places,
+        symbol: payload.symbol,
+        place: payload.place
+      });
+      if (action === "place_limit_orders" && payload.place) {
+        return await this.exchange.createLimitPurchaseOrders({
+          orders: actual_orders_to_buy.map((x) => ({
+            entry: x.entry,
+            quantity: x.quantity
+          })),
+          kind: app_config.kind,
+          decimal_places: app_config.decimal_places,
+          price_places: app_config.price_places,
+          symbol: payload.symbol
+        });
+      }
+      return actual_orders_to_buy;
+    }
     if (action === "place_limit_orders" && payload.place) {
       let result = await this.exchange.bulkPlaceLimitOrders({
         orders: trades.map((x) => ({
@@ -35952,7 +36274,17 @@ class ExchangeAccount {
         kind: payload.kind
       });
       if (db_position) {
-        await this.app_db.createOrUpdatePositionConfig(db_position, payload.params);
+        const config = db_position.expand?.config;
+        const params = {
+          entry: payload.params.entry !== undefined ? payload.params.entry : config.entry,
+          stop: payload.params.stop !== undefined ? payload.params.stop : config.stop,
+          risk_reward: payload.params.risk_reward !== undefined ? payload.params.risk_reward : config.risk_reward,
+          risk: payload.params.risk !== undefined ? payload.params.risk : config.risk,
+          profit_percent: payload.params.profit_percent !== undefined ? payload.params.profit_percent : config.profit_percent,
+          place_tp: payload.params.place_tp !== undefined ? payload.params.place_tp : true,
+          profit: payload.params.profit !== undefined ? payload.params.profit : config.profit
+        };
+        return await this.app_db.createOrUpdatePositionConfig(db_position, params);
       }
     }
     return await this.app_db.getPositionConfig({
@@ -35967,7 +36299,7 @@ class ExchangeAccount {
   async getPositionStrategy() {
     return await this.app_db.getPositionStrategy(this.instance);
   }
-  async getOriginalPlannedStop(payload) {
+  async buildReduceConfig(payload) {
     const positions = await this.syncAccount({
       symbol: payload.symbol
     });
@@ -35976,92 +36308,266 @@ class ExchangeAccount {
       symbol: payload.symbol,
       _positions: positions
     });
-    let result = await this.syncReduceClosePosition(payload.symbol, {
-      long: {
-        minimum_pnl: config?.long_minimum_pnl || 0.0001,
-        max_size: 0.003,
-        profit: config?.long_profit,
-        increase: false,
-        not_reduce: config?.not_reduce,
-        ratio: config?.reduce_ratio_long
-      },
-      short: {
-        minimum_pnl: config?.short_minimum_pnl || 0.0001,
-        max_size: 0.003,
-        profit: config?.short_profit,
-        increase: false,
-        not_reduce: config?.not_reduce,
-        ratio: config?.reduce_ratio_short
-      },
-      trigger: {
-        long: false,
-        short: false
-      }
+    if (payload.as_dict) {
+      return {
+        long: {
+          minimum_pnl: config?.long_minimum_pnl || 0.0001,
+          max_size: 0.003,
+          profit: config?.long_profit,
+          increase: false,
+          not_reduce: config?.not_reduce,
+          ratio: config?.reduce_ratio_long,
+          use_full: payload.use_full ? payload.kind == "long" ? true : false : undefined
+        },
+        short: {
+          minimum_pnl: config?.short_minimum_pnl || 0.0001,
+          max_size: 0.003,
+          profit: config?.short_profit,
+          increase: false,
+          not_reduce: config?.not_reduce,
+          ratio: config?.reduce_ratio_short,
+          use_full: payload.use_full ? payload.kind == "short" ? true : false : undefined
+        },
+        trigger: {
+          long: payload.trigger?.long ? config.trigger_long : false,
+          short: payload.trigger?.short ? config.trigger_short : false
+        }
+      };
+    }
+    return config;
+  }
+  async getOriginalPlannedStop(payload) {
+    const config = await this.buildReduceConfig({
+      symbol: payload.symbol,
+      kind: payload.kind,
+      as_dict: true
+    });
+    let result = await this.reduceMajorPositionEntry({
+      symbol: payload.symbol,
+      long: config.long,
+      short: config.short,
+      trigger: config.trigger
     });
     let _kind = payload.kind == "long" ? "short" : "long";
     let orders = result[_kind];
     return orders.result[payload.kind];
   }
-  async syncReduceClosePosition(symbol, payload) {
-    let accountInfo = await this.getActiveAccount(symbol, true);
-    let { long, short, trigger, kind } = payload || {};
-    if (!long || !short) {
-      const positions = await this.syncAccount({
-        symbol
-      });
-      const config = build_reduce_config({
-        account: this.instance,
-        symbol,
-        _positions: positions
-      });
-      long = {
-        minimum_pnl: config?.long_minimum_pnl,
-        max_size: 0.003,
-        profit: config?.long_profit,
-        increase: false,
-        not_reduce: config?.not_reduce,
-        ratio: config?.reduce_ratio_long,
-        use_full: kind == "long" ? true : false
-      };
-      short = {
-        minimum_pnl: config?.short_minimum_pnl,
-        max_size: 0.003,
-        profit: config?.short_profit,
-        increase: false,
-        not_reduce: config?.not_reduce,
-        ratio: config?.reduce_ratio_short,
-        use_full: kind == "short" ? true : false
-      };
-      trigger = {
-        long: config?.trigger_long,
-        short: config?.trigger_short
-      };
-    }
+  async syncReduceClosePosition(payload) {
+    let { symbol, kind, trigger } = payload || {};
+    const config = await this.buildReduceConfig({
+      symbol,
+      kind,
+      as_dict: true,
+      trigger: {
+        long: trigger || false,
+        short: trigger || false
+      },
+      use_full: true
+    });
+    return await this.reduceMajorPositionEntry({
+      symbol,
+      long: config.long,
+      short: config.short,
+      trigger: config.trigger
+    });
+  }
+  async reduceMajorPositionEntry(payload) {
+    const { symbol, long, short, trigger } = payload;
+    let accountInfo = await this.getActiveAccount({
+      symbol,
+      full: true
+    });
     return await reduceMajorPositionEntry({
       long,
       short
     }, accountInfo, trigger, this.exchange);
   }
-  async generate_config_params(payload) {
-    const { entry, stop, risk_reward, risk, symbol } = payload;
-    const app_config = await this.buildAppConfig({
-      entry,
-      stop,
-      risk_reward,
-      risk,
-      symbol
-    });
-    let config = generate_config_params(app_config, {
-      entry,
-      stop,
-      risk_reward,
-      risk,
-      symbol
+  async placeProfitAndStop(payload) {
+    const { symbol, trigger, refresh, kind } = payload;
+    if (refresh) {
+      await this.syncAccount({
+        symbol,
+        live_refresh: true,
+        update: true
+      });
+    }
+    const config = await this.buildReduceConfig({
+      symbol,
+      as_dict: true,
+      trigger: {
+        long: trigger || false,
+        short: trigger || false
+      }
     });
-    return { ...config, place_stop: false, profit_percent: 0 };
-  }
+    if (!kind) {
+      await this.updateTargetPnl({
+        symbol,
+        kind: "long"
+      });
+      await this.updateTargetPnl({
+        symbol,
+        kind: "short"
+      });
+    } else {
+      await this.updateTargetPnl({
+        symbol,
+        kind
+      });
+    }
+    if (payload.trigger) {
+      return await this.reduceMajorPositionEntry({
+        symbol,
+        long: config.long,
+        short: config.short,
+        trigger: config.trigger
+      });
+    }
+    return config;
+  }
+  async reEnterPositionOnEmpty(symbol) {
+    await this.getLiveExchangeInstance({
+      symbol,
+      refresh: true
+    });
+    const db_positions = await this.syncAccount({
+      symbol,
+      update: true
+    });
+    await this.syncOrders({
+      symbol,
+      kind: "long",
+      update: true
+    });
+    await this.syncOrders({
+      symbol,
+      kind: "short",
+      update: true
+    });
+    const long_position = db_positions.find((x) => x.kind === "long");
+    const short_position = db_positions.find((x) => x.kind === "short");
+    if (long_position && long_position.quantity === 0) {
+      await this.triggerTradeFromConfig({
+        symbol,
+        kind: "long"
+      });
+    }
+    if (short_position && short_position.quantity === 0) {
+      await this.triggerTradeFromConfig({
+        symbol,
+        kind: "short"
+      });
+    }
+    if (long_position.target_pnl > 0 || short_position.target_pnl > 0) {
+      await Promise.all([
+        this.updateTargetPnl({
+          symbol,
+          kind: "long"
+        }),
+        this.updateTargetPnl({
+          symbol,
+          kind: "short"
+        })
+      ]);
+    }
+  }
+  async generate_config_params(payload) {
+    const {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol,
+      with_trades = false
+    } = payload;
+    const app_config = await this.buildAppConfig({
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol
+    });
+    let config = generate_config_params(app_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol
+    });
+    if (with_trades) {
+      const app_config2 = await this.buildAppConfig({
+        entry: config.entry,
+        stop: config.stop,
+        risk_reward: config.risk_reward,
+        risk: config.risk,
+        symbol,
+        profit: 0,
+        update_db: false
+      });
+      const { trades } = await this.placeConfigOrders(app_config2, {
+        risk_reward: config.risk_reward,
+        entry: config.entry,
+        stop: config.stop,
+        risk_per_trade: config.risk,
+        avg_size: 0,
+        neg_pnl: 0,
+        min_size: app_config2.min_size,
+        symbol
+      }, false);
+      config.trades = trades;
+    }
+    return { ...config, place_stop: false, profit_percent: 0 };
+  }
+  async build_short_order(payload) {
+    const { symbol, kind } = payload;
+    await this.syncOrders({
+      symbol,
+      kind,
+      update: true
+    });
+    const position2 = await this.syncAccount({
+      symbol,
+      kind,
+      as_view: true
+    });
+    const position_config = await this.getPositionConfig({
+      symbol,
+      kind
+    });
+    if (position2 && position_config && position2.entry > 0) {
+      let next_order = position2.next_order;
+      let take_profit = position2.take_profit;
+      if (next_order && take_profit) {
+        let config = await this.buildConfigForSymbol({
+          symbol,
+          risk: position_config.risk,
+          risk_reward: position_config.risk_reward,
+          kind,
+          as_config: true
+        });
+        const focus = config.entries.filter((x) => {
+          if (kind == "long") {
+            return x.entry <= next_order;
+          } else {
+            return x.entry >= next_order;
+          }
+        });
+        const focus_entry = focus.at(-1);
+        if (focus_entry) {
+          let entry = focus_entry.entry;
+          let risk = Math.abs(focus_entry.neg_pnl);
+          return await this.generate_config_params({
+            entry,
+            stop: take_profit,
+            risk_reward: position_config.risk_reward,
+            risk,
+            symbol
+          });
+        }
+      }
+    }
+  }
   async extrapolateShortConfig(payload) {
-    const { symbol, risk_reward = 199, kind } = payload;
+    const { symbol, risk_reward = 199, kind, risk } = payload;
     let reverse_kind = kind === "long" ? "short" : "long";
     const position2 = await this.syncAccount({
       symbol,
@@ -36069,30 +36575,40 @@ class ExchangeAccount {
       as_view: true
     });
     if (position2) {
+      let entry = position2.next_order || position2.avg_liquidation;
+      if (kind == "short" && entry < 0) {
+        const symbol_config = await this.recomputeSymbolConfig({
+          symbol
+        });
+        entry = symbol_config?.support;
+      }
       return await this.generate_config_params({
-        entry: position2.next_order || position2.avg_liquidation,
+        entry,
         stop: position2.take_profit,
         risk_reward,
-        risk: position2.target_pnl,
+        risk: risk || position2.target_pnl,
         symbol
       });
     }
     return null;
   }
   async triggerTradeFromConfig(payload) {
+    const { symbol, kind, place = true } = payload;
     const position2 = await this.syncAccount({
-      symbol: payload.symbol,
-      kind: payload.kind
+      symbol,
+      kind
     });
     if (position2?.config) {
       const config = position2.expand.config;
+      let entry = payload.tp ? position2.entry || config.entry : config.entry;
       return await this.placeSharedOrder("place_limit_orders", {
-        symbol: payload.symbol,
-        entry: config.entry,
+        symbol,
+        entry,
         stop: config.stop,
         risk_reward: config.risk_reward,
         risk: config.risk,
-        place: true
+        place,
+        raw: payload.raw
       });
     }
   }
@@ -36132,179 +36648,709 @@ class ExchangeAccount {
       const opposite_kind = kind === "long" ? "short" : "long";
       await this.syncOrders({
         symbol,
-        kind: opposite_kind,
-        update: true
+        kind: opposite_kind,
+        update: true
+      });
+      await this.cancelOrders({
+        symbol,
+        kind: opposite_kind,
+        stop: true
+      });
+      await this.syncReduceClosePosition({
+        symbol,
+        kind: opposite_kind,
+        trigger: true
+      });
+      await this.syncOrders({
+        symbol,
+        kind,
+        update: true
+      });
+    }
+  }
+  async windDownSymbol(payload) {
+    const { symbol, risk_reward = 199 } = payload;
+    const positions = await this.syncAccount({
+      symbol,
+      update: true
+    });
+    let long_position = positions.find((x) => x.kind === "long");
+    let short_position = positions.find((x) => x.kind === "short");
+    if (long_position && long_position.quantity > 0) {
+      console.log("Start to wind down the long position");
+      let config = long_position?.expand?.config;
+      if (!config && long_position.config) {
+        config = await this.getPositionConfig({
+          symbol,
+          kind: "long"
+        });
+      }
+      if (config) {
+        await this.getPositionConfig({
+          symbol,
+          kind: "long",
+          params: {
+            entry: config.entry,
+            stop: config.stop,
+            risk_reward: config.risk_reward,
+            risk: config.risk,
+            profit_percent: 0
+          }
+        });
+        await this.updateTargetPnl({
+          symbol,
+          kind: "long"
+        });
+      } else {
+        const existing_long_config = await this.app_db.getPositionConfig({
+          symbol,
+          kind: "long",
+          account: this.instance
+        });
+        await this.app_db.update_db_position(long_position, {
+          config: existing_long_config?.id
+        });
+        await this.getPositionConfig({
+          symbol,
+          kind: "long",
+          params: {
+            entry: existing_long_config.entry,
+            stop: existing_long_config.stop,
+            risk_reward: existing_long_config.risk_reward,
+            risk: existing_long_config.risk,
+            profit_percent: 0
+          }
+        });
+        await this.updateTargetPnl({
+          symbol,
+          kind: "long"
+        });
+      }
+      await this.triggerTradeFromConfig({
+        symbol,
+        kind: "long"
+      });
+      const new_config = await this.extrapolateShortConfig({
+        symbol,
+        kind: "short",
+        risk_reward,
+        risk: config?.risk
+      });
+      let short_config = await this.getPositionConfig({
+        symbol,
+        kind: "short"
+      });
+      if (!short_config) {
+        short_config = await this.getPositionConfig({
+          symbol,
+          kind: "short",
+          params: {
+            entry: new_config.entry,
+            stop: new_config.stop,
+            risk_reward,
+            risk: new_config.risk,
+            profit_percent: 10
+          }
+        });
+      }
+      if (new_config && short_config) {
+        console.log("updating short position");
+        short_position = await this.app_db.update_db_position(short_position, {
+          reduce_ratio: 0.95,
+          config: short_config.id
+        });
+        console.log("Updating the short position config");
+        await this.getPositionConfig({
+          symbol,
+          kind: "short",
+          params: {
+            entry: new_config.entry,
+            stop: new_config.stop,
+            risk_reward,
+            risk: new_config.risk,
+            profit_percent: 10
+          }
+        });
+        console.log("placing the short trade based off config values");
+        await this.triggerTradeFromConfig({
+          symbol,
+          kind: "short"
+        });
+        await this.updateTargetPnl({
+          symbol,
+          kind: "short"
+        });
+        console.log("updating the stop loss for the short position from the long");
+        await this.verifyStopLoss({
+          symbol,
+          kind: "short"
+        });
+      }
+    }
+    if (long_position && long_position.quantity === 0 && short_position && short_position.quantity == 0) {
+      await Promise.all([
+        this.cancelOrders({
+          symbol,
+          kind: "long",
+          all: true
+        }),
+        this.cancelOrders({
+          symbol,
+          kind: "short",
+          all: true
+        })
+      ]);
+      await Promise.all([
+        this.app_db.removePosition(long_position),
+        this.app_db.removePosition(short_position)
+      ]);
+    }
+  }
+  async updateTargetPnl(payload) {
+    const { symbol, kind } = payload;
+    const position2 = await this.syncAccount({
+      symbol,
+      kind
+    });
+    if (position2?.expand?.config) {
+      const config = position2.expand.config;
+      let _profit = config.profit;
+      let _profit_percent = config?.profit_percent;
+      if (_profit_percent && (position2?.quantity || 0) > 0) {
+        _profit = to_f(position2.quantity * _profit_percent * position2.entry / 100);
+      }
+      await this.app_db.update_db_position(position2, {
+        target_pnl: _profit
+      });
+      return _profit;
+    }
+    return 0;
+  }
+  async recomputeSymbolConfig(payload) {
+    const { symbol, refresh = false } = payload;
+    const _config = await this.app_db.getSymbolConfigFromDB(symbol);
+    if (_config && !refresh) {
+      return _config;
+    }
+    const config = await this.exchange.generateConfig({
+      symbol,
+      limit: _config?.candle_count || 5,
+      interval: _config?.interval || "1w"
+    });
+    await this.app_db.updateSymbolConfigs({
+      configs: [
+        {
+          symbol,
+          support: config.support,
+          resistance: config.resistance,
+          leverage: config.leverage,
+          min_size: config.min_size,
+          price_places: config.price_places,
+          decimal_places: config.decimal_places
+        }
+      ]
+    });
+    return this.app_db.getSymbolConfigFromDB(symbol);
+  }
+  async buildConfigForSymbol(payload) {
+    const {
+      symbol,
+      risk,
+      risk_reward = 199,
+      as_config = false,
+      kind = "long"
+    } = payload;
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol
+    });
+    const long_config = await this.generate_config_params({
+      entry: kind === "long" ? symbol_config.resistance : symbol_config.support,
+      stop: kind === "long" ? symbol_config.support : symbol_config.resistance,
+      risk_reward,
+      risk,
+      symbol
+    });
+    if (as_config) {
+      const app_config = buildAppConfig(symbol_config, {
+        entry: long_config.entry,
+        stop: long_config.stop,
+        risk_reward,
+        risk: long_config.risk,
+        symbol
+      });
+      return app_config;
+    }
+    return long_config;
+  }
+  async triggerBullishMarket(payload) {
+    let { symbol, profit_percent = 10, risk_reward = 199 } = payload;
+    const bullish_instance = await this.app_db.getBullishMarket(symbol);
+    if (!bullish_instance) {
+      return false;
+    }
+    const db_instance = await this.app_db.get_exchange_db_instance(this.instance);
+    if (db_instance.profit_percent) {
+      profit_percent = db_instance.profit_percent;
+    }
+    const position2 = await this.syncAccount({
+      symbol,
+      update: true,
+      kind: "long"
+    });
+    const long_config = await this.buildConfigForSymbol({
+      symbol,
+      risk: bullish_instance.risk,
+      risk_reward
+    });
+    let changed = false;
+    if (!position2?.config) {
+      await this.buildAppConfig({
+        entry: long_config.entry,
+        stop: long_config.stop,
+        risk_reward: long_config.risk_reward,
+        risk: long_config.risk,
+        symbol,
+        profit_percent,
+        update_db: true
+      });
+      changed = true;
+    } else {
+      if (position2.expand.config.entry !== long_config.entry || position2.expand.config.stop !== long_config.stop || position2.expand.config.risk !== long_config.risk) {
+        changed = true;
+      }
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          entry: long_config.entry,
+          stop: long_config.stop,
+          risk: long_config.risk,
+          risk_reward: position2?.expand?.config?.risk_reward || long_config.risk_reward
+        }
+      });
+    }
+    const short_position = await this.syncAccount({
+      symbol,
+      kind: "short",
+      update: true
+    });
+    const orders = await this.getOrders({
+      symbol,
+      kind: "short",
+      type: "limit",
+      refresh: true
+    });
+    if (orders.length > 0) {
+      await this.toggleStopBuying({
+        should_stop: true,
+        kind: "short",
+        symbol
+      });
+      await this.cancelOrders({
+        symbol,
+        kind: "short",
+        all: true
+      });
+    }
+    if (short_position?.config) {
+      await this.app_db.update_db_position(short_position, {
+        config: null,
+        reduce_ratio: 0.9
+      });
+    }
+    if (changed) {
+      const rr = await this.triggerTradeFromConfig({
+        symbol,
+        kind: "long",
+        tp: true
+      });
+      await this.placeProfitAndStop({
+        symbol,
+        trigger: true
+      });
+      return rr;
+    }
+    return false;
+  }
+  async updateAllActiveSymbols(payload) {
+    const { interval = 5 } = payload;
+    const symbols = await this.app_db.getAllSymbolsFromPositions({
+      no_position: true,
+      kind: "long"
+    });
+    const all_open_symbols = await this.exchange.getAllOpenSymbols();
+    await new Promise((resolve) => setTimeout(resolve, interval * 1000));
+    for (const symbol of Array.from(new Set(symbols.concat(all_open_symbols)))) {
+      await this.getLiveExchangeInstance({ symbol, refresh: true });
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  }
+  async updateAllPositionsWithNoConfig(payload) {
+    const { kind } = payload;
+    const symbols = await this.app_db.getAllSymbolsFromPositions({
+      custom_filter: `config = null && kind = "${kind}"`
+    });
+    for (const symbol of symbols) {
+      await this.syncAccount({
+        symbol,
+        update: true,
+        kind,
+        live_refresh: true
+      });
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  }
+  async getSymbolsForPositions() {
+    const positions = await this.app_db.getPositions({
+      custom_filter: `account.owner:lower = "${this.instance.owner.toLowerCase()}" && account.exchange:lower = "${this.instance.exchange.toLowerCase()}" && quantity > 0`,
+      symbol: "",
+      account: {
+        owner: "",
+        exchange: ""
+      }
+    });
+    return Array.from(new Set(positions.map((p) => p.symbol)));
+  }
+  async getNonEssentialSymbols() {
+    const [all_open_symbols, essential_symbols] = await Promise.all([
+      this.exchange.getAllOpenSymbols(),
+      this.app_db.getAllSymbolConfigs({
+        custom_filter: `essential = true`
+      })
+    ]);
+    const essential_symbols_set = new Set(essential_symbols.map((s2) => s2.symbol));
+    const open_symbols_set = new Set(all_open_symbols);
+    const non_essential_symbols = Array.from(essential_symbols_set).filter((s2) => !open_symbols_set.has(s2));
+    const bullish_markets = await this.app_db.getBullishMarkets();
+    const bullish_symbols = Array.from(new Set(bullish_markets.updated_bullish.map((m) => m.symbol)));
+    const symbols = Array.from(new Set(essential_symbols.map((s2) => s2.symbol))).concat(bullish_symbols);
+    const not_symbols_filter = symbols.map((s2) => `symbol:lower != "${s2.toLowerCase()}"`).join(" && ");
+    const positions = await this.app_db.getPositions({
+      custom_filter: `${not_symbols_filter} && account.owner:lower = "${this.instance.owner.toLowerCase()}" && account.exchange:lower = "${this.instance.exchange.toLowerCase()}"`,
+      symbol: "",
+      account: {
+        owner: "",
+        exchange: ""
+      }
+    });
+    return Array.from(new Set(positions.map((p) => p.symbol).concat(non_essential_symbols)));
+  }
+  async _terminatePositions(payload) {
+    const { symbol } = payload;
+    let db_positions = await this.syncAccount({
+      symbol,
+      update: true,
+      live_refresh: true
+    });
+    const symbol_config = await this.app_db.getSymbolConfigFromDB(symbol);
+    let long_position = db_positions.find((x) => x.kind === "long");
+    let short_position = db_positions.find((x) => x.kind === "short");
+    if (long_position && long_position.quantity > 0 && symbol_config) {
+      await this.toggleStopBuying({
+        symbol,
+        kind: "long",
+        should_stop: true
+      });
+      await this.exchange.closePosition({
+        symbol,
+        kind: "long",
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places
+      });
+      await this.cancelOrders({
+        symbol,
+        kind: "long",
+        all: true
+      });
+    }
+    if (short_position && short_position.quantity > 0 && symbol_config) {
+      await this.toggleStopBuying({
+        symbol,
+        kind: "short",
+        should_stop: true
+      });
+      await this.exchange.closePosition({
+        symbol,
+        kind: "short",
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places
+      });
+      await this.cancelOrders({
+        symbol,
+        kind: "short",
+        all: true
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+    db_positions = await this.syncAccount({
+      symbol,
+      update: true,
+      live_refresh: true
+    });
+    long_position = db_positions.find((x) => x.kind === "long");
+    short_position = db_positions.find((x) => x.kind === "short");
+    if (long_position && long_position.quantity === 0) {
+      await this.app_db.removePosition(long_position);
+    }
+    if (short_position && short_position.quantity === 0) {
+      await this.app_db.removePosition(short_position);
+    }
+  }
+  async getOrders(payload) {
+    const { symbol, kind, type, refresh = false } = payload;
+    if (refresh) {
+      await this.syncOrders({
+        symbol,
+        kind
+      });
+    }
+    let side;
+    if (kind == "long") {
+      if (type === "limit") {
+        side = "buy";
+      } else {
+        side = "sell";
+      }
+    } else {
+      if (type === "limit") {
+        side = "sell";
+      } else {
+        side = "buy";
+      }
+    }
+    const orders = await this.app_db.getOrders(this.instance, {
+      symbol,
+      kind
+    });
+    return orders.filter((x) => {
+      if (type === "stop") {
+        return x.side === side && x.stop > 0;
+      }
+      if (type === "tp") {
+        return x.side === side && x.stop === 0;
+      }
+      return x.side === side;
+    });
+  }
+  async syncPositionConfigs(payload) {
+    const { symbol, kind, refresh = false } = payload;
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol,
+      refresh
+    });
+    const long_config = await this.getPositionConfig({
+      symbol,
+      kind: "long"
+    });
+    const short_config = await this.getPositionConfig({
+      symbol,
+      kind: "short"
+    });
+    if (long_config && kind === "long") {
+      await this.app_db.updateScheduledTrade(long_config.id, {
+        entry: symbol_config.resistance,
+        stop: symbol_config.support
+      });
+    }
+    if (short_config && kind === "short") {
+      await this.app_db.updateScheduledTrade(short_config.id, {
+        entry: symbol_config.support,
+        stop: symbol_config.resistance
+      });
+    }
+  }
+  async terminatePositions(payload) {
+    const { symbol } = payload;
+    let db_positions = await this.syncAccount({
+      symbol,
+      update: true,
+      live_refresh: true
+    });
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol
+    });
+    let long_position = db_positions.find((x) => x.kind === "long");
+    let short_position = db_positions.find((x) => x.kind === "short");
+    if (long_position && long_position.quantity > 0 && symbol_config) {
+      await this.toggleStopBuying({
+        symbol,
+        kind: "long",
+        should_stop: true
+      });
+      await this.cancelOrders({
+        symbol,
+        kind: "long",
+        all: true
+      });
+      await this.app_db.update_db_position(long_position, {
+        config: null,
+        reduce_ratio: 0.9
+      });
+    }
+    const long_config = await this.getPositionConfig({
+      symbol,
+      kind: "long"
+    });
+    let the_same_config = false;
+    if (long_config && long_position && long_position.quantity > 0) {
+      const existing_short_config = await this.getPositionConfig({
+        symbol,
+        kind: "short"
+      });
+      const diff = (long_position.entry - long_config.stop) * long_position.quantity;
+      if (existing_short_config) {
+        the_same_config = long_config.entry === existing_short_config.stop && long_config.stop === existing_short_config.entry;
+      }
+      const short_config = await this.getPositionConfig({
+        symbol,
+        kind: "short",
+        params: {
+          entry: long_config.stop,
+          stop: long_config.entry,
+          risk_reward: long_config.risk_reward,
+          profit_percent: 0,
+          risk: long_config.risk,
+          profit: Math.abs(diff),
+          place_tp: false
+        }
+      });
+      if (short_config) {
+        await this.app_db.update_db_position(short_position, {
+          config: short_config.id,
+          reduce_ratio: 0.9
+        });
+        if (!the_same_config) {
+          await this.placeTrade({
+            symbol,
+            kind: "short",
+            place: true
+          });
+        }
+      }
+      await this.placeProfitAndStop({
+        symbol,
+        kind: "short"
       });
+    }
+    if (long_position && short_position && long_position.quantity === 0 && short_position.quantity === 0) {
       await this.cancelOrders({
         symbol,
-        kind: opposite_kind,
-        stop: true
-      });
-      await this.syncReduceClosePosition(symbol, {
-        kind: opposite_kind
+        kind: "long",
+        all: true
       });
-      await this.syncOrders({
+      await this.cancelOrders({
         symbol,
-        kind,
-        update: true
+        kind: "short",
+        all: true
       });
+      await this.app_db.removePosition(long_position);
+      await this.app_db.removePosition(short_position);
+      await this.app_db.unwindSymbolFromDB(symbol);
     }
   }
-  async windDownSymbol(symbol, risk_reward = 199) {
-    const positions = await this.syncAccount({
+  async fetchAndUpdateTopMovers() {
+    const db_instance = await this.app_db.get_exchange_db_instance(this.instance);
+    const {
+      bullish,
+      bearish: _bearish,
+      movePercent,
+      totalRisk,
+      max_non_essential = 0,
+      exclude_coins
+    } = db_instance;
+    let dont_trade = exclude_coins?.bullish || [];
+    let bullishMarkets = [];
+    if (bullish) {
+      const { movers } = await this.exchange.checkDelistedMovers({
+        movePercent
+      });
+      bullishMarkets = movers;
+    }
+    const non_essential_symbols = await this.getNonEssentialSymbols();
+    let symbols_to_remove = non_essential_symbols.filter((k) => !bullishMarkets.map((m) => m.symbol).includes(k)).slice(0, max_non_essential).concat(dont_trade);
+    bullishMarkets = bullishMarkets.filter((m) => !symbols_to_remove.includes(m.symbol));
+    if (symbols_to_remove.length > 0) {
+      for (const symbol of symbols_to_remove) {
+        await this.terminatePositions({ symbol });
+      }
+    }
+    const result = await this.app_db.getBullishMarkets({
+      new_markets: bullishMarkets.map((m) => ({
+        symbol: m.symbol,
+        percent: m.priceChangePercent
+      })),
+      totalRisk,
+      max_count: max_non_essential
+    });
+    if (result.updated_bullish.length > max_non_essential) {
+      return {
+        updated_bullish: [],
+        moved_to_winding: []
+      };
+    }
+    return result;
+  }
+  async computeTargetPnl(payload) {
+    const { symbol, kind } = payload;
+    const reverse_kind = kind === "long" ? "short" : "long";
+    const root_position = await this.syncAccount({
       symbol,
-      update: true
+      kind
     });
-    let long_position = positions.find((x) => x.kind === "long");
-    let short_position = positions.find((x) => x.kind === "short");
-    if (long_position && long_position.quantity > 0) {
-      console.log("Start to wind down the long position");
-      let config = long_position?.expand?.config;
-      if (!config && long_position.config) {
-        config = await this.getPositionConfig({
-          symbol,
-          kind: "long"
-        });
-      }
-      if (config) {
-        console.log("cancelling any existing open orders for the long position");
-        await this.cancelOrders({
-          symbol,
-          kind: "long",
-          price: long_position.entry
-        });
-        console.log("updating the long position target_pnl");
-        console.log("toggling the stop buying for the long position");
-        await this.toggleStopBuying({
-          symbol,
-          kind: "long",
-          should_stop: true
-        });
-      }
-      const new_config = await this.extrapolateShortConfig({
-        symbol,
-        kind: "short",
-        risk_reward
-      });
-      const short_config = await this.getPositionConfig({
-        symbol,
-        kind: "short"
-      });
-      if (new_config && short_config && (short_config.entry !== new_config.entry || short_config.stop !== new_config.stop || short_config.risk !== new_config.risk)) {
-        console.log("updating short position");
-        short_position = await this.app_db.update_db_position(short_position, {
-          reduce_ratio: 0.95,
-          config: short_config.id
+    const reverse_position = await this.syncAccount({
+      symbol,
+      kind: reverse_kind
+    });
+    if (reverse_position?.expand?.config && root_position.quantity > 0) {
+      const reverse_config = reverse_position.expand.config;
+      const diff = Math.abs(reverse_config.stop - root_position.entry);
+      const result = to_f(diff * root_position.quantity);
+      if (root_position.target_pnl !== result) {
+        await this.app_db.update_db_position(root_position, {
+          target_pnl: result
         });
-        console.log("Updating the short position config");
         await this.getPositionConfig({
+          kind: reverse_kind,
           symbol,
-          kind: "short",
           params: {
-            entry: new_config.entry,
-            stop: new_config.stop,
-            risk_reward,
-            risk: new_config.risk,
-            profit_percent: 1
+            ...reverse_config,
+            risk: result
           }
         });
-        console.log("placing the short trade based off config values");
-        await this.triggerTradeFromConfig({
-          symbol,
-          kind: "short"
-        });
-        console.log("updating the stop loss for the short position from the long");
-        await this.verifyStopLoss({
-          symbol,
-          kind: "short"
-        });
       }
+      return result;
     }
-    if (long_position && long_position.quantity === 0 && short_position && short_position.quantity == 0) {
-      this.app_db.removePosition(long_position);
-      this.app_db.removePosition(short_position);
-    }
+    return 0;
   }
-  async triggerBullishMarket(payload) {
-    const { symbol, profit_percent = 10 } = payload;
-    const bullish_instance = await this.app_db.getBullishMarket(symbol);
-    if (!bullish_instance) {
-      return false;
+  async placeTrade(payload) {
+    const { symbol, kind, place, tp } = payload;
+    if (place) {
+      return await this.triggerTradeFromConfig({
+        symbol,
+        kind
+      });
     }
-    const config = await this.exchange.generateConfig({
-      symbol
-    });
-    await this.app_db.updateSymbolConfigs({
-      configs: [
-        {
-          symbol,
-          support: config.support,
-          resistance: config.resistance,
-          leverage: config.leverage,
-          min_size: config.min_size,
-          price_places: config.price_places,
-          decimal_places: config.decimal_places
-        }
-      ]
-    });
-    const position2 = await this.syncAccount({
+    await this.syncAccount({
       symbol,
-      update: true,
-      kind: "long"
+      live_refresh: true,
+      update: true
     });
-    const symbol_config = await this.app_db.getSymbolConfigFromDB(symbol);
-    const long_config = await this.generate_config_params({
-      entry: symbol_config.resistance,
-      stop: symbol_config.support,
-      risk_reward: 199,
-      risk: bullish_instance.risk,
-      symbol
+    const result = await this.syncOrders({
+      symbol,
+      kind,
+      update: true
     });
-    let changed = false;
-    if (!position2?.config) {
-      await this.buildAppConfig({
-        entry: long_config.entry,
-        stop: long_config.stop,
-        risk_reward: long_config.risk_reward,
-        risk: long_config.risk,
-        symbol,
-        profit_percent,
-        update_db: true
-      });
-      changed = true;
-    } else {
-      if (position2.expand.config.entry !== long_config.entry || position2.expand.config.stop !== long_config.stop || position2.expand.config.risk !== long_config.risk) {
-        changed = true;
-      }
-      await this.getPositionConfig({
-        symbol,
-        kind: "long",
-        params: {
-          entry: long_config.entry,
-          stop: long_config.stop,
-          risk: long_config.risk,
-          risk_reward: position2?.expand?.config?.risk_reward || long_config.risk_reward
-        }
-      });
-    }
-    const short_position = await this.syncAccount({
+    await this.updateTargetPnl({
       symbol,
-      kind: "short"
+      kind
     });
-    if (short_position?.config) {
-      await this.toggleStopBuying({
-        should_stop: true,
-        kind: "short",
-        symbol
-      });
-    }
-    if (changed) {
-      return this.triggerTradeFromConfig({
+    if (tp) {
+      await this.placeProfitAndStop({
         symbol,
-        kind: "long"
+        trigger: true
       });
     }
-    return false;
+    return result;
   }
 }
 function getExchangeKlass(exchange) {
@@ -36316,10 +37362,17 @@ function getExchangeKlass(exchange) {
       type: "future",
       proxyAgent: payload.proxyAgent
     });
+    let main_client = null;
+    if (exchange === "binance") {
+      main_client = await initClient(credentials, {
+        type: "spot",
+        proxyAgent: payload.proxyAgent
+      });
+    }
     if (!client) {
       throw new Error(`Failed to initialize ${exchange} client`);
     }
-    return new func(client);
+    return new func(client, main_client);
   };
 }
 async function getExchangeAccount(payload) {
@@ -36495,7 +37548,9 @@ class App {
       as_view: true,
       symbol
     });
-    const active_account = await exchange_account.getActiveAccount(symbol);
+    const active_account = await exchange_account.getActiveAccount({
+      symbol
+    });
     const long_position = active_account.position.long;
     const short_position = active_account.position.short;
     const long_db_position = positions.find((p) => p.kind === "long");
@@ -36517,65 +37572,6 @@ class App {
       balance: active_account.usd_balance
     };
   }
-  async verifyStopLoss(payload) {
-    const { account, symbol, kind, revert } = payload;
-    const exchange_account = await this.getExchangeAccount(payload.account);
-    await exchange_account.syncOrders({
-      symbol,
-      kind,
-      update: true
-    });
-    let original = null;
-    if (revert) {
-      original = await exchange_account.getOriginalPlannedStop({
-        ...account,
-        symbol,
-        kind
-      });
-    }
-    const position2 = await exchange_account.syncAccount({
-      symbol,
-      kind,
-      as_view: true
-    });
-    if (original && position2?.stop_loss && original.quantity != position2.stop_loss.quantity) {
-      const opposite_kind = kind === "long" ? "short" : "long";
-      await exchange_account.cancelOrders({
-        symbol,
-        kind: opposite_kind,
-        stop: true
-      });
-      return await exchange_account.syncOrders({
-        symbol,
-        kind,
-        update: true
-      });
-    }
-    if (true) {
-      const opposite_kind = kind === "long" ? "short" : "long";
-      await exchange_account.syncOrders({
-        symbol,
-        kind: opposite_kind,
-        update: true
-      });
-      await exchange_account.cancelOrders({
-        symbol,
-        kind: opposite_kind,
-        stop: true
-      });
-      await exchange_account.syncReduceClosePosition(symbol, {
-        kind: opposite_kind
-      });
-      await exchange_account.syncOrders({
-        symbol,
-        kind,
-        update: true
-      });
-    }
-  }
-  async updateTopMovers(payload) {
-    return await this.app_db.getBullishMarkets(payload);
-  }
   async getWindingDownMarkets() {
     return await this.app_db.getWindingDownMarkets();
   }
@@ -36585,15 +37581,13 @@ class App {
   async updateAllAccountWithSymbols(with_positions) {
     const [accounts, symbol_configs] = await Promise.all([
       this.app_db.getAccounts(),
-      this.app_db.getAllSymbolConfigs(with_positions)
+      this.app_db.getAllSymbolConfigs({ with_positions })
     ]);
     for (const account of accounts) {
       for (const symbol_config of symbol_configs) {
         const exchange_account = await this.getExchangeAccount(account);
         await exchange_account.getLiveExchangeInstance({
           symbol: symbol_config.symbol,
-          price_places: symbol_config.price_places,
-          decimal_places: symbol_config.decimal_places,
           refresh: true
         });
         await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -36601,13 +37595,14 @@ class App {
       await new Promise((resolve) => setTimeout(resolve, 5000));
     }
   }
-  async windDownSymbol(symbol) {
+  async windDownSymbol(payload) {
+    const { symbol, risk: _risk } = payload;
     let winding_instance = await this.app_db.getWindingDownMarkets(symbol);
     if (winding_instance && winding_instance.length > 0) {
       winding_instance = winding_instance[0];
     }
     if (!winding_instance || winding_instance.length === 0) {
-      return true;
+      winding_instance = null;
     }
     const positions = await this.app_db.hasExistingPosition(symbol);
     if (positions.length === 0) {
@@ -36626,6 +37621,17 @@ class App {
     if (position_pairs.length > 0) {
       console.log("removing position pairs");
       for (const pair of position_pairs) {
+        const exchange_account = await this.getExchangeAccount(pair.expand.account);
+        await exchange_account.cancelOrders({
+          symbol: pair.symbol,
+          kind: "long",
+          all: true
+        });
+        await exchange_account.cancelOrders({
+          symbol: pair.symbol,
+          kind: "short",
+          all: true
+        });
         await this.app_db.removePosition(pair);
       }
     }
@@ -36633,23 +37639,118 @@ class App {
       console.log("winding down not paired positions");
       for (const pair of not_paired_positions) {
         const exchange_account = await this.getExchangeAccount(pair.expand.account);
-        await exchange_account.windDownSymbol(pair.symbol, winding_instance?.risk_reward || 199);
+        const result = await exchange_account.terminatePositions({
+          symbol: pair.symbol
+        });
+        console.log("result", result);
       }
     }
   }
-  async fetchAndUpdateTopMovers(payload) {
-    const exchange_account = await this.getExchangeAccount(payload.account);
-    const { movers } = await exchange_account.exchange.checkDelistedMovers({
-      movePercent: payload.movePercent
+  async getNonEssentialSymbols() {
+    const essential_symbols = await this.app_db.getAllSymbolConfigs({
+      custom_filter: `essential = true`
     });
-    const result = await this.updateTopMovers({
-      new_markets: movers.map((m) => ({
-        symbol: m.symbol,
-        percent: m.priceChangePercent
-      })),
-      totalRisk: payload.totalRisk
+    const bullish_markets = await this.app_db.getBullishMarkets();
+    const bullish_symbols = Array.from(new Set(bullish_markets.updated_bullish.map((m) => m.symbol)));
+    const symbols = Array.from(new Set(essential_symbols.map((s2) => s2.symbol))).concat(bullish_symbols);
+    const not_symbols_filter = symbols.map((s2) => `symbol:lower != "${s2.toLowerCase()}"`).join(" && ");
+    const positions = await this.app_db.getPositions({
+      custom_filter: not_symbols_filter,
+      symbol: "",
+      account: {
+        owner: "",
+        exchange: ""
+      }
     });
-    return result;
+    return new Set(positions.map((p) => p.symbol));
+  }
+  async refreshAllPositionsWithSymbol(payload) {
+    const { symbol } = payload;
+    const positions = await this.app_db.getPositions({
+      custom_filter: `symbol:lower="${symbol.toLowerCase()}"`,
+      symbol: "",
+      account: {
+        owner: "",
+        exchange: ""
+      }
+    });
+    const exchanges = positions.map((p) => p.expand.account);
+    const all_exchanges = {};
+    for (const exchange of exchanges) {
+      let id = `${exchange.owner}-${exchange.exchange}`;
+      if (all_exchanges[id]) {
+        continue;
+      }
+      all_exchanges[id] = exchange;
+    }
+    const unique_exchanges = Object.values(all_exchanges);
+    for (const exchange of unique_exchanges) {
+      const exchange_account = await this.getExchangeAccount({
+        owner: exchange.owner,
+        exchange: exchange.exchange
+      });
+      await exchange_account.syncAccount({
+        symbol,
+        update: true,
+        live_refresh: true
+      });
+      await exchange_account.placeProfitAndStop({
+        symbol,
+        trigger: false
+      });
+    }
+  }
+  async getMoverExchangeInstances() {
+    return await this.app_db.getMoverExchangeInstances();
+  }
+  async updateTpOnAllMarkets() {
+    const move_instances = await this.getMoverExchangeInstances();
+    for (const instance of move_instances) {
+      const params = {
+        account: {
+          owner: instance.owner,
+          exchange: instance.exchange
+        }
+      };
+      const exchange_account = await this.getExchangeAccount(params.account);
+      const symbols = await exchange_account.getSymbolsForPositions();
+      for (const symbol of symbols) {
+        await exchange_account.placeTrade({
+          symbol,
+          kind: "long",
+          tp: true
+        });
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+  }
+  async triggerMoverTask(payload) {
+    const { callback, removeCallback } = payload;
+    const move_instances = await this.getMoverExchangeInstances();
+    for (const instance of move_instances) {
+      const params = {
+        account: {
+          owner: instance.owner,
+          exchange: instance.exchange
+        }
+      };
+      const exchange_account = await this.getExchangeAccount(params.account);
+      const result = await exchange_account.fetchAndUpdateTopMovers();
+      const { updated_bullish } = result;
+      for (const m of updated_bullish) {
+        await callback({
+          symbol: m.symbol,
+          account: params.account
+        });
+      }
+      const winding_down_symbols = await this.app_db.getWindingDownMarkets();
+      for (const w of winding_down_symbols) {
+        await removeCallback({
+          symbol: w.symbol,
+          account: params.account
+        });
+      }
+    }
   }
 }
 async function initApp(payload) {
@@ -36675,6 +37776,10 @@ async function getCredentials(account, exchange) {
       apiKey = process.env.GBOZEE1_SUB_ACCOUNT_API_KEY;
       apiSecret = process.env.GBOZEE1_SUB_ACCOUNT_API_SECRET;
       break;
+    case "tomi_account":
+      apiKey = process.env.TOMI_ACCOUNT_API_KEY;
+      apiSecret = process.env.TOMI_ACCOUNT_API_SECRET;
+      break;
     case "main_account":
     default:
       apiKey = process.env.MAIN_ACCOUNT_API_KEY;