@gbozee/ultimate 0.0.2-73 → 0.0.2-75

package/dist/frontend-index.d.ts

@@ -402,6 +402,19 @@ export type StrategyPosition = {
 	entry: number;
 	quantity: number;
 };
+export type GapCloserResult = {
+	avg_entry: number;
+	avg_size: number;
+	loss: number;
+	stop: number;
+	stop_quantity: number;
+	re_entry_quantity: number;
+	initial_pnl: number;
+	tp: number;
+	incurred_loss: number;
+	pnl: number;
+	remaining_quantity: number;
+};
 export type Config = {
 	tp_percent: number;
 	short_tp_factor: number;
@@ -438,25 +451,54 @@ export declare class Strategy {
 	get short_tp(): number;
 	generateGapClosingAlgorithm(payload: {
 		kind: "long" | "short";
+		ignore_entries?: boolean;
+		reduce_ratio?: number;
+		sell_factor?: number;
 	}): {
-		[x: string]: any;
-		risk: number;
-		risk_reward: number;
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: GapCloserResult;
+		short: GapCloserResult;
+	};
+	gapCloserHelper(payload: {
+		risk: number;
+		entries?: any[];
+		kind: "long" | "short";
+		sell_factor?: number;
+		reduce_ratio?: number;
+	}): {
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: GapCloserResult;
+		short: GapCloserResult;
 	};
 	runIterations(payload: {
 		kind: "long" | "short";
 		iterations: number;
 		risk_reward?: number;
+		ignore_entries?: boolean;
+		reduce_ratio?: number;
+		sell_factor?: number;
 	}): {
-		[x: string]: any;
-		risk: number;
-		risk_reward: number;
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: GapCloserResult;
+		short: GapCloserResult;
 	}[];
 	getPositionAfterTp(payload: {
 		kind: "long" | "short";

package/dist/frontend-index.js

@@ -1830,16 +1830,18 @@ class Strategy {
     return this.tp("short");
   }
   generateGapClosingAlgorithm(payload) {
-    const { kind } = payload;
+    const {
+      kind,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const { entry, quantity } = this.position[kind];
     const focus_position = this.position[kind];
     const reverse_kind = kind == "long" ? "short" : "long";
     const reverse_position = this.position[reverse_kind];
     let _entry = this.tp(kind);
     let _stop = this.tp(reverse_kind);
-    if (!_entry && !_stop) {
-      return null;
-    }
     const second_payload = {
       entry: _entry,
       stop: _stop,
@@ -1854,11 +1856,60 @@ class Strategy {
     };
     console.log({ second_payload, third_payload });
     const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
-    if (!app_config) {
-      return null;
+    let entries = [];
+    let risk_per_trade = this.config.budget;
+    let last_value = null;
+    if (app_config) {
+      let { entries: _entries, ...rest } = app_config;
+      entries = _entries;
+      risk_per_trade = rest.risk_per_trade;
+      last_value = rest.last_value;
+      if (ignore_entries) {
+        entries = [];
+      }
     }
-    const { entries, ...rest } = app_config;
-    const risk = this.to_f(rest.risk_per_trade);
+    const risk = this.to_f(risk_per_trade);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < (reverse_position.entry || focus_position.entry);
+    }) : entries.filter((u) => {
+      return u.entry > (reverse_position.entry || focus_position.entry);
+    });
+    const threshold = below_reverse_entries.at(-1);
+    const result = this.gapCloserHelper({
+      risk,
+      entries,
+      kind,
+      sell_factor,
+      reduce_ratio
+    });
+    return {
+      ...result,
+      last_entry: last_value?.entry,
+      first_entry: entries.at(-1)?.entry,
+      threshold
+    };
+  }
+  gapCloserHelper(payload) {
+    const {
+      risk,
+      entries = [],
+      kind,
+      sell_factor = 1,
+      reduce_ratio = 1
+    } = payload;
+    const { entry, quantity } = this.position[kind];
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    let _entry = this.tp(kind);
+    let _stop = this.tp(reverse_kind);
+    const second_payload = {
+      entry: _entry,
+      stop: _stop,
+      risk_reward: this.config.risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
       if (focus_position.quantity > 0) {
@@ -1878,8 +1929,8 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const focus_loss = this.to_f(Math.abs(avg.price - second_payload.stop) * avg.quantity);
     let below_reverse_entries = kind === "long" ? entries.filter((u) => {
       return u.entry < (reverse_position.entry || focus_position.entry);
     }) : entries.filter((u) => {
@@ -1905,19 +1956,21 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const reverse_pnl = this.to_f((reverse_avg.price - second_payload.stop) * reverse_avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const sell_quantity = this.to_df(reverse_avg.quantity * sell_factor);
+    const reverse_pnl = this.to_f(Math.abs(reverse_avg.price - second_payload.stop) * sell_quantity);
     const fee_to_pay = this.calculate_fee({
       price: avg.entry,
       quantity: avg.quantity
     }) + this.calculate_fee({
       price: reverse_avg.entry,
-      quantity: reverse_avg.quantity
+      quantity: sell_quantity
     });
     const net_reverse_pnl = reverse_pnl - fee_to_pay;
-    const ratio = net_reverse_pnl / focus_loss;
+    const ratio = net_reverse_pnl * reduce_ratio / focus_loss;
     const quantity_to_sell = this.to_df(ratio * avg.quantity);
     const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    const incurred_loss = this.to_f((avg.price - second_payload.stop) * quantity_to_sell);
     return {
       risk,
       risk_reward: this.config.risk_reward,
@@ -1929,7 +1982,8 @@ class Strategy {
         stop_quantity: quantity_to_sell,
         re_entry_quantity: remaining_quantity,
         initial_pnl: this.pnl(kind),
-        tp: second_payload.entry
+        tp: second_payload.entry,
+        incurred_loss
       },
       [reverse_kind]: {
         avg_entry: reverse_avg.entry,
@@ -1937,32 +1991,45 @@ class Strategy {
         pnl: reverse_pnl,
         tp: second_payload.stop,
         re_entry_quantity: remaining_quantity,
-        initial_pnl: this.pnl(reverse_kind)
+        initial_pnl: this.pnl(reverse_kind),
+        remaining_quantity: this.to_df(reverse_avg.quantity - sell_quantity)
       },
-      last_entry: rest.last_value.entry,
-      first_entry: entries.at(-1).entry,
-      threshold
+      spread: Math.abs(avg.entry - reverse_avg.entry),
+      gap_loss: to_f(Math.abs(avg.entry - reverse_avg.entry) * reverse_avg.quantity, "%.2f"),
+      net_profit: incurred_loss + reverse_pnl
     };
   }
   runIterations(payload) {
-    const { kind, iterations } = payload;
+    const {
+      kind,
+      iterations,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const reverse_kind = kind == "long" ? "short" : "long";
     const result = [];
     let position2 = {
       long: this.position.long,
       short: this.position.short
     };
+    let tp_percent_multiplier = 1;
+    let short_tp_factor_multiplier = 1;
     for (let i = 0;i < iterations; i++) {
       const instance = new Strategy({
         long: position2.long,
         short: position2.short,
         config: {
           ...this.config,
-          tp_percent: this.config.tp_percent + i * 4
+          tp_percent: this.config.tp_percent * tp_percent_multiplier,
+          short_tp_factor: this.config.short_tp_factor * short_tp_factor_multiplier
         }
       });
       const algorithm = instance.generateGapClosingAlgorithm({
-        kind
+        kind,
+        ignore_entries,
+        reduce_ratio,
+        sell_factor
       });
       if (!algorithm) {
         console.log("No algorithm found");
@@ -1974,9 +2041,31 @@ class Strategy {
         entry: algorithm[kind].avg_entry,
         quantity: algorithm[kind].re_entry_quantity
       };
+      let reverse_entry = algorithm[reverse_kind].tp;
+      let reverse_quantity = algorithm[reverse_kind].re_entry_quantity;
+      if (algorithm[reverse_kind].remaining_quantity > 0) {
+        const purchase_to_occur = {
+          price: reverse_entry,
+          quantity: algorithm[reverse_kind].remaining_quantity
+        };
+        const avg = determine_average_entry_and_size([
+          purchase_to_occur,
+          {
+            price: algorithm[reverse_kind].avg_entry,
+            quantity: reverse_quantity - algorithm[reverse_kind].remaining_quantity
+          }
+        ], this.config.global_config.decimal_places, this.config.global_config.price_places);
+        reverse_entry = avg.entry;
+        reverse_quantity = avg.quantity;
+        if (reverse_kind === "short") {
+          short_tp_factor_multiplier = 2;
+        } else {
+          tp_percent_multiplier = 2;
+        }
+      }
       position2[reverse_kind] = {
-        entry: algorithm[reverse_kind].tp,
-        quantity: algorithm[reverse_kind].re_entry_quantity
+        entry: reverse_entry,
+        quantity: reverse_quantity
       };
     }
     return result;

package/dist/index.cjs

@@ -53890,16 +53890,18 @@ class Strategy {
     return this.tp("short");
   }
   generateGapClosingAlgorithm(payload) {
-    const { kind } = payload;
+    const {
+      kind,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const { entry, quantity } = this.position[kind];
     const focus_position = this.position[kind];
     const reverse_kind = kind == "long" ? "short" : "long";
     const reverse_position = this.position[reverse_kind];
     let _entry = this.tp(kind);
     let _stop = this.tp(reverse_kind);
-    if (!_entry && !_stop) {
-      return null;
-    }
     const second_payload = {
       entry: _entry,
       stop: _stop,
@@ -53914,11 +53916,60 @@ class Strategy {
     };
     console.log({ second_payload, third_payload });
     const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
-    if (!app_config) {
-      return null;
-    }
-    const { entries, ...rest } = app_config;
-    const risk = this.to_f(rest.risk_per_trade);
+    let entries = [];
+    let risk_per_trade = this.config.budget;
+    let last_value = null;
+    if (app_config) {
+      let { entries: _entries, ...rest } = app_config;
+      entries = _entries;
+      risk_per_trade = rest.risk_per_trade;
+      last_value = rest.last_value;
+      if (ignore_entries) {
+        entries = [];
+      }
+    }
+    const risk = this.to_f(risk_per_trade);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < (reverse_position.entry || focus_position.entry);
+    }) : entries.filter((u) => {
+      return u.entry > (reverse_position.entry || focus_position.entry);
+    });
+    const threshold = below_reverse_entries.at(-1);
+    const result = this.gapCloserHelper({
+      risk,
+      entries,
+      kind,
+      sell_factor,
+      reduce_ratio
+    });
+    return {
+      ...result,
+      last_entry: last_value?.entry,
+      first_entry: entries.at(-1)?.entry,
+      threshold
+    };
+  }
+  gapCloserHelper(payload) {
+    const {
+      risk,
+      entries = [],
+      kind,
+      sell_factor = 1,
+      reduce_ratio = 1
+    } = payload;
+    const { entry, quantity } = this.position[kind];
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    let _entry = this.tp(kind);
+    let _stop = this.tp(reverse_kind);
+    const second_payload = {
+      entry: _entry,
+      stop: _stop,
+      risk_reward: this.config.risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
       if (focus_position.quantity > 0) {
@@ -53938,8 +53989,8 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const focus_loss = this.to_f(Math.abs(avg.price - second_payload.stop) * avg.quantity);
     let below_reverse_entries = kind === "long" ? entries.filter((u) => {
       return u.entry < (reverse_position.entry || focus_position.entry);
     }) : entries.filter((u) => {
@@ -53965,19 +54016,21 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const reverse_pnl = this.to_f((reverse_avg.price - second_payload.stop) * reverse_avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const sell_quantity = this.to_df(reverse_avg.quantity * sell_factor);
+    const reverse_pnl = this.to_f(Math.abs(reverse_avg.price - second_payload.stop) * sell_quantity);
     const fee_to_pay = this.calculate_fee({
       price: avg.entry,
       quantity: avg.quantity
     }) + this.calculate_fee({
       price: reverse_avg.entry,
-      quantity: reverse_avg.quantity
+      quantity: sell_quantity
     });
     const net_reverse_pnl = reverse_pnl - fee_to_pay;
-    const ratio = net_reverse_pnl / focus_loss;
+    const ratio = net_reverse_pnl * reduce_ratio / focus_loss;
     const quantity_to_sell = this.to_df(ratio * avg.quantity);
     const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    const incurred_loss = this.to_f((avg.price - second_payload.stop) * quantity_to_sell);
     return {
       risk,
       risk_reward: this.config.risk_reward,
@@ -53989,7 +54042,8 @@ class Strategy {
         stop_quantity: quantity_to_sell,
         re_entry_quantity: remaining_quantity,
         initial_pnl: this.pnl(kind),
-        tp: second_payload.entry
+        tp: second_payload.entry,
+        incurred_loss
       },
       [reverse_kind]: {
         avg_entry: reverse_avg.entry,
@@ -53997,32 +54051,45 @@ class Strategy {
         pnl: reverse_pnl,
         tp: second_payload.stop,
         re_entry_quantity: remaining_quantity,
-        initial_pnl: this.pnl(reverse_kind)
+        initial_pnl: this.pnl(reverse_kind),
+        remaining_quantity: this.to_df(reverse_avg.quantity - sell_quantity)
       },
-      last_entry: rest.last_value.entry,
-      first_entry: entries.at(-1).entry,
-      threshold
+      spread: Math.abs(avg.entry - reverse_avg.entry),
+      gap_loss: to_f2(Math.abs(avg.entry - reverse_avg.entry) * reverse_avg.quantity, "%.2f"),
+      net_profit: incurred_loss + reverse_pnl
     };
   }
   runIterations(payload) {
-    const { kind, iterations } = payload;
+    const {
+      kind,
+      iterations,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const reverse_kind = kind == "long" ? "short" : "long";
     const result = [];
     let position2 = {
       long: this.position.long,
       short: this.position.short
     };
+    let tp_percent_multiplier = 1;
+    let short_tp_factor_multiplier = 1;
     for (let i2 = 0;i2 < iterations; i2++) {
       const instance = new Strategy({
         long: position2.long,
         short: position2.short,
         config: {
           ...this.config,
-          tp_percent: this.config.tp_percent + i2 * 4
+          tp_percent: this.config.tp_percent * tp_percent_multiplier,
+          short_tp_factor: this.config.short_tp_factor * short_tp_factor_multiplier
         }
       });
       const algorithm = instance.generateGapClosingAlgorithm({
-        kind
+        kind,
+        ignore_entries,
+        reduce_ratio,
+        sell_factor
       });
       if (!algorithm) {
         console.log("No algorithm found");
@@ -54034,9 +54101,31 @@ class Strategy {
         entry: algorithm[kind].avg_entry,
         quantity: algorithm[kind].re_entry_quantity
       };
+      let reverse_entry = algorithm[reverse_kind].tp;
+      let reverse_quantity = algorithm[reverse_kind].re_entry_quantity;
+      if (algorithm[reverse_kind].remaining_quantity > 0) {
+        const purchase_to_occur = {
+          price: reverse_entry,
+          quantity: algorithm[reverse_kind].remaining_quantity
+        };
+        const avg = determine_average_entry_and_size([
+          purchase_to_occur,
+          {
+            price: algorithm[reverse_kind].avg_entry,
+            quantity: reverse_quantity - algorithm[reverse_kind].remaining_quantity
+          }
+        ], this.config.global_config.decimal_places, this.config.global_config.price_places);
+        reverse_entry = avg.entry;
+        reverse_quantity = avg.quantity;
+        if (reverse_kind === "short") {
+          short_tp_factor_multiplier = 2;
+        } else {
+          tp_percent_multiplier = 2;
+        }
+      }
       position2[reverse_kind] = {
-        entry: algorithm[reverse_kind].tp,
-        quantity: algorithm[reverse_kind].re_entry_quantity
+        entry: reverse_entry,
+        quantity: reverse_quantity
       };
     }
     return result;
@@ -57669,6 +57758,9 @@ class ExchangeAccount {
     if (threshold_qty > 0 && track_position.quantity >= threshold_qty) {
       should_place_order = true;
     }
+    if (focus_position.quantity === 0) {
+      should_place_order = true;
+    }
     if (track_position.quantity !== focus_position.quantity && focus_position.quantity < track_position.quantity && should_place_order) {
       const remaining_quantity = Math.abs(track_position.quantity - focus_position.quantity);
       await this.placeMarketOrder({

package/dist/index.d.ts

@@ -528,6 +528,19 @@ export type StrategyPosition = {
 	entry: number;
 	quantity: number;
 };
+export type GapCloserResult = {
+	avg_entry: number;
+	avg_size: number;
+	loss: number;
+	stop: number;
+	stop_quantity: number;
+	re_entry_quantity: number;
+	initial_pnl: number;
+	tp: number;
+	incurred_loss: number;
+	pnl: number;
+	remaining_quantity: number;
+};
 export type Config = {
 	tp_percent: number;
 	short_tp_factor: number;
@@ -564,25 +577,54 @@ export declare class Strategy {
 	get short_tp(): number;
 	generateGapClosingAlgorithm(payload: {
 		kind: "long" | "short";
+		ignore_entries?: boolean;
+		reduce_ratio?: number;
+		sell_factor?: number;
 	}): {
-		[x: string]: any;
-		risk: number;
-		risk_reward: number;
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: GapCloserResult;
+		short: GapCloserResult;
+	};
+	gapCloserHelper(payload: {
+		risk: number;
+		entries?: any[];
+		kind: "long" | "short";
+		sell_factor?: number;
+		reduce_ratio?: number;
+	}): {
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: GapCloserResult;
+		short: GapCloserResult;
 	};
 	runIterations(payload: {
 		kind: "long" | "short";
 		iterations: number;
 		risk_reward?: number;
+		ignore_entries?: boolean;
+		reduce_ratio?: number;
+		sell_factor?: number;
 	}): {
-		[x: string]: any;
-		risk: number;
-		risk_reward: number;
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: GapCloserResult;
+		short: GapCloserResult;
 	}[];
 	getPositionAfterTp(payload: {
 		kind: "long" | "short";
@@ -1457,12 +1499,40 @@ declare class ExchangeAccount$1 {
 		iterations?: number;
 		raw?: boolean;
 	}): Promise<Strategy | {
-		[x: string]: any;
-		risk: number;
-		risk_reward: number;
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		risk: number;
+		risk_reward: number;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
+		long: {
+			avg_entry: number;
+			avg_size: number;
+			loss: number;
+			stop: number;
+			stop_quantity: number;
+			re_entry_quantity: number;
+			initial_pnl: number;
+			tp: number;
+			incurred_loss: number;
+			pnl: number;
+			remaining_quantity: number;
+		};
+		short: {
+			avg_entry: number;
+			avg_size: number;
+			loss: number;
+			stop: number;
+			stop_quantity: number;
+			re_entry_quantity: number;
+			initial_pnl: number;
+			tp: number;
+			incurred_loss: number;
+			pnl: number;
+			remaining_quantity: number;
+		};
 	}[]>;
 	getCurrentRun(payload: {
 		symbol: string;

package/dist/index.js

@@ -53845,16 +53845,18 @@ class Strategy {
     return this.tp("short");
   }
   generateGapClosingAlgorithm(payload) {
-    const { kind } = payload;
+    const {
+      kind,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const { entry, quantity } = this.position[kind];
     const focus_position = this.position[kind];
     const reverse_kind = kind == "long" ? "short" : "long";
     const reverse_position = this.position[reverse_kind];
     let _entry = this.tp(kind);
     let _stop = this.tp(reverse_kind);
-    if (!_entry && !_stop) {
-      return null;
-    }
     const second_payload = {
       entry: _entry,
       stop: _stop,
@@ -53869,11 +53871,60 @@ class Strategy {
     };
     console.log({ second_payload, third_payload });
     const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
-    if (!app_config) {
-      return null;
-    }
-    const { entries, ...rest } = app_config;
-    const risk = this.to_f(rest.risk_per_trade);
+    let entries = [];
+    let risk_per_trade = this.config.budget;
+    let last_value = null;
+    if (app_config) {
+      let { entries: _entries, ...rest } = app_config;
+      entries = _entries;
+      risk_per_trade = rest.risk_per_trade;
+      last_value = rest.last_value;
+      if (ignore_entries) {
+        entries = [];
+      }
+    }
+    const risk = this.to_f(risk_per_trade);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < (reverse_position.entry || focus_position.entry);
+    }) : entries.filter((u) => {
+      return u.entry > (reverse_position.entry || focus_position.entry);
+    });
+    const threshold = below_reverse_entries.at(-1);
+    const result = this.gapCloserHelper({
+      risk,
+      entries,
+      kind,
+      sell_factor,
+      reduce_ratio
+    });
+    return {
+      ...result,
+      last_entry: last_value?.entry,
+      first_entry: entries.at(-1)?.entry,
+      threshold
+    };
+  }
+  gapCloserHelper(payload) {
+    const {
+      risk,
+      entries = [],
+      kind,
+      sell_factor = 1,
+      reduce_ratio = 1
+    } = payload;
+    const { entry, quantity } = this.position[kind];
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    let _entry = this.tp(kind);
+    let _stop = this.tp(reverse_kind);
+    const second_payload = {
+      entry: _entry,
+      stop: _stop,
+      risk_reward: this.config.risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
       if (focus_position.quantity > 0) {
@@ -53893,8 +53944,8 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const focus_loss = this.to_f(Math.abs(avg.price - second_payload.stop) * avg.quantity);
     let below_reverse_entries = kind === "long" ? entries.filter((u) => {
       return u.entry < (reverse_position.entry || focus_position.entry);
     }) : entries.filter((u) => {
@@ -53920,19 +53971,21 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const reverse_pnl = this.to_f((reverse_avg.price - second_payload.stop) * reverse_avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const sell_quantity = this.to_df(reverse_avg.quantity * sell_factor);
+    const reverse_pnl = this.to_f(Math.abs(reverse_avg.price - second_payload.stop) * sell_quantity);
     const fee_to_pay = this.calculate_fee({
       price: avg.entry,
       quantity: avg.quantity
     }) + this.calculate_fee({
       price: reverse_avg.entry,
-      quantity: reverse_avg.quantity
+      quantity: sell_quantity
     });
     const net_reverse_pnl = reverse_pnl - fee_to_pay;
-    const ratio = net_reverse_pnl / focus_loss;
+    const ratio = net_reverse_pnl * reduce_ratio / focus_loss;
     const quantity_to_sell = this.to_df(ratio * avg.quantity);
     const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    const incurred_loss = this.to_f((avg.price - second_payload.stop) * quantity_to_sell);
     return {
       risk,
       risk_reward: this.config.risk_reward,
@@ -53944,7 +53997,8 @@ class Strategy {
         stop_quantity: quantity_to_sell,
         re_entry_quantity: remaining_quantity,
         initial_pnl: this.pnl(kind),
-        tp: second_payload.entry
+        tp: second_payload.entry,
+        incurred_loss
       },
       [reverse_kind]: {
         avg_entry: reverse_avg.entry,
@@ -53952,32 +54006,45 @@ class Strategy {
         pnl: reverse_pnl,
         tp: second_payload.stop,
         re_entry_quantity: remaining_quantity,
-        initial_pnl: this.pnl(reverse_kind)
+        initial_pnl: this.pnl(reverse_kind),
+        remaining_quantity: this.to_df(reverse_avg.quantity - sell_quantity)
       },
-      last_entry: rest.last_value.entry,
-      first_entry: entries.at(-1).entry,
-      threshold
+      spread: Math.abs(avg.entry - reverse_avg.entry),
+      gap_loss: to_f2(Math.abs(avg.entry - reverse_avg.entry) * reverse_avg.quantity, "%.2f"),
+      net_profit: incurred_loss + reverse_pnl
     };
   }
   runIterations(payload) {
-    const { kind, iterations } = payload;
+    const {
+      kind,
+      iterations,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const reverse_kind = kind == "long" ? "short" : "long";
     const result = [];
     let position2 = {
       long: this.position.long,
       short: this.position.short
     };
+    let tp_percent_multiplier = 1;
+    let short_tp_factor_multiplier = 1;
     for (let i2 = 0;i2 < iterations; i2++) {
       const instance = new Strategy({
         long: position2.long,
         short: position2.short,
         config: {
           ...this.config,
-          tp_percent: this.config.tp_percent + i2 * 4
+          tp_percent: this.config.tp_percent * tp_percent_multiplier,
+          short_tp_factor: this.config.short_tp_factor * short_tp_factor_multiplier
         }
       });
       const algorithm = instance.generateGapClosingAlgorithm({
-        kind
+        kind,
+        ignore_entries,
+        reduce_ratio,
+        sell_factor
       });
       if (!algorithm) {
         console.log("No algorithm found");
@@ -53989,9 +54056,31 @@ class Strategy {
         entry: algorithm[kind].avg_entry,
         quantity: algorithm[kind].re_entry_quantity
       };
+      let reverse_entry = algorithm[reverse_kind].tp;
+      let reverse_quantity = algorithm[reverse_kind].re_entry_quantity;
+      if (algorithm[reverse_kind].remaining_quantity > 0) {
+        const purchase_to_occur = {
+          price: reverse_entry,
+          quantity: algorithm[reverse_kind].remaining_quantity
+        };
+        const avg = determine_average_entry_and_size([
+          purchase_to_occur,
+          {
+            price: algorithm[reverse_kind].avg_entry,
+            quantity: reverse_quantity - algorithm[reverse_kind].remaining_quantity
+          }
+        ], this.config.global_config.decimal_places, this.config.global_config.price_places);
+        reverse_entry = avg.entry;
+        reverse_quantity = avg.quantity;
+        if (reverse_kind === "short") {
+          short_tp_factor_multiplier = 2;
+        } else {
+          tp_percent_multiplier = 2;
+        }
+      }
       position2[reverse_kind] = {
-        entry: algorithm[reverse_kind].tp,
-        quantity: algorithm[reverse_kind].re_entry_quantity
+        entry: reverse_entry,
+        quantity: reverse_quantity
       };
     }
     return result;
@@ -57624,6 +57713,9 @@ class ExchangeAccount {
     if (threshold_qty > 0 && track_position.quantity >= threshold_qty) {
       should_place_order = true;
     }
+    if (focus_position.quantity === 0) {
+      should_place_order = true;
+    }
     if (track_position.quantity !== focus_position.quantity && focus_position.quantity < track_position.quantity && should_place_order) {
       const remaining_quantity = Math.abs(track_position.quantity - focus_position.quantity);
       await this.placeMarketOrder({

package/dist/mcp-server.cjs

@@ -60581,16 +60581,18 @@ class Strategy {
     return this.tp("short");
   }
   generateGapClosingAlgorithm(payload) {
-    const { kind } = payload;
+    const {
+      kind,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const { entry, quantity } = this.position[kind];
     const focus_position = this.position[kind];
     const reverse_kind = kind == "long" ? "short" : "long";
     const reverse_position = this.position[reverse_kind];
     let _entry = this.tp(kind);
     let _stop = this.tp(reverse_kind);
-    if (!_entry && !_stop) {
-      return null;
-    }
     const second_payload = {
       entry: _entry,
       stop: _stop,
@@ -60605,11 +60607,60 @@ class Strategy {
     };
     console.log({ second_payload, third_payload });
     const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
-    if (!app_config) {
-      return null;
-    }
-    const { entries, ...rest } = app_config;
-    const risk = this.to_f(rest.risk_per_trade);
+    let entries = [];
+    let risk_per_trade = this.config.budget;
+    let last_value = null;
+    if (app_config) {
+      let { entries: _entries, ...rest } = app_config;
+      entries = _entries;
+      risk_per_trade = rest.risk_per_trade;
+      last_value = rest.last_value;
+      if (ignore_entries) {
+        entries = [];
+      }
+    }
+    const risk = this.to_f(risk_per_trade);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < (reverse_position.entry || focus_position.entry);
+    }) : entries.filter((u) => {
+      return u.entry > (reverse_position.entry || focus_position.entry);
+    });
+    const threshold = below_reverse_entries.at(-1);
+    const result = this.gapCloserHelper({
+      risk,
+      entries,
+      kind,
+      sell_factor,
+      reduce_ratio
+    });
+    return {
+      ...result,
+      last_entry: last_value?.entry,
+      first_entry: entries.at(-1)?.entry,
+      threshold
+    };
+  }
+  gapCloserHelper(payload) {
+    const {
+      risk,
+      entries = [],
+      kind,
+      sell_factor = 1,
+      reduce_ratio = 1
+    } = payload;
+    const { entry, quantity } = this.position[kind];
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    let _entry = this.tp(kind);
+    let _stop = this.tp(reverse_kind);
+    const second_payload = {
+      entry: _entry,
+      stop: _stop,
+      risk_reward: this.config.risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
       if (focus_position.quantity > 0) {
@@ -60629,8 +60680,8 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const focus_loss = this.to_f(Math.abs(avg.price - second_payload.stop) * avg.quantity);
     let below_reverse_entries = kind === "long" ? entries.filter((u) => {
       return u.entry < (reverse_position.entry || focus_position.entry);
     }) : entries.filter((u) => {
@@ -60656,19 +60707,21 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const reverse_pnl = this.to_f((reverse_avg.price - second_payload.stop) * reverse_avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const sell_quantity = this.to_df(reverse_avg.quantity * sell_factor);
+    const reverse_pnl = this.to_f(Math.abs(reverse_avg.price - second_payload.stop) * sell_quantity);
     const fee_to_pay = this.calculate_fee({
       price: avg.entry,
       quantity: avg.quantity
     }) + this.calculate_fee({
       price: reverse_avg.entry,
-      quantity: reverse_avg.quantity
+      quantity: sell_quantity
     });
     const net_reverse_pnl = reverse_pnl - fee_to_pay;
-    const ratio = net_reverse_pnl / focus_loss;
+    const ratio = net_reverse_pnl * reduce_ratio / focus_loss;
     const quantity_to_sell = this.to_df(ratio * avg.quantity);
     const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    const incurred_loss = this.to_f((avg.price - second_payload.stop) * quantity_to_sell);
     return {
       risk,
       risk_reward: this.config.risk_reward,
@@ -60680,7 +60733,8 @@ class Strategy {
         stop_quantity: quantity_to_sell,
         re_entry_quantity: remaining_quantity,
         initial_pnl: this.pnl(kind),
-        tp: second_payload.entry
+        tp: second_payload.entry,
+        incurred_loss
       },
       [reverse_kind]: {
         avg_entry: reverse_avg.entry,
@@ -60688,32 +60742,45 @@ class Strategy {
         pnl: reverse_pnl,
         tp: second_payload.stop,
         re_entry_quantity: remaining_quantity,
-        initial_pnl: this.pnl(reverse_kind)
+        initial_pnl: this.pnl(reverse_kind),
+        remaining_quantity: this.to_df(reverse_avg.quantity - sell_quantity)
       },
-      last_entry: rest.last_value.entry,
-      first_entry: entries.at(-1).entry,
-      threshold
+      spread: Math.abs(avg.entry - reverse_avg.entry),
+      gap_loss: to_f2(Math.abs(avg.entry - reverse_avg.entry) * reverse_avg.quantity, "%.2f"),
+      net_profit: incurred_loss + reverse_pnl
     };
   }
   runIterations(payload) {
-    const { kind, iterations } = payload;
+    const {
+      kind,
+      iterations,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const reverse_kind = kind == "long" ? "short" : "long";
     const result = [];
     let position2 = {
       long: this.position.long,
       short: this.position.short
     };
+    let tp_percent_multiplier = 1;
+    let short_tp_factor_multiplier = 1;
     for (let i2 = 0;i2 < iterations; i2++) {
       const instance = new Strategy({
         long: position2.long,
         short: position2.short,
         config: {
           ...this.config,
-          tp_percent: this.config.tp_percent + i2 * 4
+          tp_percent: this.config.tp_percent * tp_percent_multiplier,
+          short_tp_factor: this.config.short_tp_factor * short_tp_factor_multiplier
         }
       });
       const algorithm = instance.generateGapClosingAlgorithm({
-        kind
+        kind,
+        ignore_entries,
+        reduce_ratio,
+        sell_factor
       });
       if (!algorithm) {
         console.log("No algorithm found");
@@ -60725,9 +60792,31 @@ class Strategy {
         entry: algorithm[kind].avg_entry,
         quantity: algorithm[kind].re_entry_quantity
       };
+      let reverse_entry = algorithm[reverse_kind].tp;
+      let reverse_quantity = algorithm[reverse_kind].re_entry_quantity;
+      if (algorithm[reverse_kind].remaining_quantity > 0) {
+        const purchase_to_occur = {
+          price: reverse_entry,
+          quantity: algorithm[reverse_kind].remaining_quantity
+        };
+        const avg = determine_average_entry_and_size([
+          purchase_to_occur,
+          {
+            price: algorithm[reverse_kind].avg_entry,
+            quantity: reverse_quantity - algorithm[reverse_kind].remaining_quantity
+          }
+        ], this.config.global_config.decimal_places, this.config.global_config.price_places);
+        reverse_entry = avg.entry;
+        reverse_quantity = avg.quantity;
+        if (reverse_kind === "short") {
+          short_tp_factor_multiplier = 2;
+        } else {
+          tp_percent_multiplier = 2;
+        }
+      }
       position2[reverse_kind] = {
-        entry: algorithm[reverse_kind].tp,
-        quantity: algorithm[reverse_kind].re_entry_quantity
+        entry: reverse_entry,
+        quantity: reverse_quantity
       };
     }
     return result;
@@ -64360,6 +64449,9 @@ class ExchangeAccount {
     if (threshold_qty > 0 && track_position.quantity >= threshold_qty) {
       should_place_order = true;
     }
+    if (focus_position.quantity === 0) {
+      should_place_order = true;
+    }
     if (track_position.quantity !== focus_position.quantity && focus_position.quantity < track_position.quantity && should_place_order) {
       const remaining_quantity = Math.abs(track_position.quantity - focus_position.quantity);
       await this.placeMarketOrder({

package/dist/mcp-server.js

@@ -60558,16 +60558,18 @@ class Strategy {
     return this.tp("short");
   }
   generateGapClosingAlgorithm(payload) {
-    const { kind } = payload;
+    const {
+      kind,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const { entry, quantity } = this.position[kind];
     const focus_position = this.position[kind];
     const reverse_kind = kind == "long" ? "short" : "long";
     const reverse_position = this.position[reverse_kind];
     let _entry = this.tp(kind);
     let _stop = this.tp(reverse_kind);
-    if (!_entry && !_stop) {
-      return null;
-    }
     const second_payload = {
       entry: _entry,
       stop: _stop,
@@ -60582,11 +60584,60 @@ class Strategy {
     };
     console.log({ second_payload, third_payload });
     const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
-    if (!app_config) {
-      return null;
-    }
-    const { entries, ...rest } = app_config;
-    const risk = this.to_f(rest.risk_per_trade);
+    let entries = [];
+    let risk_per_trade = this.config.budget;
+    let last_value = null;
+    if (app_config) {
+      let { entries: _entries, ...rest } = app_config;
+      entries = _entries;
+      risk_per_trade = rest.risk_per_trade;
+      last_value = rest.last_value;
+      if (ignore_entries) {
+        entries = [];
+      }
+    }
+    const risk = this.to_f(risk_per_trade);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < (reverse_position.entry || focus_position.entry);
+    }) : entries.filter((u) => {
+      return u.entry > (reverse_position.entry || focus_position.entry);
+    });
+    const threshold = below_reverse_entries.at(-1);
+    const result = this.gapCloserHelper({
+      risk,
+      entries,
+      kind,
+      sell_factor,
+      reduce_ratio
+    });
+    return {
+      ...result,
+      last_entry: last_value?.entry,
+      first_entry: entries.at(-1)?.entry,
+      threshold
+    };
+  }
+  gapCloserHelper(payload) {
+    const {
+      risk,
+      entries = [],
+      kind,
+      sell_factor = 1,
+      reduce_ratio = 1
+    } = payload;
+    const { entry, quantity } = this.position[kind];
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    let _entry = this.tp(kind);
+    let _stop = this.tp(reverse_kind);
+    const second_payload = {
+      entry: _entry,
+      stop: _stop,
+      risk_reward: this.config.risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
       if (focus_position.quantity > 0) {
@@ -60606,8 +60657,8 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const focus_loss = this.to_f(Math.abs(avg.price - second_payload.stop) * avg.quantity);
     let below_reverse_entries = kind === "long" ? entries.filter((u) => {
       return u.entry < (reverse_position.entry || focus_position.entry);
     }) : entries.filter((u) => {
@@ -60633,19 +60684,21 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
-    const reverse_pnl = this.to_f((reverse_avg.price - second_payload.stop) * reverse_avg.quantity);
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const sell_quantity = this.to_df(reverse_avg.quantity * sell_factor);
+    const reverse_pnl = this.to_f(Math.abs(reverse_avg.price - second_payload.stop) * sell_quantity);
     const fee_to_pay = this.calculate_fee({
       price: avg.entry,
       quantity: avg.quantity
     }) + this.calculate_fee({
       price: reverse_avg.entry,
-      quantity: reverse_avg.quantity
+      quantity: sell_quantity
     });
     const net_reverse_pnl = reverse_pnl - fee_to_pay;
-    const ratio = net_reverse_pnl / focus_loss;
+    const ratio = net_reverse_pnl * reduce_ratio / focus_loss;
     const quantity_to_sell = this.to_df(ratio * avg.quantity);
     const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    const incurred_loss = this.to_f((avg.price - second_payload.stop) * quantity_to_sell);
     return {
       risk,
       risk_reward: this.config.risk_reward,
@@ -60657,7 +60710,8 @@ class Strategy {
         stop_quantity: quantity_to_sell,
         re_entry_quantity: remaining_quantity,
         initial_pnl: this.pnl(kind),
-        tp: second_payload.entry
+        tp: second_payload.entry,
+        incurred_loss
       },
       [reverse_kind]: {
         avg_entry: reverse_avg.entry,
@@ -60665,32 +60719,45 @@ class Strategy {
         pnl: reverse_pnl,
         tp: second_payload.stop,
         re_entry_quantity: remaining_quantity,
-        initial_pnl: this.pnl(reverse_kind)
+        initial_pnl: this.pnl(reverse_kind),
+        remaining_quantity: this.to_df(reverse_avg.quantity - sell_quantity)
       },
-      last_entry: rest.last_value.entry,
-      first_entry: entries.at(-1).entry,
-      threshold
+      spread: Math.abs(avg.entry - reverse_avg.entry),
+      gap_loss: to_f2(Math.abs(avg.entry - reverse_avg.entry) * reverse_avg.quantity, "%.2f"),
+      net_profit: incurred_loss + reverse_pnl
     };
   }
   runIterations(payload) {
-    const { kind, iterations } = payload;
+    const {
+      kind,
+      iterations,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
     const reverse_kind = kind == "long" ? "short" : "long";
     const result = [];
     let position2 = {
       long: this.position.long,
       short: this.position.short
     };
+    let tp_percent_multiplier = 1;
+    let short_tp_factor_multiplier = 1;
     for (let i2 = 0;i2 < iterations; i2++) {
       const instance = new Strategy({
         long: position2.long,
         short: position2.short,
         config: {
           ...this.config,
-          tp_percent: this.config.tp_percent + i2 * 4
+          tp_percent: this.config.tp_percent * tp_percent_multiplier,
+          short_tp_factor: this.config.short_tp_factor * short_tp_factor_multiplier
         }
       });
       const algorithm = instance.generateGapClosingAlgorithm({
-        kind
+        kind,
+        ignore_entries,
+        reduce_ratio,
+        sell_factor
       });
       if (!algorithm) {
         console.log("No algorithm found");
@@ -60702,9 +60769,31 @@ class Strategy {
         entry: algorithm[kind].avg_entry,
         quantity: algorithm[kind].re_entry_quantity
       };
+      let reverse_entry = algorithm[reverse_kind].tp;
+      let reverse_quantity = algorithm[reverse_kind].re_entry_quantity;
+      if (algorithm[reverse_kind].remaining_quantity > 0) {
+        const purchase_to_occur = {
+          price: reverse_entry,
+          quantity: algorithm[reverse_kind].remaining_quantity
+        };
+        const avg = determine_average_entry_and_size([
+          purchase_to_occur,
+          {
+            price: algorithm[reverse_kind].avg_entry,
+            quantity: reverse_quantity - algorithm[reverse_kind].remaining_quantity
+          }
+        ], this.config.global_config.decimal_places, this.config.global_config.price_places);
+        reverse_entry = avg.entry;
+        reverse_quantity = avg.quantity;
+        if (reverse_kind === "short") {
+          short_tp_factor_multiplier = 2;
+        } else {
+          tp_percent_multiplier = 2;
+        }
+      }
       position2[reverse_kind] = {
-        entry: algorithm[reverse_kind].tp,
-        quantity: algorithm[reverse_kind].re_entry_quantity
+        entry: reverse_entry,
+        quantity: reverse_quantity
       };
     }
     return result;
@@ -64337,6 +64426,9 @@ class ExchangeAccount {
     if (threshold_qty > 0 && track_position.quantity >= threshold_qty) {
       should_place_order = true;
     }
+    if (focus_position.quantity === 0) {
+      should_place_order = true;
+    }
     if (track_position.quantity !== focus_position.quantity && focus_position.quantity < track_position.quantity && should_place_order) {
       const remaining_quantity = Math.abs(track_position.quantity - focus_position.quantity);
       await this.placeMarketOrder({

package/package.json

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