@gbozee/ultimate 0.0.2-100 → 0.0.2-102

package/dist/frontend-index.d.ts

@@ -450,6 +450,8 @@ export declare function generateGapTp(payload: {
 		entry: number;
 		quantity: number;
 	};
+	risk?: number;
+	kind?: "long" | "short";
 	factor?: number;
 	sell_factor?: number;
 	price_places?: string;
@@ -671,6 +673,8 @@ export declare class Strategy {
 	identifyGapConfig(payload: {
 		factor?: number;
 		sell_factor?: number;
+		kind?: "long" | "short";
+		risk?: number;
 	}): {
 		profit_percent: {
 			long: number;
@@ -716,6 +720,45 @@ export declare class Strategy {
 		price_places: string;
 		decimal_places: string;
 	};
+	simulateGapReduction(payload: {
+		iterations?: number;
+		factor?: number;
+		direction: "long" | "short";
+		kind?: "long" | "short";
+		risk?: number;
+		sell_factor?: number;
+	}): {
+		results: {
+			profit_percent: {
+				long: number;
+				short: number;
+			};
+			risk: {
+				short: number;
+				long: number;
+			};
+			take_profit: {
+				long: number;
+				short: number;
+			};
+			sell_quantity: {
+				short: number;
+				long: number;
+			};
+			gap_loss: number;
+			position: {
+				long: {
+					entry: number;
+					quantity: number;
+				};
+				short: {
+					entry: number;
+					quantity: number;
+				};
+			};
+		}[];
+		quantity: number;
+	};
 }
 
 export {};

package/dist/frontend-index.js

@@ -1809,11 +1809,26 @@ function generateGapTp(payload) {
   const {
     long,
     short,
-    factor = 1,
+    factor: factor_value = 0,
+    risk: desired_risk,
     sell_factor = 1,
+    kind,
     price_places = "%.1f",
     decimal_places = "%.3f"
   } = payload;
+  if (!factor_value && !desired_risk) {
+    throw new Error("Either factor or risk must be provided");
+  }
+  if (desired_risk && !kind) {
+    throw new Error("Kind must be provided when risk is provided");
+  }
+  let factor = factor_value || calculate_factor({
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor
+  });
   const gap = Math.abs(long.entry - short.entry);
   const max_quantity = Math.max(long.quantity, short.quantity);
   const gapLoss = gap * max_quantity;
@@ -1826,7 +1841,7 @@ function generateGapTp(payload) {
   const actualShortReduce = to_f(shortToReduce * sell_factor, "%.1f");
   const actualLongReduce = to_f(longToReduce * sell_factor, "%.1f");
   const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, actualShortReduce, "short", decimal_places);
-  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, actualLongReduce, "long", decimal_places);
   const risk_amount_short = to_f(shortToReduce - actualShortReduce, "%.2f");
   const risk_amount_long = to_f(longToReduce - actualLongReduce, "%.2f");
   const profit_percent_long = to_f(shortToReduce * 100 / (long.entry * long.quantity), "%.4f");
@@ -1860,6 +1875,32 @@ function generateGapTp(payload) {
     gap_loss: to_f(gapLoss, "%.2f")
   };
 }
+function calculate_factor(payload) {
+  const {
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor,
+    places = "%.4f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  let calculated_factor;
+  const long_notional = long.entry * long.quantity;
+  const short_notional = short.entry * short.quantity;
+  const target_to_reduce = desired_risk / (1 - sell_factor);
+  if (kind === "short") {
+    const calculate_longPercent = target_to_reduce / long_notional;
+    calculated_factor = calculate_longPercent * short_notional / gapLoss;
+  } else {
+    const calculated_shortPercent = target_to_reduce / (short_notional - target_to_reduce);
+    calculated_factor = calculated_shortPercent * long_notional / gapLoss;
+  }
+  calculated_factor = to_f(calculated_factor, places);
+  return calculated_factor;
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -2262,12 +2303,14 @@ class Strategy {
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
   identifyGapConfig(payload) {
-    const { factor = 1, sell_factor = 1 } = payload;
+    const { factor, sell_factor = 1, kind, risk } = payload;
     return generateGapTp({
       long: this.position.long,
       short: this.position.short,
       factor,
       sell_factor,
+      kind,
+      risk,
       decimal_places: this.config.global_config.decimal_places,
       price_places: this.config.global_config.price_places
     });
@@ -2291,6 +2334,67 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const {
+      factor,
+      direction,
+      sell_factor = 1,
+      iterations = 10,
+      risk: desired_risk,
+      kind
+    } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    for (let i = 0;i < iterations; i++) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor,
+        kind,
+        risk: desired_risk
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = direction == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[direction] = {
+        entry: take_profit[direction],
+        quantity: remaining
+      };
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[direction];
+    const entry = this.position[direction].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity
+    };
+  }
 }
 export {
   to_f,

package/dist/index.cjs

@@ -53820,11 +53820,26 @@ function generateGapTp(payload) {
   const {
     long,
     short,
-    factor = 1,
+    factor: factor_value = 0,
+    risk: desired_risk,
     sell_factor = 1,
+    kind,
     price_places = "%.1f",
     decimal_places = "%.3f"
   } = payload;
+  if (!factor_value && !desired_risk) {
+    throw new Error("Either factor or risk must be provided");
+  }
+  if (desired_risk && !kind) {
+    throw new Error("Kind must be provided when risk is provided");
+  }
+  let factor = factor_value || calculate_factor({
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor
+  });
   const gap = Math.abs(long.entry - short.entry);
   const max_quantity = Math.max(long.quantity, short.quantity);
   const gapLoss = gap * max_quantity;
@@ -53837,7 +53852,7 @@ function generateGapTp(payload) {
   const actualShortReduce = to_f2(shortToReduce * sell_factor, "%.1f");
   const actualLongReduce = to_f2(longToReduce * sell_factor, "%.1f");
   const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, actualShortReduce, "short", decimal_places);
-  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, actualLongReduce, "long", decimal_places);
   const risk_amount_short = to_f2(shortToReduce - actualShortReduce, "%.2f");
   const risk_amount_long = to_f2(longToReduce - actualLongReduce, "%.2f");
   const profit_percent_long = to_f2(shortToReduce * 100 / (long.entry * long.quantity), "%.4f");
@@ -53871,6 +53886,32 @@ function generateGapTp(payload) {
     gap_loss: to_f2(gapLoss, "%.2f")
   };
 }
+function calculate_factor(payload) {
+  const {
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor,
+    places = "%.4f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  let calculated_factor;
+  const long_notional = long.entry * long.quantity;
+  const short_notional = short.entry * short.quantity;
+  const target_to_reduce = desired_risk / (1 - sell_factor);
+  if (kind === "short") {
+    const calculate_longPercent = target_to_reduce / long_notional;
+    calculated_factor = calculate_longPercent * short_notional / gapLoss;
+  } else {
+    const calculated_shortPercent = target_to_reduce / (short_notional - target_to_reduce);
+    calculated_factor = calculated_shortPercent * long_notional / gapLoss;
+  }
+  calculated_factor = to_f2(calculated_factor, places);
+  return calculated_factor;
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -54274,12 +54315,14 @@ class Strategy {
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
   identifyGapConfig(payload) {
-    const { factor = 1, sell_factor = 1 } = payload;
+    const { factor, sell_factor = 1, kind, risk } = payload;
     return generateGapTp({
       long: this.position.long,
       short: this.position.short,
       factor,
       sell_factor,
+      kind,
+      risk,
       decimal_places: this.config.global_config.decimal_places,
       price_places: this.config.global_config.price_places
     });
@@ -54303,6 +54346,67 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const {
+      factor,
+      direction,
+      sell_factor = 1,
+      iterations = 10,
+      risk: desired_risk,
+      kind
+    } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    for (let i2 = 0;i2 < iterations; i2++) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor,
+        kind,
+        risk: desired_risk
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = direction == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[direction] = {
+        entry: take_profit[direction],
+        quantity: remaining
+      };
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[direction];
+    const entry = this.position[direction].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -58199,19 +58303,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -59056,6 +59165,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/dist/index.d.ts

@@ -760,6 +760,8 @@ export declare class Strategy {
 	identifyGapConfig(payload: {
 		factor?: number;
 		sell_factor?: number;
+		kind?: "long" | "short";
+		risk?: number;
 	}): {
 		profit_percent: {
 			long: number;
@@ -805,6 +807,45 @@ export declare class Strategy {
 		price_places: string;
 		decimal_places: string;
 	};
+	simulateGapReduction(payload: {
+		iterations?: number;
+		factor?: number;
+		direction: "long" | "short";
+		kind?: "long" | "short";
+		risk?: number;
+		sell_factor?: number;
+	}): {
+		results: {
+			profit_percent: {
+				long: number;
+				short: number;
+			};
+			risk: {
+				short: number;
+				long: number;
+			};
+			take_profit: {
+				long: number;
+				short: number;
+			};
+			sell_quantity: {
+				short: number;
+				long: number;
+			};
+			gap_loss: number;
+			position: {
+				long: {
+					entry: number;
+					quantity: number;
+				};
+				short: {
+					entry: number;
+					quantity: number;
+				};
+			};
+		}[];
+		quantity: number;
+	};
 }
 export type SignalConfigType = {
 	focus: number;
@@ -1166,6 +1207,8 @@ export declare function generateGapTp(payload: {
 		entry: number;
 		quantity: number;
 	};
+	risk?: number;
+	kind?: "long" | "short";
 	factor?: number;
 	sell_factor?: number;
 	price_places?: string;

package/dist/index.js

@@ -53769,11 +53769,26 @@ function generateGapTp(payload) {
   const {
     long,
     short,
-    factor = 1,
+    factor: factor_value = 0,
+    risk: desired_risk,
     sell_factor = 1,
+    kind,
     price_places = "%.1f",
     decimal_places = "%.3f"
   } = payload;
+  if (!factor_value && !desired_risk) {
+    throw new Error("Either factor or risk must be provided");
+  }
+  if (desired_risk && !kind) {
+    throw new Error("Kind must be provided when risk is provided");
+  }
+  let factor = factor_value || calculate_factor({
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor
+  });
   const gap = Math.abs(long.entry - short.entry);
   const max_quantity = Math.max(long.quantity, short.quantity);
   const gapLoss = gap * max_quantity;
@@ -53786,7 +53801,7 @@ function generateGapTp(payload) {
   const actualShortReduce = to_f2(shortToReduce * sell_factor, "%.1f");
   const actualLongReduce = to_f2(longToReduce * sell_factor, "%.1f");
   const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, actualShortReduce, "short", decimal_places);
-  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, actualLongReduce, "long", decimal_places);
   const risk_amount_short = to_f2(shortToReduce - actualShortReduce, "%.2f");
   const risk_amount_long = to_f2(longToReduce - actualLongReduce, "%.2f");
   const profit_percent_long = to_f2(shortToReduce * 100 / (long.entry * long.quantity), "%.4f");
@@ -53820,6 +53835,32 @@ function generateGapTp(payload) {
     gap_loss: to_f2(gapLoss, "%.2f")
   };
 }
+function calculate_factor(payload) {
+  const {
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor,
+    places = "%.4f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  let calculated_factor;
+  const long_notional = long.entry * long.quantity;
+  const short_notional = short.entry * short.quantity;
+  const target_to_reduce = desired_risk / (1 - sell_factor);
+  if (kind === "short") {
+    const calculate_longPercent = target_to_reduce / long_notional;
+    calculated_factor = calculate_longPercent * short_notional / gapLoss;
+  } else {
+    const calculated_shortPercent = target_to_reduce / (short_notional - target_to_reduce);
+    calculated_factor = calculated_shortPercent * long_notional / gapLoss;
+  }
+  calculated_factor = to_f2(calculated_factor, places);
+  return calculated_factor;
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -54223,12 +54264,14 @@ class Strategy {
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
   identifyGapConfig(payload) {
-    const { factor = 1, sell_factor = 1 } = payload;
+    const { factor, sell_factor = 1, kind, risk } = payload;
     return generateGapTp({
       long: this.position.long,
       short: this.position.short,
       factor,
       sell_factor,
+      kind,
+      risk,
       decimal_places: this.config.global_config.decimal_places,
       price_places: this.config.global_config.price_places
     });
@@ -54252,6 +54295,67 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const {
+      factor,
+      direction,
+      sell_factor = 1,
+      iterations = 10,
+      risk: desired_risk,
+      kind
+    } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    for (let i2 = 0;i2 < iterations; i2++) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor,
+        kind,
+        risk: desired_risk
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = direction == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[direction] = {
+        entry: take_profit[direction],
+        quantity: remaining
+      };
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[direction];
+    const entry = this.position[direction].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -58148,19 +58252,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -59005,6 +59114,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/dist/mcp-server.cjs

@@ -60507,11 +60507,26 @@ function generateGapTp(payload) {
   const {
     long,
     short,
-    factor = 1,
+    factor: factor_value = 0,
+    risk: desired_risk,
     sell_factor = 1,
+    kind,
     price_places = "%.1f",
     decimal_places = "%.3f"
   } = payload;
+  if (!factor_value && !desired_risk) {
+    throw new Error("Either factor or risk must be provided");
+  }
+  if (desired_risk && !kind) {
+    throw new Error("Kind must be provided when risk is provided");
+  }
+  let factor = factor_value || calculate_factor({
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor
+  });
   const gap = Math.abs(long.entry - short.entry);
   const max_quantity = Math.max(long.quantity, short.quantity);
   const gapLoss = gap * max_quantity;
@@ -60524,7 +60539,7 @@ function generateGapTp(payload) {
   const actualShortReduce = to_f2(shortToReduce * sell_factor, "%.1f");
   const actualLongReduce = to_f2(longToReduce * sell_factor, "%.1f");
   const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, actualShortReduce, "short", decimal_places);
-  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, actualLongReduce, "long", decimal_places);
   const risk_amount_short = to_f2(shortToReduce - actualShortReduce, "%.2f");
   const risk_amount_long = to_f2(longToReduce - actualLongReduce, "%.2f");
   const profit_percent_long = to_f2(shortToReduce * 100 / (long.entry * long.quantity), "%.4f");
@@ -60558,6 +60573,32 @@ function generateGapTp(payload) {
     gap_loss: to_f2(gapLoss, "%.2f")
   };
 }
+function calculate_factor(payload) {
+  const {
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor,
+    places = "%.4f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  let calculated_factor;
+  const long_notional = long.entry * long.quantity;
+  const short_notional = short.entry * short.quantity;
+  const target_to_reduce = desired_risk / (1 - sell_factor);
+  if (kind === "short") {
+    const calculate_longPercent = target_to_reduce / long_notional;
+    calculated_factor = calculate_longPercent * short_notional / gapLoss;
+  } else {
+    const calculated_shortPercent = target_to_reduce / (short_notional - target_to_reduce);
+    calculated_factor = calculated_shortPercent * long_notional / gapLoss;
+  }
+  calculated_factor = to_f2(calculated_factor, places);
+  return calculated_factor;
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -60961,12 +61002,14 @@ class Strategy {
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
   identifyGapConfig(payload) {
-    const { factor = 1, sell_factor = 1 } = payload;
+    const { factor, sell_factor = 1, kind, risk } = payload;
     return generateGapTp({
       long: this.position.long,
       short: this.position.short,
       factor,
       sell_factor,
+      kind,
+      risk,
       decimal_places: this.config.global_config.decimal_places,
       price_places: this.config.global_config.price_places
     });
@@ -60990,6 +61033,67 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const {
+      factor,
+      direction,
+      sell_factor = 1,
+      iterations = 10,
+      risk: desired_risk,
+      kind
+    } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    for (let i2 = 0;i2 < iterations; i2++) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor,
+        kind,
+        risk: desired_risk
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = direction == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[direction] = {
+        entry: take_profit[direction],
+        quantity: remaining
+      };
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[direction];
+    const entry = this.position[direction].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -64886,19 +64990,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -65743,6 +65852,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/dist/mcp-server.js

@@ -60480,11 +60480,26 @@ function generateGapTp(payload) {
   const {
     long,
     short,
-    factor = 1,
+    factor: factor_value = 0,
+    risk: desired_risk,
     sell_factor = 1,
+    kind,
     price_places = "%.1f",
     decimal_places = "%.3f"
   } = payload;
+  if (!factor_value && !desired_risk) {
+    throw new Error("Either factor or risk must be provided");
+  }
+  if (desired_risk && !kind) {
+    throw new Error("Kind must be provided when risk is provided");
+  }
+  let factor = factor_value || calculate_factor({
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor
+  });
   const gap = Math.abs(long.entry - short.entry);
   const max_quantity = Math.max(long.quantity, short.quantity);
   const gapLoss = gap * max_quantity;
@@ -60497,7 +60512,7 @@ function generateGapTp(payload) {
   const actualShortReduce = to_f2(shortToReduce * sell_factor, "%.1f");
   const actualLongReduce = to_f2(longToReduce * sell_factor, "%.1f");
   const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, actualShortReduce, "short", decimal_places);
-  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, actualLongReduce, "long", decimal_places);
   const risk_amount_short = to_f2(shortToReduce - actualShortReduce, "%.2f");
   const risk_amount_long = to_f2(longToReduce - actualLongReduce, "%.2f");
   const profit_percent_long = to_f2(shortToReduce * 100 / (long.entry * long.quantity), "%.4f");
@@ -60531,6 +60546,32 @@ function generateGapTp(payload) {
     gap_loss: to_f2(gapLoss, "%.2f")
   };
 }
+function calculate_factor(payload) {
+  const {
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor,
+    places = "%.4f"
+  } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  let calculated_factor;
+  const long_notional = long.entry * long.quantity;
+  const short_notional = short.entry * short.quantity;
+  const target_to_reduce = desired_risk / (1 - sell_factor);
+  if (kind === "short") {
+    const calculate_longPercent = target_to_reduce / long_notional;
+    calculated_factor = calculate_longPercent * short_notional / gapLoss;
+  } else {
+    const calculated_shortPercent = target_to_reduce / (short_notional - target_to_reduce);
+    calculated_factor = calculated_shortPercent * long_notional / gapLoss;
+  }
+  calculated_factor = to_f2(calculated_factor, places);
+  return calculated_factor;
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -60934,12 +60975,14 @@ class Strategy {
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
   identifyGapConfig(payload) {
-    const { factor = 1, sell_factor = 1 } = payload;
+    const { factor, sell_factor = 1, kind, risk } = payload;
     return generateGapTp({
       long: this.position.long,
       short: this.position.short,
       factor,
       sell_factor,
+      kind,
+      risk,
       decimal_places: this.config.global_config.decimal_places,
       price_places: this.config.global_config.price_places
     });
@@ -60963,6 +61006,67 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const {
+      factor,
+      direction,
+      sell_factor = 1,
+      iterations = 10,
+      risk: desired_risk,
+      kind
+    } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    for (let i2 = 0;i2 < iterations; i2++) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor,
+        kind,
+        risk: desired_risk
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = direction == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[direction] = {
+        entry: take_profit[direction],
+        quantity: remaining
+      };
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[direction];
+    const entry = this.position[direction].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -64859,19 +64963,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -65716,6 +65825,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/package.json

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