@gbozee/ultimate 0.0.2-151 → 0.0.2-154

package/dist/mcp-server.js

@@ -58423,7 +58423,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}`);
       }
@@ -58471,13 +58470,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) {
@@ -60987,7 +60986,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) => {
@@ -61027,10 +61033,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);
@@ -61142,13 +61171,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) {
@@ -61477,6 +61506,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;
@@ -64398,6 +64488,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;
@@ -64411,6 +64504,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;
   }
@@ -64424,6 +64524,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) {
@@ -65231,6 +65345,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
@@ -65303,6 +65457,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,
@@ -65311,6 +65466,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) {
@@ -65550,29 +65706,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);
@@ -66306,15 +66441,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;
@@ -66697,6 +66826,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
@@ -66718,6 +66848,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,

package/package.json

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