@gbozee/ultimate 0.0.2-99 → 0.0.2-next.4

package/dist/frontend-index.js

@@ -1,3 +1,315 @@
+// 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 }, (_, i) => {
+    const price = kind === "long" ? margin_range[1] - spread * i : margin_range[0] + spread * i;
+    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 }, (_, i) => {
+    const price = kind === "long" ? margin_range[1] * Math.pow(1 - effectivePercentChange, i) : margin_range[0] * Math.pow(1 + effectivePercentChange, i);
+    return to_f(price, price_places);
+  });
+}
+function approximateInverseNormal(p) {
+  p = Math.max(0.0001, Math.min(0.9999, p));
+  if (p < 0.5) {
+    const t = 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 -(t - (c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t));
+  } else {
+    const t = 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 t - (c0 + c1 * t + c2 * t * t) / (1 + d1 * t + d2 * t * t + d3 * t * t * t);
+  }
+}
+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 }, (_, i) => {
+    const p = (i + 0.5) / (risk_reward + 1);
+    const z = approximateInverseNormal(p);
+    let price = adjustedMean + stdDev * z;
+    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 }, (_, i) => {
+    const t = i / risk_reward;
+    const exponentialProgress = 1 - Math.exp(-effectiveLambda * t);
+    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 }, (_, i) => {
+    const t = i / risk_reward;
+    const progress = (Math.exp(curveFactor * t) - 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,
+  zone_prices,
+  kind = "long",
+  config = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config;
+  const sorted_prices = zone_prices;
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const win_zones = kind === "long" ? sorted_prices.filter((price) => price > current_entry) : sorted_prices.filter((price) => price < current_entry);
+  const lose_zones = kind === "long" ? sorted_prices.filter((price) => price < current_entry) : sorted_prices.filter((price) => price > current_entry);
+  const { win_probability, avg_win_ratio, avg_loss_ratio } = calculateZoneProbabilities({
+    current_entry,
+    win_zones,
+    lose_zones,
+    price_prediction_model,
+    confidence_factor,
+    kind
+  });
+  const odds_ratio = avg_win_ratio / avg_loss_ratio;
+  const loss_probability = 1 - win_probability;
+  let kelly_fraction = (win_probability * odds_ratio - loss_probability) / odds_ratio;
+  if (volatility_adjustment) {
+    const zone_volatility = calculateZoneVolatility(sorted_prices);
+    const vol_adjustment = 1 / (1 + zone_volatility);
+    kelly_fraction *= vol_adjustment;
+  }
+  kelly_fraction = Math.max(0.005, Math.min(kelly_fraction, 0.5));
+  return to_f(kelly_fraction, "%.4f");
+}
+function calculateZoneProbabilities({
+  current_entry,
+  win_zones,
+  lose_zones,
+  price_prediction_model,
+  confidence_factor,
+  kind
+}) {
+  if (win_zones.length === 0 && lose_zones.length === 0) {
+    return { win_probability: 0.5, avg_win_ratio: 0.02, avg_loss_ratio: 0.02 };
+  }
+  let win_probability;
+  switch (price_prediction_model) {
+    case "uniform":
+      win_probability = win_zones.length / (win_zones.length + lose_zones.length);
+      break;
+    case "normal":
+      const win_weight = win_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      const lose_weight = lose_zones.reduce((sum, _, idx) => sum + 1 / (idx + 1), 0);
+      win_probability = win_weight / (win_weight + lose_weight);
+      break;
+    case "exponential":
+      const exp_win_weight = win_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      const exp_lose_weight = lose_zones.reduce((sum, _, idx) => sum + Math.exp(-idx * 0.5), 0);
+      win_probability = exp_win_weight / (exp_win_weight + exp_lose_weight);
+      break;
+    default:
+      win_probability = 0.5;
+  }
+  win_probability = win_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const avg_win_ratio = win_zones.length > 0 ? win_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / win_zones.length : 0.02;
+  const avg_loss_ratio = lose_zones.length > 0 ? lose_zones.reduce((sum, price) => {
+    return sum + Math.abs(price - current_entry) / current_entry;
+  }, 0) / lose_zones.length : 0.02;
+  return {
+    win_probability: Math.max(0.1, Math.min(0.9, win_probability)),
+    avg_win_ratio: Math.max(0.005, avg_win_ratio),
+    avg_loss_ratio: Math.max(0.005, avg_loss_ratio)
+  };
+}
+function calculateZoneVolatility(zone_prices) {
+  if (zone_prices.length < 2)
+    return 0;
+  const price_changes = zone_prices.slice(1).map((price, i) => Math.abs(price - zone_prices[i]) / zone_prices[i]);
+  return price_changes.reduce((sum, change) => sum + change, 0) / price_changes.length;
+}
+function calculateTheoreticalKellyFixed({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor = 0.6,
+    volatility_adjustment = true
+  } = config;
+  const sorted_prices = zone_prices;
+  const current_index = sorted_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  let stop_loss;
+  let target_zones;
+  if (kind === "long") {
+    stop_loss = Math.min(...zone_prices);
+    target_zones = zone_prices.filter((price) => price > current_entry);
+  } else {
+    stop_loss = Math.max(...zone_prices);
+    target_zones = zone_prices.filter((price) => price < current_entry);
+  }
+  const risk_amount = Math.abs(current_entry - stop_loss);
+  const avg_reward = target_zones.length > 0 ? target_zones.reduce((sum, price) => sum + Math.abs(price - current_entry), 0) / target_zones.length : risk_amount;
+  const risk_reward_ratio = avg_reward / risk_amount;
+  let position_quality;
+  if (kind === "long") {
+    const distance_from_stop = current_entry - stop_loss;
+    const max_distance = Math.max(...zone_prices) - stop_loss;
+    position_quality = 1 - distance_from_stop / max_distance;
+  } else {
+    const distance_from_stop = stop_loss - current_entry;
+    const max_distance = stop_loss - Math.min(...zone_prices);
+    position_quality = 1 - distance_from_stop / max_distance;
+  }
+  let base_probability = 0.5;
+  switch (price_prediction_model) {
+    case "uniform":
+      base_probability = 0.5;
+      break;
+    case "normal":
+      base_probability = 0.3 + position_quality * 0.4;
+      break;
+    case "exponential":
+      base_probability = 0.2 + Math.pow(position_quality, 0.5) * 0.6;
+      break;
+  }
+  const win_probability = base_probability * confidence_factor + (1 - confidence_factor) * 0.5;
+  const odds_ratio = Math.max(risk_reward_ratio, 0.5);
+  const loss_probability = 1 - win_probability;
+  let kelly_fraction = (win_probability * odds_ratio - loss_probability) / odds_ratio;
+  if (volatility_adjustment) {
+    const zone_volatility = calculateZoneVolatility(sorted_prices);
+    const vol_adjustment = 1 / (1 + zone_volatility);
+    kelly_fraction *= vol_adjustment;
+  }
+  kelly_fraction = Math.max(0.005, Math.min(kelly_fraction, 0.5));
+  return to_f(kelly_fraction, "%.4f");
+}
+function calculatePositionBasedKelly({
+  current_entry,
+  zone_prices,
+  kind = "long",
+  config = {}
+}) {
+  const {
+    price_prediction_model = "uniform",
+    confidence_factor: _confidence_factor = 0.6
+  } = config;
+  const current_index = zone_prices.findIndex((price) => price === current_entry);
+  if (current_index === -1)
+    return 0.02;
+  const total_zones = zone_prices.length;
+  const position_score = (total_zones - current_index) / total_zones;
+  let adjusted_score;
+  switch (price_prediction_model) {
+    case "uniform":
+      adjusted_score = 0.5;
+      break;
+    case "normal":
+      adjusted_score = 0.3 + position_score * 0.4;
+      break;
+    case "exponential":
+      adjusted_score = 0.2 + Math.pow(position_score, 0.3) * 0.6;
+      break;
+    default:
+      adjusted_score = 0.5;
+  }
+  const base_kelly = 0.02;
+  const max_kelly = 0.2;
+  const kelly_fraction = base_kelly + adjusted_score * (max_kelly - base_kelly);
+  return to_f(kelly_fraction, "%.4f");
+}
+
 // src/helpers/trade_signal.ts
 function determine_close_price({
   entry,
@@ -64,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;
@@ -80,8 +393,22 @@ class Signal {
   first_order_size;
   gap = 10;
   max_size = 0;
+  use_kelly = false;
+  kelly_prediction_model = "exponential";
+  kelly_confidence_factor = 0.6;
+  kelly_minimum_risk = 0.2;
+  kelly_func = "theoretical";
+  symbol;
+  distribution = {
+    long: "arithmetic",
+    short: "geometric"
+  };
+  use_progressive_risk;
+  risk_distribution;
+  max_quantity = 0.03;
   constructor({
     focus,
+    symbol,
     budget,
     percent_change = 0.02,
     price_places = "%.5f",
@@ -100,8 +427,25 @@ class Signal {
     minimum_size = 0,
     first_order_size = 0,
     gap = 10,
-    max_size = 0
+    max_size = 0,
+    use_kelly = false,
+    kelly_prediction_model = "exponential",
+    kelly_confidence_factor = 0.6,
+    kelly_minimum_risk = 0.2,
+    kelly_func = "theoretical",
+    full_distribution,
+    max_quantity = 0.03,
+    distribution_params = {},
+    use_progressive_risk,
+    risk_distribution
   }) {
+    if (full_distribution) {
+      this.distribution = full_distribution;
+    }
+    this.distribution_params = distribution_params;
+    this.use_progressive_risk = use_progressive_risk;
+    this.risk_distribution = risk_distribution;
+    this.symbol = symbol;
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
     this.focus = focus;
@@ -122,6 +466,12 @@ class Signal {
     this.increase_position = increase_position;
     this.gap = gap;
     this.max_size = max_size;
+    this.use_kelly = use_kelly;
+    this.kelly_prediction_model = kelly_prediction_model;
+    this.kelly_confidence_factor = kelly_confidence_factor;
+    this.kelly_minimum_risk = kelly_minimum_risk;
+    this.kelly_func = kelly_func;
+    this.max_quantity = max_quantity;
   }
   build_entry({
     current_price,
@@ -131,7 +481,15 @@ class Signal {
     kind = "long",
     risk,
     no_of_trades = 1,
-    take_profit
+    take_profit,
+    distribution,
+    distribution_params = {
+      buckets: [
+        { zone_percentage: 0.25, risk_percentage: 0.1 },
+        { zone_percentage: 0.5, risk_percentage: 0.4 },
+        { zone_percentage: 0.25, risk_percentage: 0.5 }
+      ]
+    }
   }) {
     let _stop_loss = stop_loss;
     if (!_stop_loss && stop_percent) {
@@ -140,20 +498,36 @@ 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 risk_per_trade = risk / this.risk_reward;
+    const use_progressive = distribution_params.use_progressive || this.use_progressive_risk;
+    const risk_distribution = use_progressive ? {
+      enabled: true,
+      total_risk_budget: risk,
+      risk_reward: this.risk_reward,
+      buckets: distribution_params.buckets || []
+    } : undefined;
     const derivedConfig = {
       ...this,
       percent_change,
       focus: current_price,
-      resistance: _resistance,
-      risk_per_trade: risk / this.risk_reward,
+      resistance: distribution ? simple_resistance : _resistance,
+      risk_per_trade,
       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,
+      use_progressive_risk: use_progressive,
+      distribution_params,
+      risk_distribution
     };
     const instance = new Signal(derivedConfig);
-    if (kind === "short") {
-    }
+    if (kind === "short") {}
     let result = instance.get_bulk_trade_zones({ current_price, kind });
     return result;
     return result?.filter((x) => {
@@ -309,7 +683,6 @@ class Signal {
           let potentials = new_result.filter((x) => condition(x["entry"], i["risk_sell"])).map((x) => x["entry"]);
           if (potentials.length && max_index) {
             if (kind === "long") {
-              console.log("slice: ", potentials.slice(0, max_index));
               i["risk_sell"] = Math.max(...potentials.slice(0, max_index));
             } else {
               i["risk_sell"] = Math.min(...potentials.slice(0, max_index));
@@ -366,13 +739,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";
+    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,
+      distribution_params: this.distribution_params
+    });
+    return entries.sort((a, b) => a - b);
+  }
   get_future_zones({
     current_price,
     kind = "long",
     raw
   }) {
-    if (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));
@@ -498,6 +889,24 @@ class Signal {
     }
     return null;
   }
+  getZoneRisk(index, totalZones, account) {
+    if (!account.risk_distribution?.enabled) {
+      return account.risk_per_trade;
+    }
+    const { buckets, total_risk_budget } = account.risk_distribution;
+    const reversedBuckets = [...buckets].reverse();
+    let zoneStart = 0;
+    for (const bucket of reversedBuckets) {
+      const zoneEnd = zoneStart + Math.floor(totalZones * bucket.zone_percentage);
+      if (index < zoneEnd) {
+        const zonesInBucket = zoneEnd - zoneStart;
+        const bucket_total = total_risk_budget * bucket.risk_percentage;
+        return bucket_total / zonesInBucket;
+      }
+      zoneStart = zoneEnd;
+    }
+    return account.risk_per_trade;
+  }
   process_orders({
     current_price,
     stop_loss,
@@ -560,10 +969,26 @@ class Signal {
         }
         const defaultStopLoss = i === 0 ? stop_loss : _base;
         const new_stop = kind === "long" ? this.support : stop_loss;
+        let risk_to_use = this.getZoneRisk(i, limit_orders.length, this);
+        console.log("index: ", i, " risk: ", risk_to_use);
+        if (this.use_kelly) {
+          const func = this.kelly_func === "theoretical" ? calculateTheoreticalKelly : this.kelly_func === "position_based" ? calculatePositionBasedKelly : calculateTheoreticalKellyFixed;
+          const theoretical_kelly = func({
+            current_entry: x,
+            zone_prices: limit_orders,
+            kind,
+            config: {
+              price_prediction_model: this.kelly_prediction_model,
+              confidence_factor: this.kelly_confidence_factor,
+              volatility_adjustment: true
+            }
+          });
+          risk_to_use = theoretical_kelly * risk_per_trade / this.kelly_minimum_risk;
+        }
         const y = this.build_trade_dict({
           entry: x,
           stop: (this.increase_position ? new_stop : defaultStopLoss) || defaultStopLoss,
-          risk: risk_per_trade,
+          risk: risk_to_use,
           arr: limit_orders,
           index: i,
           new_fees: total_incurred_market_fees,
@@ -577,14 +1002,13 @@ class Signal {
         return y !== null ? y : undefined;
       }) || []).filter((y) => y !== undefined).filter((y) => {
         const min_options = [0.001, 0.002, 0.003];
-        if (min_options.includes(this.minimum_size)) {
-          return y.quantity <= 0.03;
+        if (min_options.includes(this.minimum_size) && this.symbol.toUpperCase().startsWith("BTC")) {
+          return y.quantity <= this.max_quantity;
         }
         return true;
       });
       let total_orders = limit_trades.concat(market_trades);
-      if (kind === "short") {
-      }
+      if (kind === "short") {}
       if (this.minimum_size && total_orders.length > 0) {
         let payload = total_orders;
         let greater_than_min_size = total_orders.filter((o) => o ? o.quantity >= this.minimum_size : true);
@@ -670,8 +1094,7 @@ class Signal {
     });
     const multiplier = start - index;
     const incurred_fees = fees.reduce((a, b) => a + b, 0) + previous_risks.reduce((a, b) => a + b, 0);
-    if (index === 0) {
-    }
+    if (index === 0) {}
     let quantity = determine_position_size({
       entry,
       stop,
@@ -837,8 +1260,7 @@ function extractValue(_param, condition) {
     try {
       let value2 = JSON.parse(_param || "[]");
       param = value2.map((o) => parseFloat(o));
-    } catch (error) {
-    }
+    } catch (error) {}
   } else {
     param = parseFloat(_param);
   }
@@ -853,8 +1275,7 @@ function asCoins(symbol) {
   if (symbol.toLowerCase().includes("-")) {
     result = result.split("-")[0];
   }
-  if (symbol.toLowerCase() == "usdt-usd") {
-  }
+  if (symbol.toLowerCase() == "usdt-usd") {}
   let result2 = _type == "usdt" ? symbol.split(result)[0] : result;
   if (result.includes("-")) {
     result2 = result;
@@ -1153,7 +1574,64 @@ function computeSellZones(payload) {
   const spread = factor - 1;
   return Array.from({ length: zones }, (_, i) => entry * Math.pow(1 + spread, i));
 }
+function determineTPSl(payload) {
+  const { sell_ratio = 1, kind, positions, configs, decimal_places } = payload;
+  const long_settings = configs.long;
+  const short_settings = configs.short;
+  const settings = kind === "long" ? long_settings : short_settings;
+  const reverse_kind = kind === "long" ? "short" : "long";
+  const _position = positions[kind];
+  const reverse_position = positions[reverse_kind];
+  const reduce_ratio = settings.reduce_ratio;
+  const notion = _position.entry * _position.quantity;
+  const profit_percent = settings.profit_percent;
+  const places = decimal_places || reverse_position.decimal_places;
+  if (profit_percent) {
+    let quantity = to_f(_position.quantity * sell_ratio, places);
+    const as_float = parseFloat(profit_percent) * sell_ratio;
+    const pnl = to_f(as_float * notion / 100, "%.2f");
+    const diff = pnl / quantity;
+    const tp_price = to_f(kind === "long" ? _position.entry + diff : _position.entry - diff, _position.price_places);
+    const expected_loss = to_f(parseFloat(reduce_ratio) * pnl, "%.2f");
+    let reduce_quantity = 0;
+    if (reverse_position.quantity > 0) {
+      const total_loss = Math.abs(tp_price - reverse_position.entry) * reverse_position.quantity;
+      const ratio = expected_loss / total_loss;
+      reduce_quantity = to_f(reverse_position.quantity * ratio, places);
+    }
+    return {
+      tp_price,
+      pnl,
+      quantity,
+      reduce_quantity,
+      expected_loss
+    };
+  }
+  return {
+    tp_price: 0,
+    pnl: 0,
+    quantity: 0,
+    reduce_quantity: 0,
+    expected_loss: 0
+  };
+}
 // src/helpers/shared.ts
+function getMaxQuantity(x, app_config) {
+  let max_quantity = app_config.max_quantity;
+  if (max_quantity) {
+    return x <= max_quantity;
+  }
+  if (app_config.symbol === "BTCUSDT") {
+    max_quantity = 0.03;
+  }
+  if (app_config.symbol?.toLowerCase().startsWith("sol")) {
+    max_quantity = 2;
+  }
+  if (!max_quantity) {
+    return true;
+  }
+  return x <= max_quantity;
+}
 function buildConfig(app_config, {
   take_profit,
   entry,
@@ -1168,7 +1646,16 @@ function buildConfig(app_config, {
   gap,
   rr = 1,
   price_places = "%.1f",
-  decimal_places = "%.3f"
+  decimal_places = "%.3f",
+  use_kelly = false,
+  kelly_confidence_factor = 0.95,
+  kelly_minimum_risk = 0.2,
+  kelly_prediction_model = "exponential",
+  kelly_func = "theoretical",
+  min_avg_size = 0,
+  distribution,
+  distribution_params,
+  use_progressive_risk
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -1192,7 +1679,16 @@ function buildConfig(app_config, {
     kind: app_config.kind,
     gap,
     min_profit: min_profit || app_config.min_profit,
-    rr: rr || 1
+    rr: rr || 1,
+    use_kelly: use_kelly || app_config.kelly?.use_kelly,
+    kelly_confidence_factor: kelly_confidence_factor || app_config.kelly?.kelly_confidence_factor,
+    kelly_minimum_risk: kelly_minimum_risk || app_config.kelly?.kelly_minimum_risk,
+    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,
+    distribution_params: distribution_params || app_config.distribution_params,
+    use_progressive_risk
   };
   const instance = new Signal(config);
   if (raw_instance) {
@@ -1202,16 +1698,19 @@ function buildConfig(app_config, {
     return [];
   }
   const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
-  if (kind === "short") {
-  }
+  if (kind === "short") {}
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
     risk: working_risk,
     kind: kind || app_config.kind,
-    no_of_trades: trade_no
+    no_of_trades: trade_no,
+    distribution,
+    distribution_params
   }) || [] : [];
-  return computeTotalAverageForEachTrade(result, config);
+  const new_trades = computeTotalAverageForEachTrade(result, config);
+  let filtered = new_trades.filter((o) => o.avg_size > min_avg_size);
+  return computeTotalAverageForEachTrade(filtered, config);
 }
 function buildAvg({
   _trades,
@@ -1228,13 +1727,7 @@ function buildAvg({
 }
 function sortedBuildConfig(app_config, options) {
   const sorted = buildConfig(app_config, options).sort((a, b) => app_config.kind === "long" ? a.entry - b.entry : b.entry - b.entry).filter((x) => {
-    if (app_config.symbol === "BTCUSDT") {
-      return x.quantity <= 0.03;
-    }
-    if (app_config.symbol?.toLowerCase().startsWith("sol")) {
-      return x.quantity <= 2;
-    }
-    return true;
+    return getMaxQuantity(x.quantity, app_config);
   });
   return sorted.map((k, i) => {
     const arrSet = sorted.slice(0, i + 1);
@@ -1265,7 +1758,8 @@ function get_app_config_and_max_size(config, payload) {
     price_places: config.price_places,
     decimal_places: config.decimal_places,
     min_profit: config.profit_percent * config.profit / 100,
-    symbol: config.symbol
+    symbol: config.symbol,
+    max_quantity: config.max_quantity
   };
   const initialResult = sortedBuildConfig(app_config, {
     entry: app_config.entry,
@@ -1276,7 +1770,14 @@ function get_app_config_and_max_size(config, payload) {
     increase: true,
     gap: app_config.gap,
     price_places: app_config.price_places,
-    decimal_places: app_config.decimal_places
+    decimal_places: app_config.decimal_places,
+    use_kelly: payload.use_kelly,
+    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,
+    distribution: payload.distribution,
+    distribution_params: payload.distribution_params
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -1305,21 +1806,42 @@ function buildAppConfig(config, payload) {
     reverse_factor: 1,
     profit_percent: 0,
     kind: payload.entry > payload.stop ? "long" : "short",
-    symbol: payload.symbol
+    symbol: payload.symbol || config.symbol
   }, {
     entry: payload.entry,
     stop: payload.stop,
-    kind: payload.entry > payload.stop ? "long" : "short"
+    kind: payload.entry > payload.stop ? "long" : "short",
+    use_kelly: payload.use_kelly,
+    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,
+    distribution: payload.distribution,
+    distribution_params: payload.distribution_params
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
   app_config.stop = payload.stop || app_config.stop;
   app_config.last_value = last_value;
   app_config.entries = entries;
+  app_config.kelly = {
+    use_kelly: payload.use_kelly,
+    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
+  };
+  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 } = 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);
@@ -1342,7 +1864,9 @@ 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,
+      distribution_params: _distribution_params
     });
     if (result.length === 0) {
       if (isLong) {
@@ -1396,7 +1920,9 @@ 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,
+      distribution_params: _distribution_params
     });
     if (result.length === 0) {
       high_risk = mid_risk;
@@ -1441,7 +1967,9 @@ 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,
+        distribution_params: _distribution_params
       });
       if (result.length === 0)
         continue;
@@ -1564,7 +2092,8 @@ function generateOptimumAppConfig(config, 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;
@@ -1579,7 +2108,8 @@ function generateOptimumAppConfig(config, 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;
@@ -1637,7 +2167,16 @@ 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,
+    distribution,
+    max_size
+  } = payload;
   const criterion = app_config.strategy || "quantity";
   const risk_rewards = createArray(low_range, high_range, 1);
   let func = risk_rewards.map((trade_no) => {
@@ -1650,13 +2189,16 @@ function determineOptimumReward(app_config, increase = true, low_range = 30, hig
       increase,
       kind: app_config.kind,
       gap: app_config.gap,
-      decimal_places: app_config.decimal_places
+      decimal_places: app_config.decimal_places,
+      distribution,
+      distribution_params: payload.distribution_params
     });
     let total = 0;
     let max = -Infinity;
     let min = Infinity;
     let neg_pnl = trades[0]?.neg_pnl || 0;
     let entry = trades.at(-1)?.entry;
+    let avg_size = trades[0]?.avg_size || 0;
     if (!entry) {
       return null;
     }
@@ -1673,14 +2215,41 @@ function determineOptimumReward(app_config, increase = true, low_range = 30, hig
       risk_per_trade: app_config.risk_per_trade,
       max,
       min,
+      avg_size,
       neg_pnl,
       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 (max_size !== undefined && max_size > 0) {
+    func = func.filter((r) => r.avg_size <= max_size);
+  }
+  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);
@@ -1714,6 +2283,7 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
       return b.net_diff - a.net_diff;
     }
   });
+  console.log("found", sortedFound);
   if (defaultKey === "quantity") {
     return sortedFound[0].index;
   }
@@ -1734,58 +2304,154 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
   }, found[0]);
   return maximum;
 }
+function determineOptimumRisk(config, payload, params) {
+  const { highest_risk, tolerance = 0.01, max_iterations = 200 } = params;
+  let low_risk = 1;
+  let high_risk = Math.max(highest_risk * 5, payload.risk * 10);
+  let best_risk = payload.risk;
+  let best_neg_pnl = 0;
+  let best_diff = Infinity;
+  console.log(`Finding optimal risk for target neg_pnl: ${highest_risk}`);
+  let iterations = 0;
+  while (iterations < max_iterations && high_risk - low_risk > tolerance) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const test_payload = {
+      ...payload,
+      risk: mid_risk
+    };
+    const { last_value } = buildAppConfig(config, test_payload);
+    if (!last_value || !last_value.neg_pnl) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const current_neg_pnl = Math.abs(last_value.neg_pnl);
+    const diff = Math.abs(current_neg_pnl - highest_risk);
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, neg_pnl=${current_neg_pnl.toFixed(2)}, diff=${diff.toFixed(2)}`);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_risk = mid_risk;
+      best_neg_pnl = current_neg_pnl;
+    }
+    if (diff <= tolerance) {
+      console.log(`Converged! Optimal risk: ${mid_risk.toFixed(2)}`);
+      break;
+    }
+    if (current_neg_pnl < highest_risk) {
+      low_risk = mid_risk;
+    } else {
+      high_risk = mid_risk;
+    }
+  }
+  const final_payload = {
+    ...payload,
+    risk: best_risk
+  };
+  const final_result = buildAppConfig(config, final_payload);
+  return {
+    optimal_risk: to_f(best_risk, "%.2f"),
+    achieved_neg_pnl: to_f(best_neg_pnl, "%.2f"),
+    target_neg_pnl: to_f(highest_risk, "%.2f"),
+    difference: to_f(best_diff, "%.2f"),
+    iterations,
+    converged: best_diff <= tolerance,
+    last_value: final_result.last_value,
+    entries: final_result.entries,
+    app_config: final_result
+  };
+}
 function computeRiskReward(payload) {
-  const { app_config, entry, stop, risk_per_trade } = payload;
+  const {
+    app_config,
+    entry,
+    stop,
+    risk_per_trade,
+    target_loss,
+    distribution,
+    high_range,
+    max_size
+  } = 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,
+    distribution,
+    distribution_params: payload.distribution_params,
+    high_range,
+    max_size
+  });
   return result;
 }
 function getRiskReward(payload) {
-  const { entry, stop, risk, global_config } = payload;
+  const {
+    high_range,
+    max_size,
+    entry,
+    stop,
+    risk,
+    global_config,
+    force_exact_risk = false,
+    target_loss,
+    distribution,
+    risk_factor = 1
+  } = 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,
+    distribution_params: payload.distribution_params
   });
   const risk_reward = computeRiskReward({
     app_config,
     entry,
     stop,
-    risk_per_trade: risk
+    risk_per_trade: risk,
+    high_range,
+    target_loss,
+    distribution,
+    distribution_params: payload.distribution_params,
+    max_size
   });
+  if (force_exact_risk) {
+    const new_risk_per_trade = determineOptimumRisk(global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: global_config.symbol,
+      distribution,
+      distribution_params: payload.distribution_params
+    }, {
+      highest_risk: risk * risk_factor
+    }).optimal_risk;
+    return { risk: new_risk_per_trade, risk_reward };
+  }
   return risk_reward;
 }
 function computeProfitDetail(payload) {
   const {
     focus_position,
     strategy,
+    pnl,
     price_places = "%.1f",
     reduce_position,
     decimal_places,
-    reverse_position
+    reverse_position,
+    full_ratio = 1
   } = payload;
-  let reward_factor = strategy.reward_factor;
-  let risk = strategy.risk;
-  if (strategy.max_reward_factor === 0) {
-    reward_factor = strategy.reward_factor;
-  }
-  if (focus_position.avg_qty >= focus_position.quantity && strategy.max_reward_factor) {
-    reward_factor = to_f(focus_position.quantity * strategy.max_reward_factor / focus_position.avg_qty, "%.4f");
-  } else {
-    reward_factor = strategy.reward_factor;
-  }
-  const full_pnl = reward_factor * risk;
-  const profit_percent = to_f(full_pnl * 100 / (focus_position.avg_price * focus_position.avg_qty), "%.4f");
-  const pnl = to_f(focus_position.entry * focus_position.quantity * profit_percent / 100, "%.2f");
+  let reward_factor = strategy?.reward_factor || 1;
+  const profit_percent = to_f(pnl * 100 / (focus_position.avg_price * focus_position.avg_qty), "%.4f");
   const diff = pnl / focus_position.quantity;
   const sell_price = to_f(focus_position.kind === "long" ? focus_position.entry + diff : focus_position.entry - diff, price_places);
   let loss = 0;
+  let full_loss = 0;
   let expected_loss = 0;
   let quantity = 0;
   let new_pnl = pnl;
@@ -1793,6 +2459,8 @@ function computeProfitDetail(payload) {
     loss = Math.abs(reduce_position.entry - sell_price) * reduce_position.quantity;
     const ratio = pnl / loss;
     quantity = to_f(reduce_position.quantity * ratio, decimal_places);
+    expected_loss = to_f(Math.abs(reduce_position.entry - sell_price) * quantity, "%.2f");
+    full_loss = Math.abs(reduce_position.avg_price - sell_price) * reduce_position.avg_qty * full_ratio;
   }
   if (reverse_position) {
     expected_loss = Math.abs(reverse_position.avg_price - sell_price) * reverse_position.avg_qty;
@@ -1801,12 +2469,13 @@ function computeProfitDetail(payload) {
   return {
     pnl: new_pnl,
     loss: to_f(expected_loss, "%.2f"),
+    full_loss: to_f(full_loss, "%.2f"),
     original_pnl: pnl,
     reward_factor,
     profit_percent,
     kind: focus_position.kind,
     sell_price: to_f(sell_price, price_places),
-    quantity,
+    quantity: quantity * full_ratio,
     price_places,
     decimal_places
   };
@@ -1815,10 +2484,26 @@ function generateGapTp(payload) {
   const {
     long,
     short,
-    factor = 1,
+    factor: factor_value = 0,
+    risk: desired_risk,
+    sell_factor = 1,
+    kind,
     price_places = "%.1f",
     decimal_places = "%.3f"
   } = payload;
+  if (!factor_value && !desired_risk) {
+    throw new Error("Either factor or risk must be provided");
+  }
+  if (desired_risk && !kind) {
+    throw new Error("Kind must be provided when risk is provided");
+  }
+  let factor = factor_value || calculate_factor({
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor
+  });
   const gap = Math.abs(long.entry - short.entry);
   const max_quantity = Math.max(long.quantity, short.quantity);
   const gapLoss = gap * max_quantity;
@@ -1828,14 +2513,36 @@ function generateGapTp(payload) {
   const shortTp = to_f((1 + shortPercent) ** -1 * short.entry, price_places);
   const shortToReduce = to_f(Math.abs(longTp - long.entry) * long.quantity, "%.1f");
   const longToReduce = to_f(Math.abs(shortTp - short.entry) * short.quantity, "%.1f");
-  const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, shortToReduce, "short", decimal_places);
-  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, longToReduce, "long", decimal_places);
+  const actualShortReduce = to_f(shortToReduce * sell_factor, "%.1f");
+  const actualLongReduce = to_f(longToReduce * sell_factor, "%.1f");
+  const short_quantity_to_sell = determine_amount_to_sell2(short.entry, short.quantity, longTp, actualShortReduce, "short", decimal_places);
+  const long_quantity_to_sell = determine_amount_to_sell2(long.entry, long.quantity, shortTp, actualLongReduce, "long", decimal_places);
+  const risk_amount_short = to_f(shortToReduce - actualShortReduce, "%.2f");
+  const risk_amount_long = to_f(longToReduce - actualLongReduce, "%.2f");
+  const profit_percent_long = to_f(shortToReduce * 100 / (long.entry * long.quantity), "%.4f");
+  const profit_percent_short = to_f(longToReduce * 100 / (short.entry * short.quantity), "%.4f");
   return {
-    long_tp: longTp,
-    short_tp: shortTp,
-    short_to_reduce: shortToReduce,
-    long_to_reduce: longToReduce,
-    to_sell: {
+    profit_percent: {
+      long: profit_percent_long,
+      short: profit_percent_short
+    },
+    risk: {
+      short: risk_amount_short,
+      long: risk_amount_long
+    },
+    take_profit: {
+      long: longTp,
+      short: shortTp
+    },
+    to_reduce: {
+      short: actualShortReduce,
+      long: actualLongReduce
+    },
+    full_reduce: {
+      short: shortToReduce,
+      long: longToReduce
+    },
+    sell_quantity: {
       short: short_quantity_to_sell,
       long: long_quantity_to_sell
     },
@@ -1843,6 +2550,370 @@ function generateGapTp(payload) {
     gap_loss: to_f(gapLoss, "%.2f")
   };
 }
+function calculate_factor(payload) {
+  const {
+    long,
+    short,
+    risk: desired_risk,
+    kind,
+    sell_factor,
+    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;
+  let calculated_factor;
+  const long_notional = long.entry * long.quantity;
+  const short_notional = short.entry * short.quantity;
+  const target_to_reduce = desired_risk / (1 - sell_factor);
+  if (kind === "short") {
+    const calculate_longPercent = target_to_reduce / long_notional;
+    calculated_factor = calculate_longPercent * short_notional / gapLoss;
+  } else {
+    const calculated_shortPercent = target_to_reduce / (short_notional - target_to_reduce);
+    calculated_factor = calculated_shortPercent * long_notional / gapLoss;
+  }
+  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;
+  const quantity_ratio = quantity / avg_qty;
+  return to_f(reward_factor / quantity_ratio, "%.4f");
+}
+function getHedgeZone(payload) {
+  const {
+    reward_factor: _reward_factor,
+    symbol_config,
+    risk,
+    position: position2,
+    risk_factor = 1,
+    support
+  } = payload;
+  const kind = position2.kind;
+  let reward_factor = _reward_factor;
+  if (support) {
+    const _result = getOptimumHedgeFactor({
+      target_support: support,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    reward_factor = Number(_result.reward_factor);
+  }
+  const take_profit = position2.tp?.price;
+  const tp_diff = Math.abs(take_profit - position2.entry);
+  const quantity = position2.quantity;
+  const diff = risk / quantity;
+  let new_take_profit = kind === "long" ? to_f(position2.entry + diff, symbol_config.price_places) : to_f(position2.entry - diff, symbol_config.price_places);
+  let base_factor = to_f(Math.max(tp_diff, diff) / (Math.min(tp_diff, diff) || 1), "%.3f");
+  let factor = reward_factor || base_factor;
+  const new_risk = risk * factor * risk_factor;
+  const stop_loss_diff = new_risk / quantity;
+  new_take_profit = kind === "long" ? to_f(position2.entry + stop_loss_diff, symbol_config.price_places) : to_f(position2.entry - stop_loss_diff, symbol_config.price_places);
+  const stop_loss = kind === "long" ? to_f(position2.entry - stop_loss_diff, symbol_config.price_places) : to_f(position2.entry + stop_loss_diff, symbol_config.price_places);
+  const profit_percent = new_risk * 100 / (position2.entry * position2.quantity);
+  return {
+    support: Math.min(new_take_profit, stop_loss),
+    resistance: Math.max(new_take_profit, stop_loss),
+    risk: to_f(new_risk, "%.2f"),
+    profit_percent: to_f(profit_percent, "%.2f")
+  };
+}
+function getOptimumHedgeFactor(payload) {
+  const {
+    target_support,
+    max_iterations = 50,
+    min_factor = 0.1,
+    max_factor = 20,
+    symbol_config,
+    risk,
+    position: position2
+  } = payload;
+  const current_price = position2.entry;
+  const tolerance = current_price > 100 ? 0.5 : current_price > 1 ? 0.01 : 0.001;
+  let low = min_factor;
+  let high = max_factor;
+  let best_factor = low;
+  let best_diff = Infinity;
+  for (let iteration = 0;iteration < max_iterations; iteration++) {
+    const mid_factor = (low + high) / 2;
+    const hedge_zone = getHedgeZone({
+      reward_factor: mid_factor,
+      symbol_config,
+      risk,
+      position: position2
+    });
+    const current_support = hedge_zone.support;
+    const diff = Math.abs(current_support - target_support);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff <= tolerance) {
+      return {
+        reward_factor: to_f(mid_factor, "%.4f"),
+        achieved_support: to_f(current_support, symbol_config.price_places),
+        target_support: to_f(target_support, symbol_config.price_places),
+        difference: to_f(diff, symbol_config.price_places),
+        iterations: iteration + 1
+      };
+    }
+    if (current_support > target_support) {
+      low = mid_factor;
+    } else {
+      high = mid_factor;
+    }
+    if (Math.abs(high - low) < 0.0001) {
+      break;
+    }
+  }
+  const final_hedge_zone = getHedgeZone({
+    symbol_config,
+    risk,
+    position: position2,
+    reward_factor: best_factor
+  });
+  return {
+    reward_factor: to_f(best_factor, "%.4f"),
+    achieved_support: to_f(final_hedge_zone.support, symbol_config.price_places),
+    target_support: to_f(target_support, symbol_config.price_places),
+    difference: to_f(best_diff, symbol_config.price_places),
+    iterations: max_iterations,
+    converged: best_diff <= tolerance
+  };
+}
+function determineCompoundLongTrade(payload) {
+  const {
+    focus_short_position,
+    focus_long_position,
+    shortConfig,
+    global_config,
+    rr = 1
+  } = payload;
+  const short_app_config = buildAppConfig(global_config, {
+    entry: shortConfig.entry,
+    stop: shortConfig.stop,
+    risk_reward: shortConfig.risk_reward,
+    risk: shortConfig.risk,
+    symbol: shortConfig.symbol
+  });
+  const short_max_size = short_app_config.last_value.avg_size;
+  const start_risk = Math.abs(short_app_config.last_value.neg_pnl) * rr;
+  const short_profit = short_app_config.last_value.avg_size * short_app_config.last_value.avg_entry * shortConfig.profit_percent / 100;
+  const diff = short_profit * rr / short_app_config.last_value.avg_size;
+  const support = Math.abs(short_app_config.last_value.avg_entry - diff);
+  const resistance = focus_short_position.next_order || focus_long_position.take_profit;
+  console.log({ support, resistance, short_profit });
+  const result = getRiskReward({
+    entry: resistance,
+    stop: support,
+    risk: start_risk,
+    global_config,
+    force_exact_risk: true
+  });
+  const long_app_config = buildAppConfig(global_config, {
+    entry: resistance,
+    stop: support,
+    risk_reward: result.risk_reward,
+    risk: result.risk,
+    symbol: shortConfig.symbol
+  });
+  const long_profit_percent = start_risk * 2 * 100 / (long_app_config.last_value.avg_size * long_app_config.last_value.avg_entry);
+  return {
+    start_risk,
+    short_profit,
+    support: to_f(support, global_config.price_places),
+    resistance: to_f(resistance, global_config.price_places),
+    long_v: long_app_config.last_value,
+    profit_percent: to_f(long_profit_percent, "%.3f"),
+    result,
+    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,
+    distribution_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, distribution_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,
+    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;
+}
+function generateDangerousConfig(payload) {
+  const { account, global_config, config } = payload;
+  const app_config = constructAppConfig({
+    account,
+    global_config,
+    kelly_config: {},
+    distribution_config: {}
+  });
+  const { optimal_risk, optimal_stop } = getOptimumStopAndRisk(app_config, {
+    max_size: config.quantity,
+    target_stop: config.stop
+  });
+  const optimumRiskReward = computeRiskReward({
+    app_config,
+    entry: config.entry,
+    stop: optimal_stop,
+    risk_per_trade: optimal_risk,
+    target_loss: optimal_risk
+  });
+  return {
+    entry: config.entry,
+    risk: optimal_risk,
+    stop: optimal_stop,
+    risk_reward: optimumRiskReward
+  };
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -2245,11 +3316,14 @@ class Strategy {
     return { ...app_config, avg, loss: -expected_loss, profit_percent };
   }
   identifyGapConfig(payload) {
-    const { factor = 1 } = payload;
+    const { factor, sell_factor = 1, kind, risk } = payload;
     return generateGapTp({
       long: this.position.long,
       short: this.position.short,
       factor,
+      sell_factor,
+      kind,
+      risk,
       decimal_places: this.config.global_config.decimal_places,
       price_places: this.config.global_config.price_places
     });
@@ -2265,6 +3339,7 @@ class Strategy {
         avg_price: focus_position.avg_price,
         avg_qty: focus_position.avg_qty
       },
+      pnl: this.pnl(kind),
       strategy: {
         reward_factor,
         max_reward_factor,
@@ -2273,7 +3348,535 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const {
+      factor,
+      direction,
+      sell_factor = 1,
+      iterations = 10,
+      risk: desired_risk,
+      kind
+    } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    for (let i = 0;i < iterations; i++) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor,
+        kind,
+        risk: desired_risk
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      const sell_kind = direction == "long" ? "short" : "long";
+      if (sell_quantity[sell_kind] <= 0) {
+        break;
+      }
+      results.push(to_add);
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[direction] = {
+        entry: take_profit[direction],
+        quantity: remaining
+      };
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[direction];
+    const entry = this.position[direction].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity
+    };
+  }
+}
+// src/helpers/compound.ts
+function buildTrades(payload) {
+  const { appConfig, settings, kind } = payload;
+  const kelly_config = settings.kelly;
+  const distribution_params = settings.distribution_params;
+  const current_app_config = { ...appConfig[kind] };
+  const entryNum = parseFloat(settings.entry);
+  const stopNum = parseFloat(settings.stop);
+  current_app_config.entry = entryNum;
+  current_app_config.stop = stopNum;
+  current_app_config.risk_per_trade = parseFloat(settings.risk);
+  current_app_config.risk_reward = parseFloat(settings.risk_reward);
+  current_app_config.kind = kind;
+  current_app_config.kelly = kelly_config;
+  current_app_config.distribution_params = distribution_params;
+  const options = {
+    take_profit: null,
+    entry: current_app_config.entry,
+    stop: current_app_config.stop,
+    raw_instance: null,
+    risk: current_app_config.risk_per_trade,
+    no_of_trades: undefined,
+    risk_reward: current_app_config.risk_reward,
+    kind: current_app_config.kind,
+    increase: true,
+    gap: current_app_config.gap,
+    rr: current_app_config.rr,
+    price_places: current_app_config.price_places,
+    decimal_places: current_app_config.decimal_places,
+    use_kelly: kelly_config?.use_kelly,
+    kelly_confidence_factor: kelly_config?.kelly_confidence_factor,
+    kelly_minimum_risk: kelly_config?.kelly_minimum_risk,
+    kelly_prediction_model: kelly_config?.kelly_prediction_model,
+    kelly_func: kelly_config?.kelly_func,
+    distribution: settings.distribution,
+    distribution_params: settings.distribution_params
+  };
+  if (kind === "long" && entryNum <= stopNum) {
+    return [];
+  }
+  if (kind === "short" && entryNum >= stopNum) {
+    return [];
+  }
+  try {
+    const generatedTrades = sortedBuildConfig(current_app_config, options);
+    return generatedTrades ?? [];
+  } catch (error) {
+    console.error("Error generating orders:", error);
+    return [];
+  }
+}
+function generateSummary({
+  trades,
+  fee_percent = 0.05,
+  anchor
+}) {
+  const avg_entry = trades[0].avg_entry;
+  const avg_size = trades[0].avg_size;
+  const expected_fee = avg_entry * avg_size * fee_percent / 100;
+  return {
+    first_entry: trades.at(-1).entry,
+    last_entry: trades[0].entry,
+    quantity: avg_size,
+    entry: avg_entry,
+    loss: trades[0].neg_pnl,
+    number_of_trades: trades.length,
+    fee: to_f(expected_fee, "%.2f"),
+    anchor_pnl: anchor?.target_pnl
+  };
+}
+function helperFuncToBuildTrades({
+  custom_b_config,
+  symbol_config,
+  app_config_kind,
+  appConfig,
+  force_exact_risk = true
+}) {
+  const risk = custom_b_config.risk * (custom_b_config.risk_factor || 1);
+  let result = getRiskReward({
+    entry: custom_b_config.entry,
+    stop: custom_b_config.stop,
+    risk,
+    global_config: symbol_config,
+    force_exact_risk,
+    target_loss: custom_b_config.risk * (custom_b_config.risk_factor || 1),
+    distribution: custom_b_config.distribution,
+    distribution_params: custom_b_config.distribution_params
+  });
+  if (!force_exact_risk) {
+    result = {
+      risk_reward: result,
+      risk
+    };
+  }
+  const trades = result.risk_reward ? buildTrades({
+    appConfig: { [app_config_kind]: appConfig },
+    kind: app_config_kind,
+    settings: {
+      entry: custom_b_config.entry,
+      stop: custom_b_config.stop,
+      risk: result.risk || custom_b_config.risk,
+      risk_reward: result.risk_reward,
+      distribution: custom_b_config.distribution,
+      distribution_params: custom_b_config.distribution_params
+    }
+  }) : [];
+  const summary = trades.length > 0 ? generateSummary({ trades }) : {};
+  return { trades, result, summary };
+}
+function constructAppConfig2({
+  config,
+  global_config
+}) {
+  const options = {
+    entry: config?.entry,
+    stop: config?.stop,
+    risk_reward: config?.risk_reward,
+    risk: config?.risk,
+    symbol: config.symbol
+  };
+  const { entries: _entries, ...appConfig } = buildAppConfig(global_config, options);
+  return appConfig;
+}
+function buildWithOptimumReward({
+  config,
+  settings,
+  global_config,
+  force_exact
+}) {
+  const kind = config.entry > config.stop ? "long" : "short";
+  let stop = settings.stop;
+  let entry = settings.entry;
+  const risk = settings.risk;
+  const stop_ratio = settings.stop_ratio || 1;
+  const distribution = settings.distribution || config?.distribution;
+  const distribution_params = settings.distribution_params || config?.distribution_params;
+  const custom_b_config = {
+    entry,
+    stop,
+    risk,
+    distribution,
+    distribution_params
+  };
+  const appConfig = constructAppConfig2({
+    config,
+    global_config
+  });
+  const { trades, summary, result } = helperFuncToBuildTrades({
+    custom_b_config,
+    app_config_kind: kind,
+    appConfig,
+    symbol_config: global_config,
+    force_exact_risk: force_exact
+  });
+  const adjusted_size = summary.quantity;
+  const symbol_config = global_config;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, "%.2f"),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(adjusted_size, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(summary.loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    margin: to_f(summary.entry * adjusted_size / symbol_config.leverage, "%.2f")
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    config: {
+      ...custom_b_config,
+      ...result,
+      stop_ratio
+    },
+    stop_order: {
+      quantity: entryDetails.avg_size * stop_ratio,
+      price: entryDetails.stop
+    },
+    kind
+  };
+}
+function generateOppositeOptimum({
+  config,
+  global_config,
+  settings,
+  ratio = 1,
+  distribution,
+  distribution_params,
+  risk_factor = 1
+}) {
+  const configKind = config.entry > config.stop ? "long" : "short";
+  if (configKind === "long" && config.entry > config.stop) {
+    if (settings.stop <= settings.entry) {
+      throw new Error("Invalid input: For long config positions, opposite settings must have stop > entry");
+    }
+  } else if (configKind === "short" && config.entry < config.stop) {
+    if (settings.stop >= settings.entry) {
+      throw new Error("Invalid input: For short config positions, opposite settings must have stop < entry");
+    }
+  }
+  const kind = config.entry > config.stop ? "long" : "short";
+  const app_config_kind = kind === "long" ? "short" : "long";
+  let risk = settings.risk;
+  const custom_b_config = {
+    entry: settings.entry,
+    stop: settings.stop,
+    risk: risk * ratio,
+    distribution: distribution || "inverse-exponential",
+    distribution_params: distribution_params || config?.distribution_params,
+    risk_factor
+  };
+  const appConfig = constructAppConfig2({
+    config: {
+      ...config,
+      ...custom_b_config
+    },
+    global_config
+  });
+  const { result, trades, summary } = helperFuncToBuildTrades({
+    custom_b_config,
+    symbol_config: global_config,
+    app_config_kind,
+    appConfig
+  });
+  if (Object.keys(summary).length === 0) {
+    return {
+      trades,
+      summary,
+      config: custom_b_config,
+      kind: app_config_kind
+    };
+  }
+  const symbol_config = global_config;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, "%.2f"),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(summary.quantity, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(summary.loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    defaultEntry: settings.entry ? to_f(settings.entry, symbol_config.price_places) : null
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    config: {
+      ...custom_b_config,
+      ...result
+    },
+    kind: app_config_kind
+  };
+}
+function defaultTradeFromCurrentState({
+  config,
+  global_config
+}) {
+  const kind = config.entry > config.stop ? "long" : "short";
+  const settings = {
+    entry: config?.entry,
+    stop: config?.stop,
+    risk: config?.risk,
+    distribution: config?.distribution,
+    risk_reward: config?.risk_reward
+  };
+  const appConfig = constructAppConfig2({
+    config,
+    global_config
+  });
+  const trades = buildTrades({
+    appConfig: { [kind]: appConfig },
+    kind,
+    settings
+  });
+  return {
+    trades,
+    summary: generateSummary({
+      trades,
+      fee_percent: global_config.fee_percent
+    })
+  };
+}
+function increaseTradeHelper({
+  increase_qty,
+  stop,
+  config,
+  global_config,
+  style,
+  entry,
+  position: position2,
+  stop_ratio = 1,
+  distribution: default_distribution,
+  distribution_params: default_distribution_params
+}) {
+  const symbol_config = global_config;
+  const kind = config.entry > config.stop ? "long" : "short";
+  const distribution = default_distribution || config.distribution || "inverse-exponential";
+  const distribution_params = default_distribution_params || config.distribution_params;
+  const appConfig = constructAppConfig2({
+    config,
+    global_config
+  });
+  const currentState = defaultTradeFromCurrentState({
+    config,
+    global_config
+  });
+  const { optimal_risk, neg_pnl } = getOptimumStopAndRisk(appConfig, {
+    max_size: increase_qty,
+    target_stop: stop,
+    distribution
+  });
+  if (neg_pnl === 0) {
+    return {
+      trades: [],
+      summary: {},
+      config: {},
+      kind,
+      current: currentState
+    };
+  }
+  const custom_b_config = {
+    entry,
+    stop,
+    risk: style === "minimum" ? Math.abs(neg_pnl) : optimal_risk,
+    distribution,
+    distribution_params
+  };
+  const { result, trades, summary } = helperFuncToBuildTrades({
+    custom_b_config,
+    symbol_config,
+    appConfig,
+    app_config_kind: kind
+  });
+  if (Object.keys(summary).length === 0) {
+    return {
+      trades,
+      summary,
+      config: {
+        ...custom_b_config,
+        ...result
+      },
+      kind,
+      current: currentState
+    };
+  }
+  const new_avg_values = determine_average_entry_and_size([
+    {
+      price: position2.entry,
+      quantity: position2.quantity
+    },
+    {
+      price: summary?.entry,
+      quantity: summary?.quantity
+    }
+  ], symbol_config.decimal_places, symbol_config.price_places);
+  summary.entry = new_avg_values.entry;
+  summary.quantity = new_avg_values.quantity;
+  const loss = Math.abs(summary.entry - custom_b_config.stop) * summary.quantity;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, symbol_config.price_places),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(summary.quantity, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    margin: to_f(summary.entry * summary.quantity / global_config.leverage, "%.2f")
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    stop_order: {
+      quantity: entryDetails.avg_size * stop_ratio,
+      price: entryDetails.stop
+    },
+    config: {
+      ...custom_b_config,
+      ...result
+    },
+    kind,
+    current: currentState
+  };
 }
+function generatePositionIncreaseTrade({
+  account,
+  zoneAccount,
+  ratio = 0.1,
+  config,
+  global_config,
+  style = "minimum",
+  distribution = "inverse-exponential",
+  distribution_params
+}) {
+  const kind = config.entry > config.stop ? "long" : "short";
+  const target_max_quantity = kind === "long" ? account.short.quantity : account.long.quantity;
+  const increase_qty = target_max_quantity * ratio;
+  const entry = zoneAccount.entry;
+  const stop = zoneAccount.stop;
+  return increaseTradeHelper({
+    config,
+    position: account[kind],
+    global_config,
+    entry,
+    stop,
+    style,
+    increase_qty,
+    distribution,
+    distribution_params
+  });
+}
+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,
+  increaseTradeHelper,
+  generatePositionIncreaseTrade
+};
 export {
   to_f,
   sortedBuildConfig,
@@ -2288,10 +3891,14 @@ export {
   getRiskReward,
   getParamForField,
   getOptimumStopAndRisk,
+  getOptimumHedgeFactor,
+  getHedgeZone,
   getDecimalPlaces,
   generate_config_params,
   generateOptimumAppConfig,
+  generateOppositeTradeConfig,
   generateGapTp,
+  generateDangerousConfig,
   formatPrice,
   fibonacci_analysis,
   extractValue,
@@ -2302,13 +3909,21 @@ export {
   determine_average_entry_and_size,
   determine_amount_to_sell2 as determine_amount_to_sell,
   determine_amount_to_buy,
+  determineTPSl,
+  determineRewardFactor,
+  determineOptimumRisk,
   determineOptimumReward,
+  determineCompoundLongTrade,
   createGapPairs,
   createArray,
+  constructAppConfig,
   computeTotalAverageForEachTrade,
   computeSellZones,
   computeRiskReward,
   computeProfitDetail,
+  compoundAPI,
+  calculateFactorFromTakeProfit,
+  calculateFactorFromSellQuantity,
   buildConfig,
   buildAvg,
   buildAppConfig,