@gbozee/ultimate 0.0.2-204 → 0.0.2-205

package/dist/frontend-index.d.ts

@@ -165,12 +165,22 @@ export type SignalConfigType = {
 		short: GetEntriesParams["distribution"];
 	};
 	max_quantity?: number;
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 };
 declare class Signal {
 	focus: number;
 	budget: number;
 	percent_change: number;
 	price_places: string;
+	distribution_params: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 	decimal_places: string;
 	zone_risk: number;
 	fee: number;
@@ -198,8 +208,8 @@ declare class Signal {
 		short: GetEntriesParams["distribution"];
 	};
 	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, }: SignalConfigType);
-	build_entry({ current_price, stop_loss, pnl, stop_percent, kind, risk, no_of_trades, take_profit, distribution, }: {
+	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);
+	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;
 		current_price: number;
@@ -209,6 +219,11 @@ declare class Signal {
 		stop_percent?: number;
 		pnl?: number;
 		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
 	}): any;
 	get risk(): number;
 	get min_trades(): number;
@@ -376,6 +391,11 @@ export interface ScheduledTrade extends BaseSystemFields {
 		kelly_prediction_model?: "exponential" | "normal" | "uniform";
 	};
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 	settings?: {
 		gap_trading?: {
 			entry_risk?: number;
@@ -518,6 +538,12 @@ export type AppConfig = {
 		kelly_prediction_model?: "exponential" | "normal" | "uniform";
 		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	};
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 };
 export type ExtendConfigType = {
 	take_profit?: number;
@@ -541,8 +567,13 @@ export type ExtendConfigType = {
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
 	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 };
-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, }: 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, }: ExtendConfigType): any[] | Signal;
 export declare function buildAvg({ _trades, kind, }: {
 	_trades: any[];
 	kind: "long" | "short";
@@ -558,6 +589,11 @@ export declare function get_app_config_and_max_size(config: GlobalConfig, payloa
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
 	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }): {
 	app_config: AppConfig;
 	max_size: any;
@@ -583,12 +619,22 @@ export declare function buildAppConfig(config: GlobalConfig, payload: {
 	kelly_prediction_model?: "exponential" | "normal" | "uniform";
 	kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }): AppConfig;
 export declare function getOptimumStopAndRisk(app_config: AppConfig, params: {
 	max_size: number;
 	target_stop: number;
 	highest_risk?: number;
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }): {
 	optimal_stop: number;
 	optimal_risk: number;
@@ -646,6 +692,11 @@ export declare function generateOptimumAppConfig(config: GlobalConfig, payload:
 	start_risk: number;
 	max_risk?: number;
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }, position: {
 	entry: number;
 	quantity: number;
@@ -658,6 +709,11 @@ export declare function determineOptimumReward(payload: {
 	high_range?: number;
 	target_loss?: number;
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 	max_size?: number;
 }): number | {
 	result: any[];
@@ -677,6 +733,11 @@ export declare function determineOptimumRisk(config: GlobalConfig, payload: {
 	risk: number;
 	symbol: string;
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 }, params: {
 	highest_risk: number;
 	tolerance?: number;
@@ -699,6 +760,11 @@ export declare function computeRiskReward(payload: {
 	risk_per_trade: number;
 	target_loss?: number;
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 	high_range?: number;
 	max_size?: number;
 }): number | {
@@ -721,6 +787,11 @@ export declare function getRiskReward(payload: {
 	target_loss?: number;
 	max_size?: number;
 	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 	risk_factor?: number;
 	high_range?: number;
 }): any;
@@ -951,6 +1022,14 @@ export declare function constructAppConfig(payload: {
 		kelly_minimum_risk: number;
 		kelly_prediction_model: string;
 	};
+	distribution_config?: {
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
+	};
 }): {
 	fee: number;
 	risk_per_trade: number;
@@ -985,6 +1064,12 @@ export declare function constructAppConfig(payload: {
 		kelly_prediction_model?: "exponential" | "normal" | "uniform";
 		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	};
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 };
 export declare function generateDangerousConfig(payload: {
 	account: PositionsView;
@@ -1203,6 +1288,12 @@ export declare class Strategy {
 			kelly_prediction_model?: "exponential" | "normal" | "uniform";
 			kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 		};
+		distribution?: GetEntriesParams["distribution"];
+		distribution_params?: {
+			curveFactor?: number;
+			stdDevFactor?: number;
+			lambda?: number;
+		};
 	};
 	identifyGapConfig(payload: {
 		factor?: number;
@@ -1351,6 +1442,12 @@ declare function constructAppConfig$1({ config, global_config, }: {
 		kelly_prediction_model?: "exponential" | "normal" | "uniform";
 		kelly_func?: "theoretical" | "position_based" | "theoretical_fixed";
 	};
+	distribution?: GetEntriesParams["distribution"];
+	distribution_params?: {
+		curveFactor?: number;
+		stdDevFactor?: number;
+		lambda?: number;
+	};
 };
 declare function buildWithOptimumReward({ config, settings, global_config, force_exact, }: {
 	config: TradeConfig;
@@ -1572,7 +1669,44 @@ declare function generatePositionIncreaseTrade({ account, zoneAccount, ratio, co
 		};
 	};
 };
+declare function determineHedgeTradeToPlace({ position, config, global_config, profit_risk, allowable_loss, }: {
+	position: {
+		entry: number;
+		quantity: number;
+		kind: "long" | "short";
+	};
+	config: TradeConfig;
+	global_config: GlobalConfig;
+	profit_risk?: number;
+	allowable_loss?: number;
+}): {
+	opposite: {
+		trades: any[];
+		summary: {
+			entry: number;
+			stop: number;
+			risk: number;
+			risk_reward: any;
+			avg_entry: number;
+			avg_size: number;
+			first_entry: number;
+			pnl: number;
+			fee: number;
+			loss: number;
+			last_entry: number;
+			margin: number;
+		};
+		config: any;
+		stop_order: {
+			quantity: number;
+			price: number;
+		};
+		kind: string;
+	};
+	take_profit: number;
+};
 export declare const compoundAPI: {
+	determineHedgeTradeToPlace: typeof determineHedgeTradeToPlace;
 	buildWithOptimumReward: typeof buildWithOptimumReward;
 	constructAppConfig: typeof constructAppConfig$1;
 	generateOppositeOptimum: typeof generateOppositeOptimum;

package/dist/frontend-index.js

@@ -376,6 +376,7 @@ class Signal {
   budget;
   percent_change = 0.02;
   price_places = "%.5f";
+  distribution_params = {};
   decimal_places = "%.0f";
   zone_risk = 1;
   fee = 0.08 / 100;
@@ -431,11 +432,13 @@ class Signal {
     kelly_minimum_risk = 0.2,
     kelly_func = "theoretical",
     full_distribution,
-    max_quantity = 0.03
+    max_quantity = 0.03,
+    distribution_params = {}
   }) {
     if (full_distribution) {
       this.distribution = full_distribution;
     }
+    this.distribution_params = distribution_params;
     this.symbol = symbol;
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -473,7 +476,8 @@ class Signal {
     risk,
     no_of_trades = 1,
     take_profit,
-    distribution
+    distribution,
+    distribution_params = {}
   }) {
     let _stop_loss = stop_loss;
     if (!_stop_loss && stop_percent) {
@@ -497,7 +501,8 @@ class Signal {
       full_distribution: distribution ? {
         ...this.distribution,
         [kind]: distribution
-      } : undefined
+      } : undefined,
+      distribution_params
     };
     const instance = new Signal(derivedConfig);
     if (kind === "short") {}
@@ -725,7 +730,8 @@ class Signal {
       kind: _kind,
       distribution,
       risk_reward: this.risk_reward,
-      price_places: this.price_places
+      price_places: this.price_places,
+      distribution_params: this.distribution_params
     });
     return entries.sort((a, b) => a - b);
   }
@@ -1606,7 +1612,8 @@ function buildConfig(app_config, {
   kelly_prediction_model = "exponential",
   kelly_func = "theoretical",
   min_avg_size = 0,
-  distribution
+  distribution,
+  distribution_params
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -1637,7 +1644,8 @@ function buildConfig(app_config, {
     kelly_prediction_model: kelly_prediction_model || app_config.kelly?.kelly_prediction_model,
     kelly_func: kelly_func || app_config.kelly?.kelly_func,
     symbol: app_config.symbol,
-    max_quantity: app_config.max_quantity
+    max_quantity: app_config.max_quantity,
+    distribution_params: distribution_params || app_config.distribution_params
   };
   const instance = new Signal(config);
   if (raw_instance) {
@@ -1654,7 +1662,8 @@ function buildConfig(app_config, {
     risk: working_risk,
     kind: kind || app_config.kind,
     no_of_trades: trade_no,
-    distribution
+    distribution,
+    distribution_params
   }) || [] : [];
   const new_trades = computeTotalAverageForEachTrade(result, config);
   let filtered = new_trades.filter((o) => o.avg_size > min_avg_size);
@@ -1724,7 +1733,8 @@ function get_app_config_and_max_size(config, payload) {
     kelly_minimum_risk: payload.kelly_minimum_risk,
     kelly_prediction_model: payload.kelly_prediction_model,
     kelly_func: payload.kelly_func,
-    distribution: payload.distribution
+    distribution: payload.distribution,
+    distribution_params: payload.distribution_params
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -1763,7 +1773,8 @@ function buildAppConfig(config, payload) {
     kelly_minimum_risk: payload.kelly_minimum_risk,
     kelly_prediction_model: payload.kelly_prediction_model,
     kelly_func: payload.kelly_func,
-    distribution: payload.distribution
+    distribution: payload.distribution,
+    distribution_params: payload.distribution_params
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -1777,10 +1788,12 @@ function buildAppConfig(config, payload) {
     kelly_prediction_model: payload.kelly_prediction_model,
     kelly_func: payload.kelly_func
   };
+  app_config.distribution = payload.distribution;
+  app_config.distribution_params = payload.distribution_params;
   return app_config;
 }
 function getOptimumStopAndRisk(app_config, params) {
-  const { max_size, target_stop, distribution } = 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);
@@ -1804,7 +1817,8 @@ function getOptimumStopAndRisk(app_config, params) {
       gap: app_config.gap,
       price_places: app_config.price_places,
       decimal_places: app_config.decimal_places,
-      distribution
+      distribution,
+      distribution_params: _distribution_params
     });
     if (result.length === 0) {
       if (isLong) {
@@ -1859,7 +1873,8 @@ function getOptimumStopAndRisk(app_config, params) {
       gap: app_config.gap,
       price_places: app_config.price_places,
       decimal_places: app_config.decimal_places,
-      distribution
+      distribution,
+      distribution_params: _distribution_params
     });
     if (result.length === 0) {
       high_risk = mid_risk;
@@ -1905,7 +1920,8 @@ function getOptimumStopAndRisk(app_config, params) {
         gap: app_config.gap,
         price_places: app_config.price_places,
         decimal_places: app_config.decimal_places,
-        distribution
+        distribution,
+        distribution_params: _distribution_params
       });
       if (result.length === 0)
         continue;
@@ -2126,7 +2142,8 @@ function determineOptimumReward(payload) {
       kind: app_config.kind,
       gap: app_config.gap,
       decimal_places: app_config.decimal_places,
-      distribution
+      distribution,
+      distribution_params: payload.distribution_params
     });
     let total = 0;
     let max = -Infinity;
@@ -2315,6 +2332,7 @@ function computeRiskReward(payload) {
     app_config,
     target_loss,
     distribution,
+    distribution_params: payload.distribution_params,
     high_range,
     max_size
   });
@@ -2339,7 +2357,8 @@ function getRiskReward(payload) {
     risk_reward: 30,
     risk,
     symbol: global_config.symbol,
-    distribution
+    distribution,
+    distribution_params: payload.distribution_params
   });
   const risk_reward = computeRiskReward({
     app_config,
@@ -2349,6 +2368,7 @@ function getRiskReward(payload) {
     high_range,
     target_loss,
     distribution,
+    distribution_params: payload.distribution_params,
     max_size
   });
   if (force_exact_risk) {
@@ -2358,7 +2378,8 @@ function getRiskReward(payload) {
       risk_reward,
       risk,
       symbol: global_config.symbol,
-      distribution
+      distribution,
+      distribution_params: payload.distribution_params
     }, {
       highest_risk: risk * risk_factor
     }).optimal_risk;
@@ -2779,7 +2800,8 @@ function generateOppositeTradeConfig(payload) {
         }
       }
     },
-    global_config
+    global_config,
+    distribution_config: {}
   });
   const risk_reward = computeRiskReward({
     app_config,
@@ -2796,7 +2818,7 @@ function generateOppositeTradeConfig(payload) {
   };
 }
 function constructAppConfig(payload) {
-  const { account, global_config, kelly_config } = payload;
+  const { account, global_config, kelly_config, distribution_config } = payload;
   const config = account.expand?.b_config;
   if (!config) {
     return null;
@@ -2811,7 +2833,9 @@ function constructAppConfig(payload) {
     use_kelly: kelly_config?.use_kelly ?? kelly?.use_kelly,
     kelly_confidence_factor: kelly_config?.kelly_confidence_factor ?? kelly?.kelly_confidence_factor,
     kelly_minimum_risk: kelly_config?.kelly_minimum_risk ?? kelly?.kelly_minimum_risk,
-    kelly_prediction_model: kelly_config?.kelly_prediction_model ?? kelly?.kelly_prediction_model
+    kelly_prediction_model: kelly_config?.kelly_prediction_model ?? kelly?.kelly_prediction_model,
+    distribution: distribution_config?.distribution ?? config?.distribution,
+    distribution_params: distribution_config?.distribution_params ?? config?.distribution_params
   };
   const { entries: _entries, ...appConfig } = buildAppConfig(global_config, options);
   return appConfig;
@@ -2821,7 +2845,8 @@ function generateDangerousConfig(payload) {
   const app_config = constructAppConfig({
     account,
     global_config,
-    kelly_config: {}
+    kelly_config: {},
+    distribution_config: {}
   });
   const { optimal_risk, optimal_stop } = getOptimumStopAndRisk(app_config, {
     max_size: config.quantity,
@@ -3748,7 +3773,42 @@ function generatePositionIncreaseTrade({
     distribution
   });
 }
+function determineHedgeTradeToPlace({
+  position: position2,
+  config,
+  global_config,
+  profit_risk = 200,
+  allowable_loss = 1000
+}) {
+  const diff = profit_risk / position2.quantity;
+  const kind = position2.kind === "long" ? "short" : "long";
+  const tp_price = position2.kind === "long" ? diff + position2.entry : position2.entry - diff;
+  const loss_diff = allowable_loss / position2.quantity;
+  const loss_price = position2.kind === "long" ? position2.entry - loss_diff : position2.entry + loss_diff;
+  const entry = kind === "short" ? loss_price : tp_price;
+  const stop = kind === "short" ? tp_price : loss_price;
+  const result = buildWithOptimumReward({
+    config: {
+      ...config,
+      entry,
+      stop
+    },
+    global_config,
+    force_exact: true,
+    settings: {
+      entry,
+      stop,
+      risk: profit_risk,
+      distribution: config.distribution
+    }
+  });
+  return {
+    opposite: result,
+    take_profit: to_f(tp_price, global_config.price_places)
+  };
+}
 var compoundAPI = {
+  determineHedgeTradeToPlace,
   buildWithOptimumReward,
   constructAppConfig: constructAppConfig2,
   generateOppositeOptimum,