@gbozee/ultimate 0.0.2-147 → 0.0.2-148

package/dist/frontend-index.d.ts

@@ -143,6 +143,7 @@ export type SignalConfigType = {
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 };
 declare class Signal {
 	focus: number;
@@ -169,7 +170,8 @@ declare class Signal {
 	kelly_prediction_model: "exponential" | "normal" | "uniform";
 	kelly_confidence_factor: number;
 	kelly_minimum_risk: number;
-	constructor({ focus, budget, percent_change, price_places, decimal_places, zone_risk, fee, support, risk_reward, resistance, risk_per_trade, increase_size, additional_increase, minimum_pnl, take_profit, increase_position, minimum_size, first_order_size, gap, max_size, use_kelly, kelly_prediction_model, kelly_confidence_factor, kelly_minimum_risk, }: SignalConfigType);
+	kelly_func: "theoretical" | "position_based" | "theoretical_fixed";
+	constructor({ focus, budget, percent_change, price_places, decimal_places, zone_risk, fee, support, risk_reward, resistance, risk_per_trade, increase_size, additional_increase, minimum_pnl, take_profit, increase_position, minimum_size, first_order_size, gap, max_size, use_kelly, kelly_prediction_model, kelly_confidence_factor, kelly_minimum_risk, kelly_func, }: SignalConfigType);
 	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, }: {
 		take_profit?: number;
 		no_of_trades?: number;
@@ -309,6 +311,7 @@ export type AppConfig = {
 		kelly_confidence_factor?: number;
 		kelly_minimum_risk?: number;
 		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	};
 };
 export type ExtendConfigType = {
@@ -330,8 +333,9 @@ export type ExtendConfigType = {
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 };
-export declare function buildConfig(app_config: AppConfig, { take_profit, entry, stop, raw_instance, risk, no_of_trades, min_profit, risk_reward, kind, increase, gap, rr, price_places, decimal_places, use_kelly, kelly_confidence_factor, kelly_minimum_risk, kelly_prediction_model, }: ExtendConfigType): any[] | Signal;
+export declare function buildConfig(app_config: AppConfig, { take_profit, entry, stop, raw_instance, risk, no_of_trades, min_profit, risk_reward, kind, increase, gap, rr, price_places, decimal_places, use_kelly, kelly_confidence_factor, kelly_minimum_risk, kelly_prediction_model, kelly_func, }: ExtendConfigType): any[] | Signal;
 export declare function buildAvg({ _trades, kind, }: {
 	_trades: any[];
 	kind: "long" | "short";
@@ -345,6 +349,7 @@ export declare function get_app_config_and_max_size(config: GlobalConfig, payloa
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 }): {
 	app_config: AppConfig;
 	max_size: any;
@@ -368,6 +373,7 @@ export declare function buildAppConfig(config: GlobalConfig, payload: {
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 }): AppConfig;
 export declare function getOptimumStopAndRisk(app_config: AppConfig, params: {
 	max_size: number;
@@ -845,6 +851,7 @@ export declare class Strategy {
 			kelly_confidence_factor?: number;
 			kelly_minimum_risk?: number;
 			kelly_prediction_model?: "exponential" | "normal" | "uniform";
+			kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 		};
 	};
 	identifyGapConfig(payload: {

package/dist/frontend-index.js

@@ -83,6 +83,101 @@ function calculateZoneVolatility(zone_prices) {
   const price_changes = zone_prices.slice(1).map((price, i) => Math.abs(price - zone_prices[i]) / zone_prices[i]);
   return price_changes.reduce((sum, change) => sum + change, 0) / price_changes.length;
 }
+function calculateTheoreticalKellyFixed({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config;
+  const sorted_prices = zone_prices;
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  let stop_loss;
+  let target_zones;
+  if (kind === "long") {
+    stop_loss = Math.min(...zone_prices);
+    target_zones = zone_prices.filter((price) => price > current_entry);
+  } else {
+    stop_loss = Math.max(...zone_prices);
+    target_zones = zone_prices.filter((price) => price < current_entry);
+  }
+  const risk_amount = Math.abs(current_entry - stop_loss);
+  const avg_reward = target_zones.length > 0 ? target_zones.reduce((sum, price) => sum + Math.abs(price - current_entry), 0) / target_zones.length : risk_amount;
+  const risk_reward_ratio = avg_reward / risk_amount;
+  let position_quality;
+  if (kind === "long") {
+    const distance_from_stop = current_entry - stop_loss;
+    const max_distance = Math.max(...zone_prices) - stop_loss;
+    position_quality = 1 - distance_from_stop / max_distance;
+  } else {
+    const distance_from_stop = stop_loss - current_entry;
+    const max_distance = stop_loss - Math.min(...zone_prices);
+    position_quality = 1 - distance_from_stop / max_distance;
+  }
+  let base_probability = 0.5;
+  switch (price_prediction_model) {
+    case "uniform":
+      base_probability = 0.5;
+      break;
+    case "normal":
+      base_probability = 0.3 + position_quality * 0.4;
+      break;
+    case "exponential":
+      base_probability = 0.2 + Math.pow(position_quality, 0.5) * 0.6;
+      break;
+  }
+  const win_probability = base_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const odds_ratio = Math.max(risk_reward_ratio, 0.5);
+  const loss_probability = 1 - win_probability;
+  let kelly_fraction = (win_probability * odds_ratio - loss_probability) / odds_ratio;
+  if (volatility_adjustment) {
+    const zone_volatility = calculateZoneVolatility(sorted_prices);
+    const vol_adjustment = 1 / (1 + zone_volatility);
+    kelly_fraction *= vol_adjustment;
+  }
+  kelly_fraction = Math.max(0.005, Math.min(kelly_fraction, 0.5));
+  return to_f(kelly_fraction, "%.4f");
+}
+function calculatePositionBasedKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor: _confidence_factor = 0.6
+  } = config;
+  const current_index = zone_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const total_zones = zone_prices.length;
+  const position_score = (total_zones - current_index) / total_zones;
+  let adjusted_score;
+  switch (price_prediction_model) {
+    case "uniform":
+      adjusted_score = 0.5;
+      break;
+    case "normal":
+      adjusted_score = 0.3 + position_score * 0.4;
+      break;
+    case "exponential":
+      adjusted_score = 0.2 + Math.pow(position_score, 0.3) * 0.6;
+      break;
+    default:
+      adjusted_score = 0.5;
+  }
+  const base_kelly = 0.02;
+  const max_kelly = 0.2;
+  const kelly_fraction = base_kelly + adjusted_score * (max_kelly - base_kelly);
+  return to_f(kelly_fraction, "%.4f");
+}
 
 // src/helpers/trade_signal.ts
 function determine_close_price({
@@ -170,6 +265,7 @@ class Signal {
   kelly_prediction_model = "exponential";
   kelly_confidence_factor = 0.6;
   kelly_minimum_risk = 0.2;
+  kelly_func = "theoretical";
   constructor({
     focus,
     budget,
@@ -194,7 +290,8 @@ class Signal {
     use_kelly = false,
     kelly_prediction_model = "exponential",
     kelly_confidence_factor = 0.6,
-    kelly_minimum_risk = 0.2
+    kelly_minimum_risk = 0.2,
+    kelly_func = "theoretical"
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -220,6 +317,7 @@ class Signal {
     this.kelly_prediction_model = kelly_prediction_model;
     this.kelly_confidence_factor = kelly_confidence_factor;
     this.kelly_minimum_risk = kelly_minimum_risk;
+    this.kelly_func = kelly_func;
   }
   build_entry({
     current_price,
@@ -660,7 +758,8 @@ class Signal {
         const new_stop = kind === "long" ? this.support : stop_loss;
         let risk_to_use = risk_per_trade;
         if (this.use_kelly) {
-          const theoretical_kelly = calculateTheoreticalKelly({
+          const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
+          const theoretical_kelly = func({
             current_entry: x,
             zone_prices: limit_orders,
             kind,
@@ -1342,7 +1441,8 @@ function buildConfig(app_config, {
   use_kelly = false,
   kelly_confidence_factor = 0.95,
   kelly_minimum_risk = 0.2,
-  kelly_prediction_model = "exponential"
+  kelly_prediction_model = "exponential",
+  kelly_func = "theoretical"
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -1370,7 +1470,8 @@ function buildConfig(app_config, {
     use_kelly: use_kelly || app_config.kelly?.use_kelly,
     kelly_confidence_factor: kelly_confidence_factor || app_config.kelly?.kelly_confidence_factor,
     kelly_minimum_risk: kelly_minimum_risk || app_config.kelly?.kelly_minimum_risk,
-    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model
+    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model,
+    kelly_func: kelly_func || app_config.kelly?.kelly_func
   };
   const instance = new Signal(config);
   if (raw_instance) {
@@ -1453,7 +1554,8 @@ function get_app_config_and_max_size(config, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -1490,7 +1592,8 @@ function buildAppConfig(config, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -1501,7 +1604,8 @@ function buildAppConfig(config, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   };
   return app_config;
 }

package/dist/index.cjs

@@ -52955,6 +52955,101 @@ function calculateZoneVolatility(zone_prices) {
   const price_changes = zone_prices.slice(1).map((price, i2) => Math.abs(price - zone_prices[i2]) / zone_prices[i2]);
   return price_changes.reduce((sum, change) => sum + change, 0) / price_changes.length;
 }
+function calculateTheoreticalKellyFixed({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = zone_prices;
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  let stop_loss;
+  let target_zones;
+  if (kind === "long") {
+    stop_loss = Math.min(...zone_prices);
+    target_zones = zone_prices.filter((price) => price > current_entry);
+  } else {
+    stop_loss = Math.max(...zone_prices);
+    target_zones = zone_prices.filter((price) => price < current_entry);
+  }
+  const risk_amount = Math.abs(current_entry - stop_loss);
+  const avg_reward = target_zones.length > 0 ? target_zones.reduce((sum, price) => sum + Math.abs(price - current_entry), 0) / target_zones.length : risk_amount;
+  const risk_reward_ratio = avg_reward / risk_amount;
+  let position_quality;
+  if (kind === "long") {
+    const distance_from_stop = current_entry - stop_loss;
+    const max_distance = Math.max(...zone_prices) - stop_loss;
+    position_quality = 1 - distance_from_stop / max_distance;
+  } else {
+    const distance_from_stop = stop_loss - current_entry;
+    const max_distance = stop_loss - Math.min(...zone_prices);
+    position_quality = 1 - distance_from_stop / max_distance;
+  }
+  let base_probability = 0.5;
+  switch (price_prediction_model) {
+    case "uniform":
+      base_probability = 0.5;
+      break;
+    case "normal":
+      base_probability = 0.3 + position_quality * 0.4;
+      break;
+    case "exponential":
+      base_probability = 0.2 + Math.pow(position_quality, 0.5) * 0.6;
+      break;
+  }
+  const win_probability = base_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const odds_ratio = Math.max(risk_reward_ratio, 0.5);
+  const loss_probability = 1 - win_probability;
+  let kelly_fraction = (win_probability * odds_ratio - loss_probability) / odds_ratio;
+  if (volatility_adjustment) {
+    const zone_volatility = calculateZoneVolatility(sorted_prices);
+    const vol_adjustment = 1 / (1 + zone_volatility);
+    kelly_fraction *= vol_adjustment;
+  }
+  kelly_fraction = Math.max(0.005, Math.min(kelly_fraction, 0.5));
+  return to_f2(kelly_fraction, "%.4f");
+}
+function calculatePositionBasedKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor: _confidence_factor = 0.6
+  } = config2;
+  const current_index = zone_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const total_zones = zone_prices.length;
+  const position_score = (total_zones - current_index) / total_zones;
+  let adjusted_score;
+  switch (price_prediction_model) {
+    case "uniform":
+      adjusted_score = 0.5;
+      break;
+    case "normal":
+      adjusted_score = 0.3 + position_score * 0.4;
+      break;
+    case "exponential":
+      adjusted_score = 0.2 + Math.pow(position_score, 0.3) * 0.6;
+      break;
+    default:
+      adjusted_score = 0.5;
+  }
+  const base_kelly = 0.02;
+  const max_kelly = 0.2;
+  const kelly_fraction = base_kelly + adjusted_score * (max_kelly - base_kelly);
+  return to_f2(kelly_fraction, "%.4f");
+}
 
 // src/helpers/trade_signal.ts
 function determine_close_price2({
@@ -53042,6 +53137,7 @@ class Signal {
   kelly_prediction_model = "exponential";
   kelly_confidence_factor = 0.6;
   kelly_minimum_risk = 0.2;
+  kelly_func = "theoretical";
   constructor({
     focus,
     budget,
@@ -53066,7 +53162,8 @@ class Signal {
     use_kelly = false,
     kelly_prediction_model = "exponential",
     kelly_confidence_factor = 0.6,
-    kelly_minimum_risk = 0.2
+    kelly_minimum_risk = 0.2,
+    kelly_func = "theoretical"
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -53092,6 +53189,7 @@ class Signal {
     this.kelly_prediction_model = kelly_prediction_model;
     this.kelly_confidence_factor = kelly_confidence_factor;
     this.kelly_minimum_risk = kelly_minimum_risk;
+    this.kelly_func = kelly_func;
   }
   build_entry({
     current_price,
@@ -53532,7 +53630,8 @@ class Signal {
         const new_stop = kind === "long" ? this.support : stop_loss;
         let risk_to_use = risk_per_trade;
         if (this.use_kelly) {
-          const theoretical_kelly = calculateTheoreticalKelly({
+          const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
+          const theoretical_kelly = func({
             current_entry: x,
             zone_prices: limit_orders,
             kind,
@@ -53740,7 +53839,8 @@ function buildConfig(app_config, {
   use_kelly = false,
   kelly_confidence_factor = 0.95,
   kelly_minimum_risk = 0.2,
-  kelly_prediction_model = "exponential"
+  kelly_prediction_model = "exponential",
+  kelly_func = "theoretical"
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -53768,7 +53868,8 @@ function buildConfig(app_config, {
     use_kelly: use_kelly || app_config.kelly?.use_kelly,
     kelly_confidence_factor: kelly_confidence_factor || app_config.kelly?.kelly_confidence_factor,
     kelly_minimum_risk: kelly_minimum_risk || app_config.kelly?.kelly_minimum_risk,
-    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model
+    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model,
+    kelly_func: kelly_func || app_config.kelly?.kelly_func
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -53851,7 +53952,8 @@ function get_app_config_and_max_size(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -53888,7 +53990,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -53899,7 +54002,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   };
   return app_config;
 }
@@ -58286,6 +58390,7 @@ class ExchangeAccount {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
+      kelly_func: config2.kelly?.kelly_func,
       ...override
     });
     return app_config;

package/dist/index.d.ts

@@ -1027,6 +1027,7 @@ export declare class Strategy {
 			kelly_confidence_factor?: number;
 			kelly_minimum_risk?: number;
 			kelly_prediction_model?: "exponential" | "normal" | "uniform";
+			kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 		};
 	};
 	identifyGapConfig(payload: {
@@ -1145,6 +1146,7 @@ export type SignalConfigType = {
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 };
 declare class Signal {
 	focus: number;
@@ -1171,7 +1173,8 @@ declare class Signal {
 	kelly_prediction_model: "exponential" | "normal" | "uniform";
 	kelly_confidence_factor: number;
 	kelly_minimum_risk: number;
-	constructor({ focus, budget, percent_change, price_places, decimal_places, zone_risk, fee, support, risk_reward, resistance, risk_per_trade, increase_size, additional_increase, minimum_pnl, take_profit, increase_position, minimum_size, first_order_size, gap, max_size, use_kelly, kelly_prediction_model, kelly_confidence_factor, kelly_minimum_risk, }: SignalConfigType);
+	kelly_func: "theoretical" | "position_based" | "theoretical_fixed";
+	constructor({ focus, budget, percent_change, price_places, decimal_places, zone_risk, fee, support, risk_reward, resistance, risk_per_trade, increase_size, additional_increase, minimum_pnl, take_profit, increase_position, minimum_size, first_order_size, gap, max_size, use_kelly, kelly_prediction_model, kelly_confidence_factor, kelly_minimum_risk, kelly_func, }: SignalConfigType);
 	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, }: {
 		take_profit?: number;
 		no_of_trades?: number;
@@ -1299,6 +1302,7 @@ export type AppConfig = {
 		kelly_confidence_factor?: number;
 		kelly_minimum_risk?: number;
 		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	};
 };
 export type ExtendConfigType = {
@@ -1320,8 +1324,9 @@ export type ExtendConfigType = {
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 };
-export declare function buildConfig(app_config: AppConfig, { take_profit, entry, stop, raw_instance, risk, no_of_trades, min_profit, risk_reward, kind, increase, gap, rr, price_places, decimal_places, use_kelly, kelly_confidence_factor, kelly_minimum_risk, kelly_prediction_model, }: ExtendConfigType): any[] | Signal;
+export declare function buildConfig(app_config: AppConfig, { take_profit, entry, stop, raw_instance, risk, no_of_trades, min_profit, risk_reward, kind, increase, gap, rr, price_places, decimal_places, use_kelly, kelly_confidence_factor, kelly_minimum_risk, kelly_prediction_model, kelly_func, }: ExtendConfigType): any[] | Signal;
 export declare function buildAvg({ _trades, kind, }: {
 	_trades: any[];
 	kind: "long" | "short";
@@ -1335,6 +1340,7 @@ export declare function get_app_config_and_max_size(config: GlobalConfig, payloa
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 }): {
 	app_config: AppConfig;
 	max_size: any;
@@ -1358,6 +1364,7 @@ export declare function buildAppConfig(config: GlobalConfig, payload: {
 	kelly_confidence_factor?: number;
 	kelly_minimum_risk?: number;
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 }): AppConfig;
 export declare function getOptimumStopAndRisk(app_config: AppConfig, params: {
 	max_size: number;
@@ -1896,6 +1903,7 @@ declare class ExchangeAccount$1 {
 		kelly_confidence_factor?: number;
 		kelly_minimum_risk?: number;
 		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	}): Promise<AppConfig>;
 	tradeConfig(payload: {
 		symbol: string;
@@ -2249,6 +2257,7 @@ declare class ExchangeAccount$1 {
 			kelly_confidence_factor?: number;
 			kelly_minimum_risk?: number;
 			kelly_prediction_model?: "exponential" | "normal" | "uniform";
+			kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 		};
 	}>;
 	runSimulation(payload: {
@@ -2435,6 +2444,7 @@ declare class ExchangeAccount$1 {
 					kelly_confidence_factor?: number;
 					kelly_minimum_risk?: number;
 					kelly_prediction_model?: "exponential" | "normal" | "uniform";
+					kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 				};
 			};
 			last_value: any;
@@ -2708,6 +2718,7 @@ declare class App {
 					kelly_confidence_factor?: number;
 					kelly_minimum_risk?: number;
 					kelly_prediction_model?: "exponential" | "normal" | "uniform";
+					kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 				};
 			};
 			last_value: any;

package/dist/index.js

@@ -52903,6 +52903,101 @@ function calculateZoneVolatility(zone_prices) {
   const price_changes = zone_prices.slice(1).map((price, i2) => Math.abs(price - zone_prices[i2]) / zone_prices[i2]);
   return price_changes.reduce((sum, change) => sum + change, 0) / price_changes.length;
 }
+function calculateTheoreticalKellyFixed({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = zone_prices;
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  let stop_loss;
+  let target_zones;
+  if (kind === "long") {
+    stop_loss = Math.min(...zone_prices);
+    target_zones = zone_prices.filter((price) => price > current_entry);
+  } else {
+    stop_loss = Math.max(...zone_prices);
+    target_zones = zone_prices.filter((price) => price < current_entry);
+  }
+  const risk_amount = Math.abs(current_entry - stop_loss);
+  const avg_reward = target_zones.length > 0 ? target_zones.reduce((sum, price) => sum + Math.abs(price - current_entry), 0) / target_zones.length : risk_amount;
+  const risk_reward_ratio = avg_reward / risk_amount;
+  let position_quality;
+  if (kind === "long") {
+    const distance_from_stop = current_entry - stop_loss;
+    const max_distance = Math.max(...zone_prices) - stop_loss;
+    position_quality = 1 - distance_from_stop / max_distance;
+  } else {
+    const distance_from_stop = stop_loss - current_entry;
+    const max_distance = stop_loss - Math.min(...zone_prices);
+    position_quality = 1 - distance_from_stop / max_distance;
+  }
+  let base_probability = 0.5;
+  switch (price_prediction_model) {
+    case "uniform":
+      base_probability = 0.5;
+      break;
+    case "normal":
+      base_probability = 0.3 + position_quality * 0.4;
+      break;
+    case "exponential":
+      base_probability = 0.2 + Math.pow(position_quality, 0.5) * 0.6;
+      break;
+  }
+  const win_probability = base_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const odds_ratio = Math.max(risk_reward_ratio, 0.5);
+  const loss_probability = 1 - win_probability;
+  let kelly_fraction = (win_probability * odds_ratio - loss_probability) / odds_ratio;
+  if (volatility_adjustment) {
+    const zone_volatility = calculateZoneVolatility(sorted_prices);
+    const vol_adjustment = 1 / (1 + zone_volatility);
+    kelly_fraction *= vol_adjustment;
+  }
+  kelly_fraction = Math.max(0.005, Math.min(kelly_fraction, 0.5));
+  return to_f2(kelly_fraction, "%.4f");
+}
+function calculatePositionBasedKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor: _confidence_factor = 0.6
+  } = config2;
+  const current_index = zone_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const total_zones = zone_prices.length;
+  const position_score = (total_zones - current_index) / total_zones;
+  let adjusted_score;
+  switch (price_prediction_model) {
+    case "uniform":
+      adjusted_score = 0.5;
+      break;
+    case "normal":
+      adjusted_score = 0.3 + position_score * 0.4;
+      break;
+    case "exponential":
+      adjusted_score = 0.2 + Math.pow(position_score, 0.3) * 0.6;
+      break;
+    default:
+      adjusted_score = 0.5;
+  }
+  const base_kelly = 0.02;
+  const max_kelly = 0.2;
+  const kelly_fraction = base_kelly + adjusted_score * (max_kelly - base_kelly);
+  return to_f2(kelly_fraction, "%.4f");
+}
 
 // src/helpers/trade_signal.ts
 function determine_close_price2({
@@ -52990,6 +53085,7 @@ class Signal {
   kelly_prediction_model = "exponential";
   kelly_confidence_factor = 0.6;
   kelly_minimum_risk = 0.2;
+  kelly_func = "theoretical";
   constructor({
     focus,
     budget,
@@ -53014,7 +53110,8 @@ class Signal {
     use_kelly = false,
     kelly_prediction_model = "exponential",
     kelly_confidence_factor = 0.6,
-    kelly_minimum_risk = 0.2
+    kelly_minimum_risk = 0.2,
+    kelly_func = "theoretical"
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -53040,6 +53137,7 @@ class Signal {
     this.kelly_prediction_model = kelly_prediction_model;
     this.kelly_confidence_factor = kelly_confidence_factor;
     this.kelly_minimum_risk = kelly_minimum_risk;
+    this.kelly_func = kelly_func;
   }
   build_entry({
     current_price,
@@ -53480,7 +53578,8 @@ class Signal {
         const new_stop = kind === "long" ? this.support : stop_loss;
         let risk_to_use = risk_per_trade;
         if (this.use_kelly) {
-          const theoretical_kelly = calculateTheoreticalKelly({
+          const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
+          const theoretical_kelly = func({
             current_entry: x,
             zone_prices: limit_orders,
             kind,
@@ -53688,7 +53787,8 @@ function buildConfig(app_config, {
   use_kelly = false,
   kelly_confidence_factor = 0.95,
   kelly_minimum_risk = 0.2,
-  kelly_prediction_model = "exponential"
+  kelly_prediction_model = "exponential",
+  kelly_func = "theoretical"
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -53716,7 +53816,8 @@ function buildConfig(app_config, {
     use_kelly: use_kelly || app_config.kelly?.use_kelly,
     kelly_confidence_factor: kelly_confidence_factor || app_config.kelly?.kelly_confidence_factor,
     kelly_minimum_risk: kelly_minimum_risk || app_config.kelly?.kelly_minimum_risk,
-    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model
+    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model,
+    kelly_func: kelly_func || app_config.kelly?.kelly_func
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -53799,7 +53900,8 @@ function get_app_config_and_max_size(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -53836,7 +53938,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -53847,7 +53950,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   };
   return app_config;
 }
@@ -58234,6 +58338,7 @@ class ExchangeAccount {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
+      kelly_func: config2.kelly?.kelly_func,
       ...override
     });
     return app_config;

package/dist/mcp-server.cjs

@@ -59650,6 +59650,101 @@ function calculateZoneVolatility(zone_prices) {
   const price_changes = zone_prices.slice(1).map((price, i2) => Math.abs(price - zone_prices[i2]) / zone_prices[i2]);
   return price_changes.reduce((sum, change) => sum + change, 0) / price_changes.length;
 }
+function calculateTheoreticalKellyFixed({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = zone_prices;
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  let stop_loss;
+  let target_zones;
+  if (kind === "long") {
+    stop_loss = Math.min(...zone_prices);
+    target_zones = zone_prices.filter((price) => price > current_entry);
+  } else {
+    stop_loss = Math.max(...zone_prices);
+    target_zones = zone_prices.filter((price) => price < current_entry);
+  }
+  const risk_amount = Math.abs(current_entry - stop_loss);
+  const avg_reward = target_zones.length > 0 ? target_zones.reduce((sum, price) => sum + Math.abs(price - current_entry), 0) / target_zones.length : risk_amount;
+  const risk_reward_ratio = avg_reward / risk_amount;
+  let position_quality;
+  if (kind === "long") {
+    const distance_from_stop = current_entry - stop_loss;
+    const max_distance = Math.max(...zone_prices) - stop_loss;
+    position_quality = 1 - distance_from_stop / max_distance;
+  } else {
+    const distance_from_stop = stop_loss - current_entry;
+    const max_distance = stop_loss - Math.min(...zone_prices);
+    position_quality = 1 - distance_from_stop / max_distance;
+  }
+  let base_probability = 0.5;
+  switch (price_prediction_model) {
+    case "uniform":
+      base_probability = 0.5;
+      break;
+    case "normal":
+      base_probability = 0.3 + position_quality * 0.4;
+      break;
+    case "exponential":
+      base_probability = 0.2 + Math.pow(position_quality, 0.5) * 0.6;
+      break;
+  }
+  const win_probability = base_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const odds_ratio = Math.max(risk_reward_ratio, 0.5);
+  const loss_probability = 1 - win_probability;
+  let kelly_fraction = (win_probability * odds_ratio - loss_probability) / odds_ratio;
+  if (volatility_adjustment) {
+    const zone_volatility = calculateZoneVolatility(sorted_prices);
+    const vol_adjustment = 1 / (1 + zone_volatility);
+    kelly_fraction *= vol_adjustment;
+  }
+  kelly_fraction = Math.max(0.005, Math.min(kelly_fraction, 0.5));
+  return to_f2(kelly_fraction, "%.4f");
+}
+function calculatePositionBasedKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor: _confidence_factor = 0.6
+  } = config2;
+  const current_index = zone_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const total_zones = zone_prices.length;
+  const position_score = (total_zones - current_index) / total_zones;
+  let adjusted_score;
+  switch (price_prediction_model) {
+    case "uniform":
+      adjusted_score = 0.5;
+      break;
+    case "normal":
+      adjusted_score = 0.3 + position_score * 0.4;
+      break;
+    case "exponential":
+      adjusted_score = 0.2 + Math.pow(position_score, 0.3) * 0.6;
+      break;
+    default:
+      adjusted_score = 0.5;
+  }
+  const base_kelly = 0.02;
+  const max_kelly = 0.2;
+  const kelly_fraction = base_kelly + adjusted_score * (max_kelly - base_kelly);
+  return to_f2(kelly_fraction, "%.4f");
+}
 
 // src/helpers/trade_signal.ts
 function determine_close_price2({
@@ -59737,6 +59832,7 @@ class Signal {
   kelly_prediction_model = "exponential";
   kelly_confidence_factor = 0.6;
   kelly_minimum_risk = 0.2;
+  kelly_func = "theoretical";
   constructor({
     focus,
     budget,
@@ -59761,7 +59857,8 @@ class Signal {
     use_kelly = false,
     kelly_prediction_model = "exponential",
     kelly_confidence_factor = 0.6,
-    kelly_minimum_risk = 0.2
+    kelly_minimum_risk = 0.2,
+    kelly_func = "theoretical"
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -59787,6 +59884,7 @@ class Signal {
     this.kelly_prediction_model = kelly_prediction_model;
     this.kelly_confidence_factor = kelly_confidence_factor;
     this.kelly_minimum_risk = kelly_minimum_risk;
+    this.kelly_func = kelly_func;
   }
   build_entry({
     current_price,
@@ -60227,7 +60325,8 @@ class Signal {
         const new_stop = kind === "long" ? this.support : stop_loss;
         let risk_to_use = risk_per_trade;
         if (this.use_kelly) {
-          const theoretical_kelly = calculateTheoreticalKelly({
+          const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
+          const theoretical_kelly = func({
             current_entry: x,
             zone_prices: limit_orders,
             kind,
@@ -60435,7 +60534,8 @@ function buildConfig(app_config, {
   use_kelly = false,
   kelly_confidence_factor = 0.95,
   kelly_minimum_risk = 0.2,
-  kelly_prediction_model = "exponential"
+  kelly_prediction_model = "exponential",
+  kelly_func = "theoretical"
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -60463,7 +60563,8 @@ function buildConfig(app_config, {
     use_kelly: use_kelly || app_config.kelly?.use_kelly,
     kelly_confidence_factor: kelly_confidence_factor || app_config.kelly?.kelly_confidence_factor,
     kelly_minimum_risk: kelly_minimum_risk || app_config.kelly?.kelly_minimum_risk,
-    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model
+    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model,
+    kelly_func: kelly_func || app_config.kelly?.kelly_func
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -60533,7 +60634,8 @@ function get_app_config_and_max_size(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -60570,7 +60672,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -60581,7 +60684,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   };
   return app_config;
 }
@@ -64962,6 +65066,7 @@ class ExchangeAccount {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
+      kelly_func: config2.kelly?.kelly_func,
       ...override
     });
     return app_config;

package/dist/mcp-server.js

@@ -59627,6 +59627,101 @@ function calculateZoneVolatility(zone_prices) {
   const price_changes = zone_prices.slice(1).map((price, i2) => Math.abs(price - zone_prices[i2]) / zone_prices[i2]);
   return price_changes.reduce((sum, change) => sum + change, 0) / price_changes.length;
 }
+function calculateTheoreticalKellyFixed({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = zone_prices;
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  let stop_loss;
+  let target_zones;
+  if (kind === "long") {
+    stop_loss = Math.min(...zone_prices);
+    target_zones = zone_prices.filter((price) => price > current_entry);
+  } else {
+    stop_loss = Math.max(...zone_prices);
+    target_zones = zone_prices.filter((price) => price < current_entry);
+  }
+  const risk_amount = Math.abs(current_entry - stop_loss);
+  const avg_reward = target_zones.length > 0 ? target_zones.reduce((sum, price) => sum + Math.abs(price - current_entry), 0) / target_zones.length : risk_amount;
+  const risk_reward_ratio = avg_reward / risk_amount;
+  let position_quality;
+  if (kind === "long") {
+    const distance_from_stop = current_entry - stop_loss;
+    const max_distance = Math.max(...zone_prices) - stop_loss;
+    position_quality = 1 - distance_from_stop / max_distance;
+  } else {
+    const distance_from_stop = stop_loss - current_entry;
+    const max_distance = stop_loss - Math.min(...zone_prices);
+    position_quality = 1 - distance_from_stop / max_distance;
+  }
+  let base_probability = 0.5;
+  switch (price_prediction_model) {
+    case "uniform":
+      base_probability = 0.5;
+      break;
+    case "normal":
+      base_probability = 0.3 + position_quality * 0.4;
+      break;
+    case "exponential":
+      base_probability = 0.2 + Math.pow(position_quality, 0.5) * 0.6;
+      break;
+  }
+  const win_probability = base_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const odds_ratio = Math.max(risk_reward_ratio, 0.5);
+  const loss_probability = 1 - win_probability;
+  let kelly_fraction = (win_probability * odds_ratio - loss_probability) / odds_ratio;
+  if (volatility_adjustment) {
+    const zone_volatility = calculateZoneVolatility(sorted_prices);
+    const vol_adjustment = 1 / (1 + zone_volatility);
+    kelly_fraction *= vol_adjustment;
+  }
+  kelly_fraction = Math.max(0.005, Math.min(kelly_fraction, 0.5));
+  return to_f2(kelly_fraction, "%.4f");
+}
+function calculatePositionBasedKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor: _confidence_factor = 0.6
+  } = config2;
+  const current_index = zone_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const total_zones = zone_prices.length;
+  const position_score = (total_zones - current_index) / total_zones;
+  let adjusted_score;
+  switch (price_prediction_model) {
+    case "uniform":
+      adjusted_score = 0.5;
+      break;
+    case "normal":
+      adjusted_score = 0.3 + position_score * 0.4;
+      break;
+    case "exponential":
+      adjusted_score = 0.2 + Math.pow(position_score, 0.3) * 0.6;
+      break;
+    default:
+      adjusted_score = 0.5;
+  }
+  const base_kelly = 0.02;
+  const max_kelly = 0.2;
+  const kelly_fraction = base_kelly + adjusted_score * (max_kelly - base_kelly);
+  return to_f2(kelly_fraction, "%.4f");
+}
 
 // src/helpers/trade_signal.ts
 function determine_close_price2({
@@ -59714,6 +59809,7 @@ class Signal {
   kelly_prediction_model = "exponential";
   kelly_confidence_factor = 0.6;
   kelly_minimum_risk = 0.2;
+  kelly_func = "theoretical";
   constructor({
     focus,
     budget,
@@ -59738,7 +59834,8 @@ class Signal {
     use_kelly = false,
     kelly_prediction_model = "exponential",
     kelly_confidence_factor = 0.6,
-    kelly_minimum_risk = 0.2
+    kelly_minimum_risk = 0.2,
+    kelly_func = "theoretical"
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -59764,6 +59861,7 @@ class Signal {
     this.kelly_prediction_model = kelly_prediction_model;
     this.kelly_confidence_factor = kelly_confidence_factor;
     this.kelly_minimum_risk = kelly_minimum_risk;
+    this.kelly_func = kelly_func;
   }
   build_entry({
     current_price,
@@ -60204,7 +60302,8 @@ class Signal {
         const new_stop = kind === "long" ? this.support : stop_loss;
         let risk_to_use = risk_per_trade;
         if (this.use_kelly) {
-          const theoretical_kelly = calculateTheoreticalKelly({
+          const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
+          const theoretical_kelly = func({
             current_entry: x,
             zone_prices: limit_orders,
             kind,
@@ -60412,7 +60511,8 @@ function buildConfig(app_config, {
   use_kelly = false,
   kelly_confidence_factor = 0.95,
   kelly_minimum_risk = 0.2,
-  kelly_prediction_model = "exponential"
+  kelly_prediction_model = "exponential",
+  kelly_func = "theoretical"
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -60440,7 +60540,8 @@ function buildConfig(app_config, {
     use_kelly: use_kelly || app_config.kelly?.use_kelly,
     kelly_confidence_factor: kelly_confidence_factor || app_config.kelly?.kelly_confidence_factor,
     kelly_minimum_risk: kelly_minimum_risk || app_config.kelly?.kelly_minimum_risk,
-    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model
+    kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model,
+    kelly_func: kelly_func || app_config.kelly?.kelly_func
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -60510,7 +60611,8 @@ function get_app_config_and_max_size(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -60547,7 +60649,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -60558,7 +60661,8 @@ function buildAppConfig(config2, payload) {
     use_kelly: payload.use_kelly,
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
-    kelly_prediction_model: payload.kelly_prediction_model
+    kelly_prediction_model: payload.kelly_prediction_model,
+    kelly_func: payload.kelly_func
   };
   return app_config;
 }
@@ -64939,6 +65043,7 @@ class ExchangeAccount {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
+      kelly_func: config2.kelly?.kelly_func,
       ...override
     });
     return app_config;

package/package.json

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