@gbozee/ultimate 0.0.2-151 → 0.0.2-154

package/dist/index.d.ts

@@ -140,6 +140,7 @@ export interface PositionsView {
 	expand?: {
 		p_account?: ExchangeAccount;
 		b_config?: ScheduledTrade;
+		proxy?: Proxy$1;
 	};
 }
 export interface BullishMarket extends RecordModel {
@@ -624,6 +625,7 @@ export declare class AppDatabase {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	private _createOrUpdatePosition;
@@ -636,6 +638,7 @@ export declare class AppDatabase {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	update_db_position(position: any, payload: any): Promise<import("pocketbase").RecordModel>;
@@ -1436,7 +1439,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;
@@ -1472,6 +1481,7 @@ export declare function computeRiskReward(payload: {
 	entry: number;
 	stop: number;
 	risk_per_trade: number;
+	target_loss?: number;
 }): number | {
 	result: any[];
 	value: number;
@@ -1656,6 +1666,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;
 declare class ExchangePosition {
 	exchange: BaseExchange;
 	symbol_config: SymbolConfig;
@@ -1670,10 +1712,12 @@ declare class ExchangePosition {
 		exchange_account: ExchangeAccount$1;
 		without_view?: PositionsView;
 	});
+	initialize(): Promise<void>;
 	getInstance(): PositionsView;
 	get symbol(): any;
 	get kind(): any;
 	get account(): ExchangeAccount;
+	getProxyForAccount(): Promise<HttpsProxyAgent<`http://${string}`> | SocksProxyAgent>;
 	cancelOrders(payload: {
 		limit?: boolean;
 		price?: number;
@@ -1939,6 +1983,37 @@ declare class ExchangePosition {
 	tradeConfig(payload: {
 		override?: any;
 	}): Promise<AppConfig>;
+	getOrCreatePositionConfig(payload: {
+		risk?: number;
+		risk_reward?: number;
+	}): Promise<import("pocketbase").RecordModel | ScheduledTrade>;
+	getOppositeConfig(payload: {
+		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;
+		};
+	};
+	getOptimumRiskReward(): Promise<number | {
+		result: any[];
+		value: number;
+		total: number;
+		risk_per_trade: number;
+		max: number;
+		min: number;
+		neg_pnl: any;
+		entry: any;
+	}>;
 }
 declare class ExchangeAccount$1 {
 	instance: {
@@ -1992,6 +2067,7 @@ declare class ExchangeAccount$1 {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	syncAccount(options: {
@@ -2005,6 +2081,7 @@ declare class ExchangeAccount$1 {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	getRunningInstanceFromDB(symbol: string): Promise<TradeBlockTracking>;
@@ -2653,6 +2730,7 @@ declare class App {
 		expand?: {
 			config: ScheduledTrade;
 			account: ExchangeAccount;
+			proxy: Proxy$1;
 		};
 	})[]>;
 	syncOrders(payload: {

package/dist/index.js

@@ -51692,7 +51692,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}`);
       }
@@ -51740,13 +51739,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) {
@@ -54276,7 +54275,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) => {
@@ -54316,10 +54322,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);
@@ -54431,13 +54460,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) {
@@ -54772,6 +54801,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;
@@ -57693,6 +57783,9 @@ async function reduceMajorPositionEntry(input, accountInfo, trigger2, exchange_i
 }
 
 // src/position.ts
+var import_https_proxy_agent2 = __toESM(require_dist2(), 1);
+var import_socks_proxy_agent2 = __toESM(require_dist3(), 1);
+
 class ExchangePosition {
   exchange;
   symbol_config;
@@ -57706,6 +57799,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;
   }
@@ -57719,6 +57819,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) {
@@ -58526,6 +58640,46 @@ class ExchangePosition {
     });
     return app_config;
   }
+  async getOrCreatePositionConfig(payload) {
+    const { risk = 50, risk_reward = 199 } = payload;
+    const config2 = await this.getConfig();
+    if (!config2) {
+      const long_c = await this.buildConfigForSymbol({
+        risk,
+        risk_reward
+      });
+      return this.getConfig({
+        params: {
+          entry: config2.entry,
+          stop: config2.stop,
+          risk_reward: long_c.risk_reward,
+          risk: long_c.risk
+        }
+      });
+    }
+    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
@@ -58598,6 +58752,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,
@@ -58606,6 +58761,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) {
@@ -58845,29 +59001,8 @@ class ExchangeAccount {
     return result;
   }
   async getOrCreatePositionConfig(payload) {
-    const { symbol, kind, risk = 50, risk_reward = 199 } = payload;
-    const config2 = await this.getPositionConfig({
-      symbol: payload.symbol,
-      kind: payload.kind
-    });
-    if (!config2) {
-      const long_c = await this.buildConfigForSymbol({
-        symbol,
-        risk,
-        risk_reward
-      });
-      return this.getPositionConfig({
-        symbol,
-        kind,
-        params: {
-          entry: kind === "long" ? long_c.entry : long_c.stop,
-          stop: kind === "long" ? long_c.stop : long_c.entry,
-          risk_reward: long_c.risk_reward,
-          risk: long_c.risk
-        }
-      });
-    }
-    return config2;
+    const focus_position = await this.getFocusPosition(payload);
+    return await focus_position.getOrCreatePositionConfig(payload);
   }
   async getPositionConfig(payload) {
     const focus_position = await this.getFocusPosition(payload);
@@ -59601,15 +59736,9 @@ class ExchangeAccount {
     const all_open_symbols = await this.exchange.getOpenPositions();
     await new Promise((resolve) => setTimeout(resolve, interval * 1000));
     for (const symbol of Array.from(new Set(symbols.concat(all_open_symbols)))) {
-      await this.getLiveExchangeInstance({ symbol, refresh: true });
+      await this.initializePositions({ symbol, kind: "long", update: true });
       await new Promise((resolve) => setTimeout(resolve, 1000));
     }
-    for (const symbol of all_open_symbols) {
-      await this.syncAccount({
-        symbol,
-        update: true
-      });
-    }
   }
   async updateAllPositionsWithNoConfig(payload) {
     const { kind } = payload;
@@ -59992,6 +60121,7 @@ class ExchangeAccount {
       return;
     }
     const kind = strategy2.kind;
+    const reward_factor = strategy2.reward_factor;
     const { entries, last_value, ...app_config } = await this.tradeConfig({
       symbol,
       kind
@@ -60013,6 +60143,36 @@ class ExchangeAccount {
       });
     }
     console.log("Checking if focus position has quantity for ", symbol, kind);
+    const focusPosition = await this.getFocusPosition({
+      symbol,
+      kind
+    });
+    const reversePosition = await this.getFocusPosition({
+      symbol,
+      kind: kind === "long" ? "short" : "long"
+    });
+    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,
@@ -60655,6 +60815,7 @@ export {
   getHedgeZone,
   generate_config_params,
   generateOptimumAppConfig,
+  generateOppositeTradeConfig,
   generateGapTp,
   exports_exchange_account as exchange_account,
   determine_break_even_price,
@@ -60666,6 +60827,7 @@ export {
   determineCompoundLongTrade,
   exports_database as database,
   createArray,
+  constructAppConfig,
   computeRiskReward,
   computeProfitDetail,
   buildConfig,