@gbozee/ultimate 0.0.2-40 → 0.0.2-43

package/dist/index.d.ts

@@ -377,6 +377,22 @@ export declare class AppDatabase {
 		order_id: string;
 		triggerPrice?: number;
 	}>): Promise<import("pocketbase").RecordModel[]>;
+	deleteAndBulCreateAllOrders(payload: {
+		account: ExchangeType & {
+			id: string;
+		};
+		symbol: string;
+		all_orders: Array<{
+			symbol: string;
+			price: number;
+			quantity: number;
+			kind: "long" | "short";
+			side: "buy" | "sell";
+			stop: number;
+			order_id: string;
+			triggerPrice?: number;
+		}>;
+	}): Promise<void>;
 	cancelLimitOrders(payload: {
 		symbol: string;
 		kind: "long" | "short";
@@ -730,11 +746,140 @@ export declare function determine_break_even_price(payload: {
 	price: number;
 	direction: string;
 };
+declare class ExchangePosition {
+	exchange: BaseExchange;
+	exchange_account: ExchangeAccount$1;
+	private app_db;
+	private instance;
+	constructor(payload: {
+		exchange: BaseExchange;
+		app_db: AppDatabase;
+		instance: PositionsView;
+		exchange_account: ExchangeAccount$1;
+		without_view?: PositionsView;
+	});
+	get symbol(): any;
+	get kind(): any;
+	get account(): any;
+	cancelOrders(payload: {
+		limit?: boolean;
+		price?: number;
+	}): Promise<void | {
+		success: boolean;
+		message: string;
+		exchange_result?: undefined;
+		error?: undefined;
+	} | {
+		success: boolean;
+		exchange_result: any;
+		message?: undefined;
+		error?: undefined;
+	} | {
+		success: boolean;
+		error: any;
+		message?: undefined;
+		exchange_result?: undefined;
+	}>;
+	getConfig(payload?: {
+		params?: {
+			entry?: number;
+			stop?: number;
+			risk_reward?: number;
+			risk?: number;
+			profit_percent?: number;
+			place_tp?: boolean;
+			profit?: number;
+		};
+	}): Promise<ScheduledTrade | import("pocketbase").RecordModel>;
+	updateTargetPnl(): Promise<number>;
+	updateConfigPnl(): Promise<void>;
+	triggerTradeFromConfig(payload: {
+		place?: boolean;
+		raw?: boolean;
+		tp?: boolean;
+		stop?: boolean;
+		use_current?: boolean;
+		ignore_config?: boolean;
+	}): Promise<any>;
+	placeSharedOrder(action: "place_limit_orders" | "place_stop_orders" | "place_tp_orders", payload: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		place?: boolean;
+		update_db?: boolean;
+		raw?: boolean;
+		use_current?: boolean;
+	}): Promise<any>;
+	buildAppConfig(payload: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		profit?: number;
+		update_db?: boolean;
+		profit_percent?: number;
+	}): Promise<AppConfig>;
+	placeConfigOrders(app_config: AppConfig, solution: {
+		risk_reward: number;
+		entry: number;
+		stop: number;
+		risk_per_trade: number;
+		avg_size: number;
+		neg_pnl: number;
+		min_size: number;
+		symbol: string;
+	}, place?: boolean, skip_stop?: boolean): Promise<{
+		entry_orders: {
+			orders: {
+				entry: any;
+				quantity: any;
+				reverse_avg_entry: any;
+				reverse_avg_quantity: any;
+				avg_entry: any;
+				avg_size: any;
+			}[];
+			kind: "long" | "short";
+		};
+		stop_orders: {
+			stop: number;
+			final_stop: number;
+			kind: "long" | "short";
+			quantity: any;
+			is_limit: boolean;
+			neg_pnl: any;
+		};
+		trades: any[];
+	}>;
+	determineAmountToBuy(payload: {
+		orders: any[];
+		kind: "long" | "short";
+		refresh?: boolean;
+		decimal_places?: string;
+		price_places?: string;
+		cancel?: boolean;
+		place?: boolean;
+	}): Promise<any[]>;
+	refresh(live_refresh?: boolean): Promise<{
+		instance: PositionsView;
+		existingOrders: void | import("pocketbase").RecordModel[];
+	}>;
+	placeTrade(payload: {
+		place?: boolean;
+		tp?: boolean;
+		stop?: boolean;
+		raw?: boolean;
+		cancel?: boolean;
+		ignore_config?: boolean;
+	}): Promise<any>;
+}
 declare class ExchangeAccount$1 {
 	private instance;
 	exchange: BaseExchange;
 	main_exchange?: BaseExchange;
 	private app_db;
+	private long_position?;
+	private short_position?;
 	constructor(payload: ExchangeType, options: {
 		exchange: BaseExchange;
 		app_db: AppDatabase;
@@ -751,6 +896,11 @@ declare class ExchangeAccount$1 {
 		refresh?: boolean;
 		refresh_symbol_config?: boolean;
 	}): Promise<import("pocketbase").RecordModel>;
+	initializePositions(payload: {
+		symbol: string;
+		as_view?: boolean;
+		kind: "long" | "short";
+	}): Promise<ExchangePosition>;
 	getActiveAccount(payload: {
 		symbol: string;
 		full?: boolean;
@@ -764,6 +914,16 @@ declare class ExchangeAccount$1 {
 		current_price: any;
 		exchange: any;
 	}>;
+	refreshAccount(payload: {
+		symbol: string;
+		live_refresh?: boolean;
+		leverage?: number;
+	}): Promise<(PositionsView & {
+		expand?: {
+			config: ScheduledTrade;
+			account: ExchangeAccount;
+		};
+	})[]>;
 	syncAccount(options: {
 		symbol: string;
 		kind?: "long" | "short";
@@ -780,9 +940,9 @@ declare class ExchangeAccount$1 {
 	getRunningInstanceFromDB(symbol: string): Promise<TradeBlockTracking>;
 	syncOrders(options: {
 		symbol: string;
-		kind: "long" | "short";
+		kind?: "long" | "short";
 		update?: boolean;
-	}): Promise<import("pocketbase").RecordModel[]>;
+	}): Promise<void | import("pocketbase").RecordModel[]>;
 	toggleStopBuying(payload: {
 		symbol: string;
 		kind: "long" | "short";
@@ -1032,7 +1192,7 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 		revert?: boolean;
-	}): Promise<import("pocketbase").RecordModel[]>;
+	}): Promise<void | import("pocketbase").RecordModel[]>;
 	windDownSymbol(payload: {
 		symbol: string;
 		risk_reward?: number;
@@ -1079,7 +1239,6 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 		type: "limit" | "stop" | "tp";
-		refresh?: boolean;
 	}): Promise<import("pocketbase").RecordModel[]>;
 	syncPositionConfigs(payload: {
 		symbol: string;

package/dist/index.js

@@ -32376,10 +32376,6 @@ class AppDatabase {
   }
   async deleteAndRecreateOrders(account, options, all_orders = []) {
     const { symbol, kind } = options;
-    await this.getOrders(account, {
-      symbol,
-      kind
-    });
     const exchange_db_instance = await this.get_exchange_db_instance(account);
     console.log(`Fetching existing DB orders for ${account.owner}/${account.exchange} - ${symbol} (${options.kind}) to delete...`);
     let pocketbase_ids_to_delete = [];
@@ -32436,6 +32432,59 @@ class AppDatabase {
       kind
     });
   }
+  async deleteAndBulCreateAllOrders(payload) {
+    const { account, symbol, all_orders } = payload;
+    console.log(`Fetching existing DB orders for ${account.owner}/${account.exchange} - ${symbol} to delete...`);
+    let pocketbase_ids_to_delete = [];
+    try {
+      const db_orders_to_delete = await this.pb.collection("orders").getFullList({
+        filter: `symbol:lower="${symbol.toLowerCase()}" && account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}"`
+      });
+      pocketbase_ids_to_delete = db_orders_to_delete.map((o) => o.id);
+      console.log(`Found ${pocketbase_ids_to_delete.length} existing DB orders to delete.`);
+    } catch (error) {
+      console.error("Error fetching DB orders for deletion:", error);
+    }
+    if (pocketbase_ids_to_delete.length > 0) {
+      console.log(`Deleting ${pocketbase_ids_to_delete.length} existing orders from PocketBase...`);
+      for (let i2 = 0;i2 < pocketbase_ids_to_delete.length; i2 += 5) {
+        const batch_to_delete = pocketbase_ids_to_delete.slice(i2, i2 + 5);
+        try {
+          await Promise.all(batch_to_delete.map((id) => this.pb.collection("orders").delete(id)));
+        } catch (error) {
+          console.error(`Error deleting batch starting at index ${i2}:`, error, "Batch IDs:", batch_to_delete);
+        }
+      }
+      console.log("Finished deleting existing DB orders.");
+    }
+    console.log(`Found ${all_orders.length} current orders on the exchange.`);
+    if (all_orders.length > 0) {
+      console.log(`Recreating ${all_orders.length} orders in PocketBase...`);
+      for (let i2 = 0;i2 < all_orders.length; i2 += 45) {
+        const orderChunk = all_orders.slice(i2, i2 + 45);
+        const batch = this.pb.createBatch();
+        for (const order of orderChunk) {
+          const order_data = {
+            symbol,
+            price: order.price,
+            quantity: order.quantity,
+            kind: order.kind,
+            side: order.side,
+            stop: order.stop || order.triggerPrice || 0,
+            order_id: order.order_id.toString(),
+            account: account.id
+          };
+          batch.collection("orders").create(order_data);
+        }
+        try {
+          await batch.send();
+        } catch (error) {
+          console.error(`Error creating batch starting at index ${i2}:`, error);
+        }
+      }
+      console.log("Finished recreating orders in PocketBase.");
+    }
+  }
   async cancelLimitOrders(payload) {
     const { symbol, kind, account, cancelExchangeOrders } = payload;
     const side = kind === "long" ? "buy" : "sell";
@@ -36252,12 +36301,382 @@ function determine_break_even_price(payload) {
   };
 }
 
+// src/position.ts
+class ExchangePosition {
+  exchange;
+  exchange_account;
+  app_db;
+  instance;
+  constructor(payload) {
+    this.exchange = payload.exchange;
+    this.app_db = payload.app_db;
+    this.instance = payload.instance;
+    this.exchange_account = payload.exchange_account;
+  }
+  get symbol() {
+    return this.instance.symbol;
+  }
+  get kind() {
+    return this.instance.kind;
+  }
+  get account() {
+    return this.instance.account;
+  }
+  async cancelOrders(payload) {
+    const { limit, price: _price } = payload;
+    if (limit) {
+      return await this.app_db.cancelLimitOrders({
+        symbol: this.symbol,
+        kind: this.kind,
+        account: this.account,
+        cancelExchangeOrders: (p) => this.exchange.cancelOrders(p)
+      });
+    }
+    let price = _price || 0;
+    if (!price) {
+      price = this.instance?.take_profit || 0;
+    }
+    let result = await this.app_db.cancelOrders({
+      cancelExchangeOrders: (p) => this.exchange.cancelOrders(p),
+      kind: this.kind,
+      account: this.account,
+      symbol: this.symbol,
+      price
+    });
+    return result;
+  }
+  async getConfig(payload) {
+    if (payload?.params) {
+      const db_position = this.instance;
+      if (db_position) {
+        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(this.instance, params);
+      }
+    }
+    return await this.app_db.getPositionConfig({
+      symbol: this.symbol,
+      kind: this.kind,
+      account: this.account
+    });
+  }
+  async updateTargetPnl() {
+    const position2 = this.instance;
+    if (position2?.expand?.config) {
+      const config = position2.expand.config;
+      let _profit = config.profit;
+      let _profit_percent = config?.profit_percent;
+      if (_profit_percent && (position2?.quantity || 0) > 0) {
+        _profit = to_f(position2.quantity * _profit_percent * position2.entry / 100);
+      }
+      await this.app_db.update_db_position(position2, {
+        target_pnl: _profit
+      });
+      return _profit;
+    }
+    return 0;
+  }
+  async updateConfigPnl() {
+    const position2 = this.instance;
+    if (!position2?.config) {
+      const config = await this.getConfig();
+      if (config) {
+        await this.app_db.update_db_position(position2, { config: config.id });
+        await this.updateTargetPnl();
+        await this.app_db.update_db_position(position2, { config: null });
+      }
+    } else {
+      await this.updateTargetPnl();
+    }
+  }
+  async triggerTradeFromConfig(payload) {
+    const { place = true, stop, use_current, ignore_config } = payload;
+    const position2 = this.instance;
+    const config = await this.getConfig();
+    let condition = ignore_config ? true : position2?.config;
+    if (condition) {
+      let entry = payload.tp ? position2.entry || config.entry : config.entry;
+      const v = stop ? "place_stop_orders" : "place_limit_orders";
+      return await this.placeSharedOrder(v, {
+        entry,
+        stop: config.stop,
+        risk_reward: config.risk_reward,
+        risk: config.risk,
+        place,
+        raw: payload.raw,
+        use_current
+      });
+    }
+  }
+  async placeSharedOrder(action, payload) {
+    const app_config = await this.buildAppConfig({
+      entry: payload.entry,
+      stop: payload.stop,
+      risk_reward: payload.risk_reward,
+      risk: payload.risk,
+      profit: 0,
+      update_db: payload.update_db
+    });
+    const { entry_orders, stop_orders, trades } = await this.placeConfigOrders(app_config, {
+      risk_reward: payload.risk_reward,
+      entry: payload.entry,
+      stop: payload.stop,
+      risk_per_trade: payload.risk,
+      avg_size: 0,
+      neg_pnl: 0,
+      min_size: app_config.min_size,
+      symbol: this.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,
+        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: this.symbol
+        });
+      }
+      return actual_orders_to_buy;
+    }
+    if (action === "place_limit_orders" && payload.place) {
+      let result = await this.exchange.bulkPlaceLimitOrders({
+        orders: trades.map((x) => ({
+          entry: x.entry,
+          quantity: x.quantity
+        })),
+        kind: app_config.kind,
+        price_places: app_config.price_places,
+        decimal_places: app_config.decimal_places,
+        symbol: this.symbol,
+        place: payload.place
+      });
+      await this.exchange_account.getLiveExchangeInstance({
+        symbol: this.symbol,
+        refresh: true
+      });
+      return result;
+    }
+    if (action === "place_stop_orders" && payload.place) {
+      const instance = this.instance;
+      let result = await this.exchange.placeStopOrders({
+        symbol: this.symbol,
+        quantity: payload.use_current ? instance.quantity : trades[0].avg_size,
+        kind: app_config.kind,
+        stop: payload.stop,
+        price_places: app_config.price_places,
+        decimal_places: app_config.decimal_places,
+        place: true
+      });
+      await this.exchange_account.getLiveExchangeInstance({
+        symbol: this.symbol,
+        refresh: true
+      });
+      return result;
+    }
+    return {
+      entry_orders,
+      stop_orders
+    };
+  }
+  async buildAppConfig(payload) {
+    let config = await this.app_db.getSymbolConfigFromDB(this.symbol);
+    const app_config = buildAppConfig(config, {
+      ...payload,
+      symbol: this.symbol
+    });
+    if (payload.update_db) {
+      const db_position = this.instance;
+      if (db_position) {
+        await this.app_db.createOrUpdatePositionConfig(db_position, {
+          entry: payload.entry,
+          stop: payload.stop,
+          risk_reward: payload.risk_reward,
+          risk: payload.risk,
+          profit_percent: payload.profit_percent
+        });
+      }
+    }
+    return app_config;
+  }
+  async placeConfigOrders(app_config, solution, place, skip_stop) {
+    app_config.entry = solution.entry;
+    app_config.stop = solution.stop;
+    app_config.risk_per_trade = solution.risk_per_trade;
+    app_config.min_size = solution.min_size;
+    app_config.risk_reward = solution.risk_reward;
+    const options = {
+      take_profit: null,
+      entry: app_config.entry,
+      stop: app_config.stop,
+      raw_instance: null,
+      risk: app_config.risk_per_trade,
+      no_of_trades: undefined,
+      risk_reward: app_config.risk_reward,
+      kind: app_config.kind,
+      increase: true,
+      gap: app_config.gap,
+      rr: app_config.rr,
+      price_places: app_config.price_places,
+      decimal_places: app_config.decimal_places
+    };
+    const trades = sortedBuildConfig(app_config, options);
+    const entry_orders = {
+      orders: trades.map((x) => ({
+        entry: x.entry,
+        quantity: x.quantity,
+        reverse_avg_entry: x.reverse_avg_entry,
+        reverse_avg_quantity: x.reverse_avg_quantity,
+        avg_entry: x.avg_entry,
+        avg_size: x.avg_size
+      })),
+      kind: app_config.kind
+    };
+    const stop_orders = {
+      stop: solution.stop,
+      final_stop: solution.stop,
+      kind: app_config.kind,
+      quantity: trades[0]?.avg_size,
+      is_limit: true,
+      neg_pnl: trades[0]?.neg_pnl
+    };
+    if (place) {
+      let arr = [
+        this.exchange.bulkPlaceLimitOrders({
+          orders: trades.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: solution.symbol,
+          place
+        })
+      ];
+      if (!skip_stop) {
+        arr.push(this.exchange.placeStopOrders({
+          symbol: solution.symbol,
+          quantity: trades[0].avg_size,
+          kind: app_config.kind,
+          stop: solution.stop,
+          price_places: app_config.price_places,
+          decimal_places: app_config.decimal_places,
+          place
+        }));
+      }
+      await Promise.all(arr);
+    }
+    return {
+      entry_orders,
+      stop_orders,
+      trades
+    };
+  }
+  async determineAmountToBuy(payload) {
+    const { orders, kind, decimal_places = "%.3f", refresh, cancel } = 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 { instance: position2, existingOrders } = await this.refresh(refresh);
+    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 && cancel) {
+      const pp = kind === "long" ? Math.max(...shouldCancel) : Math.min(...shouldCancel);
+      const cancel_orders = await this.cancelOrders({
+        price: pp
+      });
+      console.log("cancel_orders", cancel_orders);
+    }
+    return filteredOrders;
+  }
+  async refresh(live_refresh) {
+    await this.exchange_account.refreshAccount({
+      symbol: this.symbol,
+      live_refresh
+    });
+    const instance = await this.exchange_account.syncAccount({
+      symbol: this.symbol,
+      kind: this.kind,
+      update: true
+    });
+    let existingOrders = await this.exchange_account.syncOrders({
+      symbol: this.symbol,
+      kind: this.kind
+    });
+    return { instance, existingOrders };
+  }
+  async placeTrade(payload) {
+    const { place, tp, raw: _raw, cancel, stop, ignore_config } = payload;
+    if (cancel) {
+      await this.cancelOrders({
+        limit: true
+      });
+    }
+    if (place) {
+      return await this.triggerTradeFromConfig({
+        raw: payload.raw,
+        stop,
+        ignore_config
+      });
+    }
+    const rr = await this.refresh(true);
+    await this.updateTargetPnl();
+    if (tp) {
+      await this.exchange_account.placeProfitAndStop({
+        symbol: this.symbol,
+        trigger: true
+      });
+    }
+    return rr.existingOrders;
+  }
+}
+
 // src/exchange-account.ts
 class ExchangeAccount {
   instance;
   exchange;
   main_exchange;
   app_db;
+  long_position;
+  short_position;
   constructor(payload, options) {
     this.instance = payload;
     this.exchange = options.exchange;
@@ -36297,6 +36716,32 @@ class ExchangeAccount {
     }
     return result;
   }
+  async initializePositions(payload) {
+    const positions = await this.syncAccount({
+      symbol: payload.symbol,
+      as_view: payload.as_view
+    });
+    const raw_positions = await this.syncAccount({
+      symbol: payload.symbol
+    });
+    const long_position = positions.find((x) => x.kind === "long");
+    const short_position = positions.find((x) => x.kind === "short");
+    this.long_position = new ExchangePosition({
+      exchange: this.exchange,
+      exchange_account: this,
+      instance: long_position,
+      app_db: this.app_db,
+      without_view: raw_positions.find((x) => x.kind === "long")
+    });
+    this.short_position = new ExchangePosition({
+      exchange: this.exchange,
+      exchange_account: this,
+      instance: short_position,
+      app_db: this.app_db,
+      without_view: raw_positions.find((x) => x.kind === "short")
+    });
+    return payload.kind === "long" ? this.long_position : this.short_position;
+  }
   async getActiveAccount(payload) {
     const { symbol, full = false, refresh = false } = payload;
     const symbol_config = await this.recomputeSymbolConfig({
@@ -36316,6 +36761,27 @@ class ExchangeAccount {
     }
     return _all.active_account;
   }
+  async refreshAccount(payload) {
+    const { symbol, live_refresh, leverage } = payload;
+    const active_account = await this.getActiveAccount({
+      refresh: live_refresh,
+      symbol
+    });
+    if (leverage) {
+      await this.exchange.setLeverage({ symbol, leverage });
+    }
+    const db_positions = await this.app_db.createOrUpdatePositions(this.instance, {
+      symbol,
+      long_position: active_account.position.long,
+      short_position: active_account.position.short,
+      usd_balance: active_account.usd_balance || 0
+    });
+    await this.syncOrders({
+      symbol,
+      update: true
+    });
+    return db_positions;
+  }
   async syncAccount(options) {
     const { symbol, update = false, live_refresh = false } = options;
     if (!update) {
@@ -36330,18 +36796,10 @@ class ExchangeAccount {
       }
       return db_positions2;
     }
-    const active_account = await this.getActiveAccount({
-      refresh: live_refresh,
-      symbol
-    });
-    if (options.leverage) {
-      await this.exchange.setLeverage({ symbol, leverage: options.leverage });
-    }
-    const db_positions = await this.app_db.createOrUpdatePositions(this.instance, {
+    const db_positions = await this.refreshAccount({
       symbol,
-      long_position: active_account.position.long,
-      short_position: active_account.position.short,
-      usd_balance: active_account.usd_balance || 0
+      live_refresh,
+      leverage: options.leverage
     });
     if (options.kind) {
       return db_positions.find((x) => x.kind === options.kind);
@@ -36353,7 +36811,7 @@ class ExchangeAccount {
   }
   async syncOrders(options) {
     const { symbol, update = false, kind } = options;
-    if (!update) {
+    if (!update && kind) {
       const db_orders = await this.app_db.getOrders(this.instance, {
         symbol: options.symbol,
         kind: options.kind
@@ -36363,14 +36821,16 @@ class ExchangeAccount {
     const active_account = await this.getActiveAccount({
       symbol
     });
-    const orders = kind === "long" ? active_account.orders.long.entries : active_account.orders.short.entries;
-    const stop_orders = kind === "long" ? active_account.orders.long.stop_orders : active_account.orders.short.stop_orders;
-    const tp_orders = kind === "long" ? active_account.orders.long.tp_orders : active_account.orders.short.tp_orders;
+    const orders = active_account.orders.long.entries.concat(active_account.orders.short.entries);
+    const stop_orders = active_account.orders.long.stop_orders.concat(active_account.orders.short.stop_orders);
+    const tp_orders = active_account.orders.long.tp_orders.concat(active_account.orders.short.tp_orders);
     const all_orders = [...orders, ...stop_orders, ...tp_orders];
-    return this.app_db.deleteAndRecreateOrders(this.instance, {
+    const exchange_db_instance = await this.app_db.get_exchange_db_instance(this.instance);
+    return this.app_db.deleteAndBulCreateAllOrders({
+      account: exchange_db_instance,
       symbol,
-      kind
-    }, all_orders);
+      all_orders
+    });
   }
   async toggleStopBuying(payload) {
     const { symbol, kind, should_stop = false } = payload;
@@ -36398,11 +36858,7 @@ class ExchangeAccount {
   async cancelOrders(payload) {
     const { symbol, kind, price: _price, all, stop, limit } = payload;
     let price = _price || 0;
-    await this.getLiveExchangeInstance({
-      symbol,
-      refresh: true
-    });
-    await this.syncOrders({
+    await this.syncAccount({
       symbol,
       kind,
       update: true
@@ -36630,8 +37086,7 @@ class ExchangeAccount {
     });
     let existingOrders = await this.syncOrders({
       symbol,
-      kind,
-      update: true
+      kind
     });
     let filteredOrders = withCumulative.filter((order) => (order.cumulative_quantity || 0) > position2?.quantity).map((order) => ({
       ...order,
@@ -36947,16 +37402,6 @@ class ExchangeAccount {
       symbol,
       update: true
     });
-    await this.syncOrders({
-      symbol,
-      kind: "long",
-      update: true
-    });
-    await this.syncOrders({
-      symbol,
-      kind: "short",
-      update: true
-    });
     const long_position = db_positions.find((x) => x.kind === "long");
     const short_position = db_positions.find((x) => x.kind === "short");
     if (long_position && long_position.quantity === 0) {
@@ -37033,11 +37478,6 @@ class ExchangeAccount {
   }
   async build_short_order(payload) {
     const { symbol, kind } = payload;
-    await this.syncOrders({
-      symbol,
-      kind,
-      update: true
-    });
     const position2 = await this.syncAccount({
       symbol,
       kind,
@@ -37118,6 +37558,11 @@ class ExchangeAccount {
       price_places: symbol_config.price_places,
       decimal_places: symbol_config.decimal_places
     });
+    await this.syncAccount({
+      symbol,
+      update: true,
+      live_refresh: true
+    });
   }
   async placeSingleOrder(payload) {
     const { symbol, kind } = payload;
@@ -37177,11 +37622,6 @@ class ExchangeAccount {
   }
   async verifyStopLoss(payload) {
     const { symbol, kind, revert } = payload;
-    await this.syncOrders({
-      symbol,
-      kind,
-      update: true
-    });
     let original = null;
     if (revert) {
       original = await this.getOriginalPlannedStop({
@@ -37203,17 +37643,11 @@ class ExchangeAccount {
       });
       return await this.syncOrders({
         symbol,
-        kind,
-        update: true
+        kind
       });
     }
     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,
@@ -37224,11 +37658,6 @@ class ExchangeAccount {
         kind: opposite_kind,
         trigger: true
       });
-      await this.syncOrders({
-        symbol,
-        kind,
-        update: true
-      });
     }
   }
   async windDownSymbol(payload) {
@@ -37506,8 +37935,7 @@ class ExchangeAccount {
     const orders = await this.getOrders({
       symbol,
       kind: "short",
-      type: "limit",
-      refresh: true
+      type: "limit"
     });
     if (orders.length > 0) {
       await this.toggleStopBuying({
@@ -37558,16 +37986,6 @@ class ExchangeAccount {
         symbol,
         update: true
       });
-      await this.syncOrders({
-        symbol,
-        kind: "long",
-        update: true
-      });
-      await this.syncOrders({
-        symbol,
-        kind: "short",
-        update: true
-      });
     }
   }
   async updateAllPositionsWithNoConfig(payload) {
@@ -37683,13 +38101,7 @@ class ExchangeAccount {
     }
   }
   async getOrders(payload) {
-    const { symbol, kind, type, refresh = false } = payload;
-    if (refresh) {
-      await this.syncOrders({
-        symbol,
-        kind
-      });
-    }
+    const { symbol, kind, type } = payload;
     let side;
     if (kind == "long") {
       if (type === "limit") {
@@ -37949,8 +38361,7 @@ class ExchangeAccount {
     });
     const result = await this.syncOrders({
       symbol,
-      kind,
-      update: true
+      kind
     });
     await this.updateTargetPnl({
       symbol,
@@ -38078,13 +38489,6 @@ class App {
       kind: payload.kind,
       update: true
     });
-    if (payload.kind) {
-      await exchange_account.syncOrders({
-        symbol: payload.symbol,
-        kind: payload.kind,
-        update: true
-      });
-    }
     await this.app_db.updateRunningInstance(db_running_instance.id, false);
     return true;
   }
@@ -38269,6 +38673,7 @@ class App {
         symbol: position2.symbol,
         kind: position2.kind
       });
+      await new Promise((resolve) => setTimeout(resolve, 5000));
       console.log("result", result);
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gbozee/ultimate",
   "type": "module",
-  "version": "0.0.2-40",
+  "version": "0.0.2-43",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",