@gbozee/ultimate 0.0.2-16 → 0.0.2-161

package/dist/frontend-index.js

@@ -0,0 +1,3070 @@
+// 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,
+  pnl,
+  quantity,
+  leverage = 1,
+  kind = "long"
+}) {
+  const dollar_value = entry / leverage;
+  const position = dollar_value * quantity;
+  if (position) {
+    const percent = pnl / position;
+    const difference = position * percent / quantity;
+    const result = kind === "long" ? difference + entry : entry - difference;
+    return result;
+  }
+  return 0;
+}
+function determine_pnl(entry, close_price, quantity, kind = "long", contract_size) {
+  if (contract_size) {
+    const direction = kind === "long" ? 1 : -1;
+    return quantity * contract_size * direction * (1 / entry - 1 / close_price);
+  }
+  const difference = kind === "long" ? close_price - entry : entry - close_price;
+  return difference * quantity;
+}
+function* _get_zones({
+  current_price,
+  focus,
+  percent_change,
+  places = "%.5f"
+}) {
+  let last = focus;
+  let focus_high = last * (1 + percent_change);
+  let focus_low = last * Math.pow(1 + percent_change, -1);
+  if (focus_high > current_price) {
+    while (focus_high > current_price) {
+      yield to_f(last, places);
+      focus_high = last;
+      last = focus_high * Math.pow(1 + percent_change, -1);
+      focus_low = last * Math.pow(1 + percent_change, -1);
+    }
+  } else {
+    if (focus_high <= current_price) {
+      while (focus_high <= current_price) {
+        yield to_f(focus_high, places);
+        focus_low = focus_high;
+        last = focus_low * (1 + percent_change);
+        focus_high = last * (1 + percent_change);
+      }
+    } else {
+      while (focus_low <= current_price) {
+        yield to_f(focus_high, places);
+        focus_low = focus_high;
+        last = focus_low * (1 + percent_change);
+        focus_high = last * (1 + percent_change);
+      }
+    }
+  }
+}
+
+class Signal {
+  focus;
+  budget;
+  percent_change = 0.02;
+  price_places = "%.5f";
+  decimal_places = "%.0f";
+  zone_risk = 1;
+  fee = 0.08 / 100;
+  support;
+  risk_reward = 4;
+  resistance;
+  risk_per_trade;
+  increase_size = false;
+  additional_increase = 0;
+  minimum_pnl = 0;
+  take_profit;
+  increase_position = false;
+  minimum_size;
+  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";
+  constructor({
+    focus,
+    budget,
+    percent_change = 0.02,
+    price_places = "%.5f",
+    decimal_places = "%.0f",
+    zone_risk = 1,
+    fee = 0.06 / 100,
+    support,
+    risk_reward = 4,
+    resistance,
+    risk_per_trade,
+    increase_size = false,
+    additional_increase = 0,
+    minimum_pnl = 0,
+    take_profit,
+    increase_position = false,
+    minimum_size = 0,
+    first_order_size = 0,
+    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"
+  }) {
+    this.minimum_size = minimum_size;
+    this.first_order_size = first_order_size;
+    this.focus = focus;
+    this.budget = budget;
+    this.percent_change = percent_change;
+    this.price_places = price_places;
+    this.decimal_places = decimal_places;
+    this.zone_risk = zone_risk;
+    this.fee = fee;
+    this.support = support;
+    this.risk_reward = risk_reward;
+    this.resistance = resistance;
+    this.risk_per_trade = risk_per_trade;
+    this.increase_size = increase_size;
+    this.additional_increase = additional_increase;
+    this.minimum_pnl = minimum_pnl;
+    this.take_profit = take_profit;
+    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;
+  }
+  build_entry({
+    current_price,
+    stop_loss,
+    pnl,
+    stop_percent,
+    kind = "long",
+    risk,
+    no_of_trades = 1,
+    take_profit
+  }) {
+    let _stop_loss = stop_loss;
+    if (!_stop_loss && stop_percent) {
+      _stop_loss = kind === "long" ? current_price * Math.pow(1 + stop_percent, -1) : current_price * Math.pow(1 + stop_percent, 1);
+    }
+    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 derivedConfig = {
+      ...this,
+      percent_change,
+      focus: current_price,
+      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
+    };
+    const instance = new Signal(derivedConfig);
+    if (kind === "short") {
+    }
+    let result = instance.get_bulk_trade_zones({ current_price, kind });
+    return result;
+    return result?.filter((x) => {
+      let pp = parseFloat(this.decimal_places.replace("%.", "").replace("f", ""));
+      if (pp < 3) {
+        return true;
+      }
+      if (kind === "long") {
+        return x.entry > x.stop + 0.5;
+      }
+      return x.entry + 0.5 < x.stop;
+    });
+  }
+  get risk() {
+    return this.budget * this.percent_change;
+  }
+  get min_trades() {
+    return parseInt(this.risk.toString());
+  }
+  get min_price() {
+    const number = this.price_places.replace("%.", "").replace("f", "");
+    return 1 * Math.pow(10, -parseInt(number));
+  }
+  build_opposite_order({
+    current_price,
+    kind = "long"
+  }) {
+    let _current_price = current_price;
+    if (kind === "long") {
+      _current_price = current_price * Math.pow(1 + this.percent_change, -1);
+    }
+    const result = this.special_build_orders({
+      current_price: _current_price,
+      kind
+    });
+    const first_price = result[result.length - 1].entry;
+    const stop = result[0].stop;
+    const instance = new Signal({ ...this, take_profit: stop });
+    const new_kind = kind === "long" ? "short" : "long";
+    return instance.build_orders({
+      current_price: first_price,
+      kind: new_kind
+    });
+  }
+  special_build_orders({
+    current_price,
+    kind = "long"
+  }) {
+    let orders = this.build_orders({ current_price, kind });
+    if (orders?.length > 1) {
+      orders = this.build_orders({ current_price: orders[1].entry, kind });
+    }
+    if (orders.length > 0) {
+      const new_kind = kind === "long" ? "short" : "long";
+      let opposite_order = this.build_orders({
+        current_price: orders[orders.length - 1].entry,
+        kind: new_kind
+      });
+      this.take_profit = opposite_order[0].stop;
+      orders = this.build_orders({
+        current_price: orders[orders.length - 1].entry,
+        kind
+      });
+    }
+    return orders;
+  }
+  build_orders({
+    current_price,
+    kind = "long",
+    limit = false,
+    replace_focus = false,
+    max_index = 0,
+    min_index = 2
+  }) {
+    const focus = this.focus;
+    if (replace_focus) {
+      this.focus = current_price;
+    }
+    const new_kind = kind === "long" ? "short" : "long";
+    const take_profit = this.take_profit;
+    this.take_profit = undefined;
+    let result = this.get_bulk_trade_zones({
+      current_price,
+      kind: new_kind,
+      limit
+    });
+    if (result?.length) {
+      let oppositeStop = result[0]["sell_price"];
+      let oppositeEntry = result[result.length - 1]["entry"];
+      let tradeLength = this.risk_reward + 1;
+      let percentChange = Math.abs(1 - Math.max(oppositeEntry, oppositeStop) / Math.min(oppositeEntry, oppositeStop)) / tradeLength;
+      let newTrades = [];
+      for (let x = 0;x < tradeLength; x++) {
+        newTrades.push(oppositeStop * Math.pow(1 + percentChange, x));
+      }
+      if (kind === "short") {
+        newTrades = [];
+        for (let x = 0;x < tradeLength; x++) {
+          newTrades.push(oppositeStop * Math.pow(1 + percentChange, x * -1));
+        }
+      }
+      this.take_profit = take_profit;
+      newTrades = newTrades.map((r) => this.to_f(r));
+      if (kind === "long") {
+        if (newTrades[1] > current_price) {
+          const start = newTrades[0];
+          newTrades = [];
+          for (let x = 0;x < tradeLength; x++) {
+            newTrades.push(start * Math.pow(1 + percentChange, x * -1));
+          }
+          newTrades.sort();
+        }
+      }
+      const newR = this.process_orders({
+        current_price,
+        stop_loss: newTrades[0],
+        trade_zones: newTrades,
+        kind
+      });
+      return newR;
+    }
+    this.focus = focus;
+    return result;
+  }
+  build_orders_old({
+    current_price,
+    kind = "long",
+    limit = false,
+    replace_focus = false,
+    max_index = 0,
+    min_index = 2
+  }) {
+    const focus = this.focus;
+    if (replace_focus) {
+      this.focus = current_price;
+    }
+    const result = this.get_bulk_trade_zones({ current_price, kind, limit });
+    if (result?.length) {
+      let next_focus;
+      if (kind == "long") {
+        next_focus = current_price * (1 + this.percent_change);
+      } else {
+        next_focus = current_price * Math.pow(1 + this.percent_change, -1);
+      }
+      let new_result = this.get_bulk_trade_zones({
+        current_price: next_focus,
+        kind,
+        limit
+      });
+      if (new_result?.length) {
+        for (let i of result) {
+          let condition = kind === "long" ? (a, b) => a >= b : (a, b) => a <= b;
+          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));
+            }
+            i["pnl"] = this.to_df(determine_pnl(i["entry"], i["risk_sell"], i["quantity"], kind));
+          }
+        }
+      }
+    }
+    this.focus = focus;
+    return result;
+  }
+  get_bulk_trade_zones({
+    current_price,
+    kind = "long",
+    limit = false
+  }) {
+    const futures = this.get_future_zones({ current_price, kind });
+    const original = this.zone_risk;
+    if (futures) {
+      const values = futures;
+      if (values) {
+        let trade_zones = values.sort();
+        if (this.resistance) {
+          trade_zones = trade_zones.filter((x) => this.resistance ? x <= this.resistance : true);
+          if (kind === "short") {
+            trade_zones = trade_zones.sort((a, b) => b - a);
+          }
+        }
+        if (trade_zones.length > 0) {
+          const stop_loss = trade_zones[0];
+          const result = this.process_orders({
+            current_price,
+            stop_loss,
+            trade_zones,
+            kind
+          });
+          if (!result.length) {
+            if (kind === "long") {
+              let m_z = this.get_margin_range(futures[0]);
+              if (m_z && m_z[0] < current_price && current_price !== m_z[1]) {
+                return this.get_bulk_trade_zones({
+                  current_price: m_z[1],
+                  kind,
+                  limit
+                });
+              }
+            }
+          }
+          this.zone_risk = original;
+          return result;
+        }
+      }
+    }
+    this.zone_risk = original;
+  }
+  get_future_zones({
+    current_price,
+    kind = "long",
+    raw
+  }) {
+    if (raw) {
+    }
+    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));
+    if (margin_range) {
+      const difference = Math.abs(margin_range[0] - margin_range[1]);
+      const spread = to_f(difference / this.risk_reward, this.price_places);
+      let entries;
+      const percent_change = this.percent_change / this.risk_reward;
+      if (kind === "long") {
+        entries = Array.from({ length: Math.floor(this.risk_reward) + 1 }, (_, x) => to_f(margin_range[1] - spread * x, this.price_places));
+      } else {
+        entries = Array.from({ length: Math.floor(this.risk_reward) + 1 }, (_, x) => to_f(margin_range[1] * Math.pow(1 + percent_change, x), this.price_places));
+      }
+      if (Math.min(...entries) < this.to_f(current_price) && this.to_f(current_price) < Math.max(...entries)) {
+        return entries.sort((a, b) => a - b);
+      }
+      if (remaining_zones.length > 0) {
+        let new_range = remaining_zones[0];
+        let entries2 = [];
+        let x = 0;
+        if (new_range) {
+          while (entries2.length < this.risk_reward + 1) {
+            if (kind === "long") {
+              let value = this.to_f(new_range[1] - spread * x);
+              if (value <= current_price) {
+                entries2.push(value);
+              }
+            } else {
+              let value = this.to_f(new_range[1] * Math.pow(1 + percent_change, x));
+              if (value >= current_price) {
+                entries2.push(value);
+              }
+            }
+            x += 1;
+          }
+        }
+        return entries2.sort((a, b) => a - b);
+      }
+      if (remaining_zones.length === 0 && this.to_f(current_price) <= Math.min(...entries)) {
+        const next_focus = margin_range[0] * Math.pow(1 + this.percent_change, -1);
+        let entries2 = [];
+        let x = 0;
+        while (entries2.length < this.risk_reward + 1) {
+          if (kind === "long") {
+            let value = this.to_f(next_focus - spread * x);
+            if (value <= this.to_f(current_price)) {
+              entries2.push(value);
+            }
+          } else {
+            let value = this.to_f(next_focus * Math.pow(1 + percent_change, x));
+            if (value >= this.to_f(current_price)) {
+              entries2.push(value);
+            }
+          }
+          x += 1;
+        }
+        return entries2.sort((a, b) => a - b);
+      }
+      return entries.sort((a, b) => a - b);
+    }
+    return [];
+  }
+  to_f(value, places) {
+    return to_f(value, places || this.price_places);
+  }
+  get_margin_zones({
+    current_price,
+    kind = "long"
+  }) {
+    if (this.support && kind === "long") {
+      let result = [];
+      let start = current_price;
+      let counter = 0;
+      while (start > this.support) {
+        let v = this.get_margin_range(start);
+        if (v) {
+          result.push(v);
+          start = v[0] - this.min_price;
+          counter += 1;
+        }
+        if (counter > 10) {
+          break;
+        }
+      }
+      return result;
+    }
+    if (this.resistance) {
+      let result = [];
+      let start = current_price;
+      let counter = 0;
+      while (start < this.resistance) {
+        let v = this.get_margin_range(start);
+        if (v) {
+          result.push(v);
+          start = v[1] + this.min_price;
+        }
+        if (counter > 10) {
+          break;
+        }
+      }
+      return result;
+    }
+    return [this.get_margin_range(current_price)];
+  }
+  get_margin_range(current_price, kind = "long") {
+    const diff = -this.min_price;
+    const zones = _get_zones({
+      current_price: current_price + diff,
+      focus: this.focus,
+      percent_change: this.percent_change,
+      places: this.price_places
+    }) || [];
+    const top_zones = [];
+    for (const i of zones) {
+      if (i < 0.00000001) {
+        break;
+      }
+      top_zones.push(this.to_f(i));
+    }
+    if (top_zones.length > 0) {
+      const result = top_zones[top_zones.length - 1];
+      return [this.to_f(result), this.to_f(result * (1 + this.percent_change))];
+    }
+    return null;
+  }
+  process_orders({
+    current_price,
+    stop_loss,
+    trade_zones,
+    kind = "long"
+  }) {
+    const number_of_orders = trade_zones.slice(1).length;
+    let take_profit = stop_loss * (1 + 2 * this.percent_change);
+    if (kind === "short") {
+      take_profit = stop_loss * Math.pow(1 + 2 * this.percent_change, -1);
+    }
+    if (this.take_profit) {
+      take_profit = this.take_profit;
+    }
+    if (number_of_orders > 0) {
+      const risk_per_trade = this.get_risk_per_trade(number_of_orders);
+      let limit_orders = trade_zones.slice(1).filter((x) => x <= this.to_f(current_price));
+      let market_orders = trade_zones.slice(1).filter((x) => x > this.to_f(current_price));
+      if (kind === "short") {
+        limit_orders = trade_zones.slice(1).filter((x) => x >= this.to_f(current_price));
+        market_orders = trade_zones.slice(1).filter((x) => x < this.to_f(current_price));
+      }
+      if (market_orders.length === 1) {
+        limit_orders = limit_orders.concat(market_orders);
+        market_orders = [];
+      }
+      const increase_position = Boolean(this.support) && this.increase_position;
+      const market_trades = limit_orders.length > 0 ? market_orders.map((x, i) => {
+        const defaultStopLoss = i === 0 ? limit_orders[limit_orders.length - 1] : market_orders[i - 1];
+        const y = this.build_trade_dict({
+          entry: x,
+          stop: increase_position ? this.support : defaultStopLoss,
+          risk: risk_per_trade,
+          arr: market_orders,
+          index: i,
+          kind,
+          start: market_orders.length + limit_orders.length,
+          take_profit
+        });
+        return y;
+      }).filter((y) => y) : [];
+      let total_incurred_market_fees = 0;
+      if (market_trades.length > 0) {
+        let first = market_trades[0];
+        if (first) {
+          total_incurred_market_fees += first.incurred;
+          total_incurred_market_fees += first.fee;
+        }
+      }
+      const default_gap = this.gap;
+      const gap_pairs = createGapPairs(limit_orders, default_gap);
+      const limit_trades = (limit_orders.map((x, i) => {
+        let _base = limit_orders[i - 1];
+        let _stops = gap_pairs.find((o) => o[0] === x);
+        if (!_stops) {
+          return;
+        }
+        if (_stops) {
+          _base = _stops[1];
+        }
+        const defaultStopLoss = i === 0 ? stop_loss : _base;
+        const new_stop = kind === "long" ? this.support : stop_loss;
+        let risk_to_use = risk_per_trade;
+        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;
+          console.log({ risk_per_trade, theoretical_kelly });
+        }
+        const y = this.build_trade_dict({
+          entry: x,
+          stop: (this.increase_position ? new_stop : defaultStopLoss) || defaultStopLoss,
+          risk: risk_to_use,
+          arr: limit_orders,
+          index: i,
+          new_fees: total_incurred_market_fees,
+          kind,
+          start: market_orders.length + limit_orders.length,
+          take_profit
+        });
+        if (y) {
+          y.new_stop = defaultStopLoss;
+        }
+        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;
+        }
+        return true;
+      });
+      let total_orders = limit_trades.concat(market_trades);
+      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);
+        let less_than_min_size = total_orders.filter((o) => o ? o.quantity < this.minimum_size : true) || total_orders;
+        less_than_min_size = groupIntoPairsWithSumLessThan(less_than_min_size, this.minimum_size, "quantity", this.first_order_size);
+        less_than_min_size = less_than_min_size.map((q, i) => {
+          let avg_entry = determine_average_entry_and_size(q.map((o) => ({
+            price: o.entry,
+            quantity: o.quantity
+          })), this.decimal_places, this.price_places);
+          let candidate = q[0];
+          candidate.entry = avg_entry.price;
+          candidate.quantity = avg_entry.quantity;
+          return candidate;
+        });
+        less_than_min_size = less_than_min_size.map((q, i) => {
+          let new_stop = q.new_stop;
+          if (i > 0) {
+            new_stop = less_than_min_size[i - 1].entry;
+          }
+          return {
+            ...q,
+            new_stop
+          };
+        });
+        if (greater_than_min_size.length !== total_orders.length) {
+          payload = greater_than_min_size.concat(less_than_min_size);
+        }
+        return payload;
+      }
+      return total_orders;
+    }
+    return [];
+  }
+  get_risk_per_trade(number_of_orders) {
+    if (this.risk_per_trade) {
+      return this.risk_per_trade;
+    }
+    return this.zone_risk / number_of_orders;
+  }
+  build_trade_dict({
+    entry,
+    stop,
+    risk,
+    arr,
+    index,
+    new_fees = 0,
+    kind = "long",
+    start = 0,
+    take_profit
+  }) {
+    const considered = arr.map((x, i) => i).filter((i) => i > index);
+    const with_quantity = considered.map((x) => {
+      const q = determine_position_size({
+        entry: arr[x],
+        stop: arr[x - 1],
+        budget: risk,
+        places: this.decimal_places
+      });
+      if (!q) {
+        return;
+      }
+      if (this.minimum_size) {
+        if (q < this.minimum_size) {
+          return;
+        }
+      }
+      return { quantity: q, entry: arr[x] };
+    }).filter((x) => x);
+    if (this.increase_size) {
+      const arr_length = with_quantity.length;
+      with_quantity.forEach((x, i) => {
+        if (x) {
+          x.quantity = x.quantity * (arr_length - i);
+        }
+      });
+    }
+    const fees = with_quantity.map((x) => {
+      return this.to_df(this.fee * x.quantity * x.entry);
+    });
+    const previous_risks = with_quantity.map((x) => {
+      return this.to_df(risk);
+    });
+    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) {
+    }
+    let quantity = determine_position_size({
+      entry,
+      stop,
+      budget: risk,
+      places: this.decimal_places,
+      min_size: this.minimum_size
+    });
+    if (!quantity) {
+      return;
+    }
+    if (this.increase_size) {
+      quantity = quantity * multiplier;
+      const new_risk = determine_pnl(entry, stop, quantity, kind);
+      risk = Math.abs(new_risk);
+    }
+    const fee = this.to_df(this.fee * quantity * entry);
+    const increment = Math.abs(arr.length - (index + 1));
+    let pnl = this.to_df(risk) * (this.risk_reward + increment);
+    if (this.minimum_pnl) {
+      pnl = this.minimum_pnl + fee;
+    }
+    let sell_price = determine_close_price({ entry, pnl, quantity, kind });
+    if (take_profit && !this.minimum_pnl) {
+      sell_price = take_profit;
+      pnl = this.to_df(determine_pnl(entry, sell_price, quantity, kind));
+      pnl = pnl + fee;
+      sell_price = determine_close_price({ entry, pnl, quantity, kind });
+    }
+    let risk_sell = sell_price;
+    return {
+      entry,
+      risk: this.to_df(risk),
+      quantity,
+      sell_price: this.to_f(sell_price),
+      risk_sell: this.to_f(risk_sell),
+      stop,
+      pnl,
+      fee,
+      net: this.to_df(pnl - fee),
+      incurred: this.to_df(incurred_fees + new_fees),
+      stop_percent: this.to_df(Math.abs(entry - stop) / entry)
+    };
+  }
+  to_df(currentPrice, places = "%.3f") {
+    return to_f(currentPrice, places);
+  }
+}
+
+// src/helpers/pnl.ts
+function determine_position_size2(entry, stop, budget) {
+  let stop_percent = Math.abs(entry - stop) / entry;
+  let size = budget / stop_percent / entry;
+  return size;
+}
+function determine_risk(entry, stop, quantity) {
+  let stop_percent = Math.abs(entry - stop) / entry;
+  let risk = quantity * stop_percent * entry;
+  return risk;
+}
+function determine_close_price2(entry, pnl, quantity, kind, single = false, leverage = 1) {
+  const dollar_value = entry / leverage;
+  const position = dollar_value * quantity;
+  if (position) {
+    let percent = pnl / position;
+    let difference = position * percent / quantity;
+    let result;
+    if (kind === "long") {
+      result = difference + entry;
+    } else {
+      result = entry - difference;
+    }
+    if (single) {
+      return result;
+    }
+    return result;
+  }
+  return 0;
+}
+function determine_amount_to_sell(entry, quantity, sell_price, pnl, kind, places = "%.3f") {
+  const _pnl = determine_pnl2(entry, sell_price, quantity, kind);
+  const ratio = pnl / to_f2(Math.abs(_pnl), places);
+  quantity = quantity * ratio;
+  return to_f2(quantity, places);
+}
+function determine_pnl2(entry, close_price, quantity, kind, contract_size, places = "%.2f") {
+  if (contract_size) {
+    const direction = kind === "long" ? 1 : -1;
+    return quantity * contract_size * direction * (1 / entry - 1 / close_price);
+  }
+  let difference = entry - close_price;
+  if (kind === "long") {
+    difference = close_price - entry;
+  }
+  return to_f2(difference * quantity, places);
+}
+function position(entry, quantity, kind, leverage = 1) {
+  const direction = { long: 1, short: -1 };
+  return parseFloat((direction[kind] * quantity * (entry / leverage)).toFixed(3));
+}
+function to_f2(value, places) {
+  if (value) {
+    let pp = parseInt(places.replace("%.", "").replace("f", ""));
+    return parseFloat(value.toFixed(pp));
+  }
+  return value;
+}
+var value = {
+  determine_risk,
+  determine_position_size: determine_position_size2,
+  determine_close_price: determine_close_price2,
+  determine_pnl: determine_pnl2,
+  position,
+  determine_amount_to_sell,
+  to_f: to_f2
+};
+var pnl_default = value;
+
+// src/helpers/trade_utils.ts
+function profitHelper(longPosition, shortPosition, config, contract_size, balance = 0) {
+  let long = { takeProfit: 0, quantity: 0, pnl: 0 };
+  let short = { takeProfit: 0, quantity: 0, pnl: 0 };
+  if (longPosition) {
+    long = config?.getSize2(longPosition, contract_size, balance) || null;
+  }
+  if (shortPosition) {
+    short = config?.getSize2(shortPosition, contract_size, balance) || null;
+  }
+  return { long, short };
+}
+function getParamForField(self, configs, field, isGroup) {
+  if (isGroup === "group" && field === "checkbox") {
+    return configs.filter((o) => o.kind === field && o.group === true).map((o) => {
+      let _self = self;
+      let value2 = _self[o.name];
+      return { ...o, value: value2 };
+    });
+  }
+  let r = configs.find((o) => o.name == field);
+  if (r) {
+    let oo = self;
+    let tt = oo[r.name] || "";
+    r.value = tt;
+  }
+  return r;
+}
+function getTradeEntries(entry, min_size, kind, size, spread = 0) {
+  let result = [];
+  let index = 0;
+  let no_of_trades = size > min_size ? Math.round(size / min_size) : 1;
+  while (index < no_of_trades) {
+    if (kind === "long") {
+      result.push({ entry: entry - index * spread, size: min_size });
+    } else {
+      result.push({ entry: entry + index * spread, size: min_size });
+    }
+    index = index + 1;
+  }
+  return result;
+}
+function extractValue(_param, condition) {
+  let param;
+  if (condition) {
+    try {
+      let value2 = JSON.parse(_param || "[]");
+      param = value2.map((o) => parseFloat(o));
+    } catch (error) {
+    }
+  } else {
+    param = parseFloat(_param);
+  }
+  return param;
+}
+function asCoins(symbol) {
+  let _type = symbol.toLowerCase().includes("usdt") ? "usdt" : "coin";
+  if (symbol.toLowerCase() == "btcusdt") {
+    _type = "usdt";
+  }
+  let result = _type === "usdt" ? symbol.toLowerCase().includes("usdt") ? "USDT" : "BUSD" : symbol.toUpperCase().split("USD_")[0];
+  if (symbol.toLowerCase().includes("-")) {
+    result = result.split("-")[0];
+  }
+  if (symbol.toLowerCase() == "usdt-usd") {
+  }
+  let result2 = _type == "usdt" ? symbol.split(result)[0] : result;
+  if (result.includes("-")) {
+    result2 = result;
+  }
+  return result2;
+}
+var SpecialCoins = ["NGN", "USDT", "BUSD", "PAX", "USDC", "EUR"];
+function allCoins(symbols) {
+  let r = symbols.map((o, i) => asCoins(o));
+  return [...new Set(r), ...SpecialCoins];
+}
+function formatPrice(value2, opts = {}) {
+  const { locale = "en-US", currency = "USD" } = opts;
+  const formatter = new Intl.NumberFormat(locale, {
+    currency,
+    style: "currency",
+    maximumFractionDigits: 2
+  });
+  return formatter.format(value2);
+}
+function to_f(value2, places = "%.1f") {
+  let v = typeof value2 === "string" ? parseFloat(value2) : value2;
+  const formattedValue = places.replace("%.", "").replace("f", "");
+  return parseFloat(v.toFixed(parseInt(formattedValue)));
+}
+function determine_stop_and_size(entry, pnl, take_profit, kind = "long") {
+  const difference = kind === "long" ? take_profit - entry : entry - take_profit;
+  const quantity = pnl / difference;
+  return Math.abs(quantity);
+}
+var range = (start, stop, step = 1) => Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step);
+function determine_amount_to_sell2(entry, quantity, sell_price, pnl, kind, places = "%.3f") {
+  const _pnl = determine_pnl(entry, sell_price, quantity, kind);
+  const ratio = pnl / to_f(Math.abs(_pnl), places);
+  quantity = quantity * ratio;
+  return to_f(quantity, places);
+}
+function determine_position_size({
+  entry,
+  stop,
+  budget,
+  percent,
+  min_size,
+  notional_value,
+  as_coin = true,
+  places = "%.3f"
+}) {
+  let stop_percent = stop ? Math.abs(entry - stop) / entry : percent;
+  if (stop_percent && budget) {
+    let size = budget / stop_percent;
+    let notion_value = size * entry;
+    if (notional_value && notional_value > notion_value) {
+      size = notional_value / entry;
+    }
+    if (as_coin) {
+      size = size / entry;
+      if (min_size && min_size === 1) {
+        return to_f(Math.round(size), places);
+      }
+    }
+    return to_f(size, places);
+  }
+  return;
+}
+function determine_remaining_entry({
+  risk,
+  max_size,
+  stop_loss,
+  kind,
+  position: position2
+}) {
+  const avg_entry = determine_avg_entry_based_on_max_size({
+    risk,
+    max_size,
+    stop_loss,
+    kind
+  });
+  const result = avg_entry * max_size - position2.quantity * position2.entry;
+  return result / (max_size - position2.quantity);
+}
+function determine_avg_entry_based_on_max_size({
+  risk,
+  max_size,
+  stop_loss,
+  kind = "long"
+}) {
+  const diff = max_size * stop_loss;
+  if (kind === "long") {
+    return (risk + diff) / max_size;
+  }
+  return (risk - diff) / max_size;
+}
+function determine_average_entry_and_size(orders, places = "%.3f", price_places = "%.1f") {
+  const sum_values = orders.reduce((sum, order) => sum + order.price * order.quantity, 0);
+  const total_quantity = orders.reduce((sum, order) => sum + order.quantity, 0);
+  const avg_price = total_quantity ? to_f(sum_values / total_quantity, price_places) : 0;
+  return {
+    entry: avg_price,
+    price: avg_price,
+    quantity: to_f(total_quantity, places)
+  };
+}
+var createArray = (start, stop, step) => {
+  const result = [];
+  let current = start;
+  while (current <= stop) {
+    result.push(current);
+    current += step;
+  }
+  return result;
+};
+var groupBy = (xs, key) => {
+  return xs.reduce((rv, x) => {
+    (rv[x[key]] = rv[x[key]] || []).push(x);
+    return rv;
+  }, {});
+};
+function fibonacci_analysis({
+  support,
+  resistance,
+  kind = "long",
+  trend = "long",
+  places = "%.1f"
+}) {
+  const swing_high = trend === "long" ? resistance : support;
+  const swing_low = trend === "long" ? support : resistance;
+  const ranges = [0, 0.236, 0.382, 0.5, 0.618, 0.789, 1, 1.272, 1.414, 1.618];
+  const fib_calc = (p, h, l) => p * (h - l) + l;
+  const fib_values = ranges.map((x) => fib_calc(x, swing_high, swing_low)).map((x) => to_f(x, places));
+  if (kind === "short") {
+    return trend === "long" ? fib_values.reverse() : fib_values;
+  } else {
+    return trend === "short" ? fib_values.reverse() : fib_values;
+  }
+  return fib_values;
+}
+var groupIntoPairs = (arr, size) => {
+  const result = [];
+  for (let i = 0;i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+};
+var groupIntoPairsWithSumLessThan = (arr, targetSum, key = "quantity", firstSize = 0) => {
+  if (firstSize) {
+    const totalSize = arr.reduce((sum, order) => sum + order[key], 0);
+    const remainingSize = totalSize - firstSize;
+    let newSum = 0;
+    let newArray = [];
+    let lastIndex = 0;
+    for (let i = 0;i < arr.length; i++) {
+      if (newSum < remainingSize) {
+        newSum += arr[i][key];
+        newArray.push(arr[i]);
+        lastIndex = i;
+      }
+    }
+    const lastGroup = arr.slice(lastIndex + 1);
+    const previousPair = groupInPairs(newArray, key, targetSum);
+    if (lastGroup.length > 0) {
+      previousPair.push(lastGroup);
+    }
+    return previousPair;
+  }
+  return groupInPairs(arr, key, targetSum);
+};
+function groupInPairs(_arr, key, targetSum) {
+  const result = [];
+  let currentSum = 0;
+  let currentGroup = [];
+  for (let i = 0;i < _arr.length; i++) {
+    currentSum += _arr[i][key];
+    currentGroup.push(_arr[i]);
+    if (currentSum >= targetSum) {
+      result.push(currentGroup);
+      currentGroup = [];
+      currentSum = 0;
+    }
+  }
+  return result;
+}
+var computeTotalAverageForEachTrade = (trades, config) => {
+  let _take_profit = config.take_profit;
+  let kind = config.kind;
+  let entryToUse = kind === "short" ? Math.min(config.entry, config.stop) : Math.max(config.entry, config.stop);
+  let _currentEntry = config.currentEntry || entryToUse;
+  let less = trades.filter((p) => kind === "long" ? p.entry <= _currentEntry : p.entry >= _currentEntry);
+  let rrr = trades.map((r, i) => {
+    let considered = [];
+    if (kind === "long") {
+      considered = trades.filter((p) => p.entry > _currentEntry);
+    } else {
+      considered = trades.filter((p) => p.entry < _currentEntry);
+    }
+    const x_pnl = 0;
+    const remaining = less.filter((o) => {
+      if (kind === "long") {
+        return o.entry >= r.entry;
+      }
+      return o.entry <= r.entry;
+    });
+    if (remaining.length === 0) {
+      return { ...r, pnl: x_pnl };
+    }
+    const start = kind === "long" ? Math.max(...remaining.map((o) => o.entry)) : Math.min(...remaining.map((o) => o.entry));
+    considered = considered.map((o) => ({ ...o, entry: start }));
+    considered = considered.concat(remaining);
+    let avg_entry = determine_average_entry_and_size([
+      ...considered.map((o) => ({
+        price: o.entry,
+        quantity: o.quantity
+      })),
+      {
+        price: _currentEntry,
+        quantity: config.currentQty || 0
+      }
+    ], config.decimal_places, config.price_places);
+    let _pnl = r.pnl;
+    let sell_price = r.sell_price;
+    let entry_pnl = r.pnl;
+    if (_take_profit) {
+      _pnl = pnl_default.determine_pnl(avg_entry.price, _take_profit, avg_entry.quantity, kind);
+      sell_price = _take_profit;
+      entry_pnl = pnl_default.determine_pnl(r.entry, _take_profit, avg_entry.quantity, kind);
+    }
+    const loss = pnl_default.determine_pnl(avg_entry.price, r.stop, avg_entry.quantity, kind);
+    let new_stop = r.new_stop;
+    const entry_loss = pnl_default.determine_pnl(r.entry, new_stop, avg_entry.quantity, kind);
+    let min_profit = 0;
+    let min_entry_profit = 0;
+    if (config.min_profit) {
+      min_profit = pnl_default.determine_close_price(avg_entry.price, config.min_profit, avg_entry.quantity, kind);
+      min_entry_profit = pnl_default.determine_close_price(r.entry, config.min_profit, avg_entry.quantity, kind);
+    }
+    let x_fee = r.fee;
+    if (config.fee) {
+      x_fee = config.fee * r.stop * avg_entry.quantity;
+    }
+    let tp_close = pnl_default.determine_close_price(r.entry, Math.abs(entry_loss) * (config.rr || 1) + x_fee, avg_entry.quantity, kind);
+    return {
+      ...r,
+      x_fee: to_f(x_fee, "%.2f"),
+      avg_entry: avg_entry.price,
+      avg_size: avg_entry.quantity,
+      entry_pnl: to_f(entry_pnl, "%.2f"),
+      entry_loss: to_f(entry_loss, "%.2f"),
+      min_entry_pnl: to_f(min_entry_profit, "%.2f"),
+      pnl: _pnl,
+      neg_pnl: to_f(loss, "%.2f"),
+      sell_price,
+      close_p: to_f(tp_close, "%.2f"),
+      min_pnl: to_f(min_profit, "%.2f"),
+      new_stop
+    };
+  });
+  return rrr;
+};
+function getDecimalPlaces(numberString) {
+  let parts = numberString.toString().split(".");
+  if (parts.length == 2) {
+    return parts[1].length;
+  }
+  return 0;
+}
+function createGapPairs(arr, gap, item) {
+  if (arr.length === 0) {
+    return [];
+  }
+  const result = [];
+  const firstElement = arr[0];
+  for (let i = arr.length - 1;i >= 0; i--) {
+    const current = arr[i];
+    const gapIndex = i - gap;
+    const pairedElement = gapIndex < 0 ? firstElement : arr[gapIndex];
+    if (current !== pairedElement) {
+      result.push([current, pairedElement]);
+    }
+  }
+  if (item) {
+    let r = result.find((o) => o[0] === item);
+    return r ? [r] : [];
+  }
+  return result;
+}
+function logWithLineNumber(...args) {
+  const stack = new Error().stack;
+  const lines = stack?.split(`
+`).slice(2).map((line) => line.trim());
+  const lineNumber = lines?.[0]?.split(":").pop();
+  console.log(`${lineNumber}:`, ...args);
+}
+function computeSellZones(payload) {
+  const { entry, exit, zones = 10 } = payload;
+  const gap = exit / entry;
+  const factor = Math.pow(gap, 1 / zones);
+  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,
+  stop,
+  raw_instance,
+  risk,
+  no_of_trades,
+  min_profit = 0,
+  risk_reward,
+  kind,
+  increase,
+  gap,
+  rr = 1,
+  price_places = "%.1f",
+  decimal_places = "%.3f",
+  use_kelly = false,
+  kelly_confidence_factor = 0.95,
+  kelly_minimum_risk = 0.2,
+  kelly_prediction_model = "exponential",
+  kelly_func = "theoretical"
+}) {
+  let fee = app_config.fee / 100;
+  let working_risk = risk || app_config.risk_per_trade;
+  let trade_no = no_of_trades || app_config.risk_reward;
+  const config = {
+    focus: app_config.focus,
+    fee,
+    budget: app_config.budget,
+    risk_reward: risk_reward || trade_no,
+    support: app_config.support,
+    resistance: app_config.resistance,
+    price_places: app_config.price_places || price_places,
+    decimal_places,
+    percent_change: app_config.percent_change / app_config.tradeSplit,
+    risk_per_trade: working_risk,
+    take_profit: take_profit || app_config.take_profit,
+    increase_position: increase,
+    minimum_size: app_config.min_size,
+    entry,
+    stop,
+    kind: app_config.kind,
+    gap,
+    min_profit: min_profit || app_config.min_profit,
+    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
+  };
+  const instance = new Signal(config);
+  if (raw_instance) {
+    return instance;
+  }
+  if (!stop) {
+    return [];
+  }
+  const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
+  if (kind === "short") {
+  }
+  console.log({ entry, stop, condition, working_risk, config });
+  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
+  }) || [] : [];
+  return computeTotalAverageForEachTrade(result, config);
+}
+function buildAvg({
+  _trades,
+  kind
+}) {
+  let avg = determine_average_entry_and_size(_trades?.map((r) => ({
+    price: r.entry,
+    quantity: r.quantity
+  })) || []);
+  const stop_prices = _trades.map((o) => o.stop);
+  const stop_loss = kind === "long" ? Math.min(...stop_prices) : Math.max(...stop_prices);
+  avg.pnl = pnl_default.determine_pnl(avg.price, stop_loss, avg.quantity, kind);
+  return avg;
+}
+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) => {
+    return getMaxQuantity(x.quantity, app_config);
+  });
+  return sorted.map((k, i) => {
+    const arrSet = sorted.slice(0, i + 1);
+    const avg_values = determine_average_entry_and_size(arrSet.map((u) => ({ price: u.entry, quantity: u.quantity })), app_config.decimal_places, app_config.price_places);
+    return {
+      ...k,
+      reverse_avg_entry: avg_values.price,
+      reverse_avg_quantity: avg_values.quantity
+    };
+  });
+}
+function get_app_config_and_max_size(config, payload) {
+  const app_config = {
+    kind: payload.kind,
+    entry: payload.entry,
+    stop: payload.stop,
+    risk_per_trade: config.risk,
+    risk_reward: config.risk_reward || 199,
+    support: to_f(config.support, config.price_places),
+    resistance: to_f(config.resistance, config.price_places),
+    focus: payload.entry,
+    fee: 0,
+    percent_change: config.stop_percent / 100,
+    tradeSplit: 1,
+    gap: 1,
+    min_size: config.min_size,
+    budget: 0,
+    price_places: config.price_places,
+    decimal_places: config.decimal_places,
+    min_profit: config.profit_percent * config.profit / 100,
+    symbol: config.symbol,
+    max_quantity: config.max_quantity
+  };
+  const initialResult = sortedBuildConfig(app_config, {
+    entry: app_config.entry,
+    stop: app_config.stop,
+    kind: app_config.kind,
+    risk: app_config.risk_per_trade,
+    risk_reward: app_config.risk_reward,
+    increase: true,
+    gap: app_config.gap,
+    price_places: app_config.price_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
+  });
+  const max_size = initialResult[0]?.avg_size;
+  const last_value = initialResult[0];
+  const entries = initialResult.map((x) => ({
+    entry: x.entry,
+    avg_entry: x.avg_entry,
+    avg_size: x.avg_size,
+    neg_pnl: x.neg_pnl,
+    quantity: x.quantity
+  }));
+  return {
+    app_config,
+    max_size,
+    last_value,
+    entries
+  };
+}
+function buildAppConfig(config, payload) {
+  const { app_config, max_size, last_value, entries } = get_app_config_and_max_size({
+    ...config,
+    risk: payload.risk,
+    profit: payload.profit || 500,
+    risk_reward: payload.risk_reward,
+    accounts: [],
+    reduce_percent: 90,
+    reverse_factor: 1,
+    profit_percent: 0,
+    kind: payload.entry > payload.stop ? "long" : "short",
+    symbol: payload.symbol
+  }, {
+    entry: payload.entry,
+    stop: payload.stop,
+    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
+  });
+  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
+  };
+  return app_config;
+}
+function getOptimumStopAndRisk(app_config, params) {
+  const { max_size, target_stop } = 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);
+  let high_stop = isLong ? Math.min(target_stop + stopRange, app_config.entry) : target_stop + stopRange;
+  let optimal_stop = target_stop;
+  let best_stop_result = null;
+  let best_entry_diff = Infinity;
+  console.log(`Finding optimal stop for ${isLong ? "LONG" : "SHORT"} position. Target: ${target_stop}, Search range: ${low_stop} to ${high_stop}`);
+  let iterations = 0;
+  const MAX_ITERATIONS = 50;
+  while (Math.abs(high_stop - low_stop) > 0.1 && iterations < MAX_ITERATIONS) {
+    iterations++;
+    const mid_stop = (low_stop + high_stop) / 2;
+    const result = sortedBuildConfig(app_config, {
+      entry: app_config.entry,
+      stop: mid_stop,
+      kind: app_config.kind,
+      risk: app_config.risk_per_trade,
+      risk_reward: app_config.risk_reward,
+      increase: true,
+      gap: app_config.gap,
+      price_places: app_config.price_places,
+      decimal_places: app_config.decimal_places
+    });
+    if (result.length === 0) {
+      if (isLong) {
+        low_stop = mid_stop;
+      } else {
+        high_stop = mid_stop;
+      }
+      continue;
+    }
+    const first_entry = result[0].entry;
+    const entry_diff = Math.abs(first_entry - target_stop);
+    console.log(`Stop: ${mid_stop.toFixed(2)}, First Entry: ${first_entry.toFixed(2)}, Diff: ${entry_diff.toFixed(2)}`);
+    if (entry_diff < best_entry_diff) {
+      best_entry_diff = entry_diff;
+      optimal_stop = mid_stop;
+      best_stop_result = result;
+    }
+    if (first_entry < target_stop) {
+      if (isLong) {
+        low_stop = mid_stop;
+      } else {
+        low_stop = mid_stop;
+      }
+    } else {
+      if (isLong) {
+        high_stop = mid_stop;
+      } else {
+        high_stop = mid_stop;
+      }
+    }
+    if (entry_diff < 1)
+      break;
+  }
+  console.log(`Found optimal stop: ${optimal_stop.toFixed(2)} that gives first_entry: ${best_stop_result?.[0]?.entry?.toFixed(2)}, difference: ${best_entry_diff.toFixed(2)} after ${iterations} iterations`);
+  let low_risk = 10;
+  let high_risk = params.highest_risk || 2000;
+  let optimal_risk = app_config.risk_per_trade;
+  let best_size_result = best_stop_result;
+  let best_size_diff = Infinity;
+  console.log(`Finding optimal risk_per_trade for size target: ${max_size} (never exceeding it)`);
+  iterations = 0;
+  while (Math.abs(high_risk - low_risk) > 0.1 && iterations < MAX_ITERATIONS) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const result = sortedBuildConfig(app_config, {
+      entry: app_config.entry,
+      stop: optimal_stop,
+      kind: app_config.kind,
+      risk: mid_risk,
+      risk_reward: app_config.risk_reward,
+      increase: true,
+      gap: app_config.gap,
+      price_places: app_config.price_places,
+      decimal_places: app_config.decimal_places
+    });
+    if (result.length === 0) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const first_entry = result[0];
+    const avg_size = first_entry.avg_size;
+    console.log(`Risk: ${mid_risk.toFixed(2)}, Avg Size: ${avg_size.toFixed(4)}, Target: ${max_size}`);
+    if (avg_size <= max_size) {
+      const size_diff = max_size - avg_size;
+      if (size_diff < best_size_diff) {
+        best_size_diff = size_diff;
+        optimal_risk = mid_risk;
+        best_size_result = result;
+      }
+      low_risk = mid_risk;
+    } else {
+      high_risk = mid_risk;
+    }
+    if (best_size_diff < 0.001)
+      break;
+  }
+  console.log(`Found optimal risk_per_trade: ${optimal_risk.toFixed(2)} that gives avg_size: ${best_size_result?.[0]?.avg_size?.toFixed(4)}, difference: ${best_size_diff.toFixed(4)} after ${iterations} iterations`);
+  let final_risk = optimal_risk;
+  let final_result = best_size_result;
+  if (best_size_result?.[0]?.avg_size < max_size) {
+    console.log(`Current avg_size (${best_size_result?.[0].avg_size.toFixed(4)}) is less than target (${max_size}). Increasing risk to reach target...`);
+    let current_risk = optimal_risk;
+    const risk_increment = 5;
+    iterations = 0;
+    while (iterations < MAX_ITERATIONS) {
+      iterations++;
+      current_risk += risk_increment;
+      if (current_risk > 5000)
+        break;
+      const result = sortedBuildConfig(app_config, {
+        entry: app_config.entry,
+        stop: optimal_stop,
+        kind: app_config.kind,
+        risk: current_risk,
+        risk_reward: app_config.risk_reward,
+        increase: true,
+        gap: app_config.gap,
+        price_places: app_config.price_places,
+        decimal_places: app_config.decimal_places
+      });
+      if (result.length === 0)
+        continue;
+      const avg_size = result[0].avg_size;
+      console.log(`Increased Risk: ${current_risk.toFixed(2)}, New Avg Size: ${avg_size.toFixed(4)}`);
+      if (avg_size >= max_size) {
+        final_risk = current_risk;
+        final_result = result;
+        console.log(`Target size reached! Final risk: ${final_risk.toFixed(2)}, Final avg_size: ${avg_size.toFixed(4)}`);
+        break;
+      }
+    }
+  }
+  return {
+    optimal_stop: to_f(optimal_stop, app_config.price_places),
+    optimal_risk: to_f(final_risk, app_config.price_places),
+    avg_size: final_result?.[0]?.avg_size || 0,
+    avg_entry: final_result?.[0]?.avg_entry || 0,
+    result: final_result,
+    first_entry: final_result?.[0]?.entry || 0,
+    neg_pnl: final_result?.[0]?.neg_pnl || 0,
+    risk_reward: app_config.risk_reward,
+    size_diff: Math.abs((final_result?.[0]?.avg_size || 0) - max_size),
+    entry_diff: best_entry_diff
+  };
+}
+function generate_config_params(app_config, payload) {
+  const { result, ...optimum } = getOptimumStopAndRisk(app_config, {
+    max_size: app_config.max_size,
+    highest_risk: payload.risk * 2,
+    target_stop: app_config.stop
+  });
+  return {
+    entry: payload.entry,
+    stop: optimum.optimal_stop,
+    avg_size: optimum.avg_size,
+    avg_entry: optimum.avg_entry,
+    risk_reward: payload.risk_reward,
+    neg_pnl: optimum.neg_pnl,
+    risk: payload.risk
+  };
+}
+function determine_break_even_price(payload) {
+  const { long_position, short_position, fee_percent = 0.05 / 100 } = payload;
+  const long_notional = long_position.entry * long_position.quantity;
+  const short_notional = short_position.entry * short_position.quantity;
+  const net_quantity = long_position.quantity - short_position.quantity;
+  const net_capital = Math.abs(long_notional - short_notional);
+  const break_even_price = net_capital / (Math.abs(net_quantity) + fee_percent * Math.abs(net_quantity));
+  return {
+    price: break_even_price,
+    direction: net_quantity > 0 ? "long" : "short"
+  };
+}
+function determine_amount_to_buy(payload) {
+  const {
+    orders,
+    kind,
+    decimal_places = "%.3f",
+    position: position2,
+    existingOrders
+  } = payload;
+  const totalQuantity = orders.reduce((sum, order) => sum + (order.quantity || 0), 0);
+  let runningTotal = to_f(totalQuantity, decimal_places);
+  let sortedOrders = [...orders].sort((a, b) => (a.entry || 0) - (b.entry || 0));
+  if (kind === "short") {
+    sortedOrders.reverse();
+  }
+  const withCumulative = [];
+  for (const order of sortedOrders) {
+    withCumulative.push({
+      ...order,
+      cumulative_quantity: runningTotal
+    });
+    runningTotal -= order.quantity;
+    runningTotal = to_f(runningTotal, decimal_places);
+  }
+  let filteredOrders = withCumulative.filter((order) => (order.cumulative_quantity || 0) > position2?.quantity).map((order) => ({
+    ...order,
+    price: order.entry,
+    kind,
+    side: kind.toLowerCase() === "long" ? "buy" : "sell"
+  }));
+  filteredOrders = filteredOrders.filter((k) => !existingOrders.map((j) => j.price).includes(k.price));
+  return filteredOrders;
+}
+function generateOptimumAppConfig(config, payload, position2) {
+  let low_risk = payload.start_risk;
+  let high_risk = payload.max_risk || 50000;
+  let best_risk = null;
+  let best_app_config = null;
+  const tolerance = 0.1;
+  const max_iterations = 150;
+  let iterations = 0;
+  while (high_risk - low_risk > tolerance && iterations < max_iterations) {
+    iterations++;
+    const mid_risk = (low_risk + high_risk) / 2;
+    const {
+      app_config: current_app_config,
+      max_size,
+      last_value,
+      entries
+    } = get_app_config_and_max_size({
+      ...config,
+      risk: mid_risk,
+      profit_percent: config.profit_percent || 0,
+      profit: config.profit || 500,
+      risk_reward: payload.risk_reward,
+      kind: position2.kind,
+      price_places: config.price_places,
+      decimal_places: config.decimal_places,
+      accounts: config.accounts || [],
+      reduce_percent: config.reduce_percent || 90,
+      reverse_factor: config.reverse_factor || 1,
+      symbol: config.symbol || "",
+      support: config.support || 0,
+      resistance: config.resistance || 0,
+      min_size: config.min_size || 0,
+      stop_percent: config.stop_percent || 0
+    }, {
+      entry: payload.entry,
+      stop: payload.stop,
+      kind: position2.kind
+    });
+    current_app_config.max_size = max_size;
+    current_app_config.last_value = last_value;
+    current_app_config.entries = entries;
+    current_app_config.risk_reward = payload.risk_reward;
+    const full_trades = sortedBuildConfig(current_app_config, {
+      entry: current_app_config.entry,
+      stop: current_app_config.stop,
+      kind: current_app_config.kind,
+      risk: current_app_config.risk_per_trade,
+      risk_reward: current_app_config.risk_reward,
+      increase: true,
+      gap: current_app_config.gap,
+      price_places: current_app_config.price_places,
+      decimal_places: current_app_config.decimal_places
+    });
+    if (full_trades.length === 0) {
+      high_risk = mid_risk;
+      continue;
+    }
+    const trades = determine_amount_to_buy({
+      orders: full_trades,
+      kind: position2.kind,
+      decimal_places: current_app_config.decimal_places,
+      price_places: current_app_config.price_places,
+      position: position2,
+      existingOrders: []
+    });
+    if (trades.length === 0) {
+      low_risk = mid_risk;
+      continue;
+    }
+    const last_trade = trades[trades.length - 1];
+    const last_entry = last_trade.entry;
+    if (position2.kind === "long") {
+      if (last_entry > position2.entry) {
+        high_risk = mid_risk;
+      } else {
+        best_risk = mid_risk;
+        best_app_config = current_app_config;
+        low_risk = mid_risk;
+      }
+    } else {
+      if (last_entry < position2.entry) {
+        high_risk = mid_risk;
+      } else {
+        best_risk = mid_risk;
+        best_app_config = current_app_config;
+        low_risk = mid_risk;
+      }
+    }
+  }
+  if (iterations >= max_iterations) {
+    console.warn(`generateAppConfig: Reached max iterations (${max_iterations}) without converging. Returning best found result.`);
+  } else if (best_app_config) {
+    console.log(`Search finished. Best Risk: ${best_risk?.toFixed(2)}, Final Last Entry: ${best_app_config.last_value?.entry?.toFixed(4)}`);
+  } else {
+    console.warn(`generateAppConfig: Could not find a valid risk configuration.`);
+  }
+  if (!best_app_config) {
+    return null;
+  }
+  best_app_config.entries = determine_amount_to_buy({
+    orders: best_app_config.entries,
+    kind: position2.kind,
+    decimal_places: best_app_config.decimal_places,
+    price_places: best_app_config.price_places,
+    position: position2,
+    existingOrders: []
+  });
+  return best_app_config;
+}
+function determineOptimumReward(payload) {
+  const {
+    app_config,
+    increase = true,
+    low_range = 1,
+    high_range = 199,
+    target_loss
+  } = payload;
+  const criterion = app_config.strategy || "quantity";
+  const risk_rewards = createArray(low_range, high_range, 1);
+  let func = risk_rewards.map((trade_no) => {
+    let trades = sortedBuildConfig(app_config, {
+      take_profit: app_config.take_profit,
+      entry: app_config.entry,
+      stop: app_config.stop,
+      no_of_trades: trade_no,
+      risk_reward: trade_no,
+      increase,
+      kind: app_config.kind,
+      gap: app_config.gap,
+      decimal_places: app_config.decimal_places
+    });
+    let total = 0;
+    let max = -Infinity;
+    let min = Infinity;
+    let neg_pnl = trades[0]?.neg_pnl || 0;
+    let entry = trades.at(-1)?.entry;
+    if (!entry) {
+      return null;
+    }
+    for (let trade of trades) {
+      total += trade.quantity;
+      max = Math.max(max, trade.quantity);
+      min = Math.min(min, trade.quantity);
+      entry = app_config.kind === "long" ? Math.max(entry, trade.entry) : Math.min(entry, trade.entry);
+    }
+    return {
+      result: trades,
+      value: trade_no,
+      total,
+      risk_per_trade: app_config.risk_per_trade,
+      max,
+      min,
+      neg_pnl,
+      entry
+    };
+  });
+  func = func.filter((r) => Boolean(r));
+  if (target_loss === undefined) {
+    func = func.filter((r) => {
+      let foundIndex = r?.result.findIndex((e) => e.quantity === r.max);
+      return criterion === "quantity" ? foundIndex === 0 : true;
+    });
+  }
+  if (target_loss !== undefined) {
+    const validResults = func.filter((r) => Math.abs(r.neg_pnl) <= target_loss);
+    if (validResults.length > 0) {
+      validResults.sort((a, b) => {
+        const diffA = target_loss - Math.abs(a.neg_pnl);
+        const diffB = target_loss - Math.abs(b.neg_pnl);
+        return diffA - diffB;
+      });
+      if (app_config.raw) {
+        return validResults[0];
+      }
+      return validResults[0]?.value;
+    } else {
+      func.sort((a, b) => Math.abs(a.neg_pnl) - Math.abs(b.neg_pnl));
+      if (app_config.raw) {
+        return func[0];
+      }
+      return func[0]?.value;
+    }
+  }
+  const highest = criterion === "quantity" ? Math.max(...func.map((o) => o.max)) : Math.min(...func.map((o) => o.entry));
+  const key = criterion === "quantity" ? "max" : "entry";
+  const index = findIndexByCondition(func, app_config.kind, (x) => x[key] == highest, criterion);
+  if (app_config.raw) {
+    return func[index];
+  }
+  return func[index]?.value;
+}
+function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
+  const found = [];
+  let max_new_diff = 0;
+  let new_lst = lst.map((i, j) => ({
+    ...i,
+    net_diff: lst[j].neg_pnl + lst[j].risk_per_trade
+  }));
+  new_lst.forEach((item, index) => {
+    if (item.net_diff > 0) {
+      found.push(index);
+    }
+  });
+  if (found.length === 0) {
+    max_new_diff = Math.max(...new_lst.map((e) => e.net_diff));
+    found.push(new_lst.findIndex((e) => e.net_diff === max_new_diff));
+  }
+  const sortedFound = found.map((o, index) => ({ ...new_lst[o], index: o })).filter((j) => max_new_diff === 0 ? j.net_diff > 0 : j.net_diff >= max_new_diff).sort((a, b) => {
+    if (a.total !== b.total) {
+      return b.total - a.total;
+      return b.net_diff - a.net_diff;
+      return a.net_diff - b.net_diff;
+    } else {
+      return b.net_diff - a.net_diff;
+    }
+  });
+  console.log("found", sortedFound);
+  if (defaultKey === "quantity") {
+    return sortedFound[0].index;
+  }
+  if (found.length === 1) {
+    return found[0];
+  }
+  if (found.length === 0) {
+    return -1;
+  }
+  const entryCondition = (a, b) => {
+    if (kind == "long") {
+      return a.entry > b.entry;
+    }
+    return a.entry < b.entry;
+  };
+  const maximum = found.reduce((maxIndex, currentIndex) => {
+    return new_lst[currentIndex]["net_diff"] < new_lst[maxIndex]["net_diff"] && entryCondition(new_lst[currentIndex], new_lst[maxIndex]) ? currentIndex : maxIndex;
+  }, 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, target_loss } = payload;
+  const kind = entry > stop ? "long" : "short";
+  app_config.kind = kind;
+  app_config.entry = entry;
+  app_config.stop = stop;
+  app_config.risk_per_trade = risk_per_trade;
+  const result = determineOptimumReward({ app_config, target_loss });
+  return result;
+}
+function getRiskReward(payload) {
+  const {
+    entry,
+    stop,
+    risk,
+    global_config,
+    force_exact_risk = false,
+    target_loss
+  } = payload;
+  const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
+    entry,
+    stop,
+    risk_reward: 30,
+    risk,
+    symbol: global_config.symbol
+  });
+  const risk_reward = computeRiskReward({
+    app_config,
+    entry,
+    stop,
+    risk_per_trade: risk,
+    target_loss
+  });
+  if (force_exact_risk) {
+    const new_risk_per_trade = determineOptimumRisk(global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: global_config.symbol
+    }, {
+      highest_risk: risk
+    }).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,
+    full_ratio = 1
+  } = payload;
+  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;
+  if (reduce_position) {
+    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;
+    new_pnl = to_f(pnl - expected_loss, "%.2f");
+  }
+  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 * full_ratio,
+    price_places,
+    decimal_places
+  };
+}
+function generateGapTp(payload) {
+  const {
+    long,
+    short,
+    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;
+  const longPercent = gapLoss * factor / (short.entry * short.quantity);
+  const shortPercent = gapLoss * factor / (long.entry * long.quantity);
+  const longTp = to_f((1 + longPercent) * long.entry, price_places);
+  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 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 {
+    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
+    },
+    gap: to_f(gap, price_places),
+    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 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
+  });
+  const risk_reward = computeRiskReward({
+    app_config,
+    entry: stop,
+    stop: tp,
+    risk_per_trade: opposite_pnl,
+    target_loss: opposite_pnl
+  });
+  return {
+    entry: to_f(stop, global_config.price_places),
+    stop: to_f(tp, global_config.price_places),
+    risk: to_f(opposite_pnl, "%.2f"),
+    risk_reward
+  };
+}
+function constructAppConfig(payload) {
+  const { account, global_config, kelly_config } = payload;
+  const config = account.expand?.b_config;
+  if (!config) {
+    return null;
+  }
+  const kelly = config.kelly;
+  const options = {
+    entry: config?.entry,
+    stop: config?.stop,
+    risk_reward: config?.risk_reward,
+    risk: config?.risk,
+    symbol: account.symbol,
+    use_kelly: kelly_config?.use_kelly ?? kelly?.use_kelly,
+    kelly_confidence_factor: kelly_config?.kelly_confidence_factor ?? kelly?.kelly_confidence_factor,
+    kelly_minimum_risk: kelly_config?.kelly_minimum_risk ?? kelly?.kelly_minimum_risk,
+    kelly_prediction_model: kelly_config?.kelly_prediction_model ?? kelly?.kelly_prediction_model
+  };
+  const appConfig = buildAppConfig(global_config, options);
+  return appConfig;
+}
+// src/helpers/strategy.ts
+class Strategy {
+  position;
+  dominant_position = "long";
+  config;
+  constructor(payload) {
+    this.position = {
+      long: payload.long,
+      short: payload.short
+    };
+    this.dominant_position = payload.dominant_position || "long";
+    this.config = payload.config;
+    if (!this.config.fee_percent) {
+      this.config.fee_percent = 0.05;
+    }
+  }
+  get price_places() {
+    return this.config.global_config.price_places;
+  }
+  get decimal_places() {
+    return this.config.global_config.decimal_places;
+  }
+  to_f(price) {
+    return to_f(price, this.price_places);
+  }
+  to_df(quantity) {
+    return to_f(quantity, this.decimal_places);
+  }
+  pnl(kind, _position) {
+    const position2 = _position || this.position[kind];
+    const { entry, quantity } = position2;
+    const notional = entry * quantity;
+    let tp_percent = this.config.tp_percent;
+    if (kind == "short") {
+      tp_percent = tp_percent * this.config.short_tp_factor;
+    }
+    const profit = notional * (tp_percent / 100);
+    return this.to_f(profit);
+  }
+  tp(kind) {
+    let position2 = this.position[kind];
+    if (position2.quantity == 0) {
+      const reverse_kind = kind == "long" ? "short" : "long";
+      position2 = this.position[reverse_kind];
+    }
+    const { entry, quantity } = position2;
+    const profit = this.pnl(kind, position2);
+    const diff = profit / (quantity || 1);
+    return this.to_f(kind == "long" ? entry + diff : entry - diff);
+  }
+  calculate_fee(position2) {
+    const { price, quantity } = position2;
+    const fee = price * quantity * this.config.fee_percent / 100;
+    return this.to_f(fee);
+  }
+  get long_tp() {
+    return this.tp("long");
+  }
+  get short_tp() {
+    return this.tp("short");
+  }
+  generateGapClosingAlgorithm(payload) {
+    const {
+      kind,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
+    const { entry, quantity } = this.position[kind];
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    let _entry = this.tp(kind);
+    let _stop = this.tp(reverse_kind);
+    const second_payload = {
+      entry: _entry,
+      stop: _stop,
+      risk_reward: this.config.risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
+    const third_payload = {
+      entry,
+      quantity,
+      kind
+    };
+    const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
+    let entries = [];
+    let risk_per_trade = this.config.budget;
+    let last_value = null;
+    if (app_config) {
+      let { entries: _entries, ...rest } = app_config;
+      entries = _entries;
+      risk_per_trade = rest.risk_per_trade;
+      last_value = rest.last_value;
+      if (ignore_entries) {
+        entries = [];
+      }
+      console.log({ app_config });
+    }
+    const risk = this.to_f(risk_per_trade);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < (reverse_position.entry || focus_position.entry);
+    }) : entries.filter((u) => {
+      return u.entry > (reverse_position.entry || focus_position.entry);
+    });
+    const threshold = below_reverse_entries.at(-1);
+    const result = this.gapCloserHelper({
+      risk,
+      entries,
+      kind,
+      sell_factor,
+      reduce_ratio
+    });
+    return {
+      ...result,
+      last_entry: last_value?.entry,
+      first_entry: entries.at(-1)?.entry,
+      threshold
+    };
+  }
+  gapCloserHelper(payload) {
+    const {
+      risk,
+      entries = [],
+      kind,
+      sell_factor = 1,
+      reduce_ratio = 1
+    } = payload;
+    const { entry, quantity } = this.position[kind];
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    let _entry = this.tp(kind);
+    let _stop = this.tp(reverse_kind);
+    const second_payload = {
+      entry: _entry,
+      stop: _stop,
+      risk_reward: this.config.risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
+    const adjusted_focus_entries = entries.map((entry2) => {
+      let adjusted_price = entry2.price;
+      if (focus_position.quantity > 0) {
+        if (kind === "long" && entry2.price >= focus_position.entry) {
+          adjusted_price = focus_position.entry;
+        } else if (kind === "short" && entry2.price <= focus_position.entry) {
+          adjusted_price = focus_position.entry;
+        }
+      }
+      return {
+        price: adjusted_price,
+        quantity: entry2.quantity
+      };
+    });
+    const avg = determine_average_entry_and_size(adjusted_focus_entries.concat([
+      {
+        price: entry,
+        quantity
+      }
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const focus_loss = this.to_f(Math.abs(avg.price - second_payload.stop) * avg.quantity);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < (reverse_position.entry || focus_position.entry);
+    }) : entries.filter((u) => {
+      return u.entry > (reverse_position.entry || focus_position.entry);
+    });
+    const threshold = below_reverse_entries.at(-1);
+    let adjusted_reverse_entries = entries.map((entry2) => {
+      let adjusted_price = entry2.price;
+      if (threshold) {
+        if (reverse_kind === "short" && entry2.price > threshold.entry) {
+          adjusted_price = threshold.entry;
+        } else if (reverse_kind === "long" && entry2.price < threshold.entry) {
+          adjusted_price = threshold.entry;
+        }
+      }
+      return {
+        price: adjusted_price,
+        quantity: entry2.quantity
+      };
+    });
+    const reverse_avg = determine_average_entry_and_size(adjusted_reverse_entries.concat([
+      {
+        price: reverse_position.entry,
+        quantity: reverse_position.quantity
+      }
+    ]), this.config.global_config.decimal_places, this.config.global_config.price_places);
+    const sell_quantity = this.to_df(reverse_avg.quantity * sell_factor);
+    const reverse_pnl = this.to_f(Math.abs(reverse_avg.price - second_payload.stop) * sell_quantity);
+    const fee_to_pay = this.calculate_fee({
+      price: avg.entry,
+      quantity: avg.quantity
+    }) + this.calculate_fee({
+      price: reverse_avg.entry,
+      quantity: sell_quantity
+    });
+    const net_reverse_pnl = reverse_pnl - fee_to_pay;
+    const ratio = net_reverse_pnl * reduce_ratio / focus_loss;
+    const quantity_to_sell = this.to_df(ratio * avg.quantity);
+    const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    const incurred_loss = this.to_f((avg.price - second_payload.stop) * quantity_to_sell);
+    return {
+      risk,
+      risk_reward: this.config.risk_reward,
+      [kind]: {
+        avg_entry: avg.entry,
+        avg_size: avg.quantity,
+        loss: focus_loss,
+        stop: second_payload.stop,
+        stop_quantity: quantity_to_sell,
+        re_entry_quantity: remaining_quantity,
+        initial_pnl: this.pnl(kind),
+        tp: second_payload.entry,
+        incurred_loss
+      },
+      [reverse_kind]: {
+        avg_entry: reverse_avg.entry,
+        avg_size: reverse_avg.quantity,
+        pnl: reverse_pnl,
+        tp: second_payload.stop,
+        re_entry_quantity: remaining_quantity,
+        initial_pnl: this.pnl(reverse_kind),
+        remaining_quantity: this.to_df(reverse_avg.quantity - sell_quantity)
+      },
+      spread: Math.abs(avg.entry - reverse_avg.entry),
+      gap_loss: to_f(Math.abs(avg.entry - reverse_avg.entry) * reverse_avg.quantity, "%.2f"),
+      net_profit: incurred_loss + reverse_pnl
+    };
+  }
+  runIterations(payload) {
+    const {
+      kind,
+      iterations,
+      ignore_entries = false,
+      reduce_ratio = 1,
+      sell_factor = 1
+    } = payload;
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const result = [];
+    let position2 = {
+      long: this.position.long,
+      short: this.position.short
+    };
+    let tp_percent_multiplier = 1;
+    let short_tp_factor_multiplier = 1;
+    for (let i = 0;i < iterations; i++) {
+      const instance = new Strategy({
+        long: position2.long,
+        short: position2.short,
+        config: {
+          ...this.config,
+          tp_percent: this.config.tp_percent * tp_percent_multiplier,
+          short_tp_factor: this.config.short_tp_factor * short_tp_factor_multiplier
+        }
+      });
+      const algorithm = instance.generateGapClosingAlgorithm({
+        kind,
+        ignore_entries,
+        reduce_ratio,
+        sell_factor
+      });
+      if (!algorithm) {
+        console.log("No algorithm found");
+        return result;
+        break;
+      }
+      result.push(algorithm);
+      position2[kind] = {
+        entry: algorithm[kind].avg_entry,
+        quantity: algorithm[kind].re_entry_quantity
+      };
+      let reverse_entry = algorithm[reverse_kind].tp;
+      let reverse_quantity = algorithm[reverse_kind].re_entry_quantity;
+      if (algorithm[reverse_kind].remaining_quantity > 0) {
+        const purchase_to_occur = {
+          price: reverse_entry,
+          quantity: algorithm[reverse_kind].remaining_quantity
+        };
+        const avg = determine_average_entry_and_size([
+          purchase_to_occur,
+          {
+            price: algorithm[reverse_kind].avg_entry,
+            quantity: reverse_quantity - algorithm[reverse_kind].remaining_quantity
+          }
+        ], this.config.global_config.decimal_places, this.config.global_config.price_places);
+        reverse_entry = avg.entry;
+        reverse_quantity = avg.quantity;
+        if (reverse_kind === "short") {
+          short_tp_factor_multiplier = 2;
+        } else {
+          tp_percent_multiplier = 2;
+        }
+      }
+      position2[reverse_kind] = {
+        entry: reverse_entry,
+        quantity: reverse_quantity
+      };
+    }
+    return result;
+  }
+  getPositionAfterTp(payload) {
+    const { kind, include_fees = false } = payload;
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    const focus_tp = this.tp(kind);
+    const focus_pnl = this.pnl(kind);
+    const fees = include_fees ? this.calculate_fee({
+      price: focus_tp,
+      quantity: focus_position.quantity
+    }) * 2 : 0;
+    const expected_loss = (focus_pnl - fees) * this.config.reduce_ratio;
+    const actual_loss = Math.abs(focus_tp - reverse_position.entry) * reverse_position.quantity;
+    const ratio = expected_loss / actual_loss;
+    const loss_quantity = this.to_df(ratio * reverse_position.quantity);
+    const remaining_quantity = this.to_df(reverse_position.quantity - loss_quantity);
+    const diff = focus_pnl - expected_loss;
+    return {
+      [kind]: {
+        entry: focus_tp,
+        quantity: remaining_quantity
+      },
+      [reverse_kind]: {
+        entry: reverse_position.entry,
+        quantity: remaining_quantity
+      },
+      pnl: {
+        [kind]: focus_pnl,
+        [reverse_kind]: -expected_loss,
+        diff
+      },
+      spread: this.to_f(Math.abs(focus_tp - reverse_position.entry) * remaining_quantity)
+    };
+  }
+  getPositionAfterIteration(payload) {
+    const { kind, iterations, with_fees = false } = payload;
+    let _result = this.getPositionAfterTp({
+      kind,
+      include_fees: with_fees
+    });
+    const result = [_result];
+    for (let i = 0;i < iterations - 1; i++) {
+      const instance = new Strategy({
+        long: _result.long,
+        short: _result.short,
+        config: {
+          ...this.config,
+          tp_percent: this.config.tp_percent + (i + 1) * 0.3
+        }
+      });
+      _result = instance.getPositionAfterTp({
+        kind,
+        include_fees: with_fees
+      });
+      result.push(_result);
+    }
+    return result;
+  }
+  generateOppositeTrades(payload) {
+    const { kind, risk_factor = 0.5, avg_entry } = payload;
+    const entry = avg_entry || this.position[kind].entry;
+    const stop = this.tp(kind);
+    const risk = this.pnl(kind) * risk_factor;
+    const risk_reward = getRiskReward({
+      entry,
+      stop,
+      risk,
+      global_config: this.config.global_config
+    });
+    const { entries, last_value, ...app_config } = buildAppConfig(this.config.global_config, {
+      entry,
+      stop,
+      risk_reward,
+      risk,
+      symbol: this.config.global_config.symbol
+    });
+    const trades_to_place = determine_amount_to_buy({
+      orders: entries,
+      kind: app_config.kind,
+      decimal_places: app_config.decimal_places,
+      price_places: app_config.price_places,
+      position: this.position[app_config.kind],
+      existingOrders: []
+    });
+    const avg = determine_average_entry_and_size(trades_to_place.map((u) => ({
+      price: u.entry,
+      quantity: u.quantity
+    })).concat([
+      {
+        price: this.position[app_config.kind].entry,
+        quantity: this.position[app_config.kind].quantity
+      }
+    ]), app_config.decimal_places, app_config.price_places);
+    const expected_loss = to_f(Math.abs(avg.price - stop) * avg.quantity, "%.2f");
+    const profit_percent = to_f(this.pnl(kind) * 100 / (avg.price * avg.quantity), "%.3f");
+    app_config.entry = this.to_f(app_config.entry);
+    app_config.stop = this.to_f(app_config.stop);
+    return { ...app_config, avg, loss: -expected_loss, profit_percent };
+  }
+  identifyGapConfig(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
+    });
+  }
+  analyzeProfit(payload) {
+    const { reward_factor = 1, max_reward_factor, risk, kind } = payload;
+    const focus_position = this.position[kind];
+    const result = computeProfitDetail({
+      focus_position: {
+        kind,
+        entry: focus_position.entry,
+        quantity: focus_position.quantity,
+        avg_price: focus_position.avg_price,
+        avg_qty: focus_position.avg_qty
+      },
+      pnl: this.pnl(kind),
+      strategy: {
+        reward_factor,
+        max_reward_factor,
+        risk
+      }
+    });
+    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
+    };
+  }
+}
+export {
+  to_f,
+  sortedBuildConfig,
+  range,
+  profitHelper,
+  logWithLineNumber,
+  groupIntoPairsWithSumLessThan,
+  groupIntoPairs,
+  groupBy,
+  get_app_config_and_max_size,
+  getTradeEntries,
+  getRiskReward,
+  getParamForField,
+  getOptimumStopAndRisk,
+  getOptimumHedgeFactor,
+  getHedgeZone,
+  getDecimalPlaces,
+  generate_config_params,
+  generateOptimumAppConfig,
+  generateOppositeTradeConfig,
+  generateGapTp,
+  formatPrice,
+  fibonacci_analysis,
+  extractValue,
+  determine_stop_and_size,
+  determine_remaining_entry,
+  determine_position_size,
+  determine_break_even_price,
+  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,
+  buildConfig,
+  buildAvg,
+  buildAppConfig,
+  asCoins,
+  allCoins,
+  Strategy,
+  SpecialCoins
+};