@gbozee/ultimate 0.0.2-97 → 0.0.2-98

package/dist/frontend-index.d.ts

@@ -411,14 +411,14 @@ export declare function computeProfitDetail(payload: {
 		max_reward_factor: number;
 		risk: number;
 	};
-	reduce_position: {
+	reduce_position?: {
 		kind: "long" | "short";
 		entry: number;
 		quantity: number;
 		avg_qty: number;
 		avg_price: number;
 	};
-	reverse_position: {
+	reverse_position?: {
 		kind: "long" | "short";
 		avg_qty: number;
 		avg_price: number;
@@ -441,10 +441,35 @@ export declare function computeProfitDetail(payload: {
 	price_places: string;
 	decimal_places: string;
 };
+export declare function generateGapTp(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	factor?: number;
+	price_places?: string;
+	decimal_places?: string;
+}): {
+	long_tp: number;
+	short_tp: number;
+	short_to_reduce: number;
+	long_to_reduce: number;
+	to_sell: {
+		short: number;
+		long: number;
+	};
+	gap: number;
+	gap_loss: number;
+};
 export type StrategyPosition = {
 	entry: number;
 	quantity: number;
 	avg_price?: number;
+	avg_qty?: number;
 };
 export type GapCloserResult = {
 	avg_entry: number;
@@ -626,6 +651,37 @@ export declare class Strategy {
 		rr?: number;
 		max_size?: number;
 	};
+	identifyGapConfig(payload: {
+		factor?: number;
+	}): {
+		long_tp: number;
+		short_tp: number;
+		short_to_reduce: number;
+		long_to_reduce: number;
+		to_sell: {
+			short: number;
+			long: number;
+		};
+		gap: number;
+		gap_loss: number;
+	};
+	analyzeProfit(payload: {
+		reward_factor?: number;
+		max_reward_factor: number;
+		risk: number;
+		kind: "long" | "short";
+	}): {
+		pnl: number;
+		loss: number;
+		original_pnl: number;
+		reward_factor: number;
+		profit_percent: number;
+		kind: "long" | "short";
+		sell_price: number;
+		quantity: number;
+		price_places: string;
+		decimal_places: string;
+	};
 }
 
 export {};

package/dist/frontend-index.js

@@ -1776,7 +1776,7 @@ function computeProfitDetail(payload) {
     reward_factor = strategy.reward_factor;
   }
   if (focus_position.avg_qty >= focus_position.quantity && strategy.max_reward_factor) {
-    reward_factor = focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty;
+    reward_factor = to_f(focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty, "%.4f");
   } else {
     reward_factor = strategy.reward_factor;
   }
@@ -1785,11 +1785,19 @@ function computeProfitDetail(payload) {
   const pnl = to_f(focus_position.entry * focus_position.quantity * profit_percent / 100, "%.2f");
   const diff = pnl / focus_position.quantity;
   const sell_price = to_f(focus_position.kind === "long" ? focus_position.entry + diff : focus_position.entry - diff, price_places);
-  const loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
-  const ratio = pnl / loss;
-  const quantity = to_f(reduce_position.quantity * ratio, decimal_places);
-  const expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
-  const new_pnl = to_f(pnl - expected_loss, "%.2f");
+  let loss = 0;
+  let expected_loss = 0;
+  let quantity = 0;
+  let new_pnl = pnl;
+  if (reduce_position) {
+    loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
+    const ratio = pnl / loss;
+    quantity = to_f(reduce_position.quantity * ratio, decimal_places);
+  }
+  if (reverse_position) {
+    expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
+    new_pnl = to_f(pnl - expected_loss, "%.2f");
+  }
   return {
     pnl: new_pnl,
     loss: to_f(expected_loss, "%.2f"),
@@ -1803,6 +1811,38 @@ function computeProfitDetail(payload) {
     decimal_places
   };
 }
+function generateGapTp(payload) {
+  const {
+    long,
+    short,
+    factor = 1,
+    price_places = "%.1f",
+    decimal_places = "%.3f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  const longPercent = gapLoss * factor / (short.entry * short.quantity);
+  const shortPercent = gapLoss * factor / (long.entry * long.quantity);
+  const longTp = to_f((1 + longPercent) * long.entry, price_places);
+  const shortTp = to_f((1 + shortPercent) ** -1 * short.entry, price_places);
+  const shortToReduce = to_f(Math.abs(longTp - long.entry) * long.quantity, "%.1f");
+  const longToReduce = to_f(Math.abs(shortTp - short.entry) * short.quantity, "%.1f");
+  const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, shortToReduce, "short", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  return {
+    long_tp: longTp,
+    short_tp: shortTp,
+    short_to_reduce: shortToReduce,
+    long_to_reduce: longToReduce,
+    to_sell: {
+      short: short_quantity_to_sell,
+      long: long_quantity_to_sell
+    },
+    gap: to_f(gap, price_places),
+    gap_loss: to_f(gapLoss, "%.2f")
+  };
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -2204,6 +2244,35 @@ class Strategy {
     app_config.stop = this.to_f(app_config.stop);
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
+  identifyGapConfig(payload) {
+    const { factor = 1 } = payload;
+    return generateGapTp({
+      long: this.position.long,
+      short: this.position.short,
+      factor,
+      decimal_places: this.config.global_config.decimal_places,
+      price_places: this.config.global_config.price_places
+    });
+  }
+  analyzeProfit(payload) {
+    const { reward_factor = 1, max_reward_factor, risk, kind } = payload;
+    const focus_position = this.position[kind];
+    const result = computeProfitDetail({
+      focus_position: {
+        kind,
+        entry: focus_position.entry,
+        quantity: focus_position.quantity,
+        avg_price: focus_position.avg_price,
+        avg_qty: focus_position.avg_qty
+      },
+      strategy: {
+        reward_factor,
+        max_reward_factor,
+        risk
+      }
+    });
+    return result;
+  }
 }
 export {
   to_f,
@@ -2222,6 +2291,7 @@ export {
   getDecimalPlaces,
   generate_config_params,
   generateOptimumAppConfig,
+  generateGapTp,
   formatPrice,
   fibonacci_analysis,
   extractValue,

package/dist/index.cjs

@@ -41896,6 +41896,7 @@ __export(exports_src, {
   getOptimumStopAndRisk: () => getOptimumStopAndRisk,
   generate_config_params: () => generate_config_params,
   generateOptimumAppConfig: () => generateOptimumAppConfig,
+  generateGapTp: () => generateGapTp,
   exchange_account: () => exports_exchange_account,
   determine_break_even_price: () => determine_break_even_price,
   determine_average_entry_and_size: () => determine_average_entry_and_size,
@@ -52330,6 +52331,12 @@ function to_f2(value2, places = "%.1f") {
   const formattedValue = places.replace("%.", "").replace("f", "");
   return parseFloat(v.toFixed(parseInt(formattedValue)));
 }
+function determine_amount_to_sell2(entry, quantity, sell_price, pnl, kind, places = "%.3f") {
+  const _pnl = determine_pnl2(entry, sell_price, quantity, kind);
+  const ratio = pnl / to_f2(Math.abs(_pnl), places);
+  quantity = quantity * ratio;
+  return to_f2(quantity, places);
+}
 function determine_position_size2({
   entry,
   stop,
@@ -53856,7 +53863,7 @@ function computeProfitDetail(payload) {
     reward_factor = strategy.reward_factor;
   }
   if (focus_position.avg_qty >= focus_position.quantity && strategy.max_reward_factor) {
-    reward_factor = focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty;
+    reward_factor = to_f2(focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty, "%.4f");
   } else {
     reward_factor = strategy.reward_factor;
   }
@@ -53865,11 +53872,19 @@ function computeProfitDetail(payload) {
   const pnl = to_f2(focus_position.entry * focus_position.quantity * profit_percent / 100, "%.2f");
   const diff = pnl / focus_position.quantity;
   const sell_price = to_f2(focus_position.kind === "long" ? focus_position.entry + diff : focus_position.entry - diff, price_places);
-  const loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
-  const ratio = pnl / loss;
-  const quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
-  const expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
-  const new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  let loss = 0;
+  let expected_loss = 0;
+  let quantity = 0;
+  let new_pnl = pnl;
+  if (reduce_position) {
+    loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
+    const ratio = pnl / loss;
+    quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
+  }
+  if (reverse_position) {
+    expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
+    new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  }
   return {
     pnl: new_pnl,
     loss: to_f2(expected_loss, "%.2f"),
@@ -53883,6 +53898,38 @@ function computeProfitDetail(payload) {
     decimal_places
   };
 }
+function generateGapTp(payload) {
+  const {
+    long,
+    short,
+    factor = 1,
+    price_places = "%.1f",
+    decimal_places = "%.3f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  const longPercent = gapLoss * factor / (short.entry * short.quantity);
+  const shortPercent = gapLoss * factor / (long.entry * long.quantity);
+  const longTp = to_f2((1 + longPercent) * long.entry, price_places);
+  const shortTp = to_f2((1 + shortPercent) ** -1 * short.entry, price_places);
+  const shortToReduce = to_f2(Math.abs(longTp - long.entry) * long.quantity, "%.1f");
+  const longToReduce = to_f2(Math.abs(shortTp - short.entry) * short.quantity, "%.1f");
+  const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, shortToReduce, "short", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  return {
+    long_tp: longTp,
+    short_tp: shortTp,
+    short_to_reduce: shortToReduce,
+    long_to_reduce: longToReduce,
+    to_sell: {
+      short: short_quantity_to_sell,
+      long: long_quantity_to_sell
+    },
+    gap: to_f2(gap, price_places),
+    gap_loss: to_f2(gapLoss, "%.2f")
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -54285,6 +54332,35 @@ class Strategy {
     app_config.stop = this.to_f(app_config.stop);
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
+  identifyGapConfig(payload) {
+    const { factor = 1 } = payload;
+    return generateGapTp({
+      long: this.position.long,
+      short: this.position.short,
+      factor,
+      decimal_places: this.config.global_config.decimal_places,
+      price_places: this.config.global_config.price_places
+    });
+  }
+  analyzeProfit(payload) {
+    const { reward_factor = 1, max_reward_factor, risk, kind } = payload;
+    const focus_position = this.position[kind];
+    const result = computeProfitDetail({
+      focus_position: {
+        kind,
+        entry: focus_position.entry,
+        quantity: focus_position.quantity,
+        avg_price: focus_position.avg_price,
+        avg_qty: focus_position.avg_qty
+      },
+      strategy: {
+        reward_factor,
+        max_reward_factor,
+        risk
+      }
+    });
+    return result;
+  }
 }
 
 // src/exchanges/binance.ts
@@ -58212,12 +58288,14 @@ class ExchangeAccount {
       long: {
         entry: long_position.entry,
         quantity: long_position.quantity,
-        avg_price: long_position.avg_price
+        avg_price: long_position.avg_price,
+        avg_qty: long_position.avg_qty
       },
       short: {
         entry: short_position.entry,
         quantity: short_position.quantity,
-        avg_price: short_position.avg_price
+        avg_price: short_position.avg_price,
+        avg_qty: short_position.avg_qty
       },
       config: strategy_config
     });
@@ -59072,6 +59150,31 @@ class ExchangeAccount {
       }
     };
   }
+  async generateGapTp(payload) {
+    const { symbol, factor = 1 } = payload;
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol
+    });
+    const positions = await this.syncAccount({
+      symbol,
+      as_view: true
+    });
+    const long_position = positions.find((k) => k.kind === "long");
+    const short_position = positions.find((k) => k.kind === "short");
+    return generateGapTp({
+      long: {
+        entry: long_position.entry,
+        quantity: long_position.quantity
+      },
+      short: {
+        entry: short_position.entry,
+        quantity: short_position.quantity
+      },
+      factor,
+      price_places: symbol_config.price_places,
+      decimal_places: symbol_config.decimal_places
+    });
+  }
   async getSellPriceFromStrategy(payload) {
     const { symbol, reduce_position } = payload;
     const symbol_config = await this.recomputeSymbolConfig({

package/dist/index.d.ts

@@ -565,6 +565,7 @@ export type StrategyPosition = {
 	entry: number;
 	quantity: number;
 	avg_price?: number;
+	avg_qty?: number;
 };
 export type GapCloserResult = {
 	avg_entry: number;
@@ -746,6 +747,37 @@ export declare class Strategy {
 		rr?: number;
 		max_size?: number;
 	};
+	identifyGapConfig(payload: {
+		factor?: number;
+	}): {
+		long_tp: number;
+		short_tp: number;
+		short_to_reduce: number;
+		long_to_reduce: number;
+		to_sell: {
+			short: number;
+			long: number;
+		};
+		gap: number;
+		gap_loss: number;
+	};
+	analyzeProfit(payload: {
+		reward_factor?: number;
+		max_reward_factor: number;
+		risk: number;
+		kind: "long" | "short";
+	}): {
+		pnl: number;
+		loss: number;
+		original_pnl: number;
+		reward_factor: number;
+		profit_percent: number;
+		kind: "long" | "short";
+		sell_price: number;
+		quantity: number;
+		price_places: string;
+		decimal_places: string;
+	};
 }
 export type SignalConfigType = {
 	focus: number;
@@ -1068,14 +1100,14 @@ export declare function computeProfitDetail(payload: {
 		max_reward_factor: number;
 		risk: number;
 	};
-	reduce_position: {
+	reduce_position?: {
 		kind: "long" | "short";
 		entry: number;
 		quantity: number;
 		avg_qty: number;
 		avg_price: number;
 	};
-	reverse_position: {
+	reverse_position?: {
 		kind: "long" | "short";
 		avg_qty: number;
 		avg_price: number;
@@ -1098,6 +1130,30 @@ export declare function computeProfitDetail(payload: {
 	price_places: string;
 	decimal_places: string;
 };
+export declare function generateGapTp(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	factor?: number;
+	price_places?: string;
+	decimal_places?: string;
+}): {
+	long_tp: number;
+	short_tp: number;
+	short_to_reduce: number;
+	long_to_reduce: number;
+	to_sell: {
+		short: number;
+		long: number;
+	};
+	gap: number;
+	gap_loss: number;
+};
 declare class ExchangePosition {
 	exchange: BaseExchange;
 	exchange_account: ExchangeAccount$1;
@@ -1856,6 +1912,21 @@ declare class ExchangeAccount$1 {
 			pnl: number;
 		};
 	}>;
+	generateGapTp(payload: {
+		symbol: string;
+		factor?: number;
+	}): Promise<{
+		long_tp: number;
+		short_tp: number;
+		short_to_reduce: number;
+		long_to_reduce: number;
+		to_sell: {
+			short: number;
+			long: number;
+		};
+		gap: number;
+		gap_loss: number;
+	}>;
 	getSellPriceFromStrategy(payload: {
 		symbol: string;
 		reduce_position: PositionsView;

package/dist/index.js

@@ -52284,6 +52284,12 @@ function to_f2(value2, places = "%.1f") {
   const formattedValue = places.replace("%.", "").replace("f", "");
   return parseFloat(v.toFixed(parseInt(formattedValue)));
 }
+function determine_amount_to_sell2(entry, quantity, sell_price, pnl, kind, places = "%.3f") {
+  const _pnl = determine_pnl2(entry, sell_price, quantity, kind);
+  const ratio = pnl / to_f2(Math.abs(_pnl), places);
+  quantity = quantity * ratio;
+  return to_f2(quantity, places);
+}
 function determine_position_size2({
   entry,
   stop,
@@ -53810,7 +53816,7 @@ function computeProfitDetail(payload) {
     reward_factor = strategy.reward_factor;
   }
   if (focus_position.avg_qty >= focus_position.quantity && strategy.max_reward_factor) {
-    reward_factor = focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty;
+    reward_factor = to_f2(focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty, "%.4f");
   } else {
     reward_factor = strategy.reward_factor;
   }
@@ -53819,11 +53825,19 @@ function computeProfitDetail(payload) {
   const pnl = to_f2(focus_position.entry * focus_position.quantity * profit_percent / 100, "%.2f");
   const diff = pnl / focus_position.quantity;
   const sell_price = to_f2(focus_position.kind === "long" ? focus_position.entry + diff : focus_position.entry - diff, price_places);
-  const loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
-  const ratio = pnl / loss;
-  const quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
-  const expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
-  const new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  let loss = 0;
+  let expected_loss = 0;
+  let quantity = 0;
+  let new_pnl = pnl;
+  if (reduce_position) {
+    loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
+    const ratio = pnl / loss;
+    quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
+  }
+  if (reverse_position) {
+    expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
+    new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  }
   return {
     pnl: new_pnl,
     loss: to_f2(expected_loss, "%.2f"),
@@ -53837,6 +53851,38 @@ function computeProfitDetail(payload) {
     decimal_places
   };
 }
+function generateGapTp(payload) {
+  const {
+    long,
+    short,
+    factor = 1,
+    price_places = "%.1f",
+    decimal_places = "%.3f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  const longPercent = gapLoss * factor / (short.entry * short.quantity);
+  const shortPercent = gapLoss * factor / (long.entry * long.quantity);
+  const longTp = to_f2((1 + longPercent) * long.entry, price_places);
+  const shortTp = to_f2((1 + shortPercent) ** -1 * short.entry, price_places);
+  const shortToReduce = to_f2(Math.abs(longTp - long.entry) * long.quantity, "%.1f");
+  const longToReduce = to_f2(Math.abs(shortTp - short.entry) * short.quantity, "%.1f");
+  const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, shortToReduce, "short", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  return {
+    long_tp: longTp,
+    short_tp: shortTp,
+    short_to_reduce: shortToReduce,
+    long_to_reduce: longToReduce,
+    to_sell: {
+      short: short_quantity_to_sell,
+      long: long_quantity_to_sell
+    },
+    gap: to_f2(gap, price_places),
+    gap_loss: to_f2(gapLoss, "%.2f")
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -54239,6 +54285,35 @@ class Strategy {
     app_config.stop = this.to_f(app_config.stop);
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
+  identifyGapConfig(payload) {
+    const { factor = 1 } = payload;
+    return generateGapTp({
+      long: this.position.long,
+      short: this.position.short,
+      factor,
+      decimal_places: this.config.global_config.decimal_places,
+      price_places: this.config.global_config.price_places
+    });
+  }
+  analyzeProfit(payload) {
+    const { reward_factor = 1, max_reward_factor, risk, kind } = payload;
+    const focus_position = this.position[kind];
+    const result = computeProfitDetail({
+      focus_position: {
+        kind,
+        entry: focus_position.entry,
+        quantity: focus_position.quantity,
+        avg_price: focus_position.avg_price,
+        avg_qty: focus_position.avg_qty
+      },
+      strategy: {
+        reward_factor,
+        max_reward_factor,
+        risk
+      }
+    });
+    return result;
+  }
 }
 
 // src/exchanges/binance.ts
@@ -58166,12 +58241,14 @@ class ExchangeAccount {
       long: {
         entry: long_position.entry,
         quantity: long_position.quantity,
-        avg_price: long_position.avg_price
+        avg_price: long_position.avg_price,
+        avg_qty: long_position.avg_qty
       },
       short: {
         entry: short_position.entry,
         quantity: short_position.quantity,
-        avg_price: short_position.avg_price
+        avg_price: short_position.avg_price,
+        avg_qty: short_position.avg_qty
       },
       config: strategy_config
     });
@@ -59026,6 +59103,31 @@ class ExchangeAccount {
       }
     };
   }
+  async generateGapTp(payload) {
+    const { symbol, factor = 1 } = payload;
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol
+    });
+    const positions = await this.syncAccount({
+      symbol,
+      as_view: true
+    });
+    const long_position = positions.find((k) => k.kind === "long");
+    const short_position = positions.find((k) => k.kind === "short");
+    return generateGapTp({
+      long: {
+        entry: long_position.entry,
+        quantity: long_position.quantity
+      },
+      short: {
+        entry: short_position.entry,
+        quantity: short_position.quantity
+      },
+      factor,
+      price_places: symbol_config.price_places,
+      decimal_places: symbol_config.decimal_places
+    });
+  }
   async getSellPriceFromStrategy(payload) {
     const { symbol, reduce_position } = payload;
     const symbol_config = await this.recomputeSymbolConfig({
@@ -59531,6 +59633,7 @@ export {
   getOptimumStopAndRisk,
   generate_config_params,
   generateOptimumAppConfig,
+  generateGapTp,
   exports_exchange_account as exchange_account,
   determine_break_even_price,
   determine_average_entry_and_size,

package/dist/mcp-server.cjs

@@ -59033,6 +59033,12 @@ function to_f2(value2, places = "%.1f") {
   const formattedValue = places.replace("%.", "").replace("f", "");
   return parseFloat(v.toFixed(parseInt(formattedValue)));
 }
+function determine_amount_to_sell2(entry, quantity, sell_price, pnl, kind, places = "%.3f") {
+  const _pnl = determine_pnl2(entry, sell_price, quantity, kind);
+  const ratio = pnl / to_f2(Math.abs(_pnl), places);
+  quantity = quantity * ratio;
+  return to_f2(quantity, places);
+}
 function determine_position_size2({
   entry,
   stop,
@@ -60546,7 +60552,7 @@ function computeProfitDetail(payload) {
     reward_factor = strategy.reward_factor;
   }
   if (focus_position.avg_qty >= focus_position.quantity && strategy.max_reward_factor) {
-    reward_factor = focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty;
+    reward_factor = to_f2(focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty, "%.4f");
   } else {
     reward_factor = strategy.reward_factor;
   }
@@ -60555,11 +60561,19 @@ function computeProfitDetail(payload) {
   const pnl = to_f2(focus_position.entry * focus_position.quantity * profit_percent / 100, "%.2f");
   const diff = pnl / focus_position.quantity;
   const sell_price = to_f2(focus_position.kind === "long" ? focus_position.entry + diff : focus_position.entry - diff, price_places);
-  const loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
-  const ratio = pnl / loss;
-  const quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
-  const expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
-  const new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  let loss = 0;
+  let expected_loss = 0;
+  let quantity = 0;
+  let new_pnl = pnl;
+  if (reduce_position) {
+    loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
+    const ratio = pnl / loss;
+    quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
+  }
+  if (reverse_position) {
+    expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
+    new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  }
   return {
     pnl: new_pnl,
     loss: to_f2(expected_loss, "%.2f"),
@@ -60573,6 +60587,38 @@ function computeProfitDetail(payload) {
     decimal_places
   };
 }
+function generateGapTp(payload) {
+  const {
+    long,
+    short,
+    factor = 1,
+    price_places = "%.1f",
+    decimal_places = "%.3f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  const longPercent = gapLoss * factor / (short.entry * short.quantity);
+  const shortPercent = gapLoss * factor / (long.entry * long.quantity);
+  const longTp = to_f2((1 + longPercent) * long.entry, price_places);
+  const shortTp = to_f2((1 + shortPercent) ** -1 * short.entry, price_places);
+  const shortToReduce = to_f2(Math.abs(longTp - long.entry) * long.quantity, "%.1f");
+  const longToReduce = to_f2(Math.abs(shortTp - short.entry) * short.quantity, "%.1f");
+  const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, shortToReduce, "short", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  return {
+    long_tp: longTp,
+    short_tp: shortTp,
+    short_to_reduce: shortToReduce,
+    long_to_reduce: longToReduce,
+    to_sell: {
+      short: short_quantity_to_sell,
+      long: long_quantity_to_sell
+    },
+    gap: to_f2(gap, price_places),
+    gap_loss: to_f2(gapLoss, "%.2f")
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -60975,6 +61021,35 @@ class Strategy {
     app_config.stop = this.to_f(app_config.stop);
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
+  identifyGapConfig(payload) {
+    const { factor = 1 } = payload;
+    return generateGapTp({
+      long: this.position.long,
+      short: this.position.short,
+      factor,
+      decimal_places: this.config.global_config.decimal_places,
+      price_places: this.config.global_config.price_places
+    });
+  }
+  analyzeProfit(payload) {
+    const { reward_factor = 1, max_reward_factor, risk, kind } = payload;
+    const focus_position = this.position[kind];
+    const result = computeProfitDetail({
+      focus_position: {
+        kind,
+        entry: focus_position.entry,
+        quantity: focus_position.quantity,
+        avg_price: focus_position.avg_price,
+        avg_qty: focus_position.avg_qty
+      },
+      strategy: {
+        reward_factor,
+        max_reward_factor,
+        risk
+      }
+    });
+    return result;
+  }
 }
 
 // src/exchanges/binance.ts
@@ -64902,12 +64977,14 @@ class ExchangeAccount {
       long: {
         entry: long_position.entry,
         quantity: long_position.quantity,
-        avg_price: long_position.avg_price
+        avg_price: long_position.avg_price,
+        avg_qty: long_position.avg_qty
       },
       short: {
         entry: short_position.entry,
         quantity: short_position.quantity,
-        avg_price: short_position.avg_price
+        avg_price: short_position.avg_price,
+        avg_qty: short_position.avg_qty
       },
       config: strategy_config
     });
@@ -65762,6 +65839,31 @@ class ExchangeAccount {
       }
     };
   }
+  async generateGapTp(payload) {
+    const { symbol, factor = 1 } = payload;
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol
+    });
+    const positions = await this.syncAccount({
+      symbol,
+      as_view: true
+    });
+    const long_position = positions.find((k) => k.kind === "long");
+    const short_position = positions.find((k) => k.kind === "short");
+    return generateGapTp({
+      long: {
+        entry: long_position.entry,
+        quantity: long_position.quantity
+      },
+      short: {
+        entry: short_position.entry,
+        quantity: short_position.quantity
+      },
+      factor,
+      price_places: symbol_config.price_places,
+      decimal_places: symbol_config.decimal_places
+    });
+  }
   async getSellPriceFromStrategy(payload) {
     const { symbol, reduce_position } = payload;
     const symbol_config = await this.recomputeSymbolConfig({

package/dist/mcp-server.js

@@ -59010,6 +59010,12 @@ function to_f2(value2, places = "%.1f") {
   const formattedValue = places.replace("%.", "").replace("f", "");
   return parseFloat(v.toFixed(parseInt(formattedValue)));
 }
+function determine_amount_to_sell2(entry, quantity, sell_price, pnl, kind, places = "%.3f") {
+  const _pnl = determine_pnl2(entry, sell_price, quantity, kind);
+  const ratio = pnl / to_f2(Math.abs(_pnl), places);
+  quantity = quantity * ratio;
+  return to_f2(quantity, places);
+}
 function determine_position_size2({
   entry,
   stop,
@@ -60523,7 +60529,7 @@ function computeProfitDetail(payload) {
     reward_factor = strategy.reward_factor;
   }
   if (focus_position.avg_qty >= focus_position.quantity && strategy.max_reward_factor) {
-    reward_factor = focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty;
+    reward_factor = to_f2(focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty, "%.4f");
   } else {
     reward_factor = strategy.reward_factor;
   }
@@ -60532,11 +60538,19 @@ function computeProfitDetail(payload) {
   const pnl = to_f2(focus_position.entry * focus_position.quantity * profit_percent / 100, "%.2f");
   const diff = pnl / focus_position.quantity;
   const sell_price = to_f2(focus_position.kind === "long" ? focus_position.entry + diff : focus_position.entry - diff, price_places);
-  const loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
-  const ratio = pnl / loss;
-  const quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
-  const expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
-  const new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  let loss = 0;
+  let expected_loss = 0;
+  let quantity = 0;
+  let new_pnl = pnl;
+  if (reduce_position) {
+    loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
+    const ratio = pnl / loss;
+    quantity = to_f2(reduce_position.quantity * ratio, decimal_places);
+  }
+  if (reverse_position) {
+    expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
+    new_pnl = to_f2(pnl - expected_loss, "%.2f");
+  }
   return {
     pnl: new_pnl,
     loss: to_f2(expected_loss, "%.2f"),
@@ -60550,6 +60564,38 @@ function computeProfitDetail(payload) {
     decimal_places
   };
 }
+function generateGapTp(payload) {
+  const {
+    long,
+    short,
+    factor = 1,
+    price_places = "%.1f",
+    decimal_places = "%.3f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  const longPercent = gapLoss * factor / (short.entry * short.quantity);
+  const shortPercent = gapLoss * factor / (long.entry * long.quantity);
+  const longTp = to_f2((1 + longPercent) * long.entry, price_places);
+  const shortTp = to_f2((1 + shortPercent) ** -1 * short.entry, price_places);
+  const shortToReduce = to_f2(Math.abs(longTp - long.entry) * long.quantity, "%.1f");
+  const longToReduce = to_f2(Math.abs(shortTp - short.entry) * short.quantity, "%.1f");
+  const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, shortToReduce, "short", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  return {
+    long_tp: longTp,
+    short_tp: shortTp,
+    short_to_reduce: shortToReduce,
+    long_to_reduce: longToReduce,
+    to_sell: {
+      short: short_quantity_to_sell,
+      long: long_quantity_to_sell
+    },
+    gap: to_f2(gap, price_places),
+    gap_loss: to_f2(gapLoss, "%.2f")
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -60952,6 +60998,35 @@ class Strategy {
     app_config.stop = this.to_f(app_config.stop);
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
+  identifyGapConfig(payload) {
+    const { factor = 1 } = payload;
+    return generateGapTp({
+      long: this.position.long,
+      short: this.position.short,
+      factor,
+      decimal_places: this.config.global_config.decimal_places,
+      price_places: this.config.global_config.price_places
+    });
+  }
+  analyzeProfit(payload) {
+    const { reward_factor = 1, max_reward_factor, risk, kind } = payload;
+    const focus_position = this.position[kind];
+    const result = computeProfitDetail({
+      focus_position: {
+        kind,
+        entry: focus_position.entry,
+        quantity: focus_position.quantity,
+        avg_price: focus_position.avg_price,
+        avg_qty: focus_position.avg_qty
+      },
+      strategy: {
+        reward_factor,
+        max_reward_factor,
+        risk
+      }
+    });
+    return result;
+  }
 }
 
 // src/exchanges/binance.ts
@@ -64879,12 +64954,14 @@ class ExchangeAccount {
       long: {
         entry: long_position.entry,
         quantity: long_position.quantity,
-        avg_price: long_position.avg_price
+        avg_price: long_position.avg_price,
+        avg_qty: long_position.avg_qty
       },
       short: {
         entry: short_position.entry,
         quantity: short_position.quantity,
-        avg_price: short_position.avg_price
+        avg_price: short_position.avg_price,
+        avg_qty: short_position.avg_qty
       },
       config: strategy_config
     });
@@ -65739,6 +65816,31 @@ class ExchangeAccount {
       }
     };
   }
+  async generateGapTp(payload) {
+    const { symbol, factor = 1 } = payload;
+    const symbol_config = await this.recomputeSymbolConfig({
+      symbol
+    });
+    const positions = await this.syncAccount({
+      symbol,
+      as_view: true
+    });
+    const long_position = positions.find((k) => k.kind === "long");
+    const short_position = positions.find((k) => k.kind === "short");
+    return generateGapTp({
+      long: {
+        entry: long_position.entry,
+        quantity: long_position.quantity
+      },
+      short: {
+        entry: short_position.entry,
+        quantity: short_position.quantity
+      },
+      factor,
+      price_places: symbol_config.price_places,
+      decimal_places: symbol_config.decimal_places
+    });
+  }
   async getSellPriceFromStrategy(payload) {
     const { symbol, reduce_position } = payload;
     const symbol_config = await this.recomputeSymbolConfig({

package/package.json

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