@gbozee/ultimate 0.0.2-152 → 0.0.2-155

package/dist/frontend-index.d.ts

@@ -278,6 +278,100 @@ export type GlobalConfig = {
 	reverse_factor: number;
 	leverage?: number;
 };
+export interface BaseSystemFields {
+	id: string;
+	created: string;
+	updated: string;
+}
+export interface ExchangeAccount extends BaseSystemFields {
+	exchange: "binance" | "bybit";
+	owner: string;
+	email?: string;
+	user?: string;
+	usdt?: number;
+	usdc?: number;
+	proxy?: string;
+	bullish?: boolean;
+	bearish?: boolean;
+	movePercent?: number;
+	totalRisk?: number;
+	max_non_essential?: number;
+	profit_percent?: number;
+	risk_reward?: number;
+	exclude_coins?: {
+		bullish?: string[];
+	};
+	include_delisted?: boolean;
+}
+export interface ScheduledTrade extends BaseSystemFields {
+	symbol: string;
+	account: string;
+	profit?: number;
+	risk?: number;
+	entry?: number;
+	stop?: number;
+	risk_reward?: number;
+	profit_percent?: number;
+	place_tp?: boolean;
+	kind?: "long" | "short";
+	follow?: boolean | 1 | 0;
+	reduce_ratio?: number;
+	sell_ratio?: number;
+	threshold_qty?: number;
+	pause_tp?: boolean;
+	stop_percent?: number;
+	kelly?: {
+		use_kelly?: boolean;
+		kelly_confidence_factor?: number;
+		kelly_minimum_risk?: number;
+		kelly_prediction_model?: "exponential" | "normal" | "uniform";
+	};
+}
+interface Proxy$1 extends BaseSystemFields {
+	ip_address?: string;
+	type?: "http" | "socks5";
+}
+export interface PositionsView {
+	id: string;
+	symbol?: any;
+	entry?: any;
+	quantity?: any;
+	take_profit?: any;
+	account?: any;
+	kind?: any;
+	target_pnl?: number;
+	liquidation?: number;
+	avg_price?: number;
+	avg_qty?: number;
+	next_order?: number;
+	last_order?: number;
+	config?: any;
+	stop_loss?: {
+		price: number;
+		quantity: number;
+	};
+	stop_pnl?: any;
+	leverage?: any;
+	avg_liquidation?: any;
+	balance?: any;
+	reduce_ratio?: number;
+	sell_ratio?: number;
+	threshold_qty?: number;
+	follow?: boolean | 1 | 0;
+	current_price?: number;
+	usd_balance?: number;
+	tp?: {
+		price: number;
+		quantity: number;
+	};
+	next_risk?: number;
+	proxy?: string;
+	expand?: {
+		p_account?: ExchangeAccount;
+		b_config?: ScheduledTrade;
+		proxy?: Proxy$1;
+	};
+}
 export type AppConfig = {
 	fee: number;
 	risk_per_trade: number;
@@ -440,7 +534,13 @@ export declare function generateOptimumAppConfig(config: GlobalConfig, payload:
 	quantity: number;
 	kind: "long" | "short";
 }): AppConfig | null;
-export declare function determineOptimumReward(app_config: AppConfig, increase?: boolean, low_range?: number, high_range?: number): number | {
+export declare function determineOptimumReward(payload: {
+	app_config: AppConfig;
+	increase?: boolean;
+	low_range?: number;
+	high_range?: number;
+	target_loss?: number;
+}): number | {
 	result: any[];
 	value: number;
 	total: number;
@@ -476,6 +576,7 @@ export declare function computeRiskReward(payload: {
 	entry: number;
 	stop: number;
 	risk_per_trade: number;
+	target_loss?: number;
 }): number | {
 	result: any[];
 	value: number;
@@ -660,6 +761,38 @@ export declare function determineCompoundLongTrade(payload: {
 	result: any;
 	short_max_size: any;
 };
+export declare function generateOppositeTradeConfig(payload: {
+	kind: "long" | "short";
+	entry: number;
+	quantity: number;
+	target_pnl: number;
+	global_config: GlobalConfig;
+	ratio?: number;
+}): {
+	entry: number;
+	stop: number;
+	risk: number;
+	risk_reward: number | {
+		result: any[];
+		value: number;
+		total: number;
+		risk_per_trade: number;
+		max: number;
+		min: number;
+		neg_pnl: any;
+		entry: any;
+	};
+};
+export declare function constructAppConfig(payload: {
+	account: PositionsView;
+	global_config: GlobalConfig;
+	kelly_config?: {
+		use_kelly: boolean;
+		kelly_confidence_factor: number;
+		kelly_minimum_risk: number;
+		kelly_prediction_model: string;
+	};
+}): AppConfig;
 export type StrategyPosition = {
 	entry: number;
 	quantity: number;

package/dist/frontend-index.js

@@ -1928,7 +1928,14 @@ function generateOptimumAppConfig(config, payload, position2) {
   });
   return best_app_config;
 }
-function determineOptimumReward(app_config, increase = true, low_range = 30, high_range = 199) {
+function determineOptimumReward(payload) {
+  const {
+    app_config,
+    increase = true,
+    low_range = 1,
+    high_range = 199,
+    target_loss
+  } = payload;
   const criterion = app_config.strategy || "quantity";
   const risk_rewards = createArray(low_range, high_range, 1);
   let func = risk_rewards.map((trade_no) => {
@@ -1968,10 +1975,33 @@ function determineOptimumReward(app_config, increase = true, low_range = 30, hig
       entry
     };
   });
-  func = func.filter((r) => Boolean(r)).filter((r) => {
-    let foundIndex = r?.result.findIndex((e) => e.quantity === r.max);
-    return criterion === "quantity" ? foundIndex === 0 : true;
-  });
+  func = func.filter((r) => Boolean(r));
+  if (target_loss === undefined) {
+    func = func.filter((r) => {
+      let foundIndex = r?.result.findIndex((e) => e.quantity === r.max);
+      return criterion === "quantity" ? foundIndex === 0 : true;
+    });
+  }
+  if (target_loss !== undefined) {
+    const validResults = func.filter((r) => Math.abs(r.neg_pnl) <= target_loss);
+    if (validResults.length > 0) {
+      validResults.sort((a, b) => {
+        const diffA = target_loss - Math.abs(a.neg_pnl);
+        const diffB = target_loss - Math.abs(b.neg_pnl);
+        return diffA - diffB;
+      });
+      if (app_config.raw) {
+        return validResults[0];
+      }
+      return validResults[0]?.value;
+    } else {
+      func.sort((a, b) => Math.abs(a.neg_pnl) - Math.abs(b.neg_pnl));
+      if (app_config.raw) {
+        return func[0];
+      }
+      return func[0]?.value;
+    }
+  }
   const highest = criterion === "quantity" ? Math.max(...func.map((o) => o.max)) : Math.min(...func.map((o) => o.entry));
   const key = criterion === "quantity" ? "max" : "entry";
   const index = findIndexByCondition(func, app_config.kind, (x) => x[key] == highest, criterion);
@@ -2083,13 +2113,13 @@ function determineOptimumRisk(config, payload, params) {
   };
 }
 function computeRiskReward(payload) {
-  const { app_config, entry, stop, risk_per_trade } = payload;
+  const { app_config, entry, stop, risk_per_trade, target_loss } = payload;
   const kind = entry > stop ? "long" : "short";
   app_config.kind = kind;
   app_config.entry = entry;
   app_config.stop = stop;
   app_config.risk_per_trade = risk_per_trade;
-  const result = determineOptimumReward(app_config);
+  const result = determineOptimumReward({ app_config, target_loss });
   return result;
 }
 function getRiskReward(payload) {
@@ -2424,6 +2454,67 @@ function determineCompoundLongTrade(payload) {
     short_max_size
   };
 }
+function generateOppositeTradeConfig(payload) {
+  const {
+    kind,
+    entry,
+    quantity,
+    target_pnl,
+    ratio = 0.5,
+    global_config
+  } = payload;
+  const diff = target_pnl / quantity;
+  const tp = kind === "long" ? entry + diff : entry - diff;
+  const stop = kind === "long" ? entry - diff : entry + diff;
+  const opposite_pnl = target_pnl * ratio;
+  const app_config = constructAppConfig({
+    account: {
+      expand: {
+        b_config: {
+          entry,
+          stop,
+          symbol: global_config.symbol,
+          risk: target_pnl
+        }
+      }
+    },
+    global_config
+  });
+  const risk_reward = computeRiskReward({
+    app_config,
+    entry: stop,
+    stop: tp,
+    risk_per_trade: opposite_pnl,
+    target_loss: opposite_pnl
+  });
+  return {
+    entry: to_f(stop, global_config.price_places),
+    stop: to_f(tp, global_config.price_places),
+    risk: to_f(opposite_pnl, "%.2f"),
+    risk_reward
+  };
+}
+function constructAppConfig(payload) {
+  const { account, global_config, kelly_config } = payload;
+  const config = account.expand?.b_config;
+  if (!config) {
+    return null;
+  }
+  const kelly = config.kelly;
+  const options = {
+    entry: config?.entry,
+    stop: config?.stop,
+    risk_reward: config?.risk_reward,
+    risk: config?.risk,
+    symbol: account.symbol,
+    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
+  };
+  const appConfig = buildAppConfig(global_config, options);
+  return appConfig;
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -2942,6 +3033,7 @@ export {
   getDecimalPlaces,
   generate_config_params,
   generateOptimumAppConfig,
+  generateOppositeTradeConfig,
   generateGapTp,
   formatPrice,
   fibonacci_analysis,
@@ -2960,6 +3052,7 @@ export {
   determineCompoundLongTrade,
   createGapPairs,
   createArray,
+  constructAppConfig,
   computeTotalAverageForEachTrade,
   computeSellZones,
   computeRiskReward,

package/dist/index.cjs

@@ -41955,6 +41955,7 @@ __export(exports_src, {
   getHedgeZone: () => getHedgeZone,
   generate_config_params: () => generate_config_params,
   generateOptimumAppConfig: () => generateOptimumAppConfig,
+  generateOppositeTradeConfig: () => generateOppositeTradeConfig,
   generateGapTp: () => generateGapTp,
   exchange_account: () => exports_exchange_account,
   determine_break_even_price: () => determine_break_even_price,
@@ -41966,6 +41967,7 @@ __export(exports_src, {
   determineCompoundLongTrade: () => determineCompoundLongTrade,
   database: () => exports_database,
   createArray: () => createArray,
+  constructAppConfig: () => constructAppConfig,
   computeRiskReward: () => computeRiskReward,
   computeProfitDetail: () => computeProfitDetail,
   buildConfig: () => buildConfig,
@@ -51744,7 +51746,6 @@ class AppDatabase {
     const result = await this.get_exchange_db_instance(account);
     if (result?.expand?.proxy) {
       const { type, ip_address } = result.expand.proxy;
-      console.log(type, ip_address);
       if (type === "http") {
         return new import_https_proxy_agent.HttpsProxyAgent(`http://${ip_address}`);
       }
@@ -51792,13 +51793,13 @@ class AppDatabase {
       table: "positions_view",
       params: {
         filter: `symbol:lower="${symbol.toLowerCase()}" && account:lower="${account.owner.toLowerCase()} ${account.exchange.toLowerCase()}"`,
-        expand: "config, account_strategy, p_account"
+        expand: "config, account_strategy, p_account, proxy"
       }
     } : {
       table: "positions",
       params: {
         filter: `symbol:lower="${symbol.toLowerCase()}" && account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}"`,
-        expand: "account,config"
+        expand: "account,config, proxy"
       }
     };
     if (custom_filter) {
@@ -54328,7 +54329,14 @@ function generateOptimumAppConfig(config2, payload, position2) {
   });
   return best_app_config;
 }
-function determineOptimumReward(app_config, increase = true, low_range = 30, high_range = 199) {
+function determineOptimumReward(payload) {
+  const {
+    app_config,
+    increase = true,
+    low_range = 1,
+    high_range = 199,
+    target_loss
+  } = payload;
   const criterion = app_config.strategy || "quantity";
   const risk_rewards = createArray(low_range, high_range, 1);
   let func = risk_rewards.map((trade_no) => {
@@ -54368,10 +54376,33 @@ function determineOptimumReward(app_config, increase = true, low_range = 30, hig
       entry
     };
   });
-  func = func.filter((r2) => Boolean(r2)).filter((r2) => {
-    let foundIndex = r2?.result.findIndex((e2) => e2.quantity === r2.max);
-    return criterion === "quantity" ? foundIndex === 0 : true;
-  });
+  func = func.filter((r2) => Boolean(r2));
+  if (target_loss === undefined) {
+    func = func.filter((r2) => {
+      let foundIndex = r2?.result.findIndex((e2) => e2.quantity === r2.max);
+      return criterion === "quantity" ? foundIndex === 0 : true;
+    });
+  }
+  if (target_loss !== undefined) {
+    const validResults = func.filter((r2) => Math.abs(r2.neg_pnl) <= target_loss);
+    if (validResults.length > 0) {
+      validResults.sort((a, b) => {
+        const diffA = target_loss - Math.abs(a.neg_pnl);
+        const diffB = target_loss - Math.abs(b.neg_pnl);
+        return diffA - diffB;
+      });
+      if (app_config.raw) {
+        return validResults[0];
+      }
+      return validResults[0]?.value;
+    } else {
+      func.sort((a, b) => Math.abs(a.neg_pnl) - Math.abs(b.neg_pnl));
+      if (app_config.raw) {
+        return func[0];
+      }
+      return func[0]?.value;
+    }
+  }
   const highest = criterion === "quantity" ? Math.max(...func.map((o) => o.max)) : Math.min(...func.map((o) => o.entry));
   const key = criterion === "quantity" ? "max" : "entry";
   const index = findIndexByCondition(func, app_config.kind, (x) => x[key] == highest, criterion);
@@ -54483,13 +54514,13 @@ function determineOptimumRisk(config2, payload, params) {
   };
 }
 function computeRiskReward(payload) {
-  const { app_config, entry, stop, risk_per_trade } = payload;
+  const { app_config, entry, stop, risk_per_trade, target_loss } = payload;
   const kind = entry > stop ? "long" : "short";
   app_config.kind = kind;
   app_config.entry = entry;
   app_config.stop = stop;
   app_config.risk_per_trade = risk_per_trade;
-  const result = determineOptimumReward(app_config);
+  const result = determineOptimumReward({ app_config, target_loss });
   return result;
 }
 function getRiskReward(payload) {
@@ -54824,6 +54855,67 @@ function determineCompoundLongTrade(payload) {
     short_max_size
   };
 }
+function generateOppositeTradeConfig(payload) {
+  const {
+    kind,
+    entry,
+    quantity,
+    target_pnl,
+    ratio = 0.5,
+    global_config
+  } = payload;
+  const diff = target_pnl / quantity;
+  const tp = kind === "long" ? entry + diff : entry - diff;
+  const stop = kind === "long" ? entry - diff : entry + diff;
+  const opposite_pnl = target_pnl * ratio;
+  const app_config = constructAppConfig({
+    account: {
+      expand: {
+        b_config: {
+          entry,
+          stop,
+          symbol: global_config.symbol,
+          risk: target_pnl
+        }
+      }
+    },
+    global_config
+  });
+  const risk_reward = computeRiskReward({
+    app_config,
+    entry: stop,
+    stop: tp,
+    risk_per_trade: opposite_pnl,
+    target_loss: opposite_pnl
+  });
+  return {
+    entry: to_f(stop, global_config.price_places),
+    stop: to_f(tp, global_config.price_places),
+    risk: to_f(opposite_pnl, "%.2f"),
+    risk_reward
+  };
+}
+function constructAppConfig(payload) {
+  const { account, global_config, kelly_config } = payload;
+  const config2 = account.expand?.b_config;
+  if (!config2) {
+    return null;
+  }
+  const kelly = config2.kelly;
+  const options = {
+    entry: config2?.entry,
+    stop: config2?.stop,
+    risk_reward: config2?.risk_reward,
+    risk: config2?.risk,
+    symbol: account.symbol,
+    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
+  };
+  const appConfig = buildAppConfig(global_config, options);
+  return appConfig;
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -57745,6 +57837,9 @@ async function reduceMajorPositionEntry(input, accountInfo, trigger2, exchange_i
 }
 
 // src/position.ts
+var import_https_proxy_agent2 = __toESM(require_dist2());
+var import_socks_proxy_agent2 = __toESM(require_dist3());
+
 class ExchangePosition {
   exchange;
   symbol_config;
@@ -57758,6 +57853,13 @@ class ExchangePosition {
     this.instance = payload.instance;
     this.exchange_account = payload.exchange_account;
   }
+  async initialize() {
+    const proxy = await this.getProxyForAccount();
+    if (proxy) {
+      this.exchange.client.globalRequestOptions.httpAgent = proxy;
+      this.exchange.client.globalRequestOptions.httpsAgent = proxy;
+    }
+  }
   getInstance() {
     return this.instance;
   }
@@ -57771,6 +57873,20 @@ class ExchangePosition {
     const { p_account } = this.instance.expand;
     return p_account;
   }
+  async getProxyForAccount() {
+    if (this.instance.expand.proxy) {
+      const result = this.instance.expand.proxy;
+      const { type, ip_address } = result;
+      console.log("position", type, ip_address);
+      if (type === "http") {
+        return new import_https_proxy_agent2.HttpsProxyAgent(`http://${ip_address}`);
+      }
+      if (type === "socks5") {
+        return new import_socks_proxy_agent2.SocksProxyAgent(`socks://${ip_address}`);
+      }
+    }
+    return null;
+  }
   async cancelOrders(payload) {
     const { limit, price: _price, raw } = payload;
     if (limit) {
@@ -58597,6 +58713,27 @@ class ExchangePosition {
     }
     return config2;
   }
+  getOppositeConfig(payload) {
+    return generateOppositeTradeConfig({
+      kind: this.kind,
+      entry: this.instance.entry,
+      quantity: this.instance.quantity,
+      target_pnl: this.instance.target_pnl,
+      global_config: this.symbol_config,
+      ratio: payload.ratio
+    });
+  }
+  async getOptimumRiskReward() {
+    const app_config = await this.tradeConfig({});
+    const risk_reward = computeRiskReward({
+      app_config,
+      entry: app_config.entry,
+      stop: app_config.stop,
+      risk_per_trade: app_config.risk_per_trade,
+      target_loss: app_config.risk_per_trade
+    });
+    return risk_reward;
+  }
 }
 
 // src/exchange-account.ts
@@ -58669,6 +58806,7 @@ class ExchangeAccount {
       app_db: this.app_db,
       without_view: raw_positions.find((x) => x.kind === "long")
     });
+    await this.long_position.initialize();
     this.short_position = new ExchangePosition({
       symbol_config,
       exchange: this.exchange,
@@ -58677,6 +58815,7 @@ class ExchangeAccount {
       app_db: this.app_db,
       without_view: raw_positions.find((x) => x.kind === "short")
     });
+    await this.short_position.initialize();
     return payload.kind === "long" ? this.long_position : this.short_position;
   }
   async getActiveAccount(payload) {
@@ -60036,18 +60175,25 @@ class ExchangeAccount {
       return;
     }
     const kind = strategy2.kind;
+    const reward_factor = strategy2.reward_factor;
     const { entries, last_value, ...app_config } = await this.tradeConfig({
       symbol,
       kind
     });
-    await this.placeTrade({
+    const focusPosition = await this.getFocusPosition({
       symbol,
-      kind,
-      limit: false,
-      ignore_config: true,
-      tp: true
+      kind
     });
-    if (focus_position.avg_qty < last_value.avg_size) {
+    if (focusPosition.getInstance().quantity > 0) {
+      await this.placeTrade({
+        symbol,
+        kind,
+        limit: false,
+        ignore_config: true,
+        tp: true
+      });
+    }
+    if (focus_position.avg_qty < last_value.avg_size || focusPosition.getInstance().quantity === 0) {
       console.log("Placing trade for ", symbol, kind);
       await this.placeTrade({
         symbol,
@@ -60057,6 +60203,34 @@ class ExchangeAccount {
       });
     }
     console.log("Checking if focus position has quantity for ", symbol, kind);
+    const reversePosition = await this.getFocusPosition({
+      symbol,
+      kind: kind === "long" ? "short" : "long"
+    });
+    if (reversePosition.getInstance().quantity > 0) {
+      const opposite_config = focusPosition.getOppositeConfig({
+        ratio: reward_factor
+      });
+      const reverse_config = await reversePosition.getConfig();
+      if ((reverse_config.entry !== opposite_config.entry || reverse_config.stop !== opposite_config.stop || reverse_config.risk !== opposite_config.risk || reverse_config.risk_reward !== opposite_config.risk_reward) && focusPosition.getInstance().quantity > 0) {
+        console.log("Updating reverse config for ", symbol, kind, "with opposite config", opposite_config);
+        await reversePosition.getConfig({
+          params: {
+            entry: opposite_config.entry,
+            stop: opposite_config.stop,
+            risk: opposite_config.risk,
+            risk_reward: opposite_config.risk_reward
+          }
+        });
+        console.log("Placing trade for ", symbol, reversePosition.kind);
+        await reversePosition.placeTrade({
+          ignore_config: true,
+          limit: true,
+          place: true
+        });
+      }
+      console.log("Opposite config for ", symbol, kind, opposite_config);
+    }
     return {
       config_details: {
         app_config,