@gbozee/ultimate 0.0.2-74 → 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;
@@ -442,15 +455,31 @@ export declare class Strategy {
 		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";
@@ -460,15 +489,16 @@ export declare class Strategy {
 		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

@@ -1842,9 +1842,6 @@ class Strategy {
     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,
@@ -1859,14 +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, ...rest } = app_config;
-    if (ignore_entries) {
-      entries = [];
+    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(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) {
@@ -1886,7 +1929,7 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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);
@@ -1913,7 +1956,7 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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({
@@ -1951,9 +1994,6 @@ class Strategy {
         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

package/dist/index.cjs

@@ -53902,9 +53902,6 @@ class Strategy {
     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,
@@ -53919,14 +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;
-    }
-    let { entries, ...rest } = app_config;
-    if (ignore_entries) {
-      entries = [];
-    }
-    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) {
@@ -53946,7 +53989,7 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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);
@@ -53973,7 +54016,7 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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({
@@ -54011,9 +54054,6 @@ class Strategy {
         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

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;
@@ -568,15 +581,31 @@ export declare class Strategy {
 		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";
@@ -586,15 +615,16 @@ export declare class Strategy {
 		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";
@@ -1469,15 +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

@@ -53857,9 +53857,6 @@ class Strategy {
     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,
@@ -53874,14 +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;
-    }
-    let { entries, ...rest } = app_config;
-    if (ignore_entries) {
-      entries = [];
-    }
-    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) {
@@ -53901,7 +53944,7 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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);
@@ -53928,7 +53971,7 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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({
@@ -53966,9 +54009,6 @@ class Strategy {
         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

package/dist/mcp-server.cjs

@@ -60593,9 +60593,6 @@ class Strategy {
     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,
@@ -60610,14 +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;
-    }
-    let { entries, ...rest } = app_config;
-    if (ignore_entries) {
-      entries = [];
-    }
-    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) {
@@ -60637,7 +60680,7 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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);
@@ -60664,7 +60707,7 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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({
@@ -60702,9 +60745,6 @@ class Strategy {
         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

package/dist/mcp-server.js

@@ -60570,9 +60570,6 @@ class Strategy {
     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,
@@ -60587,14 +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;
-    }
-    let { entries, ...rest } = app_config;
-    if (ignore_entries) {
-      entries = [];
-    }
-    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) {
@@ -60614,7 +60657,7 @@ class Strategy {
         price: entry,
         quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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);
@@ -60641,7 +60684,7 @@ class Strategy {
         price: reverse_position.entry,
         quantity: reverse_position.quantity
       }
-    ]), rest.decimal_places, rest.price_places);
+    ]), 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({
@@ -60679,9 +60722,6 @@ class Strategy {
         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

package/package.json

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