@gbozee/ultimate 0.0.2-next.7 → 0.0.2-next.70

package/dist/frontend-index.js

@@ -9,7 +9,13 @@ function generateArithmetic(payload) {
   });
 }
 function generateGeometric(payload) {
-  const { margin_range, risk_reward, kind, price_places = "%.1f", percent_change } = payload;
+  const {
+    margin_range,
+    risk_reward,
+    kind,
+    price_places = "%.1f",
+    percent_change
+  } = payload;
   const effectivePercentChange = percent_change ?? Math.abs(margin_range[1] / margin_range[0] - 1) / risk_reward;
   return Array.from({ length: risk_reward + 1 }, (_, i) => {
     const price = kind === "long" ? margin_range[1] * Math.pow(1 - effectivePercentChange, i) : margin_range[0] * Math.pow(1 + effectivePercentChange, i);
@@ -31,7 +37,13 @@ function approximateInverseNormal(p) {
   }
 }
 function generateNormal(payload) {
-  const { margin_range, risk_reward, kind, price_places = "%.1f", stdDevFactor = 6 } = payload;
+  const {
+    margin_range,
+    risk_reward,
+    kind,
+    price_places = "%.1f",
+    stdDevFactor = 6
+  } = payload;
   const mean = (margin_range[0] + margin_range[1]) / 2;
   const stdDev = Math.abs(margin_range[1] - margin_range[0]) / stdDevFactor;
   const skew = kind === "long" ? -0.2 : 0.2;
@@ -46,23 +58,45 @@ function generateNormal(payload) {
   return entries.sort((a, b) => a - b);
 }
 function generateExponential(payload) {
-  const { margin_range, risk_reward, kind, price_places = "%.1f", lambda } = payload;
+  const {
+    margin_range,
+    risk_reward,
+    kind,
+    price_places = "%.1f",
+    lambda,
+    reverse = false
+  } = payload;
   const range = Math.abs(margin_range[1] - margin_range[0]);
   const effectiveLambda = lambda || 2.5;
+  const normalizationFactor = 1 - Math.exp(-effectiveLambda);
   return Array.from({ length: risk_reward + 1 }, (_, i) => {
     const t = i / risk_reward;
-    const exponentialProgress = 1 - Math.exp(-effectiveLambda * t);
-    const price = kind === "long" ? margin_range[1] - range * exponentialProgress : margin_range[0] + range * exponentialProgress;
+    const rawProgress = 1 - Math.exp(-effectiveLambda * t);
+    const exponentialProgress = rawProgress / normalizationFactor;
+    let price = kind === "long" ? margin_range[1] - range * exponentialProgress : margin_range[0] + range * exponentialProgress;
+    if (reverse) {
+      price = kind === "long" ? margin_range[0] + range * exponentialProgress : margin_range[1] - range * exponentialProgress;
+    }
     return to_f(price, price_places);
   });
 }
 function generateInverseExponential(payload) {
-  const { margin_range, risk_reward, kind, price_places = "%.1f", curveFactor = 2 } = payload;
+  const {
+    margin_range,
+    risk_reward,
+    kind,
+    price_places = "%.1f",
+    curveFactor = 2,
+    reverse = false
+  } = payload;
   const range = Math.abs(margin_range[1] - margin_range[0]);
   return Array.from({ length: risk_reward + 1 }, (_, i) => {
     const t = i / risk_reward;
     const progress = (Math.exp(curveFactor * t) - 1) / (Math.exp(curveFactor) - 1);
-    const price = kind === "long" ? margin_range[1] - range * progress : margin_range[0] + range * progress;
+    let price = kind === "long" ? margin_range[1] - range * progress : margin_range[0] + range * progress;
+    if (reverse) {
+      price = kind === "long" ? margin_range[0] + range * progress : margin_range[1] - range * progress;
+    }
     return to_f(price, price_places);
   });
 }
@@ -91,8 +125,7 @@ function getEntries(params) {
         margin_range,
         risk_reward,
         kind,
-        price_places,
-        percent_change: distribution_params?.curveFactor
+        price_places
       });
       break;
     case "normal":
@@ -113,6 +146,16 @@ function getEntries(params) {
         lambda: distribution_params?.lambda
       });
       break;
+    case "reverse-exponential":
+      entries = generateExponential({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        lambda: distribution_params?.lambda,
+        reverse: true
+      });
+      break;
     case "inverse-exponential":
       entries = generateInverseExponential({
         margin_range,
@@ -122,12 +165,53 @@ function getEntries(params) {
         curveFactor: distribution_params?.curveFactor
       });
       break;
+    case "reverse-inverse-exponential":
+      entries = generateInverseExponential({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        curveFactor: distribution_params?.curveFactor,
+        reverse: true
+      });
+      break;
+    case "lognormal":
+      entries = generateLognormal({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        stdDevFactor: distribution_params?.stdDevFactor
+      });
+      break;
     default:
       throw new Error(`Unknown distribution type: ${distribution}`);
   }
   return entries.sort((a, b) => a - b);
 }
 var distributions_default = getEntries;
+function generateLognormal(payload) {
+  const {
+    margin_range,
+    risk_reward,
+    kind,
+    price_places = "%.1f",
+    stdDevFactor = 6
+  } = payload;
+  const logMin = Math.log(margin_range[0]);
+  const logMax = Math.log(margin_range[1]);
+  const mean = (logMin + logMax) / 2;
+  const stdDev = Math.abs(logMax - logMin) / stdDevFactor;
+  const entries = Array.from({ length: risk_reward + 1 }, (_, i) => {
+    const p = (i + 0.5) / (risk_reward + 1);
+    const z = approximateInverseNormal(p);
+    let logPrice = mean + stdDev * z;
+    logPrice = Math.max(logMin, Math.min(logMax, logPrice));
+    const price = Math.exp(logPrice);
+    return to_f(kind === "long" ? Math.min(price, margin_range[1]) : Math.max(price, margin_range[0]), price_places);
+  });
+  return entries.sort((a, b) => a - b);
+}
 
 // src/helpers/optimizations.ts
 function calculateTheoreticalKelly({
@@ -501,7 +585,7 @@ class Signal {
     const simple_support = Math.min(current_price, stop_loss);
     const simple_resistance = Math.max(current_price, stop_loss);
     const risk_per_trade = risk / this.risk_reward;
-    const use_progressive = distribution_params.use_progressive || this.use_progressive_risk;
+    const use_progressive = distribution_params?.use_progressive || this.use_progressive_risk;
     const risk_distribution = use_progressive ? {
       enabled: true,
       total_risk_budget: risk,
@@ -1296,6 +1380,9 @@ function formatPrice(value2, opts = {}) {
   return formatter.format(value2);
 }
 function to_f(value2, places = "%.1f") {
+  if (!value2) {
+    return null;
+  }
   let v = typeof value2 === "string" ? parseFloat(value2) : value2;
   const formattedValue = places.replace("%.", "").replace("f", "");
   return parseFloat(v.toFixed(parseInt(formattedValue)));
@@ -1654,7 +1741,7 @@ function buildConfig(app_config, {
   min_avg_size = 0,
   distribution,
   distribution_params,
-  use_progressive_risk
+  use_progressive_risk = false
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -1696,7 +1783,7 @@ function buildConfig(app_config, {
   if (!stop) {
     return [];
   }
-  const condition = (kind === "long" ? entry > app_config.support : entry >= app_config.support) && stop >= app_config.support * 0.999;
+  const condition = true;
   if (kind === "short") {}
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
@@ -2179,7 +2266,7 @@ function determineOptimumReward(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, {
+    const pp = {
       take_profit: app_config.take_profit,
       entry: app_config.entry,
       stop: app_config.stop,
@@ -2191,7 +2278,8 @@ function determineOptimumReward(payload) {
       decimal_places: app_config.decimal_places,
       distribution,
       distribution_params: payload.distribution_params
-    });
+    };
+    let trades = sortedBuildConfig(app_config, pp);
     let total = 0;
     let max = -Infinity;
     let min = Infinity;
@@ -2282,7 +2370,6 @@ function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
       return b.net_diff - a.net_diff;
     }
   });
-  console.log("found", sortedFound);
   if (defaultKey === "quantity") {
     return sortedFound[0].index;
   }
@@ -2913,6 +3000,52 @@ function generateDangerousConfig(payload) {
     risk_reward: optimumRiskReward
   };
 }
+function computeMarginProtection({
+  entry,
+  quantity,
+  tp,
+  stop_loss,
+  avg_price,
+  avg_qty,
+  next_order,
+  base_asset,
+  symbol
+}) {
+  const pnl = Math.abs(tp.price - entry) * quantity;
+  const loss = Math.abs(avg_price - stop_loss.price) * avg_qty;
+  const margin_position = pnl / Math.abs(next_order - tp.price);
+  const protect_position = loss / Math.abs(stop_loss.price - tp.price);
+  const ideal_protect_position = loss / Math.abs(next_order - stop_loss.price);
+  const places = {
+    BTCUSDT: "%.5f",
+    ETHUSDT: "%.4f",
+    BNBUSDT: "%.3f"
+  };
+  const price_places = {
+    BTCUSDT: "%.2f",
+    ETHUSDT: "%.2f",
+    BNBUSDT: "%.2f"
+  };
+  let quantity_to_place = protect_position;
+  if (base_asset > 0) {
+    let diff = quantity_to_place - base_asset;
+    quantity_to_place = diff;
+  }
+  const payload = {
+    existing_quantity: base_asset,
+    quantity_to_place: to_f(quantity_to_place, places[symbol]),
+    quantity: to_f(margin_position, places[symbol]),
+    price: tp.price,
+    tp: next_order,
+    risk: to_f(pnl, "%.1f"),
+    protect_quantity: to_f(protect_position, places[symbol]),
+    ideal_protect_quantity: to_f(ideal_protect_position, places[symbol]),
+    hedge: to_f(loss, "%.1f"),
+    price_place: price_places[symbol],
+    decimal_place: places[symbol]
+  };
+  return payload;
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -3487,10 +3620,14 @@ function helperFuncToBuildTrades({
   symbol_config,
   app_config_kind,
   appConfig,
-  force_exact_risk = true
+  force_exact_risk = true,
+  use_default = false
 }) {
   const risk = custom_b_config.risk * (custom_b_config.risk_factor || 1);
-  let result = getRiskReward({
+  let result = use_default ? {
+    risk,
+    risk_reward: custom_b_config.risk_reward
+  } : getRiskReward({
     entry: custom_b_config.entry,
     stop: custom_b_config.stop,
     risk,
@@ -3539,7 +3676,8 @@ function buildWithOptimumReward({
   config,
   settings,
   global_config,
-  force_exact
+  force_exact,
+  use_default = false
 }) {
   const kind = config.entry > config.stop ? "long" : "short";
   let stop = settings.stop;
@@ -3553,7 +3691,8 @@ function buildWithOptimumReward({
     stop,
     risk,
     distribution,
-    distribution_params
+    distribution_params,
+    risk_reward: settings.risk_reward || config?.risk_reward
   };
   const appConfig = constructAppConfig2({
     config,
@@ -3564,7 +3703,8 @@ function buildWithOptimumReward({
     app_config_kind: kind,
     appConfig,
     symbol_config: global_config,
-    force_exact_risk: force_exact
+    force_exact_risk: force_exact,
+    use_default
   });
   const adjusted_size = summary.quantity;
   const symbol_config = global_config;
@@ -3876,6 +4016,351 @@ var compoundAPI = {
   increaseTradeHelper,
   generatePositionIncreaseTrade
 };
+// src/exchanges/paper/engine-class.ts
+function generateSummary2({
+  trades = [],
+  fee_percent = 0.05,
+  anchor
+}) {
+  if (trades.length === 0) {
+    return {};
+  }
+  const avg_entry = trades[0].avg_entry;
+  const avg_size = trades[0].avg_size;
+  const expected_fee = avg_entry * avg_size * fee_percent / 100;
+  return {
+    first_entry: trades.at(-1).entry,
+    last_entry: trades[0].entry,
+    quantity: avg_size,
+    entry: avg_entry,
+    loss: trades[0].neg_pnl,
+    number_of_trades: trades.length,
+    fee: to_f(expected_fee, "%.2f"),
+    anchor_pnl: anchor?.target_pnl
+  };
+}
+function cumulativeHelper({
+  tradesList,
+  pos = {
+    quantity: 0,
+    entry: 0
+  },
+  decimal_places = "%.3f"
+}) {
+  let cumulativeQty = pos.quantity || 0;
+  const reversedTrades = [...tradesList].reverse();
+  const processedTrades = reversedTrades.map((trade) => {
+    cumulativeQty += trade.quantity;
+    const avg_size = to_f(cumulativeQty, decimal_places);
+    return {
+      ...trade,
+      cumulative_size: avg_size
+    };
+  });
+  return processedTrades.reverse();
+}
+
+class PositionState {
+  position;
+  trades;
+  take_profit = null;
+  stop_loss = null;
+  entry_fees;
+  fee_percent;
+  global_config;
+  constructor({
+    position: position2,
+    trades,
+    fee_percent = 0,
+    entry_fees = 0,
+    global_config
+  }) {
+    this.position = position2;
+    this.trades = trades ?? [];
+    this.entry_fees = entry_fees ?? 0;
+    this.fee_percent = fee_percent ?? 0;
+    this.global_config = global_config;
+  }
+  get newTrades() {
+    const tradesList = this.trades;
+    const pos = this.position;
+    if (!tradesList || tradesList.length === 0) {
+      return [];
+    }
+    let cumulativeQty = pos.quantity || 0;
+    let cumulativeValue = cumulativeQty * (pos.entry || 0);
+    const reversedTrades = [...tradesList].reverse();
+    const processedTrades = reversedTrades.map((trade) => {
+      cumulativeQty += trade.quantity;
+      cumulativeValue += trade.quantity * trade.entry;
+      const avg_entry = cumulativeQty > 0 ? to_f(cumulativeValue / cumulativeQty, this.global_config.price_places) : 0;
+      const avg_size = to_f(cumulativeQty, this.global_config.decimal_places);
+      const stop = trade.stop || pos.kind === "long" ? Math.min(...tradesList.map((o) => o.entry)) : Math.max(...tradesList.map((o) => o.entry));
+      const neg_pnl = to_f(Math.abs(avg_entry - stop) * avg_size, this.global_config.price_places);
+      return {
+        ...trade,
+        avg_entry,
+        avg_size,
+        neg_pnl
+      };
+    });
+    return processedTrades.reverse();
+  }
+  generateSummary(fee_percentOverride) {
+    const trades = this.newTrades;
+    const fee_percent = fee_percentOverride ?? this.fee_percent;
+    return {
+      ...generateSummary2({
+        trades,
+        fee_percent
+      }),
+      entry_fees: to_f(this.entry_fees, "%.2f")
+    };
+  }
+  get summary() {
+    return this.generateSummary();
+  }
+  positionAt(price) {
+    const trades = this.newTrades;
+    const kind = this.position.kind;
+    const filtered = trades.filter((trade) => {
+      if (kind === "long") {
+        return trade.entry >= price;
+      }
+      return trade.entry <= price;
+    });
+    return filtered[0];
+  }
+  newPositionState(price) {
+    const position2 = this.position;
+    const trades = this.newTrades;
+    const instance = this.positionAt(price);
+    if (!instance) {
+      return new PositionState({
+        position: { ...position2 },
+        trades,
+        fee_percent: this.fee_percent,
+        entry_fees: this.entry_fees,
+        global_config: this.global_config
+      });
+    }
+    return new PositionState({
+      position: {
+        ...position2,
+        entry: instance.avg_entry,
+        quantity: instance.avg_size
+      },
+      trades,
+      fee_percent: this.fee_percent,
+      entry_fees: this.entry_fees,
+      global_config: this.global_config
+    });
+  }
+  updateTakeProfit({ entry, quantity }) {
+    this.take_profit = {
+      price: entry,
+      quantity: quantity ?? this.position.quantity
+    };
+  }
+  updateStopLoss(payload) {
+    const { stop, quantity } = payload ?? {
+      stop: this.newTrades[0].entry,
+      quantity: this.summary.quantity
+    };
+    this.stop_loss = {
+      price: stop,
+      quantity
+    };
+  }
+}
+function determineNewPosition({
+  position: position2,
+  price,
+  trades,
+  global_config
+}) {
+  const kind = position2.kind;
+  const placed = trades.filter((t) => {
+    let _price = t.entry || t.price;
+    let condition1 = kind === "long" ? _price >= price : _price <= price;
+    return condition1;
+  }).map((t) => {
+    let _price = t.entry || t.price;
+    let condition2 = kind === "long" ? _price >= position2.entry : _price <= position2.entry;
+    if (condition2) {
+      return {
+        ...t,
+        price: position2.entry,
+        entry: position2.entry
+      };
+    }
+    return t;
+  });
+  const placeQty = placed.reduce((acc, trade) => acc + trade.quantity, 0);
+  if (position2.quantity > 0) {
+    const placed_less_than_entry = placed.filter((t) => {
+      let condition1 = kind === "long" ? t.entry <= position2.entry : t.entry >= position2.entry;
+      return condition1;
+    });
+    const avg = determine_average_entry_and_size(placed_less_than_entry.map((o) => ({
+      price: o.entry || o.price,
+      quantity: o.quantity
+    })).concat([{ price: position2.entry, quantity: position2.quantity }]), global_config.decimal_places, global_config.price_places);
+    position2.entry = avg.price;
+    position2.quantity = avg.quantity;
+    return position2;
+  }
+  return {
+    ...position2,
+    entry: price,
+    quantity: placeQty
+  };
+}
+function positionAt({
+  price,
+  position: position2,
+  trades = [],
+  as_state = true,
+  global_config
+}) {
+  const kind = position2.kind;
+  const fee_rate = {
+    maker: 0.02,
+    taker: 0.05
+  };
+  const placed = trades.filter((t) => {
+    let _price = t.entry || t.price;
+    let condition1 = kind === "long" ? _price >= price : _price <= price;
+    return condition1;
+  });
+  const not_placed = trades.filter((t) => {
+    let _price = t.entry || t.price;
+    let condition1 = kind === "long" ? _price < price : _price > price;
+    return condition1;
+  });
+  const placeQty = placed.reduce((acc, trade) => acc + trade.quantity, 0);
+  const takerFee = price * placeQty * fee_rate.taker / 100;
+  const makerFee = not_placed.reduce((acc, trade) => acc + trade.entry * trade.quantity * fee_rate.maker / 100, 0);
+  const fee = to_f(takerFee + makerFee, "%.2f");
+  const result = {
+    trades: not_placed,
+    position: determineNewPosition({
+      global_config,
+      position: { ...position2, kind },
+      price,
+      trades
+    }),
+    entry_fees: fee,
+    fee_percent: fee_rate.maker,
+    global_config
+  };
+  if (as_state) {
+    const derivedState = new PositionState({
+      position: result.position,
+      trades: result.trades,
+      fee_percent: result.fee_percent,
+      entry_fees: parseFloat(result.entry_fees) || 0,
+      global_config
+    });
+    return derivedState;
+  }
+  return result;
+}
+
+class TradeEngine {
+  trade_details = null;
+  position;
+  global_config;
+  constructor({
+    global_config,
+    position: position2 = { entry: 0, quantity: 0, kind: "long" }
+  }) {
+    this.global_config = global_config;
+    this.position = position2;
+  }
+  generateShortTrades(config) {
+    const result = compoundAPI.buildWithOptimumReward({
+      global_config: this.global_config,
+      config,
+      settings: config,
+      use_default: true
+    });
+    this.trade_details = result;
+  }
+  positionAt({
+    price,
+    dangerous,
+    trades: existingTrades
+  }) {
+    const trades = existingTrades || this.trade_details?.trades || [];
+    if (dangerous) {
+      const kind = this.position.kind;
+      const naive_assumptions = positionAt({
+        price,
+        position: {
+          kind,
+          entry: 0,
+          quantity: 0
+        },
+        global_config: this.global_config,
+        trades,
+        as_state: false
+      });
+      const avg_position = determine_average_entry_and_size([
+        {
+          price: this.position.entry,
+          quantity: this.position.quantity
+        },
+        {
+          price: naive_assumptions.position.entry,
+          quantity: naive_assumptions.position.quantity
+        }
+      ], this.global_config.decimal_places, this.global_config.price_places);
+      const new_position = dangerous ? {
+        ...this.position,
+        entry: avg_position.entry,
+        quantity: avg_position.quantity
+      } : this.position;
+      return new PositionState({
+        ...naive_assumptions,
+        trades: naive_assumptions.trades,
+        position: new_position,
+        global_config: this.global_config
+      });
+    }
+    const _trades = cumulativeHelper({
+      tradesList: [...trades].concat({
+        entry: this.position.entry,
+        quantity: this.position.quantity
+      }),
+      decimal_places: this.global_config.decimal_places
+    }).filter((o) => {
+      const numeric = Number(o.cumulative_size);
+      return numeric > this.position.quantity;
+    });
+    return positionAt({
+      price,
+      position: this.position,
+      trades: _trades,
+      global_config: this.global_config
+    });
+  }
+  initializeEngine({
+    price,
+    dangerous,
+    trades,
+    config
+  }) {
+    if (config) {
+      this.generateShortTrades(config);
+    }
+    return this.positionAt({
+      price,
+      dangerous,
+      trades
+    });
+  }
+}
 export {
   to_f,
   sortedBuildConfig,
@@ -3904,6 +4389,7 @@ export {
   determine_stop_and_size,
   determine_remaining_entry,
   determine_position_size,
+  determine_pnl,
   determine_break_even_price,
   determine_average_entry_and_size,
   determine_amount_to_sell2 as determine_amount_to_sell,
@@ -3920,6 +4406,7 @@ export {
   computeSellZones,
   computeRiskReward,
   computeProfitDetail,
+  computeMarginProtection,
   compoundAPI,
   calculateFactorFromTakeProfit,
   calculateFactorFromSellQuantity,
@@ -3928,6 +4415,8 @@ export {
   buildAppConfig,
   asCoins,
   allCoins,
+  TradeEngine,
   Strategy,
-  SpecialCoins
+  SpecialCoins,
+  Signal
 };