@gbozee/ultimate 0.0.2-20 → 0.0.2-21

package/dist/index.d.ts

@@ -128,6 +128,7 @@ export interface BaseExchange {
 	}): Promise<any>;
 	generateConfig(payload: {
 		symbol: string;
+		interval?: any;
 		limit?: number;
 	}): Promise<any>;
 	checkDelistedMovers(payload: {
@@ -139,6 +140,15 @@ export interface BaseExchange {
 		price_places?: string;
 		decimal_places?: string;
 	}): Promise<any>;
+	getAllOpenSymbols(): Promise<string[]>;
+	createLimitPurchaseOrders(payload: {
+		orders: any[];
+		kind: "long" | "short";
+		decimal_places?: string;
+		price_places?: string;
+		symbol: string;
+	}): Promise<any>;
+	getDelistedSpotSymbols(): Promise<any>;
 }
 export interface BaseSystemFields {
 	id: string;
@@ -158,6 +168,10 @@ export interface ExchangeAccount extends BaseSystemFields {
 	movePercent?: number;
 	totalRisk?: number;
 	max_non_essential?: number;
+	profit_percent?: number;
+	exclude_coins?: {
+		bullish?: string[];
+	};
 }
 export interface SymbolConfig extends BaseSystemFields {
 	symbol: string;
@@ -170,6 +184,7 @@ export interface SymbolConfig extends BaseSystemFields {
 	weight?: number;
 	leverage?: number;
 	candle_count?: number;
+	interval?: any;
 }
 export interface ScheduledTrade extends BaseSystemFields {
 	symbol: string;
@@ -349,12 +364,16 @@ export declare class AppDatabase {
 		message?: undefined;
 		exchange_result?: undefined;
 	}>;
+	getMoverExchangeInstances(): Promise<ExchangeAccount[]>;
+	updateScheduledTrade(id: string, payload: any): Promise<import("pocketbase").RecordModel>;
 	createOrUpdatePositionConfig(db_position: any, payload: {
 		entry: number;
 		stop: number;
 		risk_reward: number;
 		risk: number;
 		profit_percent?: number;
+		place_tp?: boolean;
+		profit?: number;
 	}): Promise<ScheduledTrade | import("pocketbase").RecordModel>;
 	getPositionConfig(payload: {
 		symbol: string;
@@ -395,6 +414,7 @@ export declare class AppDatabase {
 	} | SymbolConfig[]>;
 	unwindSymbolFromDB(symbol: string): Promise<boolean>;
 	hasExistingPosition(symbol: string): Promise<import("pocketbase").RecordModel[]>;
+	hasExistingOrders(symbol: string): Promise<import("pocketbase").RecordModel[]>;
 	removeSymbolFromUnwindingMarkets(symbol: string): Promise<boolean>;
 	removePosition(position: any): Promise<void>;
 	removePositionConfig(position: any): Promise<void>;
@@ -424,14 +444,18 @@ export type AppConfig = {
 	gap?: number;
 	rr?: number;
 	max_size?: number;
+	last_value?: any;
+	entries?: any[];
 };
 declare class ExchangeAccount$1 {
 	private instance;
 	exchange: BaseExchange;
+	main_exchange?: BaseExchange;
 	private app_db;
 	constructor(payload: ExchangeType, options: {
 		exchange: BaseExchange;
 		app_db: AppDatabase;
+		main_exchange?: BaseExchange;
 	});
 	/**
 	 *In order to avoid rate limiting issues, we cache the live exchange
@@ -547,6 +571,14 @@ declare class ExchangeAccount$1 {
 		};
 		trades: any[];
 	}>;
+	determineAmountToBuy(payload: {
+		orders: any[];
+		kind: "long" | "short";
+		decimal_places?: string;
+		price_places?: string;
+		symbol: string;
+		place?: boolean;
+	}): Promise<any[]>;
 	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders", payload: {
 		symbol: string;
 		entry: number;
@@ -555,16 +587,19 @@ declare class ExchangeAccount$1 {
 		risk: number;
 		place?: boolean;
 		update_db?: boolean;
+		raw?: boolean;
 	}): Promise<any>;
 	getPositionConfig(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		params?: {
-			entry: number;
-			stop: number;
-			risk_reward: number;
-			risk: number;
+			entry?: number;
+			stop?: number;
+			risk_reward?: number;
+			risk?: number;
 			profit_percent?: number;
+			place_tp?: boolean;
+			profit?: number;
 		};
 	}): Promise<ScheduledTrade | import("pocketbase").RecordModel>;
 	getCurrentPrice(symbol: string): Promise<any>;
@@ -651,37 +686,24 @@ declare class ExchangeAccount$1 {
 		risk_reward: number;
 		risk: number;
 		symbol: string;
-	}): Promise<{
-		place_stop: boolean;
-		profit_percent: number;
-		entry: number;
-		stop: number;
-		avg_size: any;
-		avg_entry: any;
-		risk_reward: number;
-		neg_pnl: any;
-		risk: number;
-	}>;
+		with_trades?: boolean;
+	}): Promise<any>;
+	build_short_order(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<any>;
 	extrapolateShortConfig(payload: {
 		kind: "long" | "short";
 		symbol: string;
 		risk_reward?: number;
 		risk?: number;
-	}): Promise<{
-		place_stop: boolean;
-		profit_percent: number;
-		entry: number;
-		stop: number;
-		avg_size: any;
-		avg_entry: any;
-		risk_reward: number;
-		neg_pnl: any;
-		risk: number;
-	}>;
+	}): Promise<any>;
 	triggerTradeFromConfig(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		place?: boolean;
+		raw?: boolean;
+		tp?: boolean;
 	}): Promise<any>;
 	verifyStopLoss(payload: {
 		symbol: string;
@@ -701,16 +723,46 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		refresh?: boolean;
 	}): Promise<SymbolConfig>;
+	/**
+	 * This function builds a config for a symbol
+	 * @param payload
+	 * @returns
+	 */
+	buildConfigForSymbol(payload: {
+		symbol: string;
+		risk: number;
+		kind?: "long" | "short";
+		risk_reward?: number;
+		as_config?: boolean;
+		with_trades?: boolean;
+	}): Promise<any>;
 	triggerBullishMarket(payload: {
 		symbol: string;
 		profit_percent?: number;
 		risk_reward?: number;
 	}): Promise<any>;
-	updateAllActiveSymbols(): Promise<void>;
+	updateAllActiveSymbols(payload: {
+		interval?: number;
+	}): Promise<void>;
 	updateAllPositionsWithNoConfig(payload: {
 		kind: "long" | "short";
 	}): Promise<void>;
+	getSymbolsForPositions(): Promise<any[]>;
 	getNonEssentialSymbols(): Promise<any[]>;
+	_terminatePositions(payload: {
+		symbol: string;
+	}): Promise<void>;
+	getOrders(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		type: "limit" | "stop" | "tp";
+		refresh?: boolean;
+	}): Promise<import("pocketbase").RecordModel[]>;
+	syncPositionConfigs(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		refresh?: boolean;
+	}): Promise<void>;
 	terminatePositions(payload: {
 		symbol: string;
 	}): Promise<void>;
@@ -722,6 +774,12 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<number>;
+	placeTrade(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		place?: boolean;
+		tp?: boolean;
+	}): Promise<any>;
 }
 declare class App {
 	private app_db;
@@ -812,6 +870,18 @@ declare class App {
 	refreshAllPositionsWithSymbol(payload: {
 		symbol: string;
 	}): Promise<void>;
+	getMoverExchangeInstances(): Promise<ExchangeAccount[]>;
+	updateTpOnAllMarkets(): Promise<void>;
+	triggerMoverTask(payload: {
+		callback: (params: {
+			symbol: string;
+			account: ExchangeType;
+		}) => Promise<any>;
+		removeCallback?: (params: {
+			symbol: string;
+			account: ExchangeType;
+		}) => Promise<any>;
+	}): Promise<void>;
 }
 export declare function initApp(payload: {
 	db: {

package/dist/index.js

@@ -32410,6 +32410,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 +32431,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 +32451,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 +32464,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 +32717,12 @@ class AppDatabase {
     });
     return result;
   }
+  async hasExistingOrders(symbol) {
+    const result = await this.pb.collection("orders").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}"`
+    });
+    return result;
+  }
   async removeSymbolFromUnwindingMarkets(symbol) {
     const result = await this.pb.collection("winding_down_markets").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}"`
@@ -34168,10 +34191,10 @@ async function analyzeCharts(params) {
   return finalPairs;
 }
 async function getWeeklyKlines(payload) {
-  const { client, symbol, limit = 20 } = payload;
+  const { client, symbol, limit = 20, interval = "1w" } = payload;
   const requestParams = {
     symbol: symbol.toUpperCase(),
-    interval: "1w"
+    interval
   };
   if (limit) {
     requestParams.limit = limit;
@@ -34228,11 +34251,18 @@ async function getActiveSymbols(payload) {
   const response = await client.getExchangeInfo();
   return response.symbols;
 }
+async function getAllOpenOrders(payload) {
+  const { client } = payload;
+  const response = await client.getAllOpenOrders();
+  return response;
+}
 
 class BinanceExchange {
   client;
-  constructor(client) {
+  main_client;
+  constructor(client, main_client) {
     this.client = client;
+    this.main_client = main_client;
   }
   async placeStopOrders(payload) {
     if (payload.place) {
@@ -34249,6 +34279,22 @@ class BinanceExchange {
       });
     }
   }
+  async createLimitPurchaseOrders(payload) {
+    const {
+      orders,
+      kind,
+      decimal_places = "%.3f",
+      price_places = "%.1f",
+      symbol
+    } = payload;
+    const _orders = orders.map((order) => ({
+      ...order,
+      price: order.entry,
+      kind,
+      side: kind.toLowerCase() === "long" ? "buy" : "sell"
+    }));
+    return await createLimitPurchaseOrders(this.client, symbol, price_places, decimal_places, _orders);
+  }
   async bulkPlaceLimitOrders(payload) {
     const {
       orders,
@@ -34378,20 +34424,25 @@ class BinanceExchange {
       }
       maxLeverage = Math.max(...brackets.brackets.map((b) => b.initialLeverage));
     }
-    await this.client.setLeverage({
-      symbol: payload.symbol,
-      leverage: payload.leverage || maxLeverage
-    });
+    try {
+      await this.client.setLeverage({
+        symbol: payload.symbol,
+        leverage: payload.leverage || maxLeverage
+      });
+    } catch (error) {
+      console.log("error", error);
+    }
     return maxLeverage;
   }
   async generateConfig(payload) {
     const symbols = await getActiveSymbols({ client: this.client });
     console.log("symbols", symbols);
-    const { symbol, limit = 5 } = payload;
+    const { symbol, limit = 5, interval = "1w" } = payload;
     const klines = await getWeeklyKlines({
       client: this.client,
       symbol,
-      limit
+      limit,
+      interval
     });
     const { support, resistance } = calculateSupportResistance(klines);
     const target = symbols.find((s2) => s2.symbol === symbol);
@@ -34402,14 +34453,19 @@ class BinanceExchange {
       if (f.filterType === "MIN_NOTIONAL")
         minNotional = parseFloat(f.notional);
     });
+    if (["BTCUSDT", "BTCUSDC"].includes(symbol)) {
+      minNotional = 105;
+    }
+    const isBTC = ["BTCUSDT", "BTCUSDC"].includes(symbol);
     const currentPrice = await getCurrentPrice(this.client, symbol);
-    const price_places = `%.${getPricePlaces(currentPrice)}f`;
+    const price_places = isBTC ? "%.1f" : `%.${getPricePlaces(currentPrice)}f`;
     const decimal_places = `%.${target.quantityPrecision}f`;
+    const min_size = to_f((minNotional || 0) / support, decimal_places);
     const configObj = {
       support,
       resistance,
       minNotional,
-      min_size: to_f((minNotional || 0) / support, decimal_places),
+      min_size: isBTC ? 0.002 : min_size,
       price_places,
       decimal_places,
       leverage: await this.setLeverage({ symbol }),
@@ -34427,18 +34483,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 +34512,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 +35025,10 @@ async function analyzeCharts2(params) {
 
 class BybitExchange {
   client;
-  constructor(client) {
+  main_client;
+  constructor(client, main_client) {
     this.client = client;
+    this.main_client = main_client;
   }
   async placeStopOrders(payload) {
     if (payload.place) {
@@ -35094,6 +35172,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 +35596,7 @@ function buildConfig(app_config, {
   if (kind === "short") {
     console.log("condition", condition, entry === stop);
   }
+  console.log({ entry, support: app_config.support, stop });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -35530,8 +35630,8 @@ function get_app_config_and_max_size(config, payload) {
     stop: payload.stop,
     risk_per_trade: config.risk,
     risk_reward: config.risk_reward || 199,
-    support: config.support,
-    resistance: config.resistance,
+    support: to_f(config.support, config.price_places),
+    resistance: to_f(config.resistance, config.price_places),
     focus: payload.entry,
     fee: 0,
     percent_change: config.stop_percent / 100,
@@ -35555,13 +35655,23 @@ function get_app_config_and_max_size(config, payload) {
     decimal_places: app_config.decimal_places
   });
   const max_size = initialResult[0]?.avg_size;
+  const last_value = initialResult[0];
+  const entries = initialResult.map((x) => ({
+    entry: x.entry,
+    avg_entry: x.avg_entry,
+    avg_size: x.avg_size,
+    neg_pnl: x.neg_pnl,
+    quantity: x.quantity
+  }));
   return {
     app_config,
-    max_size
+    max_size,
+    last_value,
+    entries
   };
 }
 function buildAppConfig(config, payload) {
-  const { app_config, max_size } = get_app_config_and_max_size({
+  const { app_config, max_size, last_value, entries } = get_app_config_and_max_size({
     ...config,
     risk: payload.risk,
     profit: payload.profit || 500,
@@ -35580,6 +35690,8 @@ function buildAppConfig(config, payload) {
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
   app_config.stop = payload.stop || app_config.stop;
+  app_config.last_value = last_value;
+  app_config.entries = entries;
   return app_config;
 }
 function getOptimumStopAndRisk(app_config, params) {
@@ -35753,11 +35865,13 @@ function generate_config_params(app_config, payload) {
 class ExchangeAccount {
   instance;
   exchange;
+  main_exchange;
   app_db;
   constructor(payload, options) {
     this.instance = payload;
     this.exchange = options.exchange;
     this.app_db = options.app_db;
+    this.main_exchange = options.main_exchange;
   }
   async getLiveExchangeInstance(payload) {
     const symbol_config = await this.recomputeSymbolConfig({
@@ -36018,6 +36132,59 @@ class ExchangeAccount {
       trades
     };
   }
+  async determineAmountToBuy(payload) {
+    const {
+      orders,
+      kind,
+      decimal_places = "%.3f",
+      symbol
+    } = payload;
+    const totalQuantity = orders.reduce((sum, order) => sum + (order.quantity || 0), 0);
+    let runningTotal = to_f(totalQuantity, decimal_places);
+    let sortedOrders = [...orders].sort((a, b) => (a.entry || 0) - (b.entry || 0));
+    if (kind === "short") {
+      sortedOrders.reverse();
+    }
+    const withCumulative = [];
+    for (const order of sortedOrders) {
+      withCumulative.push({
+        ...order,
+        cumulative_quantity: runningTotal
+      });
+      runningTotal -= order.quantity;
+      runningTotal = to_f(runningTotal, decimal_places);
+    }
+    const position2 = await this.syncAccount({
+      symbol,
+      kind,
+      live_refresh: true,
+      update: true
+    });
+    let existingOrders = await this.syncOrders({
+      symbol,
+      kind,
+      update: true
+    });
+    let filteredOrders = withCumulative.filter((order) => (order.cumulative_quantity || 0) > position2?.quantity).map((order) => ({
+      ...order,
+      price: order.entry,
+      kind,
+      side: kind.toLowerCase() === "long" ? "buy" : "sell"
+    }));
+    filteredOrders = filteredOrders.filter((k) => !existingOrders.map((j) => j.price).includes(k.price));
+    const side = kind.toLowerCase() === "long" ? "buy" : "sell";
+    const shouldCancel = existingOrders.filter((k) => !orders.map((j) => j.entry).includes(k.price) && k.side === side).map((u) => u.price);
+    if (shouldCancel.length > 0) {
+      const pp = kind === "long" ? Math.max(...shouldCancel) : Math.min(...shouldCancel);
+      const cancel_orders = await this.cancelOrders({
+        symbol,
+        kind,
+        price: pp
+      });
+      console.log("cancel_orders", cancel_orders);
+    }
+    return filteredOrders;
+  }
   async placeSharedOrder(action, payload) {
     const app_config = await this.buildAppConfig({
       entry: payload.entry,
@@ -36038,6 +36205,29 @@ class ExchangeAccount {
       min_size: app_config.min_size,
       symbol: payload.symbol
     }, false);
+    if (payload.raw) {
+      let actual_orders_to_buy = await this.determineAmountToBuy({
+        orders: trades,
+        kind: app_config.kind,
+        decimal_places: app_config.decimal_places,
+        price_places: app_config.price_places,
+        symbol: payload.symbol,
+        place: payload.place
+      });
+      if (action === "place_limit_orders" && payload.place) {
+        return await this.exchange.createLimitPurchaseOrders({
+          orders: actual_orders_to_buy.map((x) => ({
+            entry: x.entry,
+            quantity: x.quantity
+          })),
+          kind: app_config.kind,
+          decimal_places: app_config.decimal_places,
+          price_places: app_config.price_places,
+          symbol: payload.symbol
+        });
+      }
+      return actual_orders_to_buy;
+    }
     if (action === "place_limit_orders" && payload.place) {
       let result = await this.exchange.bulkPlaceLimitOrders({
         orders: trades.map((x) => ({
@@ -36084,7 +36274,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 +36471,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 +36493,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 +36600,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 +36834,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 +36852,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 +36931,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 +37000,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 +37033,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 +37064,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 +37096,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 +37255,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 +37267,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 +37282,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,6 +37322,36 @@ 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;
@@ -36817,10 +37362,17 @@ function getExchangeKlass(exchange) {
       type: "future",
       proxyAgent: payload.proxyAgent
     });
+    let main_client = null;
+    if (exchange === "binance") {
+      main_client = await initClient(credentials, {
+        type: "spot",
+        proxyAgent: payload.proxyAgent
+      });
+    }
     if (!client) {
       throw new Error(`Failed to initialize ${exchange} client`);
     }
-    return new func(client);
+    return new func(client, main_client);
   };
 }
 async function getExchangeAccount(payload) {
@@ -37044,7 +37596,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 +37621,17 @@ class App {
     if (position_pairs.length > 0) {
       console.log("removing position pairs");
       for (const pair of position_pairs) {
+        const exchange_account = await this.getExchangeAccount(pair.expand.account);
+        await exchange_account.cancelOrders({
+          symbol: pair.symbol,
+          kind: "long",
+          all: true
+        });
+        await exchange_account.cancelOrders({
+          symbol: pair.symbol,
+          kind: "short",
+          all: true
+        });
         await this.app_db.removePosition(pair);
       }
     }
@@ -37076,10 +37639,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,6 +37700,58 @@ 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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gbozee/ultimate",
   "type": "module",
-  "version": "0.0.2-20",
+  "version": "0.0.2-21",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,7 +12,7 @@
     "require": "./dist/index.cjs"
   },
   "scripts": {
-    "trigger:deploy": "npx trigger.dev@latest deploy",
+    "trigger:deploy": "npx trigger.dev@latest deploy --self-hosted --push",
     "trigger:dev": "npx trigger.dev@latest dev",
     "yarn:publish": "yarn publish --prerelease",
     "build": "bun run build.ts",