@gbozee/ultimate 0.0.2-18 → 0.0.2-20

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 || {
@@ -32388,28 +32413,54 @@ class AppDatabase {
   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;
+      }
+      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
+        });
+        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.risk,
+          kind,
+          entry: payload.entry,
+          stop: payload.stop,
+          risk_reward: payload.risk_reward,
+          risk: payload.risk,
+          profit_percent: payload.profit_percent,
+          place_tp: true
+        });
+      }
       await this.pb.collection("positions").update(db_position.id, {
         config: config?.id
       });
+      return config;
     }
   }
   async getPositionConfig(payload) {
@@ -32458,7 +32509,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 = [];
@@ -33192,6 +33243,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 +33393,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 +33876,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 +33996,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 +34045,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 +34060,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",
@@ -34126,6 +34191,43 @@ function calculateSupportResistance(klines) {
   const resistance = Math.max(...highs);
   return { support, resistance };
 }
+async function getTopMovers(payload) {
+  const { client, percentThreshold = 20 } = payload;
+  const data = await client.get24hrChangeStatistics();
+  const movers = data.filter((s2) => parseFloat(s2.priceChangePercent) >= percentThreshold).map((s2) => ({
+    symbol: s2.symbol,
+    priceChangePercent: parseFloat(s2.priceChangePercent),
+    lastPrice: parseFloat(s2.lastPrice),
+    highPrice: parseFloat(s2.highPrice),
+    lowPrice: parseFloat(s2.lowPrice),
+    volume: parseFloat(s2.volume)
+  })).sort((a, b) => Math.abs(b.priceChangePercent) - Math.abs(a.priceChangePercent));
+  return movers;
+}
+async function isSymbolActive(payload) {
+  const { client, symbol } = payload;
+  try {
+    const depth_data = await client.getOrderBook({
+      symbol,
+      limit: 5
+    });
+    if (depth_data.asks.length === 0 && depth_data.bids.length === 0) {
+      return false;
+    }
+    return true;
+  } catch (err) {
+    if (err.response && err.response.data && err.response.data.code === -1121) {
+      return false;
+    }
+    console.error(`Error checking ${symbol}:`, err.message);
+    return false;
+  }
+}
+async function getActiveSymbols(payload) {
+  const { client } = payload;
+  const response = await client.getExchangeInfo();
+  return response.symbols;
+}
 
 class BinanceExchange {
   client;
@@ -34205,10 +34307,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) {
@@ -34274,8 +34385,8 @@ class BinanceExchange {
     return maxLeverage;
   }
   async generateConfig(payload) {
-    const response = await this.client.getExchangeInfo();
-    const symbols = response.symbols;
+    const symbols = await getActiveSymbols({ client: this.client });
+    console.log("symbols", symbols);
     const { symbol, limit = 5 } = payload;
     const klines = await getWeeklyKlines({
       client: this.client,
@@ -34306,6 +34417,40 @@ class BinanceExchange {
     };
     return configObj;
   }
+  async checkDelistedMovers(payload) {
+    const movers = await getTopMovers({
+      client: this.client,
+      percentThreshold: payload.movePercent
+    });
+    const _activeSymbols = await getActiveSymbols({ client: this.client });
+    const activeSymbols = _activeSymbols.map((s2) => s2.symbol);
+    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({
+        client: this.client,
+        symbol: m.symbol
+      });
+      if (isActive) {
+        activeMovers.push(m);
+      }
+    }
+    console.log(`Top movers:`, movers);
+    console.log(`Delisted movers:`, delisted);
+    return { movers: activeMovers, 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
+    });
+  }
 }
 function getPricePlaces(target) {
   const numStr = target.toString();
@@ -34621,7 +34766,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";
@@ -34631,7 +34777,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;
@@ -34666,7 +34812,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"),
@@ -34684,8 +34831,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",
@@ -34698,12 +34845,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: [],
@@ -34872,10 +35025,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) {
@@ -34928,6 +35090,10 @@ class BybitExchange {
   }
   async generateConfig(payload) {
   }
+  async checkDelistedMovers(payload) {
+  }
+  async closePosition(payload) {
+  }
 }
 
 // src/helpers/accounts.ts
@@ -35083,12 +35249,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"
     }
   };
@@ -35157,7 +35323,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) {
@@ -35180,11 +35348,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
           });
         }
       };
@@ -35194,7 +35364,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);
           });
@@ -35202,12 +35374,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
           });
         }
       };
@@ -35586,17 +35760,26 @@ class ExchangeAccount {
     this.app_db = options.app_db;
   }
   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,
@@ -35606,11 +35789,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,
@@ -35622,9 +35809,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
       });
@@ -35634,7 +35822,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 });
     }
@@ -35661,7 +35852,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;
@@ -35789,7 +35982,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 = [
@@ -35890,7 +36084,7 @@ class ExchangeAccount {
         kind: payload.kind
       });
       if (db_position) {
-        await this.app_db.createOrUpdatePositionConfig(db_position, payload.params);
+        return await this.app_db.createOrUpdatePositionConfig(db_position, payload.params);
       }
     }
     return await this.app_db.getPositionConfig({
@@ -35905,7 +36099,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
     });
@@ -35914,72 +36108,168 @@ 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 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
+      }
+    });
+    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 } = payload;
     const app_config = await this.buildAppConfig({
@@ -35989,6 +36279,13 @@ class ExchangeAccount {
       risk,
       symbol
     });
+    console.log({
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol
+    });
     let config = generate_config_params(app_config, {
       entry,
       stop,
@@ -35999,7 +36296,7 @@ class ExchangeAccount {
     return { ...config, place_stop: false, profit_percent: 0 };
   }
   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,
@@ -36007,30 +36304,38 @@ 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;
       return await this.placeSharedOrder("place_limit_orders", {
-        symbol: payload.symbol,
+        symbol,
         entry: config.entry,
         stop: config.stop,
         risk_reward: config.risk_reward,
         risk: config.risk,
-        place: true
+        place
       });
     }
   }
@@ -36078,8 +36383,10 @@ class ExchangeAccount {
         kind: opposite_kind,
         stop: true
       });
-      await this.syncReduceClosePosition(symbol, {
-        kind: opposite_kind
+      await this.syncReduceClosePosition({
+        symbol,
+        kind: opposite_kind,
+        trigger: true
       });
       await this.syncOrders({
         symbol,
@@ -36088,7 +36395,8 @@ class ExchangeAccount {
       });
     }
   }
-  async windDownSymbol(symbol, risk_reward = 199) {
+  async windDownSymbol(payload) {
+    const { symbol, risk_reward = 199 } = payload;
     const positions = await this.syncAccount({
       symbol,
       update: true
@@ -36105,30 +36413,74 @@ class ExchangeAccount {
         });
       }
       if (config) {
-        console.log("cancelling any existing open orders for the long position");
-        await this.cancelOrders({
+        await this.getPositionConfig({
           symbol,
           kind: "long",
-          price: long_position.entry
+          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
         });
-        console.log("updating the long position target_pnl");
-        console.log("toggling the stop buying for the long position");
-        await this.toggleStopBuying({
+        await this.app_db.update_db_position(long_position, {
+          config: existing_long_config?.id
+        });
+        await this.getPositionConfig({
           symbol,
           kind: "long",
-          should_stop: true
+          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_reward,
+        risk: config?.risk
       });
-      const short_config = await this.getPositionConfig({
+      let 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)) {
+      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,
@@ -36143,7 +36495,7 @@ class ExchangeAccount {
             stop: new_config.stop,
             risk_reward,
             risk: new_config.risk,
-            profit_percent: 1
+            profit_percent: 10
           }
         });
         console.log("placing the short trade based off config values");
@@ -36151,6 +36503,10 @@ class ExchangeAccount {
           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,
@@ -36159,18 +36515,53 @@ class ExchangeAccount {
       }
     }
     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);
+      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 triggerBullishMarket(payload) {
-    const { symbol, profit_percent = 10 } = payload;
-    const bullish_instance = await this.app_db.getBullishMarket(symbol);
-    if (!bullish_instance) {
-      return false;
+  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
+      symbol,
+      limit: _config?.candle_count || 5
     });
     await this.app_db.updateSymbolConfigs({
       configs: [
@@ -36185,16 +36576,27 @@ class ExchangeAccount {
         }
       ]
     });
+    return this.app_db.getSymbolConfigFromDB(symbol);
+  }
+  async triggerBullishMarket(payload) {
+    const { symbol, profit_percent = 10, risk_reward = 199 } = payload;
+    const bullish_instance = await this.app_db.getBullishMarket(symbol);
+    if (!bullish_instance) {
+      return false;
+    }
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol,
+      refresh: true
+    });
     const position2 = await this.syncAccount({
       symbol,
       update: true,
       kind: "long"
     });
-    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_reward,
       risk: bullish_instance.risk,
       symbol
     });
@@ -36237,13 +36639,174 @@ class ExchangeAccount {
       });
     }
     if (changed) {
-      return this.triggerTradeFromConfig({
+      const rr = await this.triggerTradeFromConfig({
         symbol,
         kind: "long"
       });
+      return rr;
     }
     return false;
   }
+  async updateAllActiveSymbols() {
+    const symbols = await this.app_db.getAllSymbolsFromPositions({
+      no_position: true,
+      kind: "long"
+    });
+    for (const symbol of 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 getNonEssentialSymbols() {
+    const essential_symbols = await this.app_db.getAllSymbolConfigs({
+      custom_filter: `essential = true`
+    });
+    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)));
+  }
+  async terminatePositions(payload) {
+    const { symbol } = payload;
+    const symbol_config = await this.app_db.getSymbolConfigFromDB(symbol);
+    let db_positions = await this.syncAccount({
+      symbol,
+      update: true,
+      live_refresh: true
+    });
+    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.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.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 fetchAndUpdateTopMovers() {
+    const db_instance = await this.app_db.get_exchange_db_instance(this.instance);
+    const {
+      bullish,
+      bearish: _bearish,
+      movePercent,
+      totalRisk,
+      max_non_essential = 0
+    } = db_instance;
+    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);
+    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
+    });
+    return result;
+  }
+  async computeTargetPnl(payload) {
+    const { symbol, kind } = payload;
+    const reverse_kind = kind === "long" ? "short" : "long";
+    const root_position = await this.syncAccount({
+      symbol,
+      kind
+    });
+    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
+        });
+        await this.getPositionConfig({
+          kind: reverse_kind,
+          symbol,
+          params: {
+            ...reverse_config,
+            risk: result
+          }
+        });
+      }
+      return result;
+    }
+    return 0;
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
@@ -36433,7 +36996,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");
@@ -36455,65 +37020,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();
   }
@@ -36523,15 +37029,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));
@@ -36539,13 +37043,14 @@ class App {
       await new Promise((resolve) => setTimeout(resolve, 5000));
     }
   }
-  async windDownSymbol(symbol) {
+  async windDownSymbol(payload) {
+    const { symbol, 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) {
@@ -36571,8 +37076,67 @@ 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.windDownSymbol({
+          symbol: pair.symbol,
+          risk_reward: winding_instance?.risk_reward || 199,
+          risk
+        });
+        console.log("result", result);
+      }
+    }
+  }
+  async getNonEssentialSymbols() {
+    const essential_symbols = await this.app_db.getAllSymbolConfigs({
+      custom_filter: `essential = true`
+    });
+    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 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
+      });
     }
   }
 }
@@ -36582,7 +37146,54 @@ async function initApp(payload) {
   const app = new App(app_db, payload.getCredentials);
   return app;
 }
+async function getCredentials(account, exchange) {
+  console.log(`Fetching credentials for account: ${account}, exchange: ${exchange}`);
+  let apiKey;
+  let apiSecret;
+  switch (account) {
+    case "sub_account":
+      apiKey = process.env.SUB_ACCOUNT_API_KEY;
+      apiSecret = process.env.SUB_ACCOUNT_API_SECRET;
+      break;
+    case "tola_sub_account":
+      apiKey = process.env.TOLA_SUB_ACCOUNT_API_KEY;
+      apiSecret = process.env.TOLA_SUB_ACCOUNT_API_SECRET;
+      break;
+    case "gbozee1_sub_account":
+      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;
+      apiSecret = process.env.MAIN_ACCOUNT_API_SECRET;
+      break;
+  }
+  if (!apiKey || !apiSecret) {
+    throw new Error(`Missing API Key or Secret for account '${account}' in .env file. Please check your environment variables.`);
+  }
+  return {
+    api_key: apiKey,
+    api_secret: apiSecret
+  };
+}
+async function initialize() {
+  const app = await initApp({
+    db: {
+      host: process.env.POCKETBASE_HOST,
+      email: process.env.POCKETBASE_EMAIL,
+      password: process.env.POCKETBASE_PASSWORD
+    },
+    getCredentials: (account, exchange) => getCredentials
+  });
+  return app;
+}
 export {
+  initialize,
   initApp,
   ExchangeAccount,
   AppDatabase