@gbozee/ultimate 0.0.2-next.0 → 0.0.2-next.14

package/dist/frontend-index.d.ts

@@ -170,6 +170,16 @@ export type SignalConfigType = {
 		stdDevFactor?: number;
 		lambda?: number;
 	};
+	use_progressive_risk?: boolean;
+	risk_distribution?: {
+		enabled: boolean;
+		total_risk_budget: number;
+		risk_reward: number;
+		buckets: Array<{
+			zone_percentage: number;
+			risk_percentage: number;
+		}>;
+	};
 };
 declare class Signal {
 	focus: number;
@@ -207,8 +217,18 @@ declare class Signal {
 		long: GetEntriesParams["distribution"];
 		short: GetEntriesParams["distribution"];
 	};
+	use_progressive_risk?: boolean;
+	risk_distribution?: {
+		enabled: boolean;
+		total_risk_budget: number;
+		risk_reward: number;
+		buckets: Array<{
+			zone_percentage: number;
+			risk_percentage: number;
+		}>;
+	};
 	max_quantity: number;
-	constructor({ focus, symbol, 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, full_distribution, max_quantity, distribution_params, }: SignalConfigType);
+	constructor({ focus, symbol, 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, full_distribution, max_quantity, distribution_params, use_progressive_risk, risk_distribution, }: SignalConfigType);
 	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, distribution, distribution_params, }: {
 		take_profit?: number;
 		no_of_trades?: number;
@@ -223,6 +243,11 @@ declare class Signal {
 			curveFactor?: number;
 			stdDevFactor?: number;
 			lambda?: number;
+			use_progressive?: boolean;
+			buckets?: Array<{
+				zone_percentage: number;
+				risk_percentage: number;
+			}>;
 		};
 	}): any;
 	get risk(): number;
@@ -273,6 +298,14 @@ declare class Signal {
 		kind?: "long" | "short";
 	}): number[][];
 	get_margin_range(current_price: number, kind?: string): number[];
+	/**
+	 * Helper function to calculate zone-specific risk based on progressive risk distribution
+	 * @param index - The index of the current zone
+	 * @param totalZones - Total number of zones
+	 * @param account - Account configuration with risk settings
+	 * @returns The risk amount for the specific zone
+	 */
+	private getZoneRisk;
 	process_orders({ current_price, stop_loss, trade_zones, kind, }: {
 		current_price: number;
 		stop_loss: number;
@@ -572,9 +605,15 @@ export type ExtendConfigType = {
 		curveFactor?: number;
 		stdDevFactor?: number;
 		lambda?: number;
+		buckets?: Array<{
+			zone_percentage: number;
+			risk_percentage: number;
+		}>;
+		use_progressive?: boolean;
 	};
+	use_progressive_risk?: boolean;
 };
-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, min_avg_size, distribution, distribution_params, }: 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, min_avg_size, distribution, distribution_params, use_progressive_risk, }: ExtendConfigType): any[] | Signal;
 export declare function buildAvg({ _trades, kind, }: {
 	_trades: any[];
 	kind: "long" | "short";

package/dist/frontend-index.js

@@ -91,8 +91,7 @@ function getEntries(params) {
         margin_range,
         risk_reward,
         kind,
-        price_places,
-        percent_change: distribution_params?.curveFactor
+        price_places
       });
       break;
     case "normal":
@@ -403,6 +402,8 @@ class Signal {
     long: "arithmetic",
     short: "geometric"
   };
+  use_progressive_risk;
+  risk_distribution;
   max_quantity = 0.03;
   constructor({
     focus,
@@ -433,12 +434,16 @@ class Signal {
     kelly_func = "theoretical",
     full_distribution,
     max_quantity = 0.03,
-    distribution_params = {}
+    distribution_params = {},
+    use_progressive_risk,
+    risk_distribution
   }) {
     if (full_distribution) {
       this.distribution = full_distribution;
     }
     this.distribution_params = distribution_params;
+    this.use_progressive_risk = use_progressive_risk;
+    this.risk_distribution = risk_distribution;
     this.symbol = symbol;
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -477,7 +482,13 @@ class Signal {
     no_of_trades = 1,
     take_profit,
     distribution,
-    distribution_params = {}
+    distribution_params = {
+      buckets: [
+        { zone_percentage: 0.25, risk_percentage: 0.1 },
+        { zone_percentage: 0.5, risk_percentage: 0.4 },
+        { zone_percentage: 0.25, risk_percentage: 0.5 }
+      ]
+    }
   }) {
     let _stop_loss = stop_loss;
     if (!_stop_loss && stop_percent) {
@@ -488,12 +499,20 @@ class Signal {
     let _resistance = current_price * Math.pow(1 + percent_change, 1);
     const simple_support = Math.min(current_price, stop_loss);
     const simple_resistance = Math.max(current_price, stop_loss);
+    const risk_per_trade = risk / this.risk_reward;
+    const use_progressive = distribution_params?.use_progressive || this.use_progressive_risk;
+    const risk_distribution = use_progressive ? {
+      enabled: true,
+      total_risk_budget: risk,
+      risk_reward: this.risk_reward,
+      buckets: distribution_params.buckets || []
+    } : undefined;
     const derivedConfig = {
       ...this,
       percent_change,
       focus: current_price,
       resistance: distribution ? simple_resistance : _resistance,
-      risk_per_trade: risk / this.risk_reward,
+      risk_per_trade,
       minimum_pnl: pnl,
       risk_reward: _no_of_trades,
       take_profit: take_profit || this.take_profit,
@@ -502,7 +521,9 @@ class Signal {
         ...this.distribution,
         [kind]: distribution
       } : undefined,
-      distribution_params
+      use_progressive_risk: use_progressive,
+      distribution_params,
+      risk_distribution
     };
     const instance = new Signal(derivedConfig);
     if (kind === "short") {}
@@ -867,6 +888,24 @@ class Signal {
     }
     return null;
   }
+  getZoneRisk(index, totalZones, account) {
+    if (!account.risk_distribution?.enabled) {
+      return account.risk_per_trade;
+    }
+    const { buckets, total_risk_budget } = account.risk_distribution;
+    const reversedBuckets = [...buckets].reverse();
+    let zoneStart = 0;
+    for (const bucket of reversedBuckets) {
+      const zoneEnd = zoneStart + Math.floor(totalZones * bucket.zone_percentage);
+      if (index < zoneEnd) {
+        const zonesInBucket = zoneEnd - zoneStart;
+        const bucket_total = total_risk_budget * bucket.risk_percentage;
+        return bucket_total / zonesInBucket;
+      }
+      zoneStart = zoneEnd;
+    }
+    return account.risk_per_trade;
+  }
   process_orders({
     current_price,
     stop_loss,
@@ -929,7 +968,7 @@ 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;
+        let risk_to_use = this.getZoneRisk(i, limit_orders.length, this);
         if (this.use_kelly) {
           const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
           const theoretical_kelly = func({
@@ -1613,7 +1652,8 @@ function buildConfig(app_config, {
   kelly_func = "theoretical",
   min_avg_size = 0,
   distribution,
-  distribution_params
+  distribution_params,
+  use_progressive_risk = false
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -1645,7 +1685,8 @@ function buildConfig(app_config, {
     kelly_func: kelly_func || app_config.kelly?.kelly_func,
     symbol: app_config.symbol,
     max_quantity: app_config.max_quantity,
-    distribution_params: distribution_params || app_config.distribution_params
+    distribution_params: distribution_params || app_config.distribution_params,
+    use_progressive_risk
   };
   const instance = new Signal(config);
   if (raw_instance) {
@@ -1793,7 +1834,12 @@ function buildAppConfig(config, payload) {
   return app_config;
 }
 function getOptimumStopAndRisk(app_config, params) {
-  const { max_size, target_stop, distribution, distribution_params: _distribution_params } = params;
+  const {
+    max_size,
+    target_stop,
+    distribution,
+    distribution_params: _distribution_params
+  } = params;
   const isLong = app_config.kind === "long";
   const stopRange = Math.abs(app_config.entry - target_stop) * 0.5;
   let low_stop = isLong ? target_stop - stopRange : Math.max(target_stop - stopRange, app_config.entry);