@gbozee/ultimate 0.0.2-110 → 0.0.2-112

package/dist/frontend-index.d.ts

@@ -531,25 +531,51 @@ export declare function determineRewardFactor(payload: {
 	minimum_pnl: number;
 	risk: number;
 }): number;
+export type BotPosition = {
+	kind: "long" | "short";
+	entry: number;
+	quantity: number;
+	tp: {
+		price: number;
+	};
+};
 export declare function getHedgeZone(payload: {
 	symbol_config: GlobalConfig;
 	risk: number;
-	position: {
-		kind: "long" | "short";
-		entry: number;
-		quantity: number;
-		tp: {
-			price: number;
-		};
-	};
-	reward_factor: number;
+	position: BotPosition;
+	reward_factor?: number;
 	risk_factor?: number;
+	support?: number;
 }): {
 	support: number;
 	resistance: number;
 	risk: number;
 	profit_percent: number;
 };
+export declare function getOptimumHedgeFactor(payload: {
+	target_support: number;
+	tolerance?: number;
+	max_iterations?: number;
+	min_factor?: number;
+	max_factor?: number;
+	symbol_config: GlobalConfig;
+	risk: number;
+	position: BotPosition;
+}): {
+	reward_factor: number;
+	achieved_support: number;
+	target_support: number;
+	difference: number;
+	iterations: number;
+	converged?: undefined;
+} | {
+	reward_factor: number;
+	achieved_support: number;
+	target_support: number;
+	difference: number;
+	iterations: number;
+	converged: boolean;
+};
 export type StrategyPosition = {
 	entry: number;
 	quantity: number;

package/dist/frontend-index.js

@@ -1948,13 +1948,24 @@ function determineRewardFactor(payload) {
 }
 function getHedgeZone(payload) {
   const {
-    reward_factor,
+    reward_factor: _reward_factor,
     symbol_config,
     risk,
     position: position2,
-    risk_factor = 1
+    risk_factor = 1,
+    support
   } = payload;
   const kind = position2.kind;
+  let reward_factor = _reward_factor;
+  if (support) {
+    const _result = getOptimumHedgeFactor({
+      target_support: support,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    reward_factor = Number(_result.reward_factor);
+  }
   const take_profit = position2.tp?.price;
   const tp_diff = Math.abs(take_profit - position2.entry);
   const quantity = position2.quantity;
@@ -1974,6 +1985,69 @@ function getHedgeZone(payload) {
     profit_percent: to_f(profit_percent, "%.2f")
   };
 }
+function getOptimumHedgeFactor(payload) {
+  const {
+    target_support,
+    max_iterations = 50,
+    min_factor = 0.1,
+    max_factor = 20,
+    symbol_config,
+    risk,
+    position: position2
+  } = payload;
+  const current_price = position2.entry;
+  const tolerance = current_price > 100 ? 0.5 : current_price > 1 ? 0.01 : 0.001;
+  let low = min_factor;
+  let high = max_factor;
+  let best_factor = low;
+  let best_diff = Infinity;
+  for (let iteration = 0;iteration < max_iterations; iteration++) {
+    const mid_factor = (low + high) / 2;
+    const hedge_zone = getHedgeZone({
+      reward_factor: mid_factor,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    const current_support = hedge_zone.support;
+    const diff = Math.abs(current_support - target_support);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff <= tolerance) {
+      return {
+        reward_factor: to_f(mid_factor, "%.4f"),
+        achieved_support: to_f(current_support, symbol_config.price_places),
+        target_support: to_f(target_support, symbol_config.price_places),
+        difference: to_f(diff, symbol_config.price_places),
+        iterations: iteration + 1
+      };
+    }
+    if (current_support > target_support) {
+      low = mid_factor;
+    } else {
+      high = mid_factor;
+    }
+    if (Math.abs(high - low) < 0.0001) {
+      break;
+    }
+  }
+  const final_hedge_zone = getHedgeZone({
+    symbol_config,
+    risk,
+    position: position2,
+    reward_factor: best_factor
+  });
+  return {
+    reward_factor: to_f(best_factor, "%.4f"),
+    achieved_support: to_f(final_hedge_zone.support, symbol_config.price_places),
+    target_support: to_f(target_support, symbol_config.price_places),
+    difference: to_f(best_diff, symbol_config.price_places),
+    iterations: max_iterations,
+    converged: best_diff <= tolerance
+  };
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -2487,6 +2561,7 @@ export {
   getRiskReward,
   getParamForField,
   getOptimumStopAndRisk,
+  getOptimumHedgeFactor,
   getHedgeZone,
   getDecimalPlaces,
   generate_config_params,

package/dist/index.cjs

@@ -41894,6 +41894,7 @@ __export(exports_src, {
   get_app_config_and_max_size: () => get_app_config_and_max_size,
   getRiskReward: () => getRiskReward,
   getOptimumStopAndRisk: () => getOptimumStopAndRisk,
+  getOptimumHedgeFactor: () => getOptimumHedgeFactor,
   getHedgeZone: () => getHedgeZone,
   generate_config_params: () => generate_config_params,
   generateOptimumAppConfig: () => generateOptimumAppConfig,
@@ -54169,13 +54170,24 @@ function determineRewardFactor(payload) {
 }
 function getHedgeZone(payload) {
   const {
-    reward_factor,
+    reward_factor: _reward_factor,
     symbol_config,
     risk,
     position: position2,
-    risk_factor = 1
+    risk_factor = 1,
+    support
   } = payload;
   const kind = position2.kind;
+  let reward_factor = _reward_factor;
+  if (support) {
+    const _result = getOptimumHedgeFactor({
+      target_support: support,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    reward_factor = Number(_result.reward_factor);
+  }
   const take_profit = position2.tp?.price;
   const tp_diff = Math.abs(take_profit - position2.entry);
   const quantity = position2.quantity;
@@ -54195,6 +54207,69 @@ function getHedgeZone(payload) {
     profit_percent: to_f2(profit_percent, "%.2f")
   };
 }
+function getOptimumHedgeFactor(payload) {
+  const {
+    target_support,
+    max_iterations = 50,
+    min_factor = 0.1,
+    max_factor = 20,
+    symbol_config,
+    risk,
+    position: position2
+  } = payload;
+  const current_price = position2.entry;
+  const tolerance = current_price > 100 ? 0.5 : current_price > 1 ? 0.01 : 0.001;
+  let low = min_factor;
+  let high = max_factor;
+  let best_factor = low;
+  let best_diff = Infinity;
+  for (let iteration = 0;iteration < max_iterations; iteration++) {
+    const mid_factor = (low + high) / 2;
+    const hedge_zone = getHedgeZone({
+      reward_factor: mid_factor,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    const current_support = hedge_zone.support;
+    const diff = Math.abs(current_support - target_support);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff <= tolerance) {
+      return {
+        reward_factor: to_f2(mid_factor, "%.4f"),
+        achieved_support: to_f2(current_support, symbol_config.price_places),
+        target_support: to_f2(target_support, symbol_config.price_places),
+        difference: to_f2(diff, symbol_config.price_places),
+        iterations: iteration + 1
+      };
+    }
+    if (current_support > target_support) {
+      low = mid_factor;
+    } else {
+      high = mid_factor;
+    }
+    if (Math.abs(high - low) < 0.0001) {
+      break;
+    }
+  }
+  const final_hedge_zone = getHedgeZone({
+    symbol_config,
+    risk,
+    position: position2,
+    reward_factor: best_factor
+  });
+  return {
+    reward_factor: to_f2(best_factor, "%.4f"),
+    achieved_support: to_f2(final_hedge_zone.support, symbol_config.price_places),
+    target_support: to_f2(target_support, symbol_config.price_places),
+    difference: to_f2(best_diff, symbol_config.price_places),
+    iterations: max_iterations,
+    converged: best_diff <= tolerance
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -58617,6 +58692,78 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async updateGoodHedgeConfig(payload) {
+    const {
+      params,
+      place,
+      update_tp,
+      symbol,
+      risk_factor = 1,
+      update = true
+    } = payload;
+    let _params = params;
+    if (!params) {
+      const result = await this.exchange.analyzeCandlesticks({ symbol });
+      const support_price = Math.min(...Object.keys(result.support).map(Number));
+      const symbol_config = await this.recomputeSymbolConfig({ symbol });
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: "long"
+      });
+      const position2 = await this.syncAccount({
+        symbol,
+        kind: "long",
+        as_view: true
+      });
+      const bot_position = {
+        kind: "long",
+        entry: position2.entry,
+        quantity: position2.quantity,
+        tp: {
+          price: position2.take_profit
+        }
+      };
+      _params = getHedgeZone({
+        symbol_config,
+        risk: config2.risk,
+        position: bot_position,
+        support: support_price
+      });
+    }
+    if (update) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "short",
+        params: {
+          entry: _params.support,
+          stop: _params.resistance,
+          risk: _params.risk * risk_factor
+        }
+      });
+    }
+    if (update_tp) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          profit_percent: _params.profit_percent
+        }
+      });
+      await this.updateTargetPnl({
+        symbol,
+        kind: "long"
+      });
+    }
+    if (place) {
+      await this.placeTrade({
+        symbol,
+        kind: "short",
+        limit: true,
+        ignore_config: true
+      });
+    }
+    return _params;
+  }
   async placeOppositeTradeAction(payload) {
     const { symbol, kind, data } = payload;
     const position2 = await this.syncAccount({

package/dist/index.d.ts

@@ -1369,25 +1369,51 @@ export declare function determineRewardFactor(payload: {
 	minimum_pnl: number;
 	risk: number;
 }): number;
+export type BotPosition = {
+	kind: "long" | "short";
+	entry: number;
+	quantity: number;
+	tp: {
+		price: number;
+	};
+};
 export declare function getHedgeZone(payload: {
 	symbol_config: GlobalConfig;
 	risk: number;
-	position: {
-		kind: "long" | "short";
-		entry: number;
-		quantity: number;
-		tp: {
-			price: number;
-		};
-	};
-	reward_factor: number;
+	position: BotPosition;
+	reward_factor?: number;
 	risk_factor?: number;
+	support?: number;
 }): {
 	support: number;
 	resistance: number;
 	risk: number;
 	profit_percent: number;
 };
+export declare function getOptimumHedgeFactor(payload: {
+	target_support: number;
+	tolerance?: number;
+	max_iterations?: number;
+	min_factor?: number;
+	max_factor?: number;
+	symbol_config: GlobalConfig;
+	risk: number;
+	position: BotPosition;
+}): {
+	reward_factor: number;
+	achieved_support: number;
+	target_support: number;
+	difference: number;
+	iterations: number;
+	converged?: undefined;
+} | {
+	reward_factor: number;
+	achieved_support: number;
+	target_support: number;
+	difference: number;
+	iterations: number;
+	converged: boolean;
+};
 declare class ExchangePosition {
 	exchange: BaseExchange;
 	exchange_account: ExchangeAccount$1;
@@ -1866,6 +1892,27 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<number>;
+	updateGoodHedgeConfig(payload: {
+		symbol: string;
+		params?: {
+			support: number;
+			resistance: number;
+			risk: number;
+			profit_percent: number;
+		};
+		risk_factor?: number;
+		update?: boolean;
+		place?: boolean;
+		update_tp?: boolean;
+	}): Promise<{
+		support: number;
+		resistance: number;
+		risk: number;
+		profit_percent: number;
+	}>;
+	/**
+	 * This method is used to place the opposite trade action
+	 */
 	placeOppositeTradeAction(payload: {
 		symbol: string;
 		kind: "long" | "short";

package/dist/index.js

@@ -54120,13 +54120,24 @@ function determineRewardFactor(payload) {
 }
 function getHedgeZone(payload) {
   const {
-    reward_factor,
+    reward_factor: _reward_factor,
     symbol_config,
     risk,
     position: position2,
-    risk_factor = 1
+    risk_factor = 1,
+    support
   } = payload;
   const kind = position2.kind;
+  let reward_factor = _reward_factor;
+  if (support) {
+    const _result = getOptimumHedgeFactor({
+      target_support: support,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    reward_factor = Number(_result.reward_factor);
+  }
   const take_profit = position2.tp?.price;
   const tp_diff = Math.abs(take_profit - position2.entry);
   const quantity = position2.quantity;
@@ -54146,6 +54157,69 @@ function getHedgeZone(payload) {
     profit_percent: to_f2(profit_percent, "%.2f")
   };
 }
+function getOptimumHedgeFactor(payload) {
+  const {
+    target_support,
+    max_iterations = 50,
+    min_factor = 0.1,
+    max_factor = 20,
+    symbol_config,
+    risk,
+    position: position2
+  } = payload;
+  const current_price = position2.entry;
+  const tolerance = current_price > 100 ? 0.5 : current_price > 1 ? 0.01 : 0.001;
+  let low = min_factor;
+  let high = max_factor;
+  let best_factor = low;
+  let best_diff = Infinity;
+  for (let iteration = 0;iteration < max_iterations; iteration++) {
+    const mid_factor = (low + high) / 2;
+    const hedge_zone = getHedgeZone({
+      reward_factor: mid_factor,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    const current_support = hedge_zone.support;
+    const diff = Math.abs(current_support - target_support);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff <= tolerance) {
+      return {
+        reward_factor: to_f2(mid_factor, "%.4f"),
+        achieved_support: to_f2(current_support, symbol_config.price_places),
+        target_support: to_f2(target_support, symbol_config.price_places),
+        difference: to_f2(diff, symbol_config.price_places),
+        iterations: iteration + 1
+      };
+    }
+    if (current_support > target_support) {
+      low = mid_factor;
+    } else {
+      high = mid_factor;
+    }
+    if (Math.abs(high - low) < 0.0001) {
+      break;
+    }
+  }
+  const final_hedge_zone = getHedgeZone({
+    symbol_config,
+    risk,
+    position: position2,
+    reward_factor: best_factor
+  });
+  return {
+    reward_factor: to_f2(best_factor, "%.4f"),
+    achieved_support: to_f2(final_hedge_zone.support, symbol_config.price_places),
+    target_support: to_f2(target_support, symbol_config.price_places),
+    difference: to_f2(best_diff, symbol_config.price_places),
+    iterations: max_iterations,
+    converged: best_diff <= tolerance
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -58568,6 +58642,78 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async updateGoodHedgeConfig(payload) {
+    const {
+      params,
+      place,
+      update_tp,
+      symbol,
+      risk_factor = 1,
+      update = true
+    } = payload;
+    let _params = params;
+    if (!params) {
+      const result = await this.exchange.analyzeCandlesticks({ symbol });
+      const support_price = Math.min(...Object.keys(result.support).map(Number));
+      const symbol_config = await this.recomputeSymbolConfig({ symbol });
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: "long"
+      });
+      const position2 = await this.syncAccount({
+        symbol,
+        kind: "long",
+        as_view: true
+      });
+      const bot_position = {
+        kind: "long",
+        entry: position2.entry,
+        quantity: position2.quantity,
+        tp: {
+          price: position2.take_profit
+        }
+      };
+      _params = getHedgeZone({
+        symbol_config,
+        risk: config2.risk,
+        position: bot_position,
+        support: support_price
+      });
+    }
+    if (update) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "short",
+        params: {
+          entry: _params.support,
+          stop: _params.resistance,
+          risk: _params.risk * risk_factor
+        }
+      });
+    }
+    if (update_tp) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          profit_percent: _params.profit_percent
+        }
+      });
+      await this.updateTargetPnl({
+        symbol,
+        kind: "long"
+      });
+    }
+    if (place) {
+      await this.placeTrade({
+        symbol,
+        kind: "short",
+        limit: true,
+        ignore_config: true
+      });
+    }
+    return _params;
+  }
   async placeOppositeTradeAction(payload) {
     const { symbol, kind, data } = payload;
     const position2 = await this.syncAccount({
@@ -60115,6 +60261,7 @@ export {
   get_app_config_and_max_size,
   getRiskReward,
   getOptimumStopAndRisk,
+  getOptimumHedgeFactor,
   getHedgeZone,
   generate_config_params,
   generateOptimumAppConfig,

package/dist/mcp-server.cjs

@@ -60848,6 +60848,108 @@ function calculate_factor(payload) {
   calculated_factor = to_f2(calculated_factor, places);
   return calculated_factor;
 }
+function getHedgeZone(payload) {
+  const {
+    reward_factor: _reward_factor,
+    symbol_config,
+    risk,
+    position: position2,
+    risk_factor = 1,
+    support
+  } = payload;
+  const kind = position2.kind;
+  let reward_factor = _reward_factor;
+  if (support) {
+    const _result = getOptimumHedgeFactor({
+      target_support: support,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    reward_factor = Number(_result.reward_factor);
+  }
+  const take_profit = position2.tp?.price;
+  const tp_diff = Math.abs(take_profit - position2.entry);
+  const quantity = position2.quantity;
+  const diff = risk / quantity;
+  let new_take_profit = kind === "long" ? to_f2(position2.entry + diff, symbol_config.price_places) : to_f2(position2.entry - diff, symbol_config.price_places);
+  let base_factor = to_f2(Math.max(tp_diff, diff) / (Math.min(tp_diff, diff) || 1), "%.3f");
+  let factor = reward_factor || base_factor;
+  const new_risk = risk * factor * risk_factor;
+  const stop_loss_diff = new_risk / quantity;
+  new_take_profit = kind === "long" ? to_f2(position2.entry + stop_loss_diff, symbol_config.price_places) : to_f2(position2.entry - stop_loss_diff, symbol_config.price_places);
+  const stop_loss = kind === "long" ? to_f2(position2.entry - stop_loss_diff, symbol_config.price_places) : to_f2(position2.entry + stop_loss_diff, symbol_config.price_places);
+  const profit_percent = new_risk * 100 / (position2.entry * position2.quantity);
+  return {
+    support: Math.min(new_take_profit, stop_loss),
+    resistance: Math.max(new_take_profit, stop_loss),
+    risk: to_f2(new_risk, "%.2f"),
+    profit_percent: to_f2(profit_percent, "%.2f")
+  };
+}
+function getOptimumHedgeFactor(payload) {
+  const {
+    target_support,
+    max_iterations = 50,
+    min_factor = 0.1,
+    max_factor = 20,
+    symbol_config,
+    risk,
+    position: position2
+  } = payload;
+  const current_price = position2.entry;
+  const tolerance = current_price > 100 ? 0.5 : current_price > 1 ? 0.01 : 0.001;
+  let low = min_factor;
+  let high = max_factor;
+  let best_factor = low;
+  let best_diff = Infinity;
+  for (let iteration = 0;iteration < max_iterations; iteration++) {
+    const mid_factor = (low + high) / 2;
+    const hedge_zone = getHedgeZone({
+      reward_factor: mid_factor,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    const current_support = hedge_zone.support;
+    const diff = Math.abs(current_support - target_support);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff <= tolerance) {
+      return {
+        reward_factor: to_f2(mid_factor, "%.4f"),
+        achieved_support: to_f2(current_support, symbol_config.price_places),
+        target_support: to_f2(target_support, symbol_config.price_places),
+        difference: to_f2(diff, symbol_config.price_places),
+        iterations: iteration + 1
+      };
+    }
+    if (current_support > target_support) {
+      low = mid_factor;
+    } else {
+      high = mid_factor;
+    }
+    if (Math.abs(high - low) < 0.0001) {
+      break;
+    }
+  }
+  const final_hedge_zone = getHedgeZone({
+    symbol_config,
+    risk,
+    position: position2,
+    reward_factor: best_factor
+  });
+  return {
+    reward_factor: to_f2(best_factor, "%.4f"),
+    achieved_support: to_f2(final_hedge_zone.support, symbol_config.price_places),
+    target_support: to_f2(target_support, symbol_config.price_places),
+    difference: to_f2(best_diff, symbol_config.price_places),
+    iterations: max_iterations,
+    converged: best_diff <= tolerance
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -65270,6 +65372,78 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async updateGoodHedgeConfig(payload) {
+    const {
+      params,
+      place,
+      update_tp,
+      symbol,
+      risk_factor = 1,
+      update = true
+    } = payload;
+    let _params = params;
+    if (!params) {
+      const result = await this.exchange.analyzeCandlesticks({ symbol });
+      const support_price = Math.min(...Object.keys(result.support).map(Number));
+      const symbol_config = await this.recomputeSymbolConfig({ symbol });
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: "long"
+      });
+      const position2 = await this.syncAccount({
+        symbol,
+        kind: "long",
+        as_view: true
+      });
+      const bot_position = {
+        kind: "long",
+        entry: position2.entry,
+        quantity: position2.quantity,
+        tp: {
+          price: position2.take_profit
+        }
+      };
+      _params = getHedgeZone({
+        symbol_config,
+        risk: config2.risk,
+        position: bot_position,
+        support: support_price
+      });
+    }
+    if (update) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "short",
+        params: {
+          entry: _params.support,
+          stop: _params.resistance,
+          risk: _params.risk * risk_factor
+        }
+      });
+    }
+    if (update_tp) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          profit_percent: _params.profit_percent
+        }
+      });
+      await this.updateTargetPnl({
+        symbol,
+        kind: "long"
+      });
+    }
+    if (place) {
+      await this.placeTrade({
+        symbol,
+        kind: "short",
+        limit: true,
+        ignore_config: true
+      });
+    }
+    return _params;
+  }
   async placeOppositeTradeAction(payload) {
     const { symbol, kind, data } = payload;
     const position2 = await this.syncAccount({

package/dist/mcp-server.js

@@ -60825,6 +60825,108 @@ function calculate_factor(payload) {
   calculated_factor = to_f2(calculated_factor, places);
   return calculated_factor;
 }
+function getHedgeZone(payload) {
+  const {
+    reward_factor: _reward_factor,
+    symbol_config,
+    risk,
+    position: position2,
+    risk_factor = 1,
+    support
+  } = payload;
+  const kind = position2.kind;
+  let reward_factor = _reward_factor;
+  if (support) {
+    const _result = getOptimumHedgeFactor({
+      target_support: support,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    reward_factor = Number(_result.reward_factor);
+  }
+  const take_profit = position2.tp?.price;
+  const tp_diff = Math.abs(take_profit - position2.entry);
+  const quantity = position2.quantity;
+  const diff = risk / quantity;
+  let new_take_profit = kind === "long" ? to_f2(position2.entry + diff, symbol_config.price_places) : to_f2(position2.entry - diff, symbol_config.price_places);
+  let base_factor = to_f2(Math.max(tp_diff, diff) / (Math.min(tp_diff, diff) || 1), "%.3f");
+  let factor = reward_factor || base_factor;
+  const new_risk = risk * factor * risk_factor;
+  const stop_loss_diff = new_risk / quantity;
+  new_take_profit = kind === "long" ? to_f2(position2.entry + stop_loss_diff, symbol_config.price_places) : to_f2(position2.entry - stop_loss_diff, symbol_config.price_places);
+  const stop_loss = kind === "long" ? to_f2(position2.entry - stop_loss_diff, symbol_config.price_places) : to_f2(position2.entry + stop_loss_diff, symbol_config.price_places);
+  const profit_percent = new_risk * 100 / (position2.entry * position2.quantity);
+  return {
+    support: Math.min(new_take_profit, stop_loss),
+    resistance: Math.max(new_take_profit, stop_loss),
+    risk: to_f2(new_risk, "%.2f"),
+    profit_percent: to_f2(profit_percent, "%.2f")
+  };
+}
+function getOptimumHedgeFactor(payload) {
+  const {
+    target_support,
+    max_iterations = 50,
+    min_factor = 0.1,
+    max_factor = 20,
+    symbol_config,
+    risk,
+    position: position2
+  } = payload;
+  const current_price = position2.entry;
+  const tolerance = current_price > 100 ? 0.5 : current_price > 1 ? 0.01 : 0.001;
+  let low = min_factor;
+  let high = max_factor;
+  let best_factor = low;
+  let best_diff = Infinity;
+  for (let iteration = 0;iteration < max_iterations; iteration++) {
+    const mid_factor = (low + high) / 2;
+    const hedge_zone = getHedgeZone({
+      reward_factor: mid_factor,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    const current_support = hedge_zone.support;
+    const diff = Math.abs(current_support - target_support);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff <= tolerance) {
+      return {
+        reward_factor: to_f2(mid_factor, "%.4f"),
+        achieved_support: to_f2(current_support, symbol_config.price_places),
+        target_support: to_f2(target_support, symbol_config.price_places),
+        difference: to_f2(diff, symbol_config.price_places),
+        iterations: iteration + 1
+      };
+    }
+    if (current_support > target_support) {
+      low = mid_factor;
+    } else {
+      high = mid_factor;
+    }
+    if (Math.abs(high - low) < 0.0001) {
+      break;
+    }
+  }
+  const final_hedge_zone = getHedgeZone({
+    symbol_config,
+    risk,
+    position: position2,
+    reward_factor: best_factor
+  });
+  return {
+    reward_factor: to_f2(best_factor, "%.4f"),
+    achieved_support: to_f2(final_hedge_zone.support, symbol_config.price_places),
+    target_support: to_f2(target_support, symbol_config.price_places),
+    difference: to_f2(best_diff, symbol_config.price_places),
+    iterations: max_iterations,
+    converged: best_diff <= tolerance
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -65247,6 +65349,78 @@ class ExchangeAccount {
     }
     return 0;
   }
+  async updateGoodHedgeConfig(payload) {
+    const {
+      params,
+      place,
+      update_tp,
+      symbol,
+      risk_factor = 1,
+      update = true
+    } = payload;
+    let _params = params;
+    if (!params) {
+      const result = await this.exchange.analyzeCandlesticks({ symbol });
+      const support_price = Math.min(...Object.keys(result.support).map(Number));
+      const symbol_config = await this.recomputeSymbolConfig({ symbol });
+      const config2 = await this.getPositionConfig({
+        symbol,
+        kind: "long"
+      });
+      const position2 = await this.syncAccount({
+        symbol,
+        kind: "long",
+        as_view: true
+      });
+      const bot_position = {
+        kind: "long",
+        entry: position2.entry,
+        quantity: position2.quantity,
+        tp: {
+          price: position2.take_profit
+        }
+      };
+      _params = getHedgeZone({
+        symbol_config,
+        risk: config2.risk,
+        position: bot_position,
+        support: support_price
+      });
+    }
+    if (update) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "short",
+        params: {
+          entry: _params.support,
+          stop: _params.resistance,
+          risk: _params.risk * risk_factor
+        }
+      });
+    }
+    if (update_tp) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          profit_percent: _params.profit_percent
+        }
+      });
+      await this.updateTargetPnl({
+        symbol,
+        kind: "long"
+      });
+    }
+    if (place) {
+      await this.placeTrade({
+        symbol,
+        kind: "short",
+        limit: true,
+        ignore_config: true
+      });
+    }
+    return _params;
+  }
   async placeOppositeTradeAction(payload) {
     const { symbol, kind, data } = payload;
     const position2 = await this.syncAccount({

package/package.json

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