@gbozee/ultimate 0.0.2-40 → 0.0.2-45

package/dist/frontend-index.d.ts

@@ -277,5 +277,14 @@ export declare function determine_break_even_price(payload: {
 	price: number;
 	direction: string;
 };
+export declare function determine_amount_to_buy(payload: {
+	orders: any[];
+	kind: "long" | "short";
+	decimal_places?: string;
+	price_places?: string;
+	place?: boolean;
+	position: any;
+	existingOrders: any[];
+}): any[];
 
 export {};

package/dist/frontend-index.js

@@ -1317,6 +1317,38 @@ function determine_break_even_price(payload) {
     direction: net_quantity > 0 ? "long" : "short"
   };
 }
+function determine_amount_to_buy(payload) {
+  const {
+    orders,
+    kind,
+    decimal_places = "%.3f",
+    position: position2,
+    existingOrders
+  } = payload;
+  const totalQuantity = orders.reduce((sum, order) => sum + (order.quantity || 0), 0);
+  let runningTotal = to_f2(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_f2(runningTotal, decimal_places);
+  }
+  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));
+  return filteredOrders;
+}
 export {
   sortedBuildConfig,
   get_app_config_and_max_size,
@@ -1324,6 +1356,7 @@ export {
   generate_config_params,
   determine_break_even_price,
   determine_average_entry_and_size,
+  determine_amount_to_buy,
   createArray,
   buildConfig,
   buildAvg,

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,149 @@ export declare function determine_break_even_price(payload: {
 	price: number;
 	direction: string;
 };
+export declare function determine_amount_to_buy(payload: {
+	orders: any[];
+	kind: "long" | "short";
+	decimal_places?: string;
+	price_places?: string;
+	place?: boolean;
+	position: any;
+	existingOrders: any[];
+}): any[];
+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 +905,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 +923,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 +949,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 +1201,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 +1248,6 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 		type: "limit" | "stop" | "tp";
-		refresh?: boolean;
 	}): Promise<import("pocketbase").RecordModel[]>;
 	syncPositionConfigs(payload: {
 		symbol: string;
@@ -1242,6 +1410,7 @@ export declare function initApp(payload: {
 	proxy?: any;
 	ignore_proxy?: boolean;
 	canWithdraw?: boolean;
+	triggerToken?: string;
 }): Promise<App>;
 export declare function initialize(payload: {
 	password?: string;