@gbozee/ultimate 0.0.2-144 → 0.0.2-145

package/dist/frontend-index.d.ts

@@ -139,6 +139,10 @@ export type SignalConfigType = {
 	first_order_size?: number;
 	gap?: number;
 	max_size?: number;
+	use_kelly?: boolean;
+	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_confidence_factor?: number;
+	kelly_minimum_risk?: number;
 };
 declare class Signal {
 	focus: number;
@@ -161,7 +165,11 @@ declare class Signal {
 	first_order_size: number;
 	gap: number;
 	max_size: 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, }: SignalConfigType);
+	use_kelly: boolean;
+	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);
 	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, }: {
 		take_profit?: number;
 		no_of_trades?: number;
@@ -296,6 +304,7 @@ export type AppConfig = {
 	last_value?: any;
 	entries?: any[];
 	max_quantity?: number;
+	use_kelly?: boolean;
 };
 export type ExtendConfigType = {
 	take_profit?: number;
@@ -814,6 +823,7 @@ export declare class Strategy {
 		rr?: number;
 		max_size?: number;
 		max_quantity?: number;
+		use_kelly?: boolean;
 	};
 	identifyGapConfig(payload: {
 		factor?: number;

package/dist/frontend-index.js

@@ -1,3 +1,89 @@
+// src/helpers/optimizations.ts
+function calculateTheoreticalKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config;
+  const sorted_prices = kind === "long" ? zone_prices : zone_prices.reverse();
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const win_zones = kind === "long" ? sorted_prices.slice(current_index + 1) : sorted_prices.slice(0, current_index);
+  const lose_zones = kind === "long" ? sorted_prices.slice(0, current_index) : sorted_prices.slice(current_index + 1);
+  const { win_probability, avg_win_ratio, avg_loss_ratio } = calculateZoneProbabilities({
+    current_entry,
+    win_zones,
+    lose_zones,
+    price_prediction_model,
+    confidence_factor,
+    kind
+  });
+  const odds_ratio = avg_win_ratio / avg_loss_ratio;
+  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 calculateZoneProbabilities({
+  current_entry,
+  win_zones,
+  lose_zones,
+  price_prediction_model,
+  confidence_factor,
+  kind
+}) {
+  if (win_zones.length === 0 && lose_zones.length === 0) {
+    return { win_probability: 0.5, avg_win_ratio: 0.02, avg_loss_ratio: 0.02 };
+  }
+  let win_probability;
+  switch (price_prediction_model) {
+    case "uniform":
+      win_probability = win_zones.length / (win_zones.length + lose_zones.length);
+      break;
+    case "normal":
+      const win_weight = win_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      const lose_weight = lose_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      win_probability = win_weight / (win_weight + lose_weight);
+      break;
+    case "exponential":
+      const exp_win_weight = win_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      const exp_lose_weight = lose_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      win_probability = exp_win_weight / (exp_win_weight + exp_lose_weight);
+      break;
+    default:
+      win_probability = 0.5;
+  }
+  win_probability = win_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const avg_win_ratio = win_zones.length > 0 ? win_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / win_zones.length : 0.02;
+  const avg_loss_ratio = lose_zones.length > 0 ? lose_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / lose_zones.length : 0.02;
+  return {
+    win_probability: Math.max(0.1, Math.min(0.9, win_probability)),
+    avg_win_ratio: Math.max(0.005, avg_win_ratio),
+    avg_loss_ratio: Math.max(0.005, avg_loss_ratio)
+  };
+}
+function calculateZoneVolatility(zone_prices) {
+  if (zone_prices.length < 2)
+    return 0;
+  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;
+}
+
 // src/helpers/trade_signal.ts
 function determine_close_price({
   entry,
@@ -80,6 +166,10 @@ class Signal {
   first_order_size;
   gap = 10;
   max_size = 0;
+  use_kelly = false;
+  kelly_prediction_model = "exponential";
+  kelly_confidence_factor = 0.6;
+  kelly_minimum_risk = 0.2;
   constructor({
     focus,
     budget,
@@ -100,7 +190,11 @@ class Signal {
     minimum_size = 0,
     first_order_size = 0,
     gap = 10,
-    max_size = 0
+    max_size = 0,
+    use_kelly = false,
+    kelly_prediction_model = "exponential",
+    kelly_confidence_factor = 0.6,
+    kelly_minimum_risk = 0.2
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -122,6 +216,10 @@ class Signal {
     this.increase_position = increase_position;
     this.gap = gap;
     this.max_size = max_size;
+    this.use_kelly = use_kelly;
+    this.kelly_prediction_model = kelly_prediction_model;
+    this.kelly_confidence_factor = kelly_confidence_factor;
+    this.kelly_minimum_risk = kelly_minimum_risk;
   }
   build_entry({
     current_price,
@@ -560,10 +658,25 @@ class Signal {
         }
         const defaultStopLoss = i === 0 ? stop_loss : _base;
         const new_stop = kind === "long" ? this.support : stop_loss;
+        let risk_to_use = risk_per_trade;
+        if (this.use_kelly) {
+          const theoretical_kelly = calculateTheoreticalKelly({
+            current_entry: x,
+            zone_prices: limit_orders,
+            kind,
+            config: {
+              price_prediction_model: this.kelly_prediction_model,
+              confidence_factor: this.kelly_confidence_factor,
+              volatility_adjustment: true
+            }
+          });
+          risk_to_use = theoretical_kelly * risk_per_trade / this.kelly_minimum_risk;
+          console.log({ risk_per_trade, theoretical_kelly });
+        }
         const y = this.build_trade_dict({
           entry: x,
           stop: (this.increase_position ? new_stop : defaultStopLoss) || defaultStopLoss,
-          risk: risk_per_trade,
+          risk: risk_to_use,
           arr: limit_orders,
           index: i,
           new_fees: total_incurred_market_fees,
@@ -1249,7 +1362,8 @@ function buildConfig(app_config, {
     kind: app_config.kind,
     gap,
     min_profit: min_profit || app_config.min_profit,
-    rr: rr || 1
+    rr: rr || 1,
+    use_kelly: app_config.use_kelly
   };
   const instance = new Signal(config);
   if (raw_instance) {
@@ -1261,6 +1375,7 @@ function buildConfig(app_config, {
   const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
   if (kind === "short") {
   }
+  console.log({ entry, stop, condition, working_risk, config });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,

package/dist/index.cjs

@@ -52870,6 +52870,92 @@ function createGapPairs(arr, gap, item) {
   return result;
 }
 
+// src/helpers/optimizations.ts
+function calculateTheoreticalKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = kind === "long" ? zone_prices : zone_prices.reverse();
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const win_zones = kind === "long" ? sorted_prices.slice(current_index + 1) : sorted_prices.slice(0, current_index);
+  const lose_zones = kind === "long" ? sorted_prices.slice(0, current_index) : sorted_prices.slice(current_index + 1);
+  const { win_probability, avg_win_ratio, avg_loss_ratio } = calculateZoneProbabilities({
+    current_entry,
+    win_zones,
+    lose_zones,
+    price_prediction_model,
+    confidence_factor,
+    kind
+  });
+  const odds_ratio = avg_win_ratio / avg_loss_ratio;
+  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 calculateZoneProbabilities({
+  current_entry,
+  win_zones,
+  lose_zones,
+  price_prediction_model,
+  confidence_factor,
+  kind
+}) {
+  if (win_zones.length === 0 && lose_zones.length === 0) {
+    return { win_probability: 0.5, avg_win_ratio: 0.02, avg_loss_ratio: 0.02 };
+  }
+  let win_probability;
+  switch (price_prediction_model) {
+    case "uniform":
+      win_probability = win_zones.length / (win_zones.length + lose_zones.length);
+      break;
+    case "normal":
+      const win_weight = win_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      const lose_weight = lose_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      win_probability = win_weight / (win_weight + lose_weight);
+      break;
+    case "exponential":
+      const exp_win_weight = win_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      const exp_lose_weight = lose_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      win_probability = exp_win_weight / (exp_win_weight + exp_lose_weight);
+      break;
+    default:
+      win_probability = 0.5;
+  }
+  win_probability = win_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const avg_win_ratio = win_zones.length > 0 ? win_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / win_zones.length : 0.02;
+  const avg_loss_ratio = lose_zones.length > 0 ? lose_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / lose_zones.length : 0.02;
+  return {
+    win_probability: Math.max(0.1, Math.min(0.9, win_probability)),
+    avg_win_ratio: Math.max(0.005, avg_win_ratio),
+    avg_loss_ratio: Math.max(0.005, avg_loss_ratio)
+  };
+}
+function calculateZoneVolatility(zone_prices) {
+  if (zone_prices.length < 2)
+    return 0;
+  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;
+}
+
 // src/helpers/trade_signal.ts
 function determine_close_price2({
   entry,
@@ -52952,6 +53038,10 @@ class Signal {
   first_order_size;
   gap = 10;
   max_size = 0;
+  use_kelly = false;
+  kelly_prediction_model = "exponential";
+  kelly_confidence_factor = 0.6;
+  kelly_minimum_risk = 0.2;
   constructor({
     focus,
     budget,
@@ -52972,7 +53062,11 @@ class Signal {
     minimum_size = 0,
     first_order_size = 0,
     gap = 10,
-    max_size = 0
+    max_size = 0,
+    use_kelly = false,
+    kelly_prediction_model = "exponential",
+    kelly_confidence_factor = 0.6,
+    kelly_minimum_risk = 0.2
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -52994,6 +53088,10 @@ class Signal {
     this.increase_position = increase_position;
     this.gap = gap;
     this.max_size = max_size;
+    this.use_kelly = use_kelly;
+    this.kelly_prediction_model = kelly_prediction_model;
+    this.kelly_confidence_factor = kelly_confidence_factor;
+    this.kelly_minimum_risk = kelly_minimum_risk;
   }
   build_entry({
     current_price,
@@ -53432,10 +53530,25 @@ class Signal {
         }
         const defaultStopLoss = i2 === 0 ? stop_loss : _base;
         const new_stop = kind === "long" ? this.support : stop_loss;
+        let risk_to_use = risk_per_trade;
+        if (this.use_kelly) {
+          const theoretical_kelly = calculateTheoreticalKelly({
+            current_entry: x,
+            zone_prices: limit_orders,
+            kind,
+            config: {
+              price_prediction_model: this.kelly_prediction_model,
+              confidence_factor: this.kelly_confidence_factor,
+              volatility_adjustment: true
+            }
+          });
+          risk_to_use = theoretical_kelly * risk_per_trade / this.kelly_minimum_risk;
+          console.log({ risk_per_trade, theoretical_kelly });
+        }
         const y = this.build_trade_dict({
           entry: x,
           stop: (this.increase_position ? new_stop : defaultStopLoss) || defaultStopLoss,
-          risk: risk_per_trade,
+          risk: risk_to_use,
           arr: limit_orders,
           index: i2,
           new_fees: total_incurred_market_fees,
@@ -53647,7 +53760,8 @@ function buildConfig(app_config, {
     kind: app_config.kind,
     gap,
     min_profit: min_profit || app_config.min_profit,
-    rr: rr || 1
+    rr: rr || 1,
+    use_kelly: app_config.use_kelly
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -53659,6 +53773,7 @@ function buildConfig(app_config, {
   const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
   if (kind === "short") {
   }
+  console.log({ entry, stop, condition, working_risk, config: config2 });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -58935,15 +59050,25 @@ class ExchangeAccount {
     }
   }
   async increasePositionAtStop(payload) {
-    const { symbol, kind, place = false } = payload;
+    const { symbol, kind, place = false, increase = true } = payload;
     const position2 = await this.syncAccount({
       symbol,
       kind,
       as_view: true
     });
     console.log(position2);
-    if (position2 && position2.stop_loss) {
-      const { price, quantity } = position2.stop_loss;
+    let price_params = {
+      price: payload.price,
+      quantity: payload.quantity
+    };
+    if (!payload.price && position2 && position2.stop_loss) {
+      price_params.price = position2.stop_loss.price;
+    }
+    if (!payload.quantity && position2 && position2.stop_loss) {
+      price_params.quantity = position2.stop_loss.quantity;
+    }
+    if (price_params.price && price_params.quantity) {
+      const { price, quantity } = price_params;
       const symbol_config = await this.recomputeSymbolConfig({
         symbol
       });
@@ -58963,7 +59088,7 @@ class ExchangeAccount {
         quantity,
         price_places,
         decimal_places,
-        increase: true,
+        increase,
         place
       });
     }

package/dist/index.d.ts

@@ -1016,6 +1016,7 @@ export declare class Strategy {
 		rr?: number;
 		max_size?: number;
 		max_quantity?: number;
+		use_kelly?: boolean;
 	};
 	identifyGapConfig(payload: {
 		factor?: number;
@@ -1129,6 +1130,10 @@ export type SignalConfigType = {
 	first_order_size?: number;
 	gap?: number;
 	max_size?: number;
+	use_kelly?: boolean;
+	kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	kelly_confidence_factor?: number;
+	kelly_minimum_risk?: number;
 };
 declare class Signal {
 	focus: number;
@@ -1151,7 +1156,11 @@ declare class Signal {
 	first_order_size: number;
 	gap: number;
 	max_size: 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, }: SignalConfigType);
+	use_kelly: boolean;
+	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);
 	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, }: {
 		take_profit?: number;
 		no_of_trades?: number;
@@ -1274,6 +1283,7 @@ export type AppConfig = {
 	last_value?: any;
 	entries?: any[];
 	max_quantity?: number;
+	use_kelly?: boolean;
 };
 export type ExtendConfigType = {
 	take_profit?: number;
@@ -2072,6 +2082,9 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 		place?: boolean;
+		price?: number;
+		quantity?: number;
+		increase?: boolean;
 	}): Promise<any>;
 	triggerTradeFromConfig(payload: {
 		symbol: string;
@@ -2198,6 +2211,7 @@ declare class ExchangeAccount$1 {
 		rr?: number;
 		max_size?: number;
 		max_quantity?: number;
+		use_kelly?: boolean;
 	}>;
 	runSimulation(payload: {
 		symbol: string;
@@ -2378,6 +2392,7 @@ declare class ExchangeAccount$1 {
 				rr?: number;
 				max_size?: number;
 				max_quantity?: number;
+				use_kelly?: boolean;
 			};
 			last_value: any;
 			config: {
@@ -2645,6 +2660,7 @@ declare class App {
 				rr?: number;
 				max_size?: number;
 				max_quantity?: number;
+				use_kelly?: boolean;
 			};
 			last_value: any;
 			config: {

package/dist/index.js

@@ -52818,6 +52818,92 @@ function createGapPairs(arr, gap, item) {
   return result;
 }
 
+// src/helpers/optimizations.ts
+function calculateTheoreticalKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = kind === "long" ? zone_prices : zone_prices.reverse();
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const win_zones = kind === "long" ? sorted_prices.slice(current_index + 1) : sorted_prices.slice(0, current_index);
+  const lose_zones = kind === "long" ? sorted_prices.slice(0, current_index) : sorted_prices.slice(current_index + 1);
+  const { win_probability, avg_win_ratio, avg_loss_ratio } = calculateZoneProbabilities({
+    current_entry,
+    win_zones,
+    lose_zones,
+    price_prediction_model,
+    confidence_factor,
+    kind
+  });
+  const odds_ratio = avg_win_ratio / avg_loss_ratio;
+  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 calculateZoneProbabilities({
+  current_entry,
+  win_zones,
+  lose_zones,
+  price_prediction_model,
+  confidence_factor,
+  kind
+}) {
+  if (win_zones.length === 0 && lose_zones.length === 0) {
+    return { win_probability: 0.5, avg_win_ratio: 0.02, avg_loss_ratio: 0.02 };
+  }
+  let win_probability;
+  switch (price_prediction_model) {
+    case "uniform":
+      win_probability = win_zones.length / (win_zones.length + lose_zones.length);
+      break;
+    case "normal":
+      const win_weight = win_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      const lose_weight = lose_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      win_probability = win_weight / (win_weight + lose_weight);
+      break;
+    case "exponential":
+      const exp_win_weight = win_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      const exp_lose_weight = lose_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      win_probability = exp_win_weight / (exp_win_weight + exp_lose_weight);
+      break;
+    default:
+      win_probability = 0.5;
+  }
+  win_probability = win_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const avg_win_ratio = win_zones.length > 0 ? win_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / win_zones.length : 0.02;
+  const avg_loss_ratio = lose_zones.length > 0 ? lose_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / lose_zones.length : 0.02;
+  return {
+    win_probability: Math.max(0.1, Math.min(0.9, win_probability)),
+    avg_win_ratio: Math.max(0.005, avg_win_ratio),
+    avg_loss_ratio: Math.max(0.005, avg_loss_ratio)
+  };
+}
+function calculateZoneVolatility(zone_prices) {
+  if (zone_prices.length < 2)
+    return 0;
+  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;
+}
+
 // src/helpers/trade_signal.ts
 function determine_close_price2({
   entry,
@@ -52900,6 +52986,10 @@ class Signal {
   first_order_size;
   gap = 10;
   max_size = 0;
+  use_kelly = false;
+  kelly_prediction_model = "exponential";
+  kelly_confidence_factor = 0.6;
+  kelly_minimum_risk = 0.2;
   constructor({
     focus,
     budget,
@@ -52920,7 +53010,11 @@ class Signal {
     minimum_size = 0,
     first_order_size = 0,
     gap = 10,
-    max_size = 0
+    max_size = 0,
+    use_kelly = false,
+    kelly_prediction_model = "exponential",
+    kelly_confidence_factor = 0.6,
+    kelly_minimum_risk = 0.2
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -52942,6 +53036,10 @@ class Signal {
     this.increase_position = increase_position;
     this.gap = gap;
     this.max_size = max_size;
+    this.use_kelly = use_kelly;
+    this.kelly_prediction_model = kelly_prediction_model;
+    this.kelly_confidence_factor = kelly_confidence_factor;
+    this.kelly_minimum_risk = kelly_minimum_risk;
   }
   build_entry({
     current_price,
@@ -53380,10 +53478,25 @@ class Signal {
         }
         const defaultStopLoss = i2 === 0 ? stop_loss : _base;
         const new_stop = kind === "long" ? this.support : stop_loss;
+        let risk_to_use = risk_per_trade;
+        if (this.use_kelly) {
+          const theoretical_kelly = calculateTheoreticalKelly({
+            current_entry: x,
+            zone_prices: limit_orders,
+            kind,
+            config: {
+              price_prediction_model: this.kelly_prediction_model,
+              confidence_factor: this.kelly_confidence_factor,
+              volatility_adjustment: true
+            }
+          });
+          risk_to_use = theoretical_kelly * risk_per_trade / this.kelly_minimum_risk;
+          console.log({ risk_per_trade, theoretical_kelly });
+        }
         const y = this.build_trade_dict({
           entry: x,
           stop: (this.increase_position ? new_stop : defaultStopLoss) || defaultStopLoss,
-          risk: risk_per_trade,
+          risk: risk_to_use,
           arr: limit_orders,
           index: i2,
           new_fees: total_incurred_market_fees,
@@ -53595,7 +53708,8 @@ function buildConfig(app_config, {
     kind: app_config.kind,
     gap,
     min_profit: min_profit || app_config.min_profit,
-    rr: rr || 1
+    rr: rr || 1,
+    use_kelly: app_config.use_kelly
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -53607,6 +53721,7 @@ function buildConfig(app_config, {
   const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
   if (kind === "short") {
   }
+  console.log({ entry, stop, condition, working_risk, config: config2 });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -58883,15 +58998,25 @@ class ExchangeAccount {
     }
   }
   async increasePositionAtStop(payload) {
-    const { symbol, kind, place = false } = payload;
+    const { symbol, kind, place = false, increase = true } = payload;
     const position2 = await this.syncAccount({
       symbol,
       kind,
       as_view: true
     });
     console.log(position2);
-    if (position2 && position2.stop_loss) {
-      const { price, quantity } = position2.stop_loss;
+    let price_params = {
+      price: payload.price,
+      quantity: payload.quantity
+    };
+    if (!payload.price && position2 && position2.stop_loss) {
+      price_params.price = position2.stop_loss.price;
+    }
+    if (!payload.quantity && position2 && position2.stop_loss) {
+      price_params.quantity = position2.stop_loss.quantity;
+    }
+    if (price_params.price && price_params.quantity) {
+      const { price, quantity } = price_params;
       const symbol_config = await this.recomputeSymbolConfig({
         symbol
       });
@@ -58911,7 +59036,7 @@ class ExchangeAccount {
         quantity,
         price_places,
         decimal_places,
-        increase: true,
+        increase,
         place
       });
     }

package/dist/mcp-server.cjs

@@ -59565,6 +59565,92 @@ function createGapPairs(arr, gap, item) {
   return result;
 }
 
+// src/helpers/optimizations.ts
+function calculateTheoreticalKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = kind === "long" ? zone_prices : zone_prices.reverse();
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const win_zones = kind === "long" ? sorted_prices.slice(current_index + 1) : sorted_prices.slice(0, current_index);
+  const lose_zones = kind === "long" ? sorted_prices.slice(0, current_index) : sorted_prices.slice(current_index + 1);
+  const { win_probability, avg_win_ratio, avg_loss_ratio } = calculateZoneProbabilities({
+    current_entry,
+    win_zones,
+    lose_zones,
+    price_prediction_model,
+    confidence_factor,
+    kind
+  });
+  const odds_ratio = avg_win_ratio / avg_loss_ratio;
+  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 calculateZoneProbabilities({
+  current_entry,
+  win_zones,
+  lose_zones,
+  price_prediction_model,
+  confidence_factor,
+  kind
+}) {
+  if (win_zones.length === 0 && lose_zones.length === 0) {
+    return { win_probability: 0.5, avg_win_ratio: 0.02, avg_loss_ratio: 0.02 };
+  }
+  let win_probability;
+  switch (price_prediction_model) {
+    case "uniform":
+      win_probability = win_zones.length / (win_zones.length + lose_zones.length);
+      break;
+    case "normal":
+      const win_weight = win_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      const lose_weight = lose_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      win_probability = win_weight / (win_weight + lose_weight);
+      break;
+    case "exponential":
+      const exp_win_weight = win_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      const exp_lose_weight = lose_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      win_probability = exp_win_weight / (exp_win_weight + exp_lose_weight);
+      break;
+    default:
+      win_probability = 0.5;
+  }
+  win_probability = win_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const avg_win_ratio = win_zones.length > 0 ? win_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / win_zones.length : 0.02;
+  const avg_loss_ratio = lose_zones.length > 0 ? lose_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / lose_zones.length : 0.02;
+  return {
+    win_probability: Math.max(0.1, Math.min(0.9, win_probability)),
+    avg_win_ratio: Math.max(0.005, avg_win_ratio),
+    avg_loss_ratio: Math.max(0.005, avg_loss_ratio)
+  };
+}
+function calculateZoneVolatility(zone_prices) {
+  if (zone_prices.length < 2)
+    return 0;
+  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;
+}
+
 // src/helpers/trade_signal.ts
 function determine_close_price2({
   entry,
@@ -59647,6 +59733,10 @@ class Signal {
   first_order_size;
   gap = 10;
   max_size = 0;
+  use_kelly = false;
+  kelly_prediction_model = "exponential";
+  kelly_confidence_factor = 0.6;
+  kelly_minimum_risk = 0.2;
   constructor({
     focus,
     budget,
@@ -59667,7 +59757,11 @@ class Signal {
     minimum_size = 0,
     first_order_size = 0,
     gap = 10,
-    max_size = 0
+    max_size = 0,
+    use_kelly = false,
+    kelly_prediction_model = "exponential",
+    kelly_confidence_factor = 0.6,
+    kelly_minimum_risk = 0.2
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -59689,6 +59783,10 @@ class Signal {
     this.increase_position = increase_position;
     this.gap = gap;
     this.max_size = max_size;
+    this.use_kelly = use_kelly;
+    this.kelly_prediction_model = kelly_prediction_model;
+    this.kelly_confidence_factor = kelly_confidence_factor;
+    this.kelly_minimum_risk = kelly_minimum_risk;
   }
   build_entry({
     current_price,
@@ -60127,10 +60225,25 @@ class Signal {
         }
         const defaultStopLoss = i2 === 0 ? stop_loss : _base;
         const new_stop = kind === "long" ? this.support : stop_loss;
+        let risk_to_use = risk_per_trade;
+        if (this.use_kelly) {
+          const theoretical_kelly = calculateTheoreticalKelly({
+            current_entry: x,
+            zone_prices: limit_orders,
+            kind,
+            config: {
+              price_prediction_model: this.kelly_prediction_model,
+              confidence_factor: this.kelly_confidence_factor,
+              volatility_adjustment: true
+            }
+          });
+          risk_to_use = theoretical_kelly * risk_per_trade / this.kelly_minimum_risk;
+          console.log({ risk_per_trade, theoretical_kelly });
+        }
         const y = this.build_trade_dict({
           entry: x,
           stop: (this.increase_position ? new_stop : defaultStopLoss) || defaultStopLoss,
-          risk: risk_per_trade,
+          risk: risk_to_use,
           arr: limit_orders,
           index: i2,
           new_fees: total_incurred_market_fees,
@@ -60342,7 +60455,8 @@ function buildConfig(app_config, {
     kind: app_config.kind,
     gap,
     min_profit: min_profit || app_config.min_profit,
-    rr: rr || 1
+    rr: rr || 1,
+    use_kelly: app_config.use_kelly
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -60354,6 +60468,7 @@ function buildConfig(app_config, {
   const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
   if (kind === "short") {
   }
+  console.log({ entry, stop, condition, working_risk, config: config2 });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -65611,15 +65726,25 @@ class ExchangeAccount {
     }
   }
   async increasePositionAtStop(payload) {
-    const { symbol, kind, place = false } = payload;
+    const { symbol, kind, place = false, increase = true } = payload;
     const position2 = await this.syncAccount({
       symbol,
       kind,
       as_view: true
     });
     console.log(position2);
-    if (position2 && position2.stop_loss) {
-      const { price, quantity } = position2.stop_loss;
+    let price_params = {
+      price: payload.price,
+      quantity: payload.quantity
+    };
+    if (!payload.price && position2 && position2.stop_loss) {
+      price_params.price = position2.stop_loss.price;
+    }
+    if (!payload.quantity && position2 && position2.stop_loss) {
+      price_params.quantity = position2.stop_loss.quantity;
+    }
+    if (price_params.price && price_params.quantity) {
+      const { price, quantity } = price_params;
       const symbol_config = await this.recomputeSymbolConfig({
         symbol
       });
@@ -65639,7 +65764,7 @@ class ExchangeAccount {
         quantity,
         price_places,
         decimal_places,
-        increase: true,
+        increase,
         place
       });
     }

package/dist/mcp-server.js

@@ -59542,6 +59542,92 @@ function createGapPairs(arr, gap, item) {
   return result;
 }
 
+// src/helpers/optimizations.ts
+function calculateTheoreticalKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config: config2 = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config2;
+  const sorted_prices = kind === "long" ? zone_prices : zone_prices.reverse();
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const win_zones = kind === "long" ? sorted_prices.slice(current_index + 1) : sorted_prices.slice(0, current_index);
+  const lose_zones = kind === "long" ? sorted_prices.slice(0, current_index) : sorted_prices.slice(current_index + 1);
+  const { win_probability, avg_win_ratio, avg_loss_ratio } = calculateZoneProbabilities({
+    current_entry,
+    win_zones,
+    lose_zones,
+    price_prediction_model,
+    confidence_factor,
+    kind
+  });
+  const odds_ratio = avg_win_ratio / avg_loss_ratio;
+  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 calculateZoneProbabilities({
+  current_entry,
+  win_zones,
+  lose_zones,
+  price_prediction_model,
+  confidence_factor,
+  kind
+}) {
+  if (win_zones.length === 0 && lose_zones.length === 0) {
+    return { win_probability: 0.5, avg_win_ratio: 0.02, avg_loss_ratio: 0.02 };
+  }
+  let win_probability;
+  switch (price_prediction_model) {
+    case "uniform":
+      win_probability = win_zones.length / (win_zones.length + lose_zones.length);
+      break;
+    case "normal":
+      const win_weight = win_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      const lose_weight = lose_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      win_probability = win_weight / (win_weight + lose_weight);
+      break;
+    case "exponential":
+      const exp_win_weight = win_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      const exp_lose_weight = lose_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      win_probability = exp_win_weight / (exp_win_weight + exp_lose_weight);
+      break;
+    default:
+      win_probability = 0.5;
+  }
+  win_probability = win_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const avg_win_ratio = win_zones.length > 0 ? win_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / win_zones.length : 0.02;
+  const avg_loss_ratio = lose_zones.length > 0 ? lose_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / lose_zones.length : 0.02;
+  return {
+    win_probability: Math.max(0.1, Math.min(0.9, win_probability)),
+    avg_win_ratio: Math.max(0.005, avg_win_ratio),
+    avg_loss_ratio: Math.max(0.005, avg_loss_ratio)
+  };
+}
+function calculateZoneVolatility(zone_prices) {
+  if (zone_prices.length < 2)
+    return 0;
+  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;
+}
+
 // src/helpers/trade_signal.ts
 function determine_close_price2({
   entry,
@@ -59624,6 +59710,10 @@ class Signal {
   first_order_size;
   gap = 10;
   max_size = 0;
+  use_kelly = false;
+  kelly_prediction_model = "exponential";
+  kelly_confidence_factor = 0.6;
+  kelly_minimum_risk = 0.2;
   constructor({
     focus,
     budget,
@@ -59644,7 +59734,11 @@ class Signal {
     minimum_size = 0,
     first_order_size = 0,
     gap = 10,
-    max_size = 0
+    max_size = 0,
+    use_kelly = false,
+    kelly_prediction_model = "exponential",
+    kelly_confidence_factor = 0.6,
+    kelly_minimum_risk = 0.2
   }) {
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -59666,6 +59760,10 @@ class Signal {
     this.increase_position = increase_position;
     this.gap = gap;
     this.max_size = max_size;
+    this.use_kelly = use_kelly;
+    this.kelly_prediction_model = kelly_prediction_model;
+    this.kelly_confidence_factor = kelly_confidence_factor;
+    this.kelly_minimum_risk = kelly_minimum_risk;
   }
   build_entry({
     current_price,
@@ -60104,10 +60202,25 @@ class Signal {
         }
         const defaultStopLoss = i2 === 0 ? stop_loss : _base;
         const new_stop = kind === "long" ? this.support : stop_loss;
+        let risk_to_use = risk_per_trade;
+        if (this.use_kelly) {
+          const theoretical_kelly = calculateTheoreticalKelly({
+            current_entry: x,
+            zone_prices: limit_orders,
+            kind,
+            config: {
+              price_prediction_model: this.kelly_prediction_model,
+              confidence_factor: this.kelly_confidence_factor,
+              volatility_adjustment: true
+            }
+          });
+          risk_to_use = theoretical_kelly * risk_per_trade / this.kelly_minimum_risk;
+          console.log({ risk_per_trade, theoretical_kelly });
+        }
         const y = this.build_trade_dict({
           entry: x,
           stop: (this.increase_position ? new_stop : defaultStopLoss) || defaultStopLoss,
-          risk: risk_per_trade,
+          risk: risk_to_use,
           arr: limit_orders,
           index: i2,
           new_fees: total_incurred_market_fees,
@@ -60319,7 +60432,8 @@ function buildConfig(app_config, {
     kind: app_config.kind,
     gap,
     min_profit: min_profit || app_config.min_profit,
-    rr: rr || 1
+    rr: rr || 1,
+    use_kelly: app_config.use_kelly
   };
   const instance = new Signal(config2);
   if (raw_instance) {
@@ -60331,6 +60445,7 @@ function buildConfig(app_config, {
   const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
   if (kind === "short") {
   }
+  console.log({ entry, stop, condition, working_risk, config: config2 });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -65588,15 +65703,25 @@ class ExchangeAccount {
     }
   }
   async increasePositionAtStop(payload) {
-    const { symbol, kind, place = false } = payload;
+    const { symbol, kind, place = false, increase = true } = payload;
     const position2 = await this.syncAccount({
       symbol,
       kind,
       as_view: true
     });
     console.log(position2);
-    if (position2 && position2.stop_loss) {
-      const { price, quantity } = position2.stop_loss;
+    let price_params = {
+      price: payload.price,
+      quantity: payload.quantity
+    };
+    if (!payload.price && position2 && position2.stop_loss) {
+      price_params.price = position2.stop_loss.price;
+    }
+    if (!payload.quantity && position2 && position2.stop_loss) {
+      price_params.quantity = position2.stop_loss.quantity;
+    }
+    if (price_params.price && price_params.quantity) {
+      const { price, quantity } = price_params;
       const symbol_config = await this.recomputeSymbolConfig({
         symbol
       });
@@ -65616,7 +65741,7 @@ class ExchangeAccount {
         quantity,
         price_places,
         decimal_places,
-        increase: true,
+        increase,
         place
       });
     }

package/package.json

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