@gbozee/ultimate 0.0.2-73 → 0.0.2-74

package/dist/frontend-index.d.ts

@@ -438,6 +438,9 @@ 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;
@@ -445,11 +448,17 @@ export declare class Strategy {
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
 	};
 	runIterations(payload: {
 		kind: "long" | "short";
 		iterations: number;
 		risk_reward?: number;
+		ignore_entries?: boolean;
+		reduce_ratio?: number;
+		sell_factor?: number;
 	}): {
 		[x: string]: any;
 		risk: number;
@@ -457,6 +466,9 @@ export declare class Strategy {
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
 	}[];
 	getPositionAfterTp(payload: {
 		kind: "long" | "short";

package/dist/frontend-index.js

@@ -1830,7 +1830,12 @@ 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";
@@ -1857,7 +1862,10 @@ class Strategy {
     if (!app_config) {
       return null;
     }
-    const { entries, ...rest } = app_config;
+    let { entries, ...rest } = app_config;
+    if (ignore_entries) {
+      entries = [];
+    }
     const risk = this.to_f(rest.risk_per_trade);
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
@@ -1879,7 +1887,7 @@ class Strategy {
         quantity
       }
     ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    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) => {
@@ -1906,18 +1914,20 @@ class Strategy {
         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);
+    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 +1939,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 +1948,48 @@ 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
+      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 +2001,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,7 +53890,12 @@ 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";
@@ -53917,7 +53922,10 @@ class Strategy {
     if (!app_config) {
       return null;
     }
-    const { entries, ...rest } = app_config;
+    let { entries, ...rest } = app_config;
+    if (ignore_entries) {
+      entries = [];
+    }
     const risk = this.to_f(rest.risk_per_trade);
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
@@ -53939,7 +53947,7 @@ class Strategy {
         quantity
       }
     ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    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) => {
@@ -53966,18 +53974,20 @@ class Strategy {
         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);
+    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 +53999,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 +54008,48 @@ 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
+      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 +54061,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 +57718,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

@@ -564,6 +564,9 @@ 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;
@@ -571,11 +574,17 @@ export declare class Strategy {
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
 	};
 	runIterations(payload: {
 		kind: "long" | "short";
 		iterations: number;
 		risk_reward?: number;
+		ignore_entries?: boolean;
+		reduce_ratio?: number;
+		sell_factor?: number;
 	}): {
 		[x: string]: any;
 		risk: number;
@@ -583,6 +592,9 @@ export declare class Strategy {
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
 	}[];
 	getPositionAfterTp(payload: {
 		kind: "long" | "short";
@@ -1463,6 +1475,9 @@ declare class ExchangeAccount$1 {
 		last_entry: any;
 		first_entry: any;
 		threshold: any;
+		spread: number;
+		gap_loss: number;
+		net_profit: number;
 	}[]>;
 	getCurrentRun(payload: {
 		symbol: string;

package/dist/index.js

@@ -53845,7 +53845,12 @@ 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";
@@ -53872,7 +53877,10 @@ class Strategy {
     if (!app_config) {
       return null;
     }
-    const { entries, ...rest } = app_config;
+    let { entries, ...rest } = app_config;
+    if (ignore_entries) {
+      entries = [];
+    }
     const risk = this.to_f(rest.risk_per_trade);
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
@@ -53894,7 +53902,7 @@ class Strategy {
         quantity
       }
     ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    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) => {
@@ -53921,18 +53929,20 @@ class Strategy {
         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);
+    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 +53954,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 +53963,48 @@ 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
+      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 +54016,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 +57673,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,7 +60581,12 @@ 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";
@@ -60608,7 +60613,10 @@ class Strategy {
     if (!app_config) {
       return null;
     }
-    const { entries, ...rest } = app_config;
+    let { entries, ...rest } = app_config;
+    if (ignore_entries) {
+      entries = [];
+    }
     const risk = this.to_f(rest.risk_per_trade);
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
@@ -60630,7 +60638,7 @@ class Strategy {
         quantity
       }
     ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    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) => {
@@ -60657,18 +60665,20 @@ class Strategy {
         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);
+    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 +60690,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 +60699,48 @@ 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
+      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 +60752,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 +64409,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,7 +60558,12 @@ 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";
@@ -60585,7 +60590,10 @@ class Strategy {
     if (!app_config) {
       return null;
     }
-    const { entries, ...rest } = app_config;
+    let { entries, ...rest } = app_config;
+    if (ignore_entries) {
+      entries = [];
+    }
     const risk = this.to_f(rest.risk_per_trade);
     const adjusted_focus_entries = entries.map((entry2) => {
       let adjusted_price = entry2.price;
@@ -60607,7 +60615,7 @@ class Strategy {
         quantity
       }
     ]), rest.decimal_places, rest.price_places);
-    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    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) => {
@@ -60634,18 +60642,20 @@ class Strategy {
         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);
+    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 +60667,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 +60676,48 @@ 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
+      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 +60729,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 +64386,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-74",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",