@gbozee/ultimate 0.0.2-174 → 0.0.2-177

package/dist/index.cjs

@@ -44901,6 +44901,8 @@ __export(exports_src, {
   constructAppConfig: () => constructAppConfig,
   computeRiskReward: () => computeRiskReward,
   computeProfitDetail: () => computeProfitDetail,
+  calculateFactorFromTakeProfit: () => calculateFactorFromTakeProfit,
+  calculateFactorFromSellQuantity: () => calculateFactorFromSellQuantity,
   buildConfig: () => buildConfig,
   buildAvg: () => buildAvg,
   buildAppConfig: () => buildAppConfig,
@@ -54705,7 +54707,7 @@ class AppDatabase {
       table: "positions_view",
       params: {
         filter: `symbol:lower="${symbol.toLowerCase()}" && p_account.owner:lower="${account.owner.toLowerCase()}" && p_account.exchange:lower="${account.exchange.toLowerCase()}"`,
-        expand: "b_config, account_strategy, p_account, proxy"
+        expand: "b_config, account_strategy, p_account, proxy, compound_instance.ref,support"
       }
     } : {
       table: "positions",
@@ -55515,6 +55517,33 @@ class AppDatabase {
       parent: config_id
     });
   }
+  async getCompoundInstance(payload) {
+    const { position } = payload;
+    const found = await this.pb.collection("compound_instances").getFullList({
+      filter: `position.id = "${position.id}"`,
+      expand: `ref`
+    });
+    if (found.length == 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async getSupportTable(payload) {
+    const { symbol, kind } = payload;
+    const found = await this.pb.collection("support_table").getFullList({
+      filter: `symbol = "${symbol}" && kind = "${kind}"`
+    });
+    if (found.length === 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async updateCompoundInstance(payload) {
+    const { id, params } = payload;
+    return await this.pb.collection("compound_instances").update(id, params);
+  }
 }
 
 // src/exchange-account.ts
@@ -55527,6 +55556,137 @@ __export(exports_exchange_account, {
 // src/exchanges/binance/index.ts
 var import_binance = __toESM(require_lib2());
 
+// src/helpers/distributions.ts
+function generateArithmetic(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f" } = payload;
+  const difference = Math.abs(margin_range[1] - margin_range[0]);
+  const spread = difference / risk_reward;
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const price = kind === "long" ? margin_range[1] - spread * i2 : margin_range[0] + spread * i2;
+    return to_f(price, price_places);
+  });
+}
+function generateGeometric(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", percent_change } = payload;
+  const effectivePercentChange = percent_change ?? Math.abs(margin_range[1] / margin_range[0] - 1) / risk_reward;
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const price = kind === "long" ? margin_range[1] * Math.pow(1 - effectivePercentChange, i2) : margin_range[0] * Math.pow(1 + effectivePercentChange, i2);
+    return to_f(price, price_places);
+  });
+}
+function approximateInverseNormal(p) {
+  p = Math.max(0.0001, Math.min(0.9999, p));
+  if (p < 0.5) {
+    const t2 = Math.sqrt(-2 * Math.log(p));
+    const c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
+    const d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
+    return -(t2 - (c0 + c1 * t2 + c2 * t2 * t2) / (1 + d1 * t2 + d2 * t2 * t2 + d3 * t2 * t2 * t2));
+  } else {
+    const t2 = Math.sqrt(-2 * Math.log(1 - p));
+    const c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
+    const d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
+    return t2 - (c0 + c1 * t2 + c2 * t2 * t2) / (1 + d1 * t2 + d2 * t2 * t2 + d3 * t2 * t2 * t2);
+  }
+}
+function generateNormal(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", stdDevFactor = 6 } = payload;
+  const mean = (margin_range[0] + margin_range[1]) / 2;
+  const stdDev = Math.abs(margin_range[1] - margin_range[0]) / stdDevFactor;
+  const skew = kind === "long" ? -0.2 : 0.2;
+  const adjustedMean = mean + stdDev * skew;
+  const entries = Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const p = (i2 + 0.5) / (risk_reward + 1);
+    const z2 = approximateInverseNormal(p);
+    let price = adjustedMean + stdDev * z2;
+    price = Math.max(margin_range[0], Math.min(margin_range[1], price));
+    return to_f(price, price_places);
+  });
+  return entries.sort((a, b) => a - b);
+}
+function generateExponential(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", lambda } = payload;
+  const range = Math.abs(margin_range[1] - margin_range[0]);
+  const effectiveLambda = lambda || 2.5;
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const t2 = i2 / risk_reward;
+    const exponentialProgress = 1 - Math.exp(-effectiveLambda * t2);
+    const price = kind === "long" ? margin_range[1] - range * exponentialProgress : margin_range[0] + range * exponentialProgress;
+    return to_f(price, price_places);
+  });
+}
+function generateInverseExponential(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", curveFactor = 2 } = payload;
+  const range = Math.abs(margin_range[1] - margin_range[0]);
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const t2 = i2 / risk_reward;
+    const progress = (Math.exp(curveFactor * t2) - 1) / (Math.exp(curveFactor) - 1);
+    const price = kind === "long" ? margin_range[1] - range * progress : margin_range[0] + range * progress;
+    return to_f(price, price_places);
+  });
+}
+function getEntries(params) {
+  const {
+    kind,
+    distribution,
+    margin_range,
+    risk_reward,
+    price_places = "%.1f",
+    distribution_params = {}
+  } = params;
+  let entries = [];
+  switch (distribution) {
+    case "arithmetic":
+      entries = generateArithmetic({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        percent_change: distribution_params.curveFactor
+      });
+      break;
+    case "geometric":
+      entries = generateGeometric({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        percent_change: distribution_params.curveFactor
+      });
+      break;
+    case "normal":
+      entries = generateNormal({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        stdDevFactor: distribution_params.stdDevFactor
+      });
+      break;
+    case "exponential":
+      entries = generateExponential({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        lambda: distribution_params.lambda
+      });
+      break;
+    case "inverse-exponential":
+      entries = generateInverseExponential({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        curveFactor: distribution_params.curveFactor
+      });
+      break;
+    default:
+      throw new Error(`Unknown distribution type: ${distribution}`);
+  }
+  return entries.sort((a, b) => a - b);
+}
+var distributions_default = getEntries;
+
 // src/helpers/optimizations.ts
 function calculateTheoreticalKelly({
   current_entry,
@@ -55796,6 +55956,10 @@ class Signal {
   kelly_minimum_risk = 0.2;
   kelly_func = "theoretical";
   symbol;
+  distribution = {
+    long: "arithmetic",
+    short: "geometric"
+  };
   constructor({
     focus,
     symbol,
@@ -55822,8 +55986,12 @@ class Signal {
     kelly_prediction_model = "exponential",
     kelly_confidence_factor = 0.6,
     kelly_minimum_risk = 0.2,
-    kelly_func = "theoretical"
+    kelly_func = "theoretical",
+    full_distribution
   }) {
+    if (full_distribution) {
+      this.distribution = full_distribution;
+    }
     this.symbol = symbol;
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -55859,7 +56027,8 @@ class Signal {
     kind = "long",
     risk,
     no_of_trades = 1,
-    take_profit
+    take_profit,
+    distribution
   }) {
     let _stop_loss = stop_loss;
     if (!_stop_loss && stop_percent) {
@@ -55868,16 +56037,22 @@ class Signal {
     const percent_change = _stop_loss ? Math.max(current_price, _stop_loss) / Math.min(current_price, _stop_loss) - 1 : this.percent_change;
     const _no_of_trades = no_of_trades || this.risk_reward;
     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 derivedConfig = {
       ...this,
       percent_change,
       focus: current_price,
-      resistance: _resistance,
+      resistance: distribution ? simple_resistance : _resistance,
       risk_per_trade: risk / this.risk_reward,
       minimum_pnl: pnl,
       risk_reward: _no_of_trades,
       take_profit: take_profit || this.take_profit,
-      support: kind === "long" ? _stop_loss : this.support
+      support: distribution ? simple_support : kind === "long" ? _stop_loss : this.support,
+      full_distribution: distribution ? {
+        ...this.distribution,
+        [kind]: distribution
+      } : undefined
     };
     const instance = new Signal(derivedConfig);
     if (kind === "short") {}
@@ -56093,12 +56268,31 @@ class Signal {
     }
     this.zone_risk = original;
   }
+  get_future_zones_simple({
+    current_price,
+    kind = "long",
+    raw
+  }) {
+    const margin_zones = [this.support, this.resistance];
+    const distribution = this.distribution ? this.distribution[kind] : "geometric";
+    console.log("margin_zones", { margin_zones, distribution });
+    let _kind = distribution === "inverse-exponential" ? kind === "long" ? "short" : "long" : kind;
+    const entries = distributions_default({
+      margin_range: margin_zones,
+      kind: _kind,
+      distribution,
+      risk_reward: this.risk_reward,
+      price_places: this.price_places
+    });
+    return entries.sort((a, b) => a - b);
+  }
   get_future_zones({
     current_price,
     kind = "long",
     raw
   }) {
     if (raw) {}
+    return this.get_future_zones_simple({ current_price, raw, kind });
     const margin_range = this.get_margin_range(current_price, kind);
     let margin_zones = this.get_margin_zones({ current_price });
     let remaining_zones = margin_zones.filter((x) => JSON.stringify(x) != JSON.stringify(margin_range));
@@ -56757,7 +56951,9 @@ function buildConfig(app_config, {
   kelly_confidence_factor = 0.95,
   kelly_minimum_risk = 0.2,
   kelly_prediction_model = "exponential",
-  kelly_func = "theoretical"
+  kelly_func = "theoretical",
+  min_avg_size = 0,
+  distribution
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -56804,9 +57000,12 @@ function buildConfig(app_config, {
     stop_loss: stop,
     risk: working_risk,
     kind: kind || app_config.kind,
-    no_of_trades: trade_no
+    no_of_trades: trade_no,
+    distribution
   }) || [] : [];
-  return computeTotalAverageForEachTrade(result, config2);
+  const new_trades = computeTotalAverageForEachTrade(result, config2);
+  let filtered = new_trades.filter((o) => o.avg_size > min_avg_size);
+  return computeTotalAverageForEachTrade(filtered, config2);
 }
 function buildAvg({
   _trades,
@@ -56871,7 +57070,8 @@ function get_app_config_and_max_size(config2, payload) {
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
     kelly_prediction_model: payload.kelly_prediction_model,
-    kelly_func: payload.kelly_func
+    kelly_func: payload.kelly_func,
+    distribution: payload.distribution
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -56909,7 +57109,8 @@ function buildAppConfig(config2, payload) {
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
     kelly_prediction_model: payload.kelly_prediction_model,
-    kelly_func: payload.kelly_func
+    kelly_func: payload.kelly_func,
+    distribution: payload.distribution
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -56926,7 +57127,7 @@ function buildAppConfig(config2, payload) {
   return app_config;
 }
 function getOptimumStopAndRisk(app_config, params) {
-  const { max_size, target_stop } = params;
+  const { max_size, target_stop, distribution } = 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);
@@ -56949,7 +57150,8 @@ function getOptimumStopAndRisk(app_config, params) {
       increase: true,
       gap: app_config.gap,
       price_places: app_config.price_places,
-      decimal_places: app_config.decimal_places
+      decimal_places: app_config.decimal_places,
+      distribution
     });
     if (result.length === 0) {
       if (isLong) {
@@ -57003,7 +57205,8 @@ function getOptimumStopAndRisk(app_config, params) {
       increase: true,
       gap: app_config.gap,
       price_places: app_config.price_places,
-      decimal_places: app_config.decimal_places
+      decimal_places: app_config.decimal_places,
+      distribution
     });
     if (result.length === 0) {
       high_risk = mid_risk;
@@ -57048,7 +57251,8 @@ function getOptimumStopAndRisk(app_config, params) {
         increase: true,
         gap: app_config.gap,
         price_places: app_config.price_places,
-        decimal_places: app_config.decimal_places
+        decimal_places: app_config.decimal_places,
+        distribution
       });
       if (result.length === 0)
         continue;
@@ -57171,7 +57375,8 @@ function generateOptimumAppConfig(config2, payload, position2) {
     }, {
       entry: payload.entry,
       stop: payload.stop,
-      kind: position2.kind
+      kind: position2.kind,
+      distribution: payload.distribution
     });
     current_app_config.max_size = max_size;
     current_app_config.last_value = last_value;
@@ -57186,7 +57391,8 @@ function generateOptimumAppConfig(config2, payload, position2) {
       increase: true,
       gap: current_app_config.gap,
       price_places: current_app_config.price_places,
-      decimal_places: current_app_config.decimal_places
+      decimal_places: current_app_config.decimal_places,
+      distribution: payload.distribution
     });
     if (full_trades.length === 0) {
       high_risk = mid_risk;
@@ -57250,7 +57456,8 @@ function determineOptimumReward(payload) {
     increase = true,
     low_range = 1,
     high_range = 199,
-    target_loss
+    target_loss,
+    distribution
   } = payload;
   const criterion = app_config.strategy || "quantity";
   const risk_rewards = createArray(low_range, high_range, 1);
@@ -57264,7 +57471,8 @@ function determineOptimumReward(payload) {
       increase,
       kind: app_config.kind,
       gap: app_config.gap,
-      decimal_places: app_config.decimal_places
+      decimal_places: app_config.decimal_places,
+      distribution
     });
     let total = 0;
     let max = -Infinity;
@@ -57429,14 +57637,17 @@ function determineOptimumRisk(config2, payload, params) {
   };
 }
 function computeRiskReward(payload) {
-  const { app_config, entry, stop, risk_per_trade, target_loss } = payload;
+  const { app_config, entry, stop, risk_per_trade, target_loss, distribution } = 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, target_loss });
-  console.log("result", result, "target_loss", target_loss);
+  const result = determineOptimumReward({
+    app_config,
+    target_loss,
+    distribution
+  });
   return result;
 }
 function getRiskReward(payload) {
@@ -57446,21 +57657,24 @@ function getRiskReward(payload) {
     risk,
     global_config,
     force_exact_risk = false,
-    target_loss
+    target_loss,
+    distribution
   } = payload;
   const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
     entry,
     stop,
     risk_reward: 30,
     risk,
-    symbol: global_config.symbol
+    symbol: global_config.symbol,
+    distribution
   });
   const risk_reward = computeRiskReward({
     app_config,
     entry,
     stop,
     risk_per_trade: risk,
-    target_loss
+    target_loss,
+    distribution
   });
   if (force_exact_risk) {
     const new_risk_per_trade = determineOptimumRisk(global_config, {
@@ -57468,7 +57682,8 @@ function getRiskReward(payload) {
       stop,
       risk_reward,
       risk,
-      symbol: global_config.symbol
+      symbol: global_config.symbol,
+      distribution
     }, {
       highest_risk: risk
     }).optimal_risk;
@@ -57617,6 +57832,98 @@ function calculate_factor(payload) {
   calculated_factor = to_f(calculated_factor, places);
   return calculated_factor;
 }
+function calculateFactorFromTakeProfit(payload) {
+  const { long, short, knownTp, tpType, price_places = "%.4f" } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let factor;
+  if (tpType === "long") {
+    const longPercent = knownTp / long.entry - 1;
+    factor = longPercent * short.entry * short.quantity / gapLoss;
+  } else {
+    const shortPercent = short.entry / knownTp - 1;
+    factor = shortPercent * long.entry * long.quantity / gapLoss;
+  }
+  return to_f(factor, price_places);
+}
+function calculateFactorFromSellQuantity(payload) {
+  const {
+    long,
+    short,
+    knownSellQuantity,
+    sellType,
+    sell_factor = 1,
+    price_places = "%.4f"
+  } = payload;
+  if (knownSellQuantity < 0.00001) {
+    return 0;
+  }
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let low_factor = 0.001;
+  let high_factor = 1;
+  let best_factor = 0;
+  let best_diff = Infinity;
+  const tolerance = 0.00001;
+  const max_iterations = 150;
+  let expansions = 0;
+  const max_expansions = 15;
+  let iterations = 0;
+  while (iterations < max_iterations) {
+    iterations++;
+    const mid_factor = (low_factor + high_factor) / 2;
+    const testResult = generateGapTp({
+      long,
+      short,
+      factor: mid_factor,
+      sell_factor,
+      price_places: "%.8f",
+      decimal_places: "%.8f"
+    });
+    const testSellQty = sellType === "long" ? testResult.sell_quantity.long : testResult.sell_quantity.short;
+    const diff = Math.abs(testSellQty - knownSellQuantity);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff < tolerance) {
+      return to_f(mid_factor, price_places);
+    }
+    if (testSellQty < knownSellQuantity) {
+      low_factor = mid_factor;
+      if (mid_factor > high_factor * 0.9 && expansions < max_expansions) {
+        const ratio = knownSellQuantity / testSellQty;
+        if (ratio > 2) {
+          high_factor = high_factor * Math.min(ratio, 10);
+        } else {
+          high_factor = high_factor * 2;
+        }
+        expansions++;
+        continue;
+      }
+    } else {
+      high_factor = mid_factor;
+    }
+    if (Math.abs(high_factor - low_factor) < 0.00001 && diff > tolerance) {
+      if (testSellQty < knownSellQuantity && expansions < max_expansions) {
+        high_factor = high_factor * 1.1;
+        expansions++;
+        continue;
+      } else {
+        break;
+      }
+    }
+  }
+  return to_f(best_factor, price_places);
+}
 function determineRewardFactor(payload) {
   const { quantity, avg_qty, minimum_pnl, risk } = payload;
   const reward_factor = minimum_pnl / risk;
@@ -57831,7 +58138,7 @@ function constructAppConfig(payload) {
     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);
+  const { entries: _entries, ...appConfig } = buildAppConfig(global_config, options);
   return appConfig;
 }
 function generateDangerousConfig(payload) {
@@ -60790,7 +61097,6 @@ 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;
@@ -60830,6 +61136,19 @@ class ExchangePosition {
     const { p_account } = this.instance.expand;
     return p_account;
   }
+  get compound() {
+    const { compound_instance } = this.instance.expand;
+    if (compound_instance) {
+      const { ref } = compound_instance.expand;
+      const profit_percent = ref.profit_percent / 100;
+      return {
+        ...compound_instance,
+        profit_percent,
+        amount_to_risk: to_f(compound_instance.risk * profit_percent, "%.2f")
+      };
+    }
+    return compound_instance;
+  }
   async getProxyForAccount() {
     if (this.instance.expand.proxy) {
       const result = this.instance.expand.proxy;
@@ -60955,7 +61274,8 @@ class ExchangePosition {
         place,
         raw: payload.raw,
         use_current,
-        stop_percent: config2.stop_percent || 100
+        stop_percent: config2.stop_percent || 100,
+        distribution: config2.distribution
       });
     }
   }
@@ -60989,7 +61309,8 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func
+      kelly_func: config2.kelly?.kelly_func,
+      distribution: config2.distribution
     }, false);
     if (payload.raw) {
       let actual_orders_to_buy = await this.determineAmountToBuy({
@@ -61112,7 +61433,8 @@ class ExchangePosition {
       kelly_confidence_factor: solution.kelly_confidence_factor,
       kelly_minimum_risk: solution.kelly_minimum_risk,
       kelly_prediction_model: solution.kelly_prediction_model,
-      kelly_func: solution.kelly_func
+      kelly_func: solution.kelly_func,
+      distribution: solution.distribution
     };
     const trades = sortedBuildConfig(app_config, options);
     const entry_orders = {
@@ -61504,6 +61826,7 @@ class ExchangePosition {
     });
   }
   async generate_config_params(payload) {
+    const db_config = await this.getConfig();
     const { entry, stop, risk_reward, risk, with_trades = false } = payload;
     const symbol = this.symbol;
     const app_config = await this.buildAppConfig({
@@ -61536,7 +61859,8 @@ class ExchangePosition {
         avg_size: 0,
         neg_pnl: 0,
         min_size: app_config2.min_size,
-        symbol
+        symbol,
+        distribution: db_config.distribution
       }, false);
       config2.trades = trades;
     }
@@ -61637,7 +61961,8 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func
+      kelly_func: config2.kelly?.kelly_func,
+      distribution: config2.distribution
     });
     const position2 = this.instance;
     const orders_to_place = await this.determineAmountToBuy({
@@ -61835,6 +62160,46 @@ class ExchangePosition {
       increase: false
     });
   }
+  get support() {
+    return this.instance.expand?.support;
+  }
+  get linkedConfig() {
+    return this.instance.expand?.b_config;
+  }
+  get isActiveTrade() {
+    const config2 = this.linkedConfig;
+    return {
+      config: config2,
+      condition: this.compound && this.support?.price === config2.stop
+    };
+  }
+  async updateCompound(payload) {
+    const pb = this.app_db.pb;
+    const item = this.compound;
+    const new_risk = item.risk + item.amount_to_risk;
+    const { condition, config: config2 } = this.isActiveTrade;
+    if (payload?.place && condition) {
+      await pb.collection("compound_instances").update(item.id, {
+        risk: new_risk
+      });
+      await pb.collection("scheduled_trades").update(config2.id, {
+        profit: to_f(new_risk * item.profit_percent, "%.3f")
+      });
+    }
+    return {
+      support: this.support?.price,
+      counter: this.support?.counter,
+      new_risk,
+      condition,
+      stop: config2.stop
+    };
+  }
+  async cleanOnActiveCompoundInstance() {
+    const { condition } = this.isActiveTrade;
+    if (condition && this.instance.quantity === 0) {
+      await this.cancelOrders({ limit: true });
+    }
+  }
 }
 function convert_to_exchange_order(order) {
   return {