@gbozee/ultimate 0.0.2-1 → 0.0.2-11

package/dist/index.d.ts

@@ -2,11 +2,12 @@
 
 import { HttpsProxyAgent } from 'https-proxy-agent';
 import PocketBase from 'pocketbase';
+import { RecordModel } from 'pocketbase';
 import { SocksProxyAgent } from 'socks-proxy-agent';
 
 interface Position$1 {
 	id: number;
-	kind: string;
+	kind: "long" | "short";
 	entry: number;
 	symbol: string;
 	quantity: number;
@@ -16,6 +17,9 @@ interface Position$1 {
 	take_profit: number;
 	tp_quantity: number;
 	stop_quantity: number;
+	target_pnl?: number;
+	reduce_ratio?: number;
+	use_full?: boolean;
 }
 export interface Account {
 	id: number | string;
@@ -113,10 +117,11 @@ export interface BaseExchange {
 		price_places?: string;
 		decimal_places?: string;
 	}): Promise<any>;
+	setLeverage(payload: {
+		symbol: string;
+		leverage: number;
+	}): Promise<any>;
 }
-/**
- * TypeScript type definitions for PocketBase collections and views
- */
 export interface BaseSystemFields {
 	id: string;
 	created: string;
@@ -204,6 +209,16 @@ export interface PositionsView {
 	avg_liquidation?: any;
 	balance?: any;
 }
+export interface BullishMarket extends RecordModel {
+	id: string;
+	symbol: string;
+	risk: number;
+}
+export interface WindingDownMarket extends RecordModel {
+	id: string;
+	symbol: string;
+	risk_reward: number;
+}
 export type ExchangeType = {
 	owner: string;
 	exchange: string;
@@ -211,7 +226,19 @@ export type ExchangeType = {
 export declare class AppDatabase {
 	private pb;
 	constructor(pb: PocketBase);
+	createOrUpdateLiveExchangeInstance(payload: {
+		account: ExchangeType;
+		symbol: string;
+		data?: any;
+	}): Promise<import("pocketbase").RecordModel>;
+	getLiveExchangeInstance(payload: {
+		account: ExchangeType;
+		symbol: string;
+		data?: any;
+	}): Promise<import("pocketbase").RecordModel>;
 	getProxyForAccount(account: ExchangeType): Promise<HttpsProxyAgent<`http://${string}`> | SocksProxyAgent>;
+	getAccounts(): Promise<ExchangeAccount[]>;
+	getAllSymbolConfigs(with_positions?: boolean): Promise<SymbolConfig[]>;
 	get_exchange_db_instance(account: ExchangeType): Promise<ExchangeAccount & {
 		expand?: {
 			proxy: Proxy$1;
@@ -297,11 +324,42 @@ export declare class AppDatabase {
 		symbol: string;
 		kind: "long" | "short";
 		account: ExchangeType;
-	}): Promise<import("pocketbase").RecordModel>;
+	}): Promise<ScheduledTrade | null>;
 	getPositionStrategy(account: ExchangeType): Promise<{
 		strategy_instance: Strategy;
 		focus_account: ExchangeAccount;
 	}>;
+	createOrUpdateWindingDownMarket(symbol: string): Promise<import("pocketbase").RecordModel>;
+	getWindingDownMarkets(symbol?: string): Promise<WindingDownMarket[]>;
+	getBullishMarkets(options?: {
+		new_markets: Array<{
+			symbol: string;
+			percent: number;
+		}>;
+		totalRisk: number;
+	}): Promise<{
+		updated_bullish: BullishMarket[];
+		moved_to_winding: WindingDownMarket[];
+	}>;
+	updateSymbolConfigs(payload?: {
+		configs: Array<{
+			symbol: string;
+			support: number;
+			leverage: number;
+			min_size: number;
+			resistance: number;
+			price_places: string;
+			decimal_places: string;
+		}>;
+	}): Promise<{
+		updated: number;
+		created: number;
+	} | SymbolConfig[]>;
+	unwindSymbolFromDB(symbol: string): Promise<boolean>;
+	hasExistingPosition(symbol: string): Promise<import("pocketbase").RecordModel[]>;
+	removeSymbolFromUnwindingMarkets(symbol: string): Promise<boolean>;
+	removePosition(position: any): Promise<void>;
+	removePositionConfig(position: any): Promise<void>;
 }
 export interface CodeNode {
 	minimum_pnl: number;
@@ -347,6 +405,17 @@ declare class ExchangeAccount$1 {
 		exchange: BaseExchange;
 		app_db: AppDatabase;
 	});
+	/**
+	 *In order to avoid rate limiting issues, we cache the live exchange
+	 details for each symbol for an account in the database with an option
+	 to refresh.
+	 */
+	getLiveExchangeInstance(payload: {
+		symbol: string;
+		refresh?: boolean;
+		price_places?: string;
+		decimal_places?: string;
+	}): Promise<import("pocketbase").RecordModel>;
 	getActiveAccount(symbol: string, full?: boolean): Promise<Account | {
 		liquidation: {
 			long: number;
@@ -361,6 +430,7 @@ declare class ExchangeAccount$1 {
 		kind?: "long" | "short";
 		update?: boolean;
 		as_view?: boolean;
+		leverage?: number;
 	}): Promise<(PositionsView & {
 		expand?: {
 			config: ScheduledTrade;
@@ -376,6 +446,11 @@ declare class ExchangeAccount$1 {
 		kind: "long" | "short";
 		update?: boolean;
 	}): Promise<import("pocketbase").RecordModel[]>;
+	toggleStopBuying(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		should_stop?: boolean;
+	}): Promise<import("pocketbase").RecordModel>;
 	cancelOrders(payload: {
 		symbol: string;
 		kind: "long" | "short";
@@ -461,7 +536,7 @@ declare class ExchangeAccount$1 {
 			risk: number;
 			profit_percent?: number;
 		};
-	}): Promise<import("pocketbase").RecordModel>;
+	}): Promise<ScheduledTrade>;
 	getCurrentPrice(symbol: string): Promise<any>;
 	getPositionStrategy(): Promise<{
 		strategy_instance: Strategy;
@@ -480,6 +555,48 @@ declare class ExchangeAccount$1 {
 			short: boolean;
 		};
 	}): Promise<any>;
+	generate_config_params(payload: {
+		entry: number;
+		stop: number;
+		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;
+	}>;
+	extrapolateShortConfig(payload: {
+		kind: "long" | "short";
+		symbol: string;
+		risk_reward?: 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;
+	}>;
+	triggerTradeFromConfig(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<any>;
+	verifyStopLoss(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		revert?: boolean;
+	}): Promise<import("pocketbase").RecordModel[]>;
+	windDownSymbol(symbol: string, risk_reward?: number): Promise<void>;
 }
 declare class App {
 	private app_db;
@@ -532,34 +649,6 @@ declare class App {
 		message?: undefined;
 		exchange_result?: undefined;
 	}>;
-	triggerTradeFromConfig(payload: {
-		account: ExchangeType;
-		symbol: string;
-		kind: "long" | "short";
-	}): Promise<any>;
-	toggleStopBuying(payload: {
-		account: ExchangeType;
-		symbol: string;
-		kind: "long" | "short";
-		should_stop?: boolean;
-	}): Promise<import("pocketbase").RecordModel>;
-	generate_config_params(exchange_account: ExchangeAccount$1, payload: {
-		entry: number;
-		stop: number;
-		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;
-	}>;
 	generateConfig(payload: {
 		account: ExchangeType;
 		symbol: string;
@@ -577,28 +666,39 @@ declare class App {
 		short_db_position: any;
 		balance: any;
 	}>;
-	extrapolateShortConfig(payload: {
-		account: ExchangeType;
-		kind: "long" | "short";
-		symbol: string;
-		risk_reward?: number;
-	}): Promise<PositionsView | {
-		place_stop: boolean;
-		profit_percent: number;
-		entry: number;
-		stop: number;
-		avg_size: any;
-		avg_entry: any;
-		risk_reward: number;
-		neg_pnl: any;
-		risk: number;
-	}>;
 	verifyStopLoss(payload: {
 		account: ExchangeType;
 		symbol: string;
 		kind: "long" | "short";
 		revert?: boolean;
 	}): Promise<import("pocketbase").RecordModel[]>;
+	updateTopMovers(payload?: {
+		new_markets: {
+			symbol: string;
+			percent: number;
+		}[];
+		totalRisk: number;
+	}): Promise<{
+		updated_bullish: BullishMarket[];
+		moved_to_winding: WindingDownMarket[];
+	}>;
+	getWindingDownMarkets(): Promise<WindingDownMarket[]>;
+	updateSymbolConfigs(payload: {
+		configs: {
+			symbol: string;
+			support: number;
+			leverage: number;
+			min_size: number;
+			resistance: number;
+			price_places: string;
+			decimal_places: string;
+		}[];
+	}): Promise<SymbolConfig[] | {
+		updated: number;
+		created: number;
+	}>;
+	updateAllAccountWithSymbols(with_positions?: boolean): Promise<void>;
+	windDownSymbol(symbol: string): Promise<boolean>;
 }
 export declare function initApp(payload: {
 	db: {

package/dist/index.js

@@ -31646,6 +31646,31 @@ class AppDatabase {
   constructor(pb) {
     this.pb = pb;
   }
+  async createOrUpdateLiveExchangeInstance(payload) {
+    const result = await this.getLiveExchangeInstance(payload);
+    if (result) {
+      return await this.pb.collection("live_exchange_details").update(result.id, {
+        data: payload.data
+      });
+    } else {
+      const exchange_account = await this.get_exchange_db_instance(payload.account);
+      return await this.pb.collection("live_exchange_details").create({
+        symbol: payload.symbol,
+        account: exchange_account.id,
+        data: payload.data
+      });
+    }
+  }
+  async getLiveExchangeInstance(payload) {
+    const result = await this.pb.collection("live_exchange_details").getFullList({
+      filter: `account.owner:lower="${payload.account.owner.toLowerCase()}" && account.exchange:lower="${payload.account.exchange.toLowerCase()}" && symbol:lower="${payload.symbol.toLowerCase()}"`,
+      expand: "account"
+    });
+    if (result.length > 0) {
+      return result[0];
+    }
+    return null;
+  }
   async getProxyForAccount(account) {
     const result = await this.get_exchange_db_instance(account);
     if (result?.expand?.proxy) {
@@ -31660,6 +31685,22 @@ class AppDatabase {
     }
     return null;
   }
+  async getAccounts() {
+    return await this.pb.collection("exchange_accounts").getFullList();
+  }
+  async getAllSymbolConfigs(with_positions) {
+    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
+      });
+    }
+    return await this.pb.collection("symbol_configs").getFullList();
+  }
   async get_exchange_db_instance(account) {
     const result = await this.pb.collection("exchange_accounts").getFirstListItem(`owner="${account.owner}" && exchange="${account.exchange}"`, {
       expand: "proxy"
@@ -31920,6 +31961,236 @@ class AppDatabase {
     }
     return null;
   }
+  async createOrUpdateWindingDownMarket(symbol) {
+    const existing_winding_down_market = await this.pb.collection("winding_down_markets").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}"`
+    });
+    if (existing_winding_down_market.length > 0) {
+      return existing_winding_down_market[0];
+    }
+    return await this.pb.collection("winding_down_markets").create({ symbol, risk_reward: 199 });
+  }
+  async getWindingDownMarkets(symbol) {
+    const result = await this.pb.collection("winding_down_markets").getFullList();
+    if (symbol) {
+      return result.filter((m) => m.symbol === symbol);
+    }
+    return result;
+  }
+  async getBullishMarkets(options) {
+    if (!options) {
+      return {
+        updated_bullish: await this.pb.collection("bullish_markets").getFullList(),
+        moved_to_winding: []
+      };
+    }
+    const { new_markets, totalRisk } = 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 = [];
+    try {
+      currentBullish = await this.pb.collection("bullish_markets").getFullList();
+      console.log(`Found ${currentBullish.length} existing bullish markets.`);
+    } catch (error) {
+      console.error("Error fetching current bullish markets:", error);
+      currentBullish = [];
+    }
+    const currentBullishSymbols = new Set(currentBullish.map((m) => m.symbol));
+    const moved_to_winding = [];
+    const recordsToDeleteFromBullish = [];
+    let windDownCreatedCount = 0;
+    let currentWindingDown = [];
+    let currentWindingDownSymbols = new Set;
+    try {
+      currentWindingDown = await this.getWindingDownMarkets();
+      currentWindingDownSymbols = new Set(currentWindingDown.map((m) => m.symbol));
+      console.log(`Found ${currentWindingDown.length} existing winding down markets.`);
+    } catch (error) {
+      console.error("Error fetching current winding down markets:", error);
+    }
+    console.log("Processing markets to potentially move to winding down...");
+    for (const market of currentBullish) {
+      if (!newMarketSymbols.has(market.symbol)) {
+        console.log(`Processing ${market.symbol} for winding down.`);
+        recordsToDeleteFromBullish.push(market.id);
+        try {
+          const windingDownRecord = await this.createOrUpdateWindingDownMarket(market.symbol);
+          if (windingDownRecord) {
+            moved_to_winding.push(windingDownRecord);
+            windDownCreatedCount++;
+          }
+        } catch (windDownError) {
+          console.error(`Error creating/updating winding down market for ${market.symbol} sequentially:`, windDownError);
+        }
+      }
+    }
+    console.log(`Finished processing potential winding down markets. ${windDownCreatedCount} processed.`);
+    let deletedCount = 0;
+    if (recordsToDeleteFromBullish.length > 0) {
+      console.log(`Attempting to delete ${recordsToDeleteFromBullish.length} records sequentially from bullish_markets.`);
+      for (const id of recordsToDeleteFromBullish) {
+        try {
+          await this.pb.collection("bullish_markets").delete(id);
+          deletedCount++;
+        } catch (deleteError) {
+          console.error(`Error deleting bullish market record ${id} sequentially:`, deleteError);
+        }
+      }
+      console.log(`Finished sequential deletion. Successfully deleted ${deletedCount} of ${recordsToDeleteFromBullish.length} records.`);
+    }
+    let updatedCount = 0;
+    let createdMarkets = [];
+    const recordsToDeleteFromWindingDown = [];
+    if (totalRisk <= 0) {
+      console.warn("Total percent movement is zero or negative. Cannot allocate risk.");
+    } else {
+      for (const newMarket of new_markets) {
+        const calculatedRisk = newMarket.percent / totalRisk * totalRisk;
+        if (currentWindingDownSymbols.has(newMarket.symbol)) {
+          console.log(`Marking ${newMarket.symbol} for removal from winding down markets as it is now bullish.`);
+          const windingDownRecord = currentWindingDown.find((w) => w.symbol === newMarket.symbol);
+          if (windingDownRecord) {
+            recordsToDeleteFromWindingDown.push(windingDownRecord.id);
+            currentWindingDownSymbols.delete(newMarket.symbol);
+          }
+        }
+        const existingMarket = currentBullish.find((m) => m.symbol === newMarket.symbol);
+        if (existingMarket && !recordsToDeleteFromBullish.includes(existingMarket.id)) {
+          if (existingMarket.risk !== calculatedRisk) {
+            console.log(`Updating existing bullish market sequentially: ${newMarket.symbol} with risk ${calculatedRisk}`);
+            try {
+              await this.pb.collection("bullish_markets").update(existingMarket.id, {
+                risk: calculatedRisk
+              });
+              updatedCount++;
+            } catch (updateError) {
+              console.error(`Error updating bullish market ${newMarket.symbol} sequentially:`, updateError);
+            }
+          }
+        } else if (!currentBullishSymbols.has(newMarket.symbol)) {
+          console.log(`Creating new bullish market sequentially: ${newMarket.symbol} with risk ${calculatedRisk}`);
+          try {
+            const createdMarket = await this.pb.collection("bullish_markets").create({
+              symbol: newMarket.symbol,
+              risk: calculatedRisk
+            });
+            createdMarkets.push(createdMarket);
+          } catch (createError) {
+            console.error(`Error creating bullish market ${newMarket.symbol} sequentially:`, createError);
+          }
+        }
+      }
+    }
+    let windingDownDeletedCount = 0;
+    if (recordsToDeleteFromWindingDown.length > 0) {
+      console.log(`Attempting to delete ${recordsToDeleteFromWindingDown.length} records sequentially from winding_down_markets.`);
+      for (const id of recordsToDeleteFromWindingDown) {
+        try {
+          await this.pb.collection("winding_down_markets").delete(id);
+          windingDownDeletedCount++;
+        } catch (deleteError) {
+          console.error(`Error deleting winding down market record ${id} sequentially:`, deleteError);
+        }
+      }
+      console.log(`Finished sequential deletion from winding down. Successfully deleted ${windingDownDeletedCount} of ${recordsToDeleteFromWindingDown.length} records.`);
+    }
+    console.log(`Successfully updated ${updatedCount} bullish markets sequentially.`);
+    console.log(`Successfully created ${createdMarkets.length} bullish markets sequentially.`);
+    const updated_bullish = await this.pb.collection("bullish_markets").getFullList();
+    return { updated_bullish, moved_to_winding };
+  }
+  async updateSymbolConfigs(payload) {
+    if (!payload || !payload.configs) {
+      console.log("No payload provided. Fetching all symbol configs...");
+      try {
+        const allConfigs = await this.pb.collection("symbol_configs").getFullList();
+        console.log(`Found ${allConfigs.length} symbol configs.`);
+        return allConfigs;
+      } catch (error) {
+        console.error("Error fetching all symbol configs:", error);
+        throw error;
+      }
+    }
+    console.log(`Processing ${payload.configs.length} symbol config updates/creates...`);
+    let existingConfigsMap = new Map;
+    try {
+      const existingConfigsList = await this.pb.collection("symbol_configs").getFullList();
+      existingConfigsMap = new Map(existingConfigsList.map((c) => [c.symbol.toLowerCase(), c]));
+      console.log(`Found ${existingConfigsMap.size} existing symbol configs in DB.`);
+    } catch (error) {
+      console.error("Error fetching existing symbol configs:", error);
+    }
+    let updatedCount = 0;
+    let createdCount = 0;
+    for (const config of payload.configs) {
+      const lowerCaseSymbol = config.symbol.toLowerCase();
+      const existingConfig = existingConfigsMap.get(lowerCaseSymbol);
+      const dataToUpsert = {
+        symbol: config.symbol,
+        support: config.support,
+        resistance: config.resistance,
+        leverage: config.leverage,
+        min_size: config.min_size,
+        price_places: config.price_places,
+        decimal_places: config.decimal_places
+      };
+      if (existingConfig) {
+        try {
+          if (Object.keys(dataToUpsert).some((key) => dataToUpsert[key] !== existingConfig[key])) {
+            console.log(`Updating symbol config for: ${config.symbol}`);
+            await this.pb.collection("symbol_configs").update(existingConfig.id, dataToUpsert);
+            updatedCount++;
+          } else {
+            console.log(`No changes detected for symbol config: ${config.symbol}. Skipping update.`);
+          }
+        } catch (updateError) {
+          console.error(`Error updating symbol config for ${config.symbol}:`, updateError);
+        }
+      } else {
+        try {
+          console.log(`Creating new symbol config for: ${config.symbol}`);
+          await this.pb.collection("symbol_configs").create(dataToUpsert);
+          createdCount++;
+        } catch (createError) {
+          console.error(`Error creating symbol config for ${config.symbol}:`, createError);
+        }
+      }
+    }
+    console.log(`Finished processing symbol configs. Updated: ${updatedCount}, Created: ${createdCount}`);
+    return { updated: updatedCount, created: createdCount };
+  }
+  async unwindSymbolFromDB(symbol) {
+    const symbol_configs = await this.pb.collection("symbol_configs").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}"`
+    });
+    if (symbol_configs.length > 0) {
+      await this.pb.collection("symbol_configs").delete(symbol_configs[0].id);
+    }
+    return await this.removeSymbolFromUnwindingMarkets(symbol);
+  }
+  async hasExistingPosition(symbol) {
+    const result = await this.pb.collection("positions").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}"`,
+      expand: "account"
+    });
+    return result;
+  }
+  async removeSymbolFromUnwindingMarkets(symbol) {
+    const result = await this.pb.collection("winding_down_markets").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}"`
+    });
+    if (result.length > 0) {
+      await this.pb.collection("winding_down_markets").delete(result[0].id);
+      return true;
+    }
+    return false;
+  }
+  async removePosition(position) {
+    await this.pb.collection("positions").delete(position.id);
+  }
+  async removePositionConfig(position) {
+    await this.pb.collection("scheduled_trades").delete(position.config);
+  }
 }
 
 // src/exchanges/binance.ts
@@ -32079,9 +32350,7 @@ class Signal {
       support: kind === "long" ? _stop_loss : this.support
     };
     const instance = new Signal(derivedConfig);
-    const ll = this.resistance?.toString().split(".")[0].length || 5;
     if (kind === "short") {
-      console.log("llll", ll);
     }
     let result = instance.get_bulk_trade_zones({ current_price, kind });
     return result;
@@ -32316,7 +32585,6 @@ class Signal {
         entries = Array.from({ length: Math.floor(this.risk_reward) + 1 }, (_, x) => to_f(margin_range[1] * Math.pow(1 + percent_change, x), this.price_places));
       }
       if (Math.min(...entries) < this.to_f(current_price) && this.to_f(current_price) < Math.max(...entries)) {
-        console.log("found: ", entries, "current: ", current_price);
         return entries.sort((a, b) => a - b);
       }
       if (remaining_zones.length > 0) {
@@ -32510,7 +32778,6 @@ class Signal {
       });
       let total_orders = limit_trades.concat(market_trades);
       if (kind === "short") {
-        console.log("raw_total", total_orders);
       }
       if (this.minimum_size && total_orders.length > 0) {
         let payload = total_orders;
@@ -33490,6 +33757,9 @@ class BinanceExchange {
       decimal_places: payload.decimal_places
     });
   }
+  async setLeverage(payload) {
+    return await this.client.setLeverage(payload);
+  }
 }
 
 // src/exchanges/bybit.ts
@@ -34094,6 +34364,14 @@ class BybitExchange {
       decimal_places: payload.decimal_places
     });
   }
+  async setLeverage(payload) {
+    return await this.client.setLeverage({
+      category: "linear",
+      symbol: payload.symbol,
+      buyLeverage: payload.leverage.toString(),
+      sellLeverage: payload.leverage.toString()
+    });
+  }
 }
 
 // src/helpers/accounts.ts
@@ -34546,8 +34824,6 @@ function get_app_config_and_max_size(config, payload) {
     price_places: app_config.price_places,
     decimal_places: app_config.decimal_places
   });
-  console.log("app_config", app_config);
-  console.log("initialResult", initialResult);
   const max_size = initialResult[0]?.avg_size;
   return {
     app_config,
@@ -34753,9 +35029,33 @@ class ExchangeAccount {
     this.exchange = options.exchange;
     this.app_db = options.app_db;
   }
+  async getLiveExchangeInstance(payload) {
+    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;
+      }
+      if (payload.decimal_places) {
+        data.config.decimal_places = payload.decimal_places;
+      }
+      return await this.app_db.createOrUpdateLiveExchangeInstance({
+        account: this.instance,
+        symbol: payload.symbol,
+        data
+      });
+    }
+    return result;
+  }
   async getActiveAccount(symbol, full) {
     const symbol_config = await this.app_db.getSymbolConfigFromDB(symbol);
-    const raw_active_account = await this.exchange.getExchangeAccountInfo(this.instance, symbol);
+    const live_exchange_instance = await this.getLiveExchangeInstance({
+      symbol
+    });
+    const raw_active_account = live_exchange_instance.data;
     const _all = get_active_accounts({
       active_account: raw_active_account,
       symbol_config
@@ -34779,6 +35079,9 @@ class ExchangeAccount {
       return db_positions2;
     }
     const active_account = await this.getActiveAccount(symbol);
+    if (options.leverage) {
+      await this.exchange.setLeverage({ symbol, leverage: options.leverage });
+    }
     const db_positions = await this.app_db.createOrUpdatePositions(this.instance, {
       symbol,
       long_position: active_account.position.long,
@@ -34809,15 +35112,42 @@ class ExchangeAccount {
       kind
     }, all_orders);
   }
+  async toggleStopBuying(payload) {
+    const { symbol, kind, should_stop = false } = payload;
+    const position2 = await this.syncAccount({
+      symbol,
+      kind
+    });
+    if (should_stop) {
+      return await this.app_db.update_db_position(position2, {
+        config: null
+      });
+    }
+    if (!position2.config) {
+      const config = await this.getPositionConfig({
+        symbol,
+        kind
+      });
+      if (config) {
+        return await this.app_db.update_db_position(position2, {
+          config: config.id
+        });
+      }
+    }
+  }
   async cancelOrders(payload) {
     const { symbol, kind, price: _price, all, stop } = payload;
     let price = _price || 0;
+    await this.getLiveExchangeInstance({
+      symbol,
+      refresh: true
+    });
+    await this.syncOrders({
+      symbol,
+      kind,
+      update: true
+    });
     if (all) {
-      await this.syncOrders({
-        symbol,
-        kind,
-        update: true
-      });
     } else {
       if (!price) {
         const position2 = await this.syncAccount({
@@ -34828,7 +35158,7 @@ class ExchangeAccount {
         price = position2?.take_profit || 0;
       }
     }
-    return this.app_db.cancelOrders({
+    let result = await this.app_db.cancelOrders({
       cancelExchangeOrders: this.cancelExchangeOrders.bind(this),
       all,
       kind,
@@ -34837,6 +35167,7 @@ class ExchangeAccount {
       price,
       stop
     });
+    return result;
   }
   async cancelExchangeOrders(payload) {
     return this.exchange.cancelOrders(payload);
@@ -34955,7 +35286,7 @@ class ExchangeAccount {
       symbol: payload.symbol
     }, false);
     if (action === "place_limit_orders" && payload.place) {
-      return await this.exchange.bulkPlaceLimitOrders({
+      let result = await this.exchange.bulkPlaceLimitOrders({
         orders: trades.map((x) => ({
           entry: x.entry,
           quantity: x.quantity
@@ -34965,9 +35296,14 @@ class ExchangeAccount {
         symbol: payload.symbol,
         place: payload.place
       });
+      await this.getLiveExchangeInstance({
+        symbol: payload.symbol,
+        refresh: true
+      });
+      return result;
     }
     if (action === "place_stop_orders" && payload.place) {
-      return await this.exchange.placeStopOrders({
+      let result = await this.exchange.placeStopOrders({
         symbol: payload.symbol,
         quantity: trades[0].avg_size,
         kind: app_config.kind,
@@ -34976,6 +35312,11 @@ class ExchangeAccount {
         decimal_places: app_config.decimal_places,
         place: true
       });
+      await this.getLiveExchangeInstance({
+        symbol: payload.symbol,
+        refresh: true
+      });
+      return result;
     }
     return {
       entry_orders,
@@ -35079,6 +35420,188 @@ class ExchangeAccount {
       short
     }, accountInfo, trigger, this.exchange);
   }
+  async generate_config_params(payload) {
+    const { entry, stop, risk_reward, risk, symbol } = payload;
+    const app_config = await this.buildAppConfig({
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol
+    });
+    let config = generate_config_params(app_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol
+    });
+    return { ...config, place_stop: false, profit_percent: 0 };
+  }
+  async extrapolateShortConfig(payload) {
+    const { symbol, risk_reward = 199, kind } = payload;
+    let reverse_kind = kind === "long" ? "short" : "long";
+    const position2 = await this.syncAccount({
+      symbol,
+      kind: reverse_kind,
+      as_view: true
+    });
+    if (position2) {
+      return await this.generate_config_params({
+        entry: position2.next_order || position2.avg_liquidation,
+        stop: position2.take_profit,
+        risk_reward,
+        risk: position2.target_pnl,
+        symbol
+      });
+    }
+    return null;
+  }
+  async triggerTradeFromConfig(payload) {
+    const position2 = await this.syncAccount({
+      symbol: payload.symbol,
+      kind: payload.kind
+    });
+    if (position2?.config) {
+      const config = position2.expand.config;
+      return await this.placeSharedOrder("place_limit_orders", {
+        symbol: payload.symbol,
+        entry: config.entry,
+        stop: config.stop,
+        risk_reward: config.risk_reward,
+        risk: config.risk,
+        place: true
+      });
+    }
+  }
+  async verifyStopLoss(payload) {
+    const { symbol, kind, revert } = payload;
+    await this.syncOrders({
+      symbol,
+      kind,
+      update: true
+    });
+    let original = null;
+    if (revert) {
+      original = await this.getOriginalPlannedStop({
+        symbol,
+        kind
+      });
+    }
+    const position2 = await this.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 this.cancelOrders({
+        symbol,
+        kind: opposite_kind,
+        stop: true
+      });
+      return await this.syncOrders({
+        symbol,
+        kind,
+        update: true
+      });
+    }
+    if (true) {
+      const opposite_kind = kind === "long" ? "short" : "long";
+      await this.syncOrders({
+        symbol,
+        kind: opposite_kind,
+        update: true
+      });
+      await this.cancelOrders({
+        symbol,
+        kind: opposite_kind,
+        stop: true
+      });
+      await this.syncReduceClosePosition(symbol, {
+        kind: opposite_kind
+      });
+      await this.syncOrders({
+        symbol,
+        kind,
+        update: true
+      });
+    }
+  }
+  async windDownSymbol(symbol, risk_reward = 199) {
+    const positions = await this.syncAccount({
+      symbol,
+      as_view: true
+    });
+    let long_position = positions.find((x) => x.kind === "long");
+    let short_position = positions.find((x) => x.kind === "short");
+    if (long_position && long_position.quantity > 0) {
+      console.log("Start to wind down the long position");
+      let config = long_position?.expand?.config;
+      if (!config && long_position.config) {
+        config = await this.getPositionConfig({
+          symbol,
+          kind: "long"
+        });
+      }
+      if (config) {
+        console.log("cancelling any existing open orders for the long position");
+        await this.cancelOrders({
+          symbol,
+          kind: "long",
+          price: long_position.entry
+        });
+        console.log("updating the long position target_pnl");
+        console.log("toggling the stop buying for the long position");
+        await this.toggleStopBuying({
+          symbol,
+          kind: "long",
+          should_stop: true
+        });
+      }
+      const new_config = await this.extrapolateShortConfig({
+        symbol,
+        kind: "short",
+        risk_reward
+      });
+      const short_config = await this.getPositionConfig({
+        symbol,
+        kind: "short"
+      });
+      if (new_config && short_config && (short_config.entry !== new_config.entry || short_config.stop !== new_config.stop || short_config.risk !== new_config.risk)) {
+        console.log("updating short position");
+        short_position = await this.app_db.update_db_position(short_position, {
+          reduce_ratio: 0.95
+        });
+        console.log("Updating the short position config");
+        await this.getPositionConfig({
+          symbol,
+          kind: "short",
+          params: {
+            entry: new_config.entry,
+            stop: new_config.stop,
+            risk_reward,
+            risk: new_config.risk,
+            profit_percent: 1
+          }
+        });
+        console.log("placing the short trade based off config values");
+        await this.triggerTradeFromConfig({
+          symbol,
+          kind: "short"
+        });
+        console.log("updating the stop loss for the short position from the long");
+        await this.verifyStopLoss({
+          symbol,
+          kind: "short"
+        });
+      }
+    }
+    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);
+    }
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
@@ -35171,66 +35694,6 @@ class App {
       stop: payload.stop
     });
   }
-  async triggerTradeFromConfig(payload) {
-    const exchange_account = await this.getExchangeAccount(payload.account);
-    const position2 = await exchange_account.syncAccount({
-      symbol: payload.symbol,
-      kind: payload.kind
-    });
-    if (position2?.config) {
-      const config = position2.expand.config;
-      return await exchange_account.placeSharedOrder("place_limit_orders", {
-        symbol: payload.symbol,
-        entry: config.entry,
-        stop: config.stop,
-        risk_reward: config.risk_reward,
-        risk: config.risk,
-        place: true
-      });
-    }
-  }
-  async toggleStopBuying(payload) {
-    const { symbol, kind, should_stop = false } = payload;
-    const exchange_account = await this.getExchangeAccount(payload.account);
-    const position2 = await exchange_account.syncAccount({
-      symbol,
-      kind
-    });
-    if (should_stop) {
-      return await this.app_db.update_db_position(position2, {
-        config: null
-      });
-    }
-    if (!position2.config) {
-      const config = await exchange_account.getPositionConfig({
-        symbol,
-        kind
-      });
-      if (config) {
-        return await this.app_db.update_db_position(position2, {
-          config: config.id
-        });
-      }
-    }
-  }
-  async generate_config_params(exchange_account, payload) {
-    const { entry, stop, risk_reward, risk, symbol } = payload;
-    const app_config = await exchange_account.buildAppConfig({
-      entry,
-      stop,
-      risk_reward,
-      risk,
-      symbol
-    });
-    let config = generate_config_params(app_config, {
-      entry,
-      stop,
-      risk_reward,
-      risk,
-      symbol
-    });
-    return { ...config, place_stop: false, profit_percent: 0 };
-  }
   async generateConfig(payload) {
     const { symbol, kind } = payload;
     const exchange_account = await this.getExchangeAccount(payload.account);
@@ -35272,7 +35735,7 @@ class App {
       if (!risk_factor) {
         return null;
       }
-      let config = await this.generate_config_params(exchange_account, {
+      let config = await exchange_account.generate_config_params({
         entry,
         stop,
         risk_reward: config_instance.risk_reward,
@@ -35350,26 +35813,6 @@ class App {
       balance: active_account.usd_balance
     };
   }
-  async extrapolateShortConfig(payload) {
-    const { symbol, risk_reward = 199, kind } = payload;
-    const exchange_account = await this.getExchangeAccount(payload.account);
-    let reverse_kind = kind === "long" ? "short" : "long";
-    const position2 = await exchange_account.syncAccount({
-      symbol,
-      kind: reverse_kind,
-      as_view: true
-    });
-    if (position2) {
-      return await this.generate_config_params(exchange_account, {
-        entry: position2.next_order || position2.avg_liquidation,
-        stop: position2.take_profit,
-        risk_reward,
-        risk: position2.target_pnl,
-        symbol
-      });
-    }
-    return position2;
-  }
   async verifyStopLoss(payload) {
     const { account, symbol, kind, revert } = payload;
     const exchange_account = await this.getExchangeAccount(payload.account);
@@ -35426,6 +35869,70 @@ class App {
       });
     }
   }
+  async updateTopMovers(payload) {
+    return await this.app_db.getBullishMarkets(payload);
+  }
+  async getWindingDownMarkets() {
+    return await this.app_db.getWindingDownMarkets();
+  }
+  async updateSymbolConfigs(payload) {
+    return await this.app_db.updateSymbolConfigs(payload);
+  }
+  async updateAllAccountWithSymbols(with_positions) {
+    const [accounts, symbol_configs] = await Promise.all([
+      this.app_db.getAccounts(),
+      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));
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+  }
+  async windDownSymbol(symbol) {
+    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;
+    }
+    const positions = await this.app_db.hasExistingPosition(symbol);
+    if (positions.length === 0) {
+      return this.app_db.unwindSymbolFromDB(symbol);
+    }
+    const unique_instances = new Set(positions.map((x) => `${x.symbol}-${x.expand.account.owner}-${x.expand.account.exchange}`));
+    let position_pairs = [];
+    for (const instance of unique_instances) {
+      const pair = positions.filter((x) => `${x.symbol}-${x.expand.account.owner}-${x.expand.account.exchange}` === instance && x.quantity === 0);
+      if (pair.length === 2) {
+        position_pairs = position_pairs.concat(pair);
+      }
+    }
+    const not_paired_positions = positions.filter((x) => !position_pairs.map((p) => p.id).includes(x.id) && x.kind === "long");
+    console.log("not_paired_positions", not_paired_positions.map((x) => `${x.symbol} - ${x.expand.account.owner} - ${x.expand.account.exchange}`));
+    if (position_pairs.length > 0) {
+      console.log("removing position pairs");
+      for (const pair of position_pairs) {
+        await this.app_db.removePosition(pair);
+      }
+    }
+    if (not_paired_positions.length > 0) {
+      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);
+      }
+    }
+  }
 }
 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-1",
+  "version": "0.0.2-11",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",