@gbozee/ultimate 0.0.2-74 → 0.0.2-76

package/dist/frontend-index.d.ts

@@ -401,6 +401,20 @@ export declare function getRiskReward(payload: {
 export type StrategyPosition = {
 	entry: number;
 	quantity: number;
+	avg_price?: 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;
@@ -442,15 +456,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 +490,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
@@ -57961,10 +58001,50 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      kind,
+      raw: true
+    });
+    const result = strategy.generateOppositeTrades({
+      kind,
+      avg_entry: strategy.position[kind].avg_price
+    });
+    if (place && result?.kind) {
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: result.kind
+      });
+      await this.app_db.updateScheduledTrade(config2.id, {
+        entry: result.entry,
+        stop: result.stop,
+        risk: result.risk_per_trade,
+        profit_percent: result.profit_percent,
+        risk_reward: result.risk_reward
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        ignore_config: true
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        stop: true,
+        ignore_config: true
+      });
+    }
+    return result;
+  }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
     const positions = await this.syncAccount({
-      symbol
+      symbol,
+      as_view: true
     });
     const symbol_config = await this.recomputeSymbolConfig({
       symbol
@@ -57998,11 +58078,13 @@ class ExchangeAccount {
     const strategy = new Strategy({
       long: {
         entry: long_position.entry,
-        quantity: long_position.quantity
+        quantity: long_position.quantity,
+        avg_price: long_position.avg_price
       },
       short: {
         entry: short_position.entry,
-        quantity: short_position.quantity
+        quantity: short_position.quantity,
+        avg_price: short_position.avg_price
       },
       config: strategy_config
     });

package/dist/index.d.ts

@@ -527,6 +527,20 @@ export declare class AppDatabase {
 export type StrategyPosition = {
 	entry: number;
 	quantity: number;
+	avg_price?: 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;
@@ -568,15 +582,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 +616,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";
@@ -1463,21 +1494,83 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<number>;
+	buildOppositeTrades(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		place?: boolean;
+	}): Promise<{
+		avg: {
+			entry: number;
+			price: number;
+			quantity: number;
+		};
+		loss: number;
+		profit_percent: number;
+		fee: number;
+		risk_per_trade: number;
+		risk_reward: number;
+		symbol?: string;
+		focus: number;
+		budget: number;
+		support: number;
+		resistance: number;
+		percent_change: number;
+		tradeSplit?: number;
+		take_profit?: number;
+		kind: "long" | "short";
+		entry: number;
+		stop: number;
+		min_size: number;
+		price_places?: string;
+		strategy?: "quantity" | "entry";
+		as_array?: boolean;
+		decimal_places?: string;
+		min_profit?: number;
+		raw?: boolean;
+		gap?: number;
+		rr?: number;
+		max_size?: number;
+	}>;
 	runSimulation(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		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
@@ -57916,10 +57956,50 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      kind,
+      raw: true
+    });
+    const result = strategy.generateOppositeTrades({
+      kind,
+      avg_entry: strategy.position[kind].avg_price
+    });
+    if (place && result?.kind) {
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: result.kind
+      });
+      await this.app_db.updateScheduledTrade(config2.id, {
+        entry: result.entry,
+        stop: result.stop,
+        risk: result.risk_per_trade,
+        profit_percent: result.profit_percent,
+        risk_reward: result.risk_reward
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        ignore_config: true
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        stop: true,
+        ignore_config: true
+      });
+    }
+    return result;
+  }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
     const positions = await this.syncAccount({
-      symbol
+      symbol,
+      as_view: true
     });
     const symbol_config = await this.recomputeSymbolConfig({
       symbol
@@ -57953,11 +58033,13 @@ class ExchangeAccount {
     const strategy = new Strategy({
       long: {
         entry: long_position.entry,
-        quantity: long_position.quantity
+        quantity: long_position.quantity,
+        avg_price: long_position.avg_price
       },
       short: {
         entry: short_position.entry,
-        quantity: short_position.quantity
+        quantity: short_position.quantity,
+        avg_price: short_position.avg_price
       },
       config: strategy_config
     });

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
@@ -64652,10 +64692,50 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      kind,
+      raw: true
+    });
+    const result = strategy.generateOppositeTrades({
+      kind,
+      avg_entry: strategy.position[kind].avg_price
+    });
+    if (place && result?.kind) {
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: result.kind
+      });
+      await this.app_db.updateScheduledTrade(config2.id, {
+        entry: result.entry,
+        stop: result.stop,
+        risk: result.risk_per_trade,
+        profit_percent: result.profit_percent,
+        risk_reward: result.risk_reward
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        ignore_config: true
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        stop: true,
+        ignore_config: true
+      });
+    }
+    return result;
+  }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
     const positions = await this.syncAccount({
-      symbol
+      symbol,
+      as_view: true
     });
     const symbol_config = await this.recomputeSymbolConfig({
       symbol
@@ -64689,11 +64769,13 @@ class ExchangeAccount {
     const strategy = new Strategy({
       long: {
         entry: long_position.entry,
-        quantity: long_position.quantity
+        quantity: long_position.quantity,
+        avg_price: long_position.avg_price
       },
       short: {
         entry: short_position.entry,
-        quantity: short_position.quantity
+        quantity: short_position.quantity,
+        avg_price: short_position.avg_price
       },
       config: strategy_config
     });

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
@@ -64629,10 +64669,50 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      kind,
+      raw: true
+    });
+    const result = strategy.generateOppositeTrades({
+      kind,
+      avg_entry: strategy.position[kind].avg_price
+    });
+    if (place && result?.kind) {
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: result.kind
+      });
+      await this.app_db.updateScheduledTrade(config2.id, {
+        entry: result.entry,
+        stop: result.stop,
+        risk: result.risk_per_trade,
+        profit_percent: result.profit_percent,
+        risk_reward: result.risk_reward
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        ignore_config: true
+      });
+      await this.placeTrade({
+        symbol,
+        kind: result.kind,
+        place: true,
+        stop: true,
+        ignore_config: true
+      });
+    }
+    return result;
+  }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
     const positions = await this.syncAccount({
-      symbol
+      symbol,
+      as_view: true
     });
     const symbol_config = await this.recomputeSymbolConfig({
       symbol
@@ -64666,11 +64746,13 @@ class ExchangeAccount {
     const strategy = new Strategy({
       long: {
         entry: long_position.entry,
-        quantity: long_position.quantity
+        quantity: long_position.quantity,
+        avg_price: long_position.avg_price
       },
       short: {
         entry: short_position.entry,
-        quantity: short_position.quantity
+        quantity: short_position.quantity,
+        avg_price: short_position.avg_price
       },
       config: strategy_config
     });

package/package.json

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