@gbozee/ultimate 0.0.2-176 → 0.0.2-177

package/dist/mcp-server.js

@@ -61374,7 +61374,7 @@ class AppDatabase {
       table: "positions_view",
       params: {
         filter: `symbol:lower="${symbol.toLowerCase()}" && p_account.owner:lower="${account.owner.toLowerCase()}" && p_account.exchange:lower="${account.exchange.toLowerCase()}"`,
-        expand: "b_config, account_strategy, p_account, proxy"
+        expand: "b_config, account_strategy, p_account, proxy, compound_instance.ref,support"
       }
     } : {
       table: "positions",
@@ -62216,6 +62216,137 @@ class AppDatabase {
 // src/exchanges/binance/index.ts
 var import_binance = __toESM(require_lib2(), 1);
 
+// src/helpers/distributions.ts
+function generateArithmetic(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f" } = payload;
+  const difference = Math.abs(margin_range[1] - margin_range[0]);
+  const spread = difference / risk_reward;
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const price = kind === "long" ? margin_range[1] - spread * i2 : margin_range[0] + spread * i2;
+    return to_f(price, price_places);
+  });
+}
+function generateGeometric(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", percent_change } = payload;
+  const effectivePercentChange = percent_change ?? Math.abs(margin_range[1] / margin_range[0] - 1) / risk_reward;
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const price = kind === "long" ? margin_range[1] * Math.pow(1 - effectivePercentChange, i2) : margin_range[0] * Math.pow(1 + effectivePercentChange, i2);
+    return to_f(price, price_places);
+  });
+}
+function approximateInverseNormal(p) {
+  p = Math.max(0.0001, Math.min(0.9999, p));
+  if (p < 0.5) {
+    const t2 = Math.sqrt(-2 * Math.log(p));
+    const c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
+    const d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
+    return -(t2 - (c0 + c1 * t2 + c2 * t2 * t2) / (1 + d1 * t2 + d2 * t2 * t2 + d3 * t2 * t2 * t2));
+  } else {
+    const t2 = Math.sqrt(-2 * Math.log(1 - p));
+    const c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
+    const d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
+    return t2 - (c0 + c1 * t2 + c2 * t2 * t2) / (1 + d1 * t2 + d2 * t2 * t2 + d3 * t2 * t2 * t2);
+  }
+}
+function generateNormal(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", stdDevFactor = 6 } = payload;
+  const mean = (margin_range[0] + margin_range[1]) / 2;
+  const stdDev = Math.abs(margin_range[1] - margin_range[0]) / stdDevFactor;
+  const skew = kind === "long" ? -0.2 : 0.2;
+  const adjustedMean = mean + stdDev * skew;
+  const entries = Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const p = (i2 + 0.5) / (risk_reward + 1);
+    const z3 = approximateInverseNormal(p);
+    let price = adjustedMean + stdDev * z3;
+    price = Math.max(margin_range[0], Math.min(margin_range[1], price));
+    return to_f(price, price_places);
+  });
+  return entries.sort((a, b) => a - b);
+}
+function generateExponential(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", lambda } = payload;
+  const range = Math.abs(margin_range[1] - margin_range[0]);
+  const effectiveLambda = lambda || 2.5;
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const t2 = i2 / risk_reward;
+    const exponentialProgress = 1 - Math.exp(-effectiveLambda * t2);
+    const price = kind === "long" ? margin_range[1] - range * exponentialProgress : margin_range[0] + range * exponentialProgress;
+    return to_f(price, price_places);
+  });
+}
+function generateInverseExponential(payload) {
+  const { margin_range, risk_reward, kind, price_places = "%.1f", curveFactor = 2 } = payload;
+  const range = Math.abs(margin_range[1] - margin_range[0]);
+  return Array.from({ length: risk_reward + 1 }, (_, i2) => {
+    const t2 = i2 / risk_reward;
+    const progress = (Math.exp(curveFactor * t2) - 1) / (Math.exp(curveFactor) - 1);
+    const price = kind === "long" ? margin_range[1] - range * progress : margin_range[0] + range * progress;
+    return to_f(price, price_places);
+  });
+}
+function getEntries(params) {
+  const {
+    kind,
+    distribution,
+    margin_range,
+    risk_reward,
+    price_places = "%.1f",
+    distribution_params = {}
+  } = params;
+  let entries = [];
+  switch (distribution) {
+    case "arithmetic":
+      entries = generateArithmetic({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        percent_change: distribution_params.curveFactor
+      });
+      break;
+    case "geometric":
+      entries = generateGeometric({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        percent_change: distribution_params.curveFactor
+      });
+      break;
+    case "normal":
+      entries = generateNormal({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        stdDevFactor: distribution_params.stdDevFactor
+      });
+      break;
+    case "exponential":
+      entries = generateExponential({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        lambda: distribution_params.lambda
+      });
+      break;
+    case "inverse-exponential":
+      entries = generateInverseExponential({
+        margin_range,
+        risk_reward,
+        kind,
+        price_places,
+        curveFactor: distribution_params.curveFactor
+      });
+      break;
+    default:
+      throw new Error(`Unknown distribution type: ${distribution}`);
+  }
+  return entries.sort((a, b) => a - b);
+}
+var distributions_default = getEntries;
+
 // src/helpers/optimizations.ts
 function calculateTheoreticalKelly({
   current_entry,
@@ -62485,6 +62616,10 @@ class Signal {
   kelly_minimum_risk = 0.2;
   kelly_func = "theoretical";
   symbol;
+  distribution = {
+    long: "arithmetic",
+    short: "geometric"
+  };
   constructor({
     focus,
     symbol,
@@ -62511,8 +62646,12 @@ class Signal {
     kelly_prediction_model = "exponential",
     kelly_confidence_factor = 0.6,
     kelly_minimum_risk = 0.2,
-    kelly_func = "theoretical"
+    kelly_func = "theoretical",
+    full_distribution
   }) {
+    if (full_distribution) {
+      this.distribution = full_distribution;
+    }
     this.symbol = symbol;
     this.minimum_size = minimum_size;
     this.first_order_size = first_order_size;
@@ -62548,7 +62687,8 @@ class Signal {
     kind = "long",
     risk,
     no_of_trades = 1,
-    take_profit
+    take_profit,
+    distribution
   }) {
     let _stop_loss = stop_loss;
     if (!_stop_loss && stop_percent) {
@@ -62557,16 +62697,22 @@ class Signal {
     const percent_change = _stop_loss ? Math.max(current_price, _stop_loss) / Math.min(current_price, _stop_loss) - 1 : this.percent_change;
     const _no_of_trades = no_of_trades || this.risk_reward;
     let _resistance = current_price * Math.pow(1 + percent_change, 1);
+    const simple_support = Math.min(current_price, stop_loss);
+    const simple_resistance = Math.max(current_price, stop_loss);
     const derivedConfig = {
       ...this,
       percent_change,
       focus: current_price,
-      resistance: _resistance,
+      resistance: distribution ? simple_resistance : _resistance,
       risk_per_trade: risk / this.risk_reward,
       minimum_pnl: pnl,
       risk_reward: _no_of_trades,
       take_profit: take_profit || this.take_profit,
-      support: kind === "long" ? _stop_loss : this.support
+      support: distribution ? simple_support : kind === "long" ? _stop_loss : this.support,
+      full_distribution: distribution ? {
+        ...this.distribution,
+        [kind]: distribution
+      } : undefined
     };
     const instance = new Signal(derivedConfig);
     if (kind === "short") {}
@@ -62782,12 +62928,31 @@ class Signal {
     }
     this.zone_risk = original;
   }
+  get_future_zones_simple({
+    current_price,
+    kind = "long",
+    raw
+  }) {
+    const margin_zones = [this.support, this.resistance];
+    const distribution = this.distribution ? this.distribution[kind] : "geometric";
+    console.log("margin_zones", { margin_zones, distribution });
+    let _kind = distribution === "inverse-exponential" ? kind === "long" ? "short" : "long" : kind;
+    const entries = distributions_default({
+      margin_range: margin_zones,
+      kind: _kind,
+      distribution,
+      risk_reward: this.risk_reward,
+      price_places: this.price_places
+    });
+    return entries.sort((a, b) => a - b);
+  }
   get_future_zones({
     current_price,
     kind = "long",
     raw
   }) {
     if (raw) {}
+    return this.get_future_zones_simple({ current_price, raw, kind });
     const margin_range = this.get_margin_range(current_price, kind);
     let margin_zones = this.get_margin_zones({ current_price });
     let remaining_zones = margin_zones.filter((x) => JSON.stringify(x) != JSON.stringify(margin_range));
@@ -63446,7 +63611,9 @@ function buildConfig(app_config, {
   kelly_confidence_factor = 0.95,
   kelly_minimum_risk = 0.2,
   kelly_prediction_model = "exponential",
-  kelly_func = "theoretical"
+  kelly_func = "theoretical",
+  min_avg_size = 0,
+  distribution
 }) {
   let fee = app_config.fee / 100;
   let working_risk = risk || app_config.risk_per_trade;
@@ -63493,9 +63660,12 @@ function buildConfig(app_config, {
     stop_loss: stop,
     risk: working_risk,
     kind: kind || app_config.kind,
-    no_of_trades: trade_no
+    no_of_trades: trade_no,
+    distribution
   }) || [] : [];
-  return computeTotalAverageForEachTrade(result, config2);
+  const new_trades = computeTotalAverageForEachTrade(result, config2);
+  let filtered = new_trades.filter((o) => o.avg_size > min_avg_size);
+  return computeTotalAverageForEachTrade(filtered, config2);
 }
 function 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) => {
@@ -63547,7 +63717,8 @@ function get_app_config_and_max_size(config2, payload) {
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
     kelly_prediction_model: payload.kelly_prediction_model,
-    kelly_func: payload.kelly_func
+    kelly_func: payload.kelly_func,
+    distribution: payload.distribution
   });
   const max_size = initialResult[0]?.avg_size;
   const last_value = initialResult[0];
@@ -63585,7 +63756,8 @@ function buildAppConfig(config2, payload) {
     kelly_confidence_factor: payload.kelly_confidence_factor,
     kelly_minimum_risk: payload.kelly_minimum_risk,
     kelly_prediction_model: payload.kelly_prediction_model,
-    kelly_func: payload.kelly_func
+    kelly_func: payload.kelly_func,
+    distribution: payload.distribution
   });
   app_config.max_size = max_size;
   app_config.entry = payload.entry || app_config.entry;
@@ -63602,7 +63774,7 @@ function buildAppConfig(config2, payload) {
   return app_config;
 }
 function getOptimumStopAndRisk(app_config, params) {
-  const { max_size, target_stop } = params;
+  const { max_size, target_stop, distribution } = params;
   const isLong = app_config.kind === "long";
   const stopRange = Math.abs(app_config.entry - target_stop) * 0.5;
   let low_stop = isLong ? target_stop - stopRange : Math.max(target_stop - stopRange, app_config.entry);
@@ -63625,7 +63797,8 @@ function getOptimumStopAndRisk(app_config, params) {
       increase: true,
       gap: app_config.gap,
       price_places: app_config.price_places,
-      decimal_places: app_config.decimal_places
+      decimal_places: app_config.decimal_places,
+      distribution
     });
     if (result.length === 0) {
       if (isLong) {
@@ -63679,7 +63852,8 @@ function getOptimumStopAndRisk(app_config, params) {
       increase: true,
       gap: app_config.gap,
       price_places: app_config.price_places,
-      decimal_places: app_config.decimal_places
+      decimal_places: app_config.decimal_places,
+      distribution
     });
     if (result.length === 0) {
       high_risk = mid_risk;
@@ -63724,7 +63898,8 @@ function getOptimumStopAndRisk(app_config, params) {
         increase: true,
         gap: app_config.gap,
         price_places: app_config.price_places,
-        decimal_places: app_config.decimal_places
+        decimal_places: app_config.decimal_places,
+        distribution
       });
       if (result.length === 0)
         continue;
@@ -63847,7 +64022,8 @@ function generateOptimumAppConfig(config2, payload, position2) {
     }, {
       entry: payload.entry,
       stop: payload.stop,
-      kind: position2.kind
+      kind: position2.kind,
+      distribution: payload.distribution
     });
     current_app_config.max_size = max_size;
     current_app_config.last_value = last_value;
@@ -63862,7 +64038,8 @@ function generateOptimumAppConfig(config2, payload, position2) {
       increase: true,
       gap: current_app_config.gap,
       price_places: current_app_config.price_places,
-      decimal_places: current_app_config.decimal_places
+      decimal_places: current_app_config.decimal_places,
+      distribution: payload.distribution
     });
     if (full_trades.length === 0) {
       high_risk = mid_risk;
@@ -63926,7 +64103,8 @@ function determineOptimumReward(payload) {
     increase = true,
     low_range = 1,
     high_range = 199,
-    target_loss
+    target_loss,
+    distribution
   } = payload;
   const criterion = app_config.strategy || "quantity";
   const risk_rewards = createArray(low_range, high_range, 1);
@@ -63940,7 +64118,8 @@ function determineOptimumReward(payload) {
       increase,
       kind: app_config.kind,
       gap: app_config.gap,
-      decimal_places: app_config.decimal_places
+      decimal_places: app_config.decimal_places,
+      distribution
     });
     let total = 0;
     let max = -Infinity;
@@ -64105,14 +64284,17 @@ function determineOptimumRisk(config2, payload, params) {
   };
 }
 function computeRiskReward(payload) {
-  const { app_config, entry, stop, risk_per_trade, target_loss } = payload;
+  const { app_config, entry, stop, risk_per_trade, target_loss, distribution } = payload;
   const kind = entry > stop ? "long" : "short";
   app_config.kind = kind;
   app_config.entry = entry;
   app_config.stop = stop;
   app_config.risk_per_trade = risk_per_trade;
-  const result = determineOptimumReward({ app_config, target_loss });
-  console.log("result", result, "target_loss", target_loss);
+  const result = determineOptimumReward({
+    app_config,
+    target_loss,
+    distribution
+  });
   return result;
 }
 function getRiskReward(payload) {
@@ -64122,21 +64304,24 @@ function getRiskReward(payload) {
     risk,
     global_config,
     force_exact_risk = false,
-    target_loss
+    target_loss,
+    distribution
   } = payload;
   const { entries, last_value, ...app_config } = buildAppConfig(global_config, {
     entry,
     stop,
     risk_reward: 30,
     risk,
-    symbol: global_config.symbol
+    symbol: global_config.symbol,
+    distribution
   });
   const risk_reward = computeRiskReward({
     app_config,
     entry,
     stop,
     risk_per_trade: risk,
-    target_loss
+    target_loss,
+    distribution
   });
   if (force_exact_risk) {
     const new_risk_per_trade = determineOptimumRisk(global_config, {
@@ -64144,7 +64329,8 @@ function getRiskReward(payload) {
       stop,
       risk_reward,
       risk,
-      symbol: global_config.symbol
+      symbol: global_config.symbol,
+      distribution
     }, {
       highest_risk: risk
     }).optimal_risk;
@@ -64501,7 +64687,7 @@ function constructAppConfig(payload) {
     kelly_minimum_risk: kelly_config?.kelly_minimum_risk ?? kelly?.kelly_minimum_risk,
     kelly_prediction_model: kelly_config?.kelly_prediction_model ?? kelly?.kelly_prediction_model
   };
-  const appConfig = buildAppConfig(global_config, options);
+  const { entries: _entries, ...appConfig } = buildAppConfig(global_config, options);
   return appConfig;
 }
 function generateDangerousConfig(payload) {
@@ -67499,6 +67685,19 @@ class ExchangePosition {
     const { p_account } = this.instance.expand;
     return p_account;
   }
+  get compound() {
+    const { compound_instance } = this.instance.expand;
+    if (compound_instance) {
+      const { ref } = compound_instance.expand;
+      const profit_percent = ref.profit_percent / 100;
+      return {
+        ...compound_instance,
+        profit_percent,
+        amount_to_risk: to_f(compound_instance.risk * profit_percent, "%.2f")
+      };
+    }
+    return compound_instance;
+  }
   async getProxyForAccount() {
     if (this.instance.expand.proxy) {
       const result = this.instance.expand.proxy;
@@ -67624,7 +67823,8 @@ class ExchangePosition {
         place,
         raw: payload.raw,
         use_current,
-        stop_percent: config2.stop_percent || 100
+        stop_percent: config2.stop_percent || 100,
+        distribution: config2.distribution
       });
     }
   }
@@ -67658,7 +67858,8 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func
+      kelly_func: config2.kelly?.kelly_func,
+      distribution: config2.distribution
     }, false);
     if (payload.raw) {
       let actual_orders_to_buy = await this.determineAmountToBuy({
@@ -67781,7 +67982,8 @@ class ExchangePosition {
       kelly_confidence_factor: solution.kelly_confidence_factor,
       kelly_minimum_risk: solution.kelly_minimum_risk,
       kelly_prediction_model: solution.kelly_prediction_model,
-      kelly_func: solution.kelly_func
+      kelly_func: solution.kelly_func,
+      distribution: solution.distribution
     };
     const trades = sortedBuildConfig(app_config, options);
     const entry_orders = {
@@ -68173,6 +68375,7 @@ class ExchangePosition {
     });
   }
   async generate_config_params(payload) {
+    const db_config = await this.getConfig();
     const { entry, stop, risk_reward, risk, with_trades = false } = payload;
     const symbol = this.symbol;
     const app_config = await this.buildAppConfig({
@@ -68205,7 +68408,8 @@ class ExchangePosition {
         avg_size: 0,
         neg_pnl: 0,
         min_size: app_config2.min_size,
-        symbol
+        symbol,
+        distribution: db_config.distribution
       }, false);
       config2.trades = trades;
     }
@@ -68306,7 +68510,8 @@ class ExchangePosition {
       kelly_confidence_factor: config2.kelly?.kelly_confidence_factor,
       kelly_minimum_risk: config2.kelly?.kelly_minimum_risk,
       kelly_prediction_model: config2.kelly?.kelly_prediction_model,
-      kelly_func: config2.kelly?.kelly_func
+      kelly_func: config2.kelly?.kelly_func,
+      distribution: config2.distribution
     });
     const position2 = this.instance;
     const orders_to_place = await this.determineAmountToBuy({
@@ -68504,50 +68709,43 @@ class ExchangePosition {
       increase: false
     });
   }
-  async isActiveTrade() {
-    const config2 = await this.getConfig();
-    const supportTable = await this.app_db.getSupportTable({
-      symbol: this.symbol,
-      kind: this.kind
-    });
+  get support() {
+    return this.instance.expand?.support;
+  }
+  get linkedConfig() {
+    return this.instance.expand?.b_config;
+  }
+  get isActiveTrade() {
+    const config2 = this.linkedConfig;
     return {
       config: config2,
-      condition: supportTable?.price === config2.stop,
-      supportTable
+      condition: this.compound && this.support?.price === config2.stop
     };
   }
   async updateCompound(payload) {
     const pb = this.app_db.pb;
-    const item = await this.app_db.getCompoundInstance({
-      position: this.instance
-    });
-    const {
-      expand: { ref }
-    } = item;
-    const risk = item.risk;
-    const percent = ref.profit_percent / 100;
-    const new_risk = risk * (1 + percent);
-    const { condition, supportTable, config: config2 } = await this.isActiveTrade();
+    const item = this.compound;
+    const new_risk = item.risk + item.amount_to_risk;
+    const { condition, config: config2 } = this.isActiveTrade;
     if (payload?.place && condition) {
       await pb.collection("compound_instances").update(item.id, {
         risk: new_risk
       });
       await pb.collection("scheduled_trades").update(config2.id, {
-        profit: to_f(new_risk * percent, "%.3f")
+        profit: to_f(new_risk * item.profit_percent, "%.3f")
       });
     }
     return {
-      support: supportTable.price,
-      counter: supportTable.counter,
-      new_risk
+      support: this.support?.price,
+      counter: this.support?.counter,
+      new_risk,
+      condition,
+      stop: config2.stop
     };
   }
   async cleanOnActiveCompoundInstance() {
-    const item = await this.app_db.getCompoundInstance({
-      position: this.instance
-    });
-    const { condition } = await this.isActiveTrade();
-    if (item && condition && this.instance.quantity === 0) {
+    const { condition } = this.isActiveTrade;
+    if (condition && this.instance.quantity === 0) {
       await this.cancelOrders({ limit: true });
     }
   }

package/package.json

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