@gbozee/ultimate 0.0.2-110 → 0.0.2-111

package/dist/frontend-index.d.ts

@@ -531,17 +531,18 @@ 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;
-		};
-	};
+	position: BotPosition;
 	reward_factor: number;
 	risk_factor?: number;
 }): {
@@ -550,6 +551,30 @@ export declare function getHedgeZone(payload: {
 	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

@@ -1974,6 +1974,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 +2550,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,
@@ -54195,6 +54196,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 {

package/dist/index.d.ts

@@ -1369,17 +1369,18 @@ 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;
-		};
-	};
+	position: BotPosition;
 	reward_factor: number;
 	risk_factor?: number;
 }): {
@@ -1388,6 +1389,30 @@ export declare function getHedgeZone(payload: {
 	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 +1891,9 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<number>;
+	/**
+	 * This method is used to place the opposite trade action
+	 */
 	placeOppositeTradeAction(payload: {
 		symbol: string;
 		kind: "long" | "short";

package/dist/index.js

@@ -54146,6 +54146,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 {
@@ -60115,6 +60178,7 @@ export {
   get_app_config_and_max_size,
   getRiskReward,
   getOptimumStopAndRisk,
+  getOptimumHedgeFactor,
   getHedgeZone,
   generate_config_params,
   generateOptimumAppConfig,

package/package.json

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