@gbozee/ultimate 0.0.2-129 → 0.0.2-130

package/dist/frontend-index.d.ts

@@ -418,6 +418,27 @@ export declare function determineOptimumReward(app_config: AppConfig, increase?:
 	neg_pnl: any;
 	entry: any;
 };
+export declare function determineOptimumRisk(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	risk: number;
+	symbol: string;
+}, params: {
+	highest_risk: number;
+	tolerance?: number;
+	max_iterations?: number;
+}): {
+	optimal_risk: number;
+	achieved_neg_pnl: number;
+	target_neg_pnl: number;
+	difference: number;
+	iterations: number;
+	converged: boolean;
+	last_value: any;
+	entries: any[];
+	app_config: AppConfig;
+};
 export declare function computeRiskReward(payload: {
 	app_config: AppConfig;
 	entry: number;
@@ -438,6 +459,7 @@ export declare function getRiskReward(payload: {
 	stop: number;
 	risk: number;
 	global_config: GlobalConfig;
+	force_exact_risk?: boolean;
 }): any;
 export declare function computeProfitDetail(payload: {
 	focus_position: {

package/dist/frontend-index.js

@@ -1786,6 +1786,62 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
   }, found[0]);
   return maximum;
 }
+function determineOptimumRisk(config, payload, params) {
+  const { highest_risk, tolerance = 0.01, max_iterations = 200 } = params;
+  let low_risk = 1;
+  let high_risk = Math.max(highest_risk * 5, payload.risk * 10);
+  let best_risk = payload.risk;
+  let best_neg_pnl = 0;
+  let best_diff = Infinity;
+  console.log(`Finding optimal risk for target neg_pnl: ${highest_risk}`);
+  let iterations = 0;
+  while (iterations < max_iterations && high_risk - low_risk > tolerance) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const test_payload = {
+      ...payload,
+      risk: mid_risk
+    };
+    const { last_value } = buildAppConfig(config, test_payload);
+    if (!last_value || !last_value.neg_pnl) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const current_neg_pnl = Math.abs(last_value.neg_pnl);
+    const diff = Math.abs(current_neg_pnl - highest_risk);
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, neg_pnl=${current_neg_pnl.toFixed(2)}, diff=${diff.toFixed(2)}`);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_risk = mid_risk;
+      best_neg_pnl = current_neg_pnl;
+    }
+    if (diff <= tolerance) {
+      console.log(`Converged! Optimal risk: ${mid_risk.toFixed(2)}`);
+      break;
+    }
+    if (current_neg_pnl < highest_risk) {
+      low_risk = mid_risk;
+    } else {
+      high_risk = mid_risk;
+    }
+  }
+  const final_payload = {
+    ...payload,
+    risk: best_risk
+  };
+  const final_result = buildAppConfig(config, final_payload);
+  return {
+    optimal_risk: to_f(best_risk, "%.2f"),
+    achieved_neg_pnl: to_f(best_neg_pnl, "%.2f"),
+    target_neg_pnl: to_f(highest_risk, "%.2f"),
+    difference: to_f(best_diff, "%.2f"),
+    iterations,
+    converged: best_diff <= tolerance,
+    last_value: final_result.last_value,
+    entries: final_result.entries,
+    app_config: final_result
+  };
+}
 function computeRiskReward(payload) {
   const { app_config, entry, stop, risk_per_trade } = payload;
   const kind = entry > stop ? "long" : "short";
@@ -1797,7 +1853,13 @@ function computeRiskReward(payload) {
   return result;
 }
 function getRiskReward(payload) {
-  const { entry, stop, risk, global_config } = payload;
+  const {
+    entry,
+    stop,
+    risk,
+    global_config,
+    force_exact_risk = false
+  } = payload;
   const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
     entry,
     stop,
@@ -1811,6 +1873,18 @@ function getRiskReward(payload) {
     stop,
     risk_per_trade: risk
   });
+  if (force_exact_risk) {
+    const new_risk_per_trade = determineOptimumRisk(global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: global_config.symbol
+    }, {
+      highest_risk: risk
+    }).optimal_risk;
+    return { risk: new_risk_per_trade, risk_reward };
+  }
   return risk_reward;
 }
 function computeProfitDetail(payload) {
@@ -2589,6 +2663,7 @@ export {
   determine_amount_to_buy,
   determineTPSl,
   determineRewardFactor,
+  determineOptimumRisk,
   determineOptimumReward,
   createGapPairs,
   createArray,

package/dist/index.cjs

@@ -41961,6 +41961,7 @@ __export(exports_src, {
   determine_average_entry_and_size: () => determine_average_entry_and_size,
   determine_amount_to_buy: () => determine_amount_to_buy,
   determineRewardFactor: () => determineRewardFactor,
+  determineOptimumRisk: () => determineOptimumRisk,
   determineOptimumReward: () => determineOptimumReward,
   database: () => exports_database,
   createArray: () => createArray,
@@ -54090,6 +54091,62 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
   }, found[0]);
   return maximum;
 }
+function determineOptimumRisk(config2, payload, params) {
+  const { highest_risk, tolerance = 0.01, max_iterations = 200 } = params;
+  let low_risk = 1;
+  let high_risk = Math.max(highest_risk * 5, payload.risk * 10);
+  let best_risk = payload.risk;
+  let best_neg_pnl = 0;
+  let best_diff = Infinity;
+  console.log(`Finding optimal risk for target neg_pnl: ${highest_risk}`);
+  let iterations = 0;
+  while (iterations < max_iterations && high_risk - low_risk > tolerance) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const test_payload = {
+      ...payload,
+      risk: mid_risk
+    };
+    const { last_value } = buildAppConfig(config2, test_payload);
+    if (!last_value || !last_value.neg_pnl) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const current_neg_pnl = Math.abs(last_value.neg_pnl);
+    const diff = Math.abs(current_neg_pnl - highest_risk);
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, neg_pnl=${current_neg_pnl.toFixed(2)}, diff=${diff.toFixed(2)}`);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_risk = mid_risk;
+      best_neg_pnl = current_neg_pnl;
+    }
+    if (diff <= tolerance) {
+      console.log(`Converged! Optimal risk: ${mid_risk.toFixed(2)}`);
+      break;
+    }
+    if (current_neg_pnl < highest_risk) {
+      low_risk = mid_risk;
+    } else {
+      high_risk = mid_risk;
+    }
+  }
+  const final_payload = {
+    ...payload,
+    risk: best_risk
+  };
+  const final_result = buildAppConfig(config2, final_payload);
+  return {
+    optimal_risk: to_f2(best_risk, "%.2f"),
+    achieved_neg_pnl: to_f2(best_neg_pnl, "%.2f"),
+    target_neg_pnl: to_f2(highest_risk, "%.2f"),
+    difference: to_f2(best_diff, "%.2f"),
+    iterations,
+    converged: best_diff <= tolerance,
+    last_value: final_result.last_value,
+    entries: final_result.entries,
+    app_config: final_result
+  };
+}
 function computeRiskReward(payload) {
   const { app_config, entry, stop, risk_per_trade } = payload;
   const kind = entry > stop ? "long" : "short";
@@ -54101,7 +54158,13 @@ function computeRiskReward(payload) {
   return result;
 }
 function getRiskReward(payload) {
-  const { entry, stop, risk, global_config } = payload;
+  const {
+    entry,
+    stop,
+    risk,
+    global_config,
+    force_exact_risk = false
+  } = payload;
   const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
     entry,
     stop,
@@ -54115,6 +54178,18 @@ function getRiskReward(payload) {
     stop,
     risk_per_trade: risk
   });
+  if (force_exact_risk) {
+    const new_risk_per_trade = determineOptimumRisk(global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: global_config.symbol
+    }, {
+      highest_risk: risk
+    }).optimal_risk;
+    return { risk: new_risk_per_trade, risk_reward };
+  }
   return risk_reward;
 }
 function computeProfitDetail(payload) {

package/dist/index.d.ts

@@ -1347,6 +1347,27 @@ export declare function determineOptimumReward(app_config: AppConfig, increase?:
 	neg_pnl: any;
 	entry: any;
 };
+export declare function determineOptimumRisk(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	risk: number;
+	symbol: string;
+}, params: {
+	highest_risk: number;
+	tolerance?: number;
+	max_iterations?: number;
+}): {
+	optimal_risk: number;
+	achieved_neg_pnl: number;
+	target_neg_pnl: number;
+	difference: number;
+	iterations: number;
+	converged: boolean;
+	last_value: any;
+	entries: any[];
+	app_config: AppConfig;
+};
 export declare function computeRiskReward(payload: {
 	app_config: AppConfig;
 	entry: number;
@@ -1367,6 +1388,7 @@ export declare function getRiskReward(payload: {
 	stop: number;
 	risk: number;
 	global_config: GlobalConfig;
+	force_exact_risk?: boolean;
 }): any;
 export declare function computeProfitDetail(payload: {
 	focus_position: {

package/dist/index.js

@@ -54040,6 +54040,62 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
   }, found[0]);
   return maximum;
 }
+function determineOptimumRisk(config2, payload, params) {
+  const { highest_risk, tolerance = 0.01, max_iterations = 200 } = params;
+  let low_risk = 1;
+  let high_risk = Math.max(highest_risk * 5, payload.risk * 10);
+  let best_risk = payload.risk;
+  let best_neg_pnl = 0;
+  let best_diff = Infinity;
+  console.log(`Finding optimal risk for target neg_pnl: ${highest_risk}`);
+  let iterations = 0;
+  while (iterations < max_iterations && high_risk - low_risk > tolerance) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const test_payload = {
+      ...payload,
+      risk: mid_risk
+    };
+    const { last_value } = buildAppConfig(config2, test_payload);
+    if (!last_value || !last_value.neg_pnl) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const current_neg_pnl = Math.abs(last_value.neg_pnl);
+    const diff = Math.abs(current_neg_pnl - highest_risk);
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, neg_pnl=${current_neg_pnl.toFixed(2)}, diff=${diff.toFixed(2)}`);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_risk = mid_risk;
+      best_neg_pnl = current_neg_pnl;
+    }
+    if (diff <= tolerance) {
+      console.log(`Converged! Optimal risk: ${mid_risk.toFixed(2)}`);
+      break;
+    }
+    if (current_neg_pnl < highest_risk) {
+      low_risk = mid_risk;
+    } else {
+      high_risk = mid_risk;
+    }
+  }
+  const final_payload = {
+    ...payload,
+    risk: best_risk
+  };
+  const final_result = buildAppConfig(config2, final_payload);
+  return {
+    optimal_risk: to_f2(best_risk, "%.2f"),
+    achieved_neg_pnl: to_f2(best_neg_pnl, "%.2f"),
+    target_neg_pnl: to_f2(highest_risk, "%.2f"),
+    difference: to_f2(best_diff, "%.2f"),
+    iterations,
+    converged: best_diff <= tolerance,
+    last_value: final_result.last_value,
+    entries: final_result.entries,
+    app_config: final_result
+  };
+}
 function computeRiskReward(payload) {
   const { app_config, entry, stop, risk_per_trade } = payload;
   const kind = entry > stop ? "long" : "short";
@@ -54051,7 +54107,13 @@ function computeRiskReward(payload) {
   return result;
 }
 function getRiskReward(payload) {
-  const { entry, stop, risk, global_config } = payload;
+  const {
+    entry,
+    stop,
+    risk,
+    global_config,
+    force_exact_risk = false
+  } = payload;
   const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
     entry,
     stop,
@@ -54065,6 +54127,18 @@ function getRiskReward(payload) {
     stop,
     risk_per_trade: risk
   });
+  if (force_exact_risk) {
+    const new_risk_per_trade = determineOptimumRisk(global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: global_config.symbol
+    }, {
+      highest_risk: risk
+    }).optimal_risk;
+    return { risk: new_risk_per_trade, risk_reward };
+  }
   return risk_reward;
 }
 function computeProfitDetail(payload) {
@@ -60431,6 +60505,7 @@ export {
   determine_average_entry_and_size,
   determine_amount_to_buy,
   determineRewardFactor,
+  determineOptimumRisk,
   determineOptimumReward,
   exports_database as database,
   createArray,

package/dist/mcp-server.cjs

@@ -60774,6 +60774,62 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
   }, found[0]);
   return maximum;
 }
+function determineOptimumRisk(config2, payload, params) {
+  const { highest_risk, tolerance = 0.01, max_iterations = 200 } = params;
+  let low_risk = 1;
+  let high_risk = Math.max(highest_risk * 5, payload.risk * 10);
+  let best_risk = payload.risk;
+  let best_neg_pnl = 0;
+  let best_diff = Infinity;
+  console.log(`Finding optimal risk for target neg_pnl: ${highest_risk}`);
+  let iterations = 0;
+  while (iterations < max_iterations && high_risk - low_risk > tolerance) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const test_payload = {
+      ...payload,
+      risk: mid_risk
+    };
+    const { last_value } = buildAppConfig(config2, test_payload);
+    if (!last_value || !last_value.neg_pnl) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const current_neg_pnl = Math.abs(last_value.neg_pnl);
+    const diff = Math.abs(current_neg_pnl - highest_risk);
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, neg_pnl=${current_neg_pnl.toFixed(2)}, diff=${diff.toFixed(2)}`);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_risk = mid_risk;
+      best_neg_pnl = current_neg_pnl;
+    }
+    if (diff <= tolerance) {
+      console.log(`Converged! Optimal risk: ${mid_risk.toFixed(2)}`);
+      break;
+    }
+    if (current_neg_pnl < highest_risk) {
+      low_risk = mid_risk;
+    } else {
+      high_risk = mid_risk;
+    }
+  }
+  const final_payload = {
+    ...payload,
+    risk: best_risk
+  };
+  const final_result = buildAppConfig(config2, final_payload);
+  return {
+    optimal_risk: to_f2(best_risk, "%.2f"),
+    achieved_neg_pnl: to_f2(best_neg_pnl, "%.2f"),
+    target_neg_pnl: to_f2(highest_risk, "%.2f"),
+    difference: to_f2(best_diff, "%.2f"),
+    iterations,
+    converged: best_diff <= tolerance,
+    last_value: final_result.last_value,
+    entries: final_result.entries,
+    app_config: final_result
+  };
+}
 function computeRiskReward(payload) {
   const { app_config, entry, stop, risk_per_trade } = payload;
   const kind = entry > stop ? "long" : "short";
@@ -60785,7 +60841,13 @@ function computeRiskReward(payload) {
   return result;
 }
 function getRiskReward(payload) {
-  const { entry, stop, risk, global_config } = payload;
+  const {
+    entry,
+    stop,
+    risk,
+    global_config,
+    force_exact_risk = false
+  } = payload;
   const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
     entry,
     stop,
@@ -60799,6 +60861,18 @@ function getRiskReward(payload) {
     stop,
     risk_per_trade: risk
   });
+  if (force_exact_risk) {
+    const new_risk_per_trade = determineOptimumRisk(global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: global_config.symbol
+    }, {
+      highest_risk: risk
+    }).optimal_risk;
+    return { risk: new_risk_per_trade, risk_reward };
+  }
   return risk_reward;
 }
 function computeProfitDetail(payload) {

package/dist/mcp-server.js

@@ -60751,6 +60751,62 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
   }, found[0]);
   return maximum;
 }
+function determineOptimumRisk(config2, payload, params) {
+  const { highest_risk, tolerance = 0.01, max_iterations = 200 } = params;
+  let low_risk = 1;
+  let high_risk = Math.max(highest_risk * 5, payload.risk * 10);
+  let best_risk = payload.risk;
+  let best_neg_pnl = 0;
+  let best_diff = Infinity;
+  console.log(`Finding optimal risk for target neg_pnl: ${highest_risk}`);
+  let iterations = 0;
+  while (iterations < max_iterations && high_risk - low_risk > tolerance) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const test_payload = {
+      ...payload,
+      risk: mid_risk
+    };
+    const { last_value } = buildAppConfig(config2, test_payload);
+    if (!last_value || !last_value.neg_pnl) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const current_neg_pnl = Math.abs(last_value.neg_pnl);
+    const diff = Math.abs(current_neg_pnl - highest_risk);
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, neg_pnl=${current_neg_pnl.toFixed(2)}, diff=${diff.toFixed(2)}`);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_risk = mid_risk;
+      best_neg_pnl = current_neg_pnl;
+    }
+    if (diff <= tolerance) {
+      console.log(`Converged! Optimal risk: ${mid_risk.toFixed(2)}`);
+      break;
+    }
+    if (current_neg_pnl < highest_risk) {
+      low_risk = mid_risk;
+    } else {
+      high_risk = mid_risk;
+    }
+  }
+  const final_payload = {
+    ...payload,
+    risk: best_risk
+  };
+  const final_result = buildAppConfig(config2, final_payload);
+  return {
+    optimal_risk: to_f2(best_risk, "%.2f"),
+    achieved_neg_pnl: to_f2(best_neg_pnl, "%.2f"),
+    target_neg_pnl: to_f2(highest_risk, "%.2f"),
+    difference: to_f2(best_diff, "%.2f"),
+    iterations,
+    converged: best_diff <= tolerance,
+    last_value: final_result.last_value,
+    entries: final_result.entries,
+    app_config: final_result
+  };
+}
 function computeRiskReward(payload) {
   const { app_config, entry, stop, risk_per_trade } = payload;
   const kind = entry > stop ? "long" : "short";
@@ -60762,7 +60818,13 @@ function computeRiskReward(payload) {
   return result;
 }
 function getRiskReward(payload) {
-  const { entry, stop, risk, global_config } = payload;
+  const {
+    entry,
+    stop,
+    risk,
+    global_config,
+    force_exact_risk = false
+  } = payload;
   const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
     entry,
     stop,
@@ -60776,6 +60838,18 @@ function getRiskReward(payload) {
     stop,
     risk_per_trade: risk
   });
+  if (force_exact_risk) {
+    const new_risk_per_trade = determineOptimumRisk(global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: global_config.symbol
+    }, {
+      highest_risk: risk
+    }).optimal_risk;
+    return { risk: new_risk_per_trade, risk_reward };
+  }
   return risk_reward;
 }
 function computeProfitDetail(payload) {

package/package.json

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