@gbozee/ultimate 0.0.2-20 → 0.0.2-22

package/dist/index.js

@@ -25320,7 +25320,7 @@ var require_websocket = __commonJS((exports, module) => {
   var http = __require("http");
   var net = __require("net");
   var tls = __require("tls");
-  var { randomBytes, createHash } = __require("crypto");
+  var { randomBytes: randomBytes2, createHash } = __require("crypto");
   var { Duplex, Readable } = __require("stream");
   var { URL: URL2 } = __require("url");
   var PerMessageDeflate = require_permessage_deflate();
@@ -25729,7 +25729,7 @@ var require_websocket = __commonJS((exports, module) => {
       }
     }
     const defaultPort = isSecure ? 443 : 80;
-    const key = randomBytes(16).toString("base64");
+    const key = randomBytes2(16).toString("base64");
     const request = isSecure ? https.request : http.request;
     const protocolSet = new Set;
     let perMessageDeflate;
@@ -32104,6 +32104,47 @@ class Client {
 // src/database.ts
 var import_socks_proxy_agent = __toESM(require_dist2(), 1);
 var import_https_proxy_agent = __toESM(require_dist3(), 1);
+import {
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+  scryptSync
+} from "crypto";
+function encryptObject(obj, password) {
+  const jsonString = JSON.stringify(obj);
+  const salt = randomBytes(16);
+  const key = scryptSync(password, salt, 32);
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(jsonString, "utf8"),
+    cipher.final()
+  ]);
+  const authTag = cipher.getAuthTag();
+  const resultBuffer = Buffer.concat([salt, iv, authTag, encrypted]);
+  return resultBuffer.toString("base64");
+}
+function decryptObject(encryptedString, password) {
+  try {
+    const dataBuffer = Buffer.from(encryptedString, "base64");
+    const salt = dataBuffer.subarray(0, 16);
+    const iv = dataBuffer.subarray(16, 28);
+    const authTag = dataBuffer.subarray(28, 44);
+    const encrypted = dataBuffer.subarray(44);
+    const key = scryptSync(password, salt, 32);
+    const decipher = createDecipheriv("aes-256-gcm", key, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([
+      decipher.update(encrypted),
+      decipher.final()
+    ]);
+    const jsonString = decrypted.toString("utf8");
+    return JSON.parse(jsonString);
+  } catch (error) {
+    console.error("Decryption failed:", error.message);
+    return null;
+  }
+}
 async function initPocketBaseClient(proxy_credentials) {
   const pb = new Client(proxy_credentials.host);
   await pb.collection("_superusers").authWithPassword(proxy_credentials.email, proxy_credentials.password);
@@ -32115,6 +32156,37 @@ class AppDatabase {
   constructor(pb) {
     this.pb = pb;
   }
+  getCredentials(password) {
+    const credentials = this.pb.authStore.record.credentials;
+    if (credentials) {
+      return decryptObject(credentials, password);
+    }
+    return null;
+  }
+  async saveCredentials(password, credentials) {
+    const encrypted = encryptObject(credentials, password);
+    await this.pb.collection("_superusers").update(this.pb.authStore.record.id, {
+      credentials: encrypted
+    });
+  }
+  async addNewCredential(password, payload) {
+    let credentials = this.getCredentials(password);
+    if (credentials) {
+      let found = false;
+      for (const credential of credentials) {
+        if (credential.name === payload.name && credential.exchange === payload.exchange) {
+          credential.api_key = payload.api_key;
+          credential.api_secret = payload.api_secret;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        credentials.push(payload);
+      }
+      await this.saveCredentials(password, credentials);
+    }
+  }
   async getAllSymbolsFromPositions(options) {
     const { no_position = false, kind = "long", custom_filter } = options || {};
     let filter = custom_filter || (no_position ? `quantity = 0` : undefined);
@@ -32410,6 +32482,15 @@ 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) {
@@ -32422,6 +32503,12 @@ class AppDatabase {
       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 {
       const kind = payload.entry > payload.stop ? "long" : "short";
@@ -32436,7 +32523,9 @@ class AppDatabase {
           stop: payload.stop,
           risk_reward: payload.risk_reward,
           risk: payload.risk,
-          profit_percent: payload.profit_percent
+          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) {
@@ -32447,14 +32536,14 @@ class AppDatabase {
         config = await this.pb.collection("scheduled_trades").create({
           symbol: db_position.symbol,
           account: db_position.account,
-          profit: payload.risk,
+          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: true
+          place_tp: payload.place_tp !== undefined ? payload.place_tp : true
         });
       }
       await this.pb.collection("positions").update(db_position.id, {
@@ -32700,6 +32789,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()}"`
@@ -34168,10 +34263,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;
@@ -34228,11 +34323,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) {
@@ -34249,6 +34351,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,
@@ -34378,20 +34496,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);
@@ -34402,14 +34525,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 }),
@@ -34427,18 +34555,23 @@ 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;
@@ -34451,6 +34584,21 @@ class BinanceExchange {
       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) {
   const numStr = target.toString();
@@ -34949,8 +35097,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) {
@@ -35094,6 +35244,27 @@ class BybitExchange {
   }
   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
@@ -35497,6 +35668,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,
@@ -35530,8 +35702,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,
@@ -35555,13 +35727,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,
@@ -35580,6 +35762,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) {
@@ -35753,11 +35937,16 @@ 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;
+  }
+  getDBInstance() {
+    return this.app_db;
   }
   async getLiveExchangeInstance(payload) {
     const symbol_config = await this.recomputeSymbolConfig({
@@ -36018,6 +36207,54 @@ 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,
@@ -36038,6 +36275,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) => ({
@@ -36084,7 +36344,17 @@ class ExchangeAccount {
         kind: payload.kind
       });
       if (db_position) {
-        return 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({
@@ -36271,15 +36541,15 @@ class ExchangeAccount {
     }
   }
   async generate_config_params(payload) {
-    const { entry, stop, risk_reward, risk, symbol } = payload;
-    const app_config = await this.buildAppConfig({
+    const {
       entry,
       stop,
       risk_reward,
       risk,
-      symbol
-    });
-    console.log({
+      symbol,
+      with_trades = false
+    } = payload;
+    const app_config = await this.buildAppConfig({
       entry,
       stop,
       risk_reward,
@@ -36293,8 +36563,79 @@ class ExchangeAccount {
       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, risk } = payload;
     let reverse_kind = kind === "long" ? "short" : "long";
@@ -36329,13 +36670,15 @@ class ExchangeAccount {
     });
     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,
-        entry: config.entry,
+        entry,
         stop: config.stop,
         risk_reward: config.risk_reward,
         risk: config.risk,
-        place
+        place,
+        raw: payload.raw
       });
     }
   }
@@ -36561,7 +36904,8 @@ class ExchangeAccount {
     }
     const config = await this.exchange.generateConfig({
       symbol,
-      limit: _config?.candle_count || 5
+      limit: _config?.candle_count || 5,
+      interval: _config?.interval || "1w"
     });
     await this.app_db.updateSymbolConfigs({
       configs: [
@@ -36578,27 +36922,55 @@ class ExchangeAccount {
     });
     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) {
-    const { symbol, profit_percent = 10, risk_reward = 199 } = 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 symbol_config = await this.recomputeSymbolConfig({
-      symbol,
-      refresh: true
-    });
+    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.generate_config_params({
-      entry: symbol_config.resistance,
-      stop: symbol_config.support,
-      risk_reward,
+    const long_config = await this.buildConfigForSymbol({
+      symbol,
       risk: bullish_instance.risk,
-      symbol
+      risk_reward
     });
     let changed = false;
     if (!position2?.config) {
@@ -36629,30 +37001,56 @@ class ExchangeAccount {
     }
     const short_position = await this.syncAccount({
       symbol,
-      kind: "short"
+      kind: "short",
+      update: true
     });
-    if (short_position?.config) {
+    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"
+        kind: "long",
+        tp: true
+      });
+      await this.placeProfitAndStop({
+        symbol,
+        trigger: true
       });
       return rr;
     }
     return false;
   }
-  async updateAllActiveSymbols() {
+  async updateAllActiveSymbols(payload) {
+    const { interval = 5 } = payload;
     const symbols = await this.app_db.getAllSymbolsFromPositions({
       no_position: true,
       kind: "long"
     });
-    for (const symbol of symbols) {
+    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));
     }
@@ -36672,10 +37070,27 @@ class ExchangeAccount {
       await new Promise((resolve) => setTimeout(resolve, 1000));
     }
   }
-  async getNonEssentialSymbols() {
-    const essential_symbols = await this.app_db.getAllSymbolConfigs({
-      custom_filter: `essential = true`
+  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);
@@ -36688,19 +37103,24 @@ class ExchangeAccount {
         exchange: ""
       }
     });
-    return Array.from(new Set(positions.map((p) => p.symbol)));
+    return Array.from(new Set(positions.map((p) => p.symbol).concat(non_essential_symbols)));
   }
-  async terminatePositions(payload) {
+  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
     });
+    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",
@@ -36714,6 +37134,11 @@ class ExchangeAccount {
       });
     }
     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",
@@ -36741,6 +37166,158 @@ class ExchangeAccount {
       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: "long",
+        all: true
+      });
+      await this.cancelOrders({
+        symbol,
+        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 fetchAndUpdateTopMovers() {
     const db_instance = await this.app_db.get_exchange_db_instance(this.instance);
     const {
@@ -36748,8 +37325,10 @@ class ExchangeAccount {
       bearish: _bearish,
       movePercent,
       totalRisk,
-      max_non_essential = 0
+      max_non_essential = 0,
+      exclude_coins
     } = db_instance;
+    let dont_trade = exclude_coins?.bullish || [];
     let bullishMarkets = [];
     if (bullish) {
       const { movers } = await this.exchange.checkDelistedMovers({
@@ -36758,7 +37337,7 @@ class ExchangeAccount {
       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);
+    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) {
@@ -36773,6 +37352,12 @@ class ExchangeAccount {
       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) {
@@ -36807,20 +37392,57 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async placeTrade(payload) {
+    const { symbol, kind, place, tp } = payload;
+    if (place) {
+      return await this.triggerTradeFromConfig({
+        symbol,
+        kind
+      });
+    }
+    await this.syncAccount({
+      symbol,
+      live_refresh: true,
+      update: true
+    });
+    const result = await this.syncOrders({
+      symbol,
+      kind,
+      update: true
+    });
+    await this.updateTargetPnl({
+      symbol,
+      kind
+    });
+    if (tp) {
+      await this.placeProfitAndStop({
+        symbol,
+        trigger: true
+      });
+    }
+    return result;
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
   const clientFunc = exchange === "binance" ? initClient : initClient2;
   return async (payload) => {
-    const credentials = await payload.getCredentials(payload.account, exchange);
+    const credentials = payload.getCredentials(payload.account, exchange);
     const client = await clientFunc(credentials, {
       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) {
@@ -36846,11 +37468,10 @@ class App {
     this.getCredentials = getCredentials;
   }
   async getExchangeAccount(account) {
-    const credentials = this.getCredentials(account.owner, account.exchange);
     return await getExchangeAccount({
       account,
       app_db: this.app_db,
-      getCredentials: credentials
+      getCredentials: this.getCredentials
     });
   }
   async syncAccount(payload) {
@@ -37044,7 +37665,7 @@ class App {
     }
   }
   async windDownSymbol(payload) {
-    const { symbol, risk } = 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];
@@ -37069,6 +37690,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);
       }
     }
@@ -37076,10 +37708,8 @@ 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);
-        const result = await exchange_account.windDownSymbol({
-          symbol: pair.symbol,
-          risk_reward: winding_instance?.risk_reward || 199,
-          risk
+        const result = await exchange_account.terminatePositions({
+          symbol: pair.symbol
         });
         console.log("result", result);
       }
@@ -37139,14 +37769,86 @@ class App {
       });
     }
   }
+  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) {
   const pb = await initPocketBaseClient(payload.db);
   const app_db = new AppDatabase(pb);
-  const app = new App(app_db, payload.getCredentials);
+  let _getCredentials = payload.getCredentials;
+  if (payload.password) {
+    try {
+      const credentials = app_db.getCredentials(payload.password);
+      if (credentials) {
+        _getCredentials = (account, exchange) => {
+          const credential = credentials.find((c) => c.name === account && c.exchange === exchange);
+          if (!credential) {
+            throw new Error(`Missing API Key or Secret for account '${account}' in .env file. Please check your environment variables.`);
+          }
+          return {
+            api_key: credential?.api_key,
+            api_secret: credential?.api_secret
+          };
+        };
+      }
+    } catch (error) {
+      console.log("error", error);
+    }
+  }
+  const app = new App(app_db, _getCredentials);
   return app;
 }
-async function getCredentials(account, exchange) {
+function getCredentials(account, exchange) {
   console.log(`Fetching credentials for account: ${account}, exchange: ${exchange}`);
   let apiKey;
   let apiSecret;
@@ -37181,14 +37883,15 @@ async function getCredentials(account, exchange) {
     api_secret: apiSecret
   };
 }
-async function initialize() {
+async function initialize(password) {
   const app = await initApp({
     db: {
       host: process.env.POCKETBASE_HOST,
       email: process.env.POCKETBASE_EMAIL,
       password: process.env.POCKETBASE_PASSWORD
     },
-    getCredentials: (account, exchange) => getCredentials
+    password,
+    getCredentials
   });
   return app;
 }