@gbozee/ultimate 0.0.2-200 → 0.0.2-201

package/dist/index.cjs

@@ -38677,20 +38677,20 @@ var require_axios2 = __commonJS((exports2, module2) => {
   var reduceDescriptors = (obj, reducer) => {
     const descriptors2 = Object.getOwnPropertyDescriptors(obj);
     const reducedDescriptors = {};
-    forEach2(descriptors2, (descriptor, name3) => {
+    forEach2(descriptors2, (descriptor, name2) => {
       let ret;
-      if ((ret = reducer(descriptor, name3, obj)) !== false) {
-        reducedDescriptors[name3] = ret || descriptor;
+      if ((ret = reducer(descriptor, name2, obj)) !== false) {
+        reducedDescriptors[name2] = ret || descriptor;
       }
     });
     Object.defineProperties(obj, reducedDescriptors);
   };
   var freezeMethods = (obj) => {
-    reduceDescriptors(obj, (descriptor, name3) => {
-      if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name3) !== -1) {
+    reduceDescriptors(obj, (descriptor, name2) => {
+      if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name2) !== -1) {
         return false;
       }
-      const value2 = obj[name3];
+      const value2 = obj[name2];
       if (!isFunction(value2))
         return;
       descriptor.enumerable = false;
@@ -38700,7 +38700,7 @@ var require_axios2 = __commonJS((exports2, module2) => {
       }
       if (!descriptor.set) {
         descriptor.set = () => {
-          throw Error("Can not rewrite read-only method '" + name3 + "'");
+          throw Error("Can not rewrite read-only method '" + name2 + "'");
         };
       }
     });
@@ -39008,8 +39008,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
     params && toFormData(params, this, options);
   }
   var prototype = AxiosURLSearchParams.prototype;
-  prototype.append = function append(name3, value2) {
-    this._pairs.push([name3, value2]);
+  prototype.append = function append(name2, value2) {
+    this._pairs.push([name2, value2]);
   };
   prototype.toString = function toString(encoder2) {
     const _encode = encoder2 ? function(value2) {
@@ -39145,8 +39145,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
       }
     }, options));
   }
-  function parsePropPath(name3) {
-    return utils$1.matchAll(/\w+|\[(\w*)]/g, name3).map((match) => {
+  function parsePropPath(name2) {
+    return utils$1.matchAll(/\w+|\[(\w*)]/g, name2).map((match) => {
       return match[0] === "[]" ? "" : match[1] || match[0];
     });
   }
@@ -39164,33 +39164,33 @@ var require_axios2 = __commonJS((exports2, module2) => {
   }
   function formDataToJSON(formData) {
     function buildPath(path, value2, target, index) {
-      let name3 = path[index++];
-      if (name3 === "__proto__")
+      let name2 = path[index++];
+      if (name2 === "__proto__")
         return true;
-      const isNumericKey = Number.isFinite(+name3);
+      const isNumericKey = Number.isFinite(+name2);
       const isLast = index >= path.length;
-      name3 = !name3 && utils$1.isArray(target) ? target.length : name3;
+      name2 = !name2 && utils$1.isArray(target) ? target.length : name2;
       if (isLast) {
-        if (utils$1.hasOwnProp(target, name3)) {
-          target[name3] = [target[name3], value2];
+        if (utils$1.hasOwnProp(target, name2)) {
+          target[name2] = [target[name2], value2];
         } else {
-          target[name3] = value2;
+          target[name2] = value2;
         }
         return !isNumericKey;
       }
-      if (!target[name3] || !utils$1.isObject(target[name3])) {
-        target[name3] = [];
+      if (!target[name2] || !utils$1.isObject(target[name2])) {
+        target[name2] = [];
       }
-      const result = buildPath(path, value2, target[name3], index);
-      if (result && utils$1.isArray(target[name3])) {
-        target[name3] = arrayToObject(target[name3]);
+      const result = buildPath(path, value2, target[name2], index);
+      if (result && utils$1.isArray(target[name2])) {
+        target[name2] = arrayToObject(target[name2]);
       }
       return !isNumericKey;
     }
     if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {
       const obj = {};
-      utils$1.forEachEntry(formData, (name3, value2) => {
-        buildPath(parsePropPath(name3), value2, obj, 0);
+      utils$1.forEachEntry(formData, (name2, value2) => {
+        buildPath(parsePropPath(name2), value2, obj, 0);
       });
       return obj;
     }
@@ -39769,10 +39769,10 @@ var require_axios2 = __commonJS((exports2, module2) => {
   var CRLF_BYTES_COUNT = 2;
 
   class FormDataPart {
-    constructor(name3, value2) {
+    constructor(name2, value2) {
       const { escapeName } = this.constructor;
       const isStringValue = utils$1.isString(value2);
-      let headers = `Content-Disposition: form-data; name="${escapeName(name3)}"${!isStringValue && value2.name ? `; filename="${escapeName(value2.name)}"` : ""}${CRLF}`;
+      let headers = `Content-Disposition: form-data; name="${escapeName(name2)}"${!isStringValue && value2.name ? `; filename="${escapeName(value2.name)}"` : ""}${CRLF}`;
       if (isStringValue) {
         value2 = textEncoder.encode(String(value2).replace(/\r?\n|\r\n?/g, CRLF));
       } else {
@@ -39781,7 +39781,7 @@ var require_axios2 = __commonJS((exports2, module2) => {
       this.headers = textEncoder.encode(headers + CRLF);
       this.contentLength = isStringValue ? value2.byteLength : value2.size;
       this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;
-      this.name = name3;
+      this.name = name2;
       this.value = value2;
     }
     async* encode() {
@@ -39794,8 +39794,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
       }
       yield CRLF_BYTES;
     }
-    static escapeName(name3) {
-      return String(name3).replace(/[\r\n"]/g, (match) => ({
+    static escapeName(name2) {
+      return String(name2).replace(/[\r\n"]/g, (match) => ({
         "\r": "%0D",
         "\n": "%0A",
         '"': "%22"
@@ -39817,8 +39817,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
     const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
     const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF + CRLF);
     let contentLength = footerBytes.byteLength;
-    const parts = Array.from(form.entries()).map(([name3, value2]) => {
-      const part = new FormDataPart(name3, value2);
+    const parts = Array.from(form.entries()).map(([name2, value2]) => {
+      const part = new FormDataPart(name2, value2);
       contentLength += part.size;
       return part;
     });
@@ -40426,20 +40426,20 @@ var require_axios2 = __commonJS((exports2, module2) => {
     return origin2.protocol === url2.protocol && origin2.host === url2.host && (isMSIE || origin2.port === url2.port);
   })(new URL(platform.origin), platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)) : () => true;
   var cookies = platform.hasStandardBrowserEnv ? {
-    write(name3, value2, expires, path, domain, secure) {
-      const cookie = [name3 + "=" + encodeURIComponent(value2)];
+    write(name2, value2, expires, path, domain, secure) {
+      const cookie = [name2 + "=" + encodeURIComponent(value2)];
       utils$1.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString());
       utils$1.isString(path) && cookie.push("path=" + path);
       utils$1.isString(domain) && cookie.push("domain=" + domain);
       secure === true && cookie.push("secure");
       document.cookie = cookie.join("; ");
     },
-    read(name3) {
-      const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name3 + ")=([^;]*)"));
+    read(name2) {
+      const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name2 + ")=([^;]*)"));
       return match ? decodeURIComponent(match[3]) : null;
     },
-    remove(name3) {
-      this.write(name3, "", Date.now() - 86400000);
+    remove(name2) {
+      this.write(name2, "", Date.now() - 86400000);
     }
   } : {
     write() {},
@@ -44876,7 +44876,6 @@ var require_lib3 = __commonJS((exports2) => {
 var exports_src = {};
 __export(exports_src, {
   sortedBuildConfig: () => sortedBuildConfig,
-  name: () => name2,
   initialize: () => initialize,
   initApp: () => initApp,
   get_app_config_and_max_size: () => get_app_config_and_max_size,
@@ -44902,6 +44901,7 @@ __export(exports_src, {
   constructAppConfig: () => constructAppConfig,
   computeRiskReward: () => computeRiskReward,
   computeProfitDetail: () => computeProfitDetail,
+  compoundAPI: () => compoundAPI,
   calculateFactorFromTakeProfit: () => calculateFactorFromTakeProfit,
   calculateFactorFromSellQuantity: () => calculateFactorFromSellQuantity,
   buildConfig: () => buildConfig,
@@ -56150,7 +56150,6 @@ class Signal {
           let potentials = new_result.filter((x) => condition(x["entry"], i2["risk_sell"])).map((x) => x["entry"]);
           if (potentials.length && max_index) {
             if (kind === "long") {
-              console.log("slice: ", potentials.slice(0, max_index));
               i2["risk_sell"] = Math.max(...potentials.slice(0, max_index));
             } else {
               i2["risk_sell"] = Math.min(...potentials.slice(0, max_index));
@@ -56214,7 +56213,6 @@ class Signal {
   }) {
     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,
@@ -56433,7 +56431,6 @@ class Signal {
             }
           });
           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,
@@ -56933,7 +56930,6 @@ function buildConfig(app_config, {
   }
   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: config2 });
   const result = entry === stop ? [] : condition ? instance.build_entry({
     current_price: entry,
     stop_loss: stop,
@@ -58623,7 +58619,418 @@ class Strategy {
   }
 }
 // src/helpers/compound.ts
-var name2 = "";
+function buildTrades(payload) {
+  const { appConfig, settings, kind } = payload;
+  const kelly_config = settings.kelly;
+  const current_app_config = { ...appConfig[kind] };
+  const entryNum = parseFloat(settings.entry);
+  const stopNum = parseFloat(settings.stop);
+  current_app_config.entry = entryNum;
+  current_app_config.stop = stopNum;
+  current_app_config.risk_per_trade = parseFloat(settings.risk);
+  current_app_config.risk_reward = parseFloat(settings.risk_reward);
+  current_app_config.kind = kind;
+  current_app_config.kelly = kelly_config;
+  const options = {
+    take_profit: null,
+    entry: current_app_config.entry,
+    stop: current_app_config.stop,
+    raw_instance: null,
+    risk: current_app_config.risk_per_trade,
+    no_of_trades: undefined,
+    risk_reward: current_app_config.risk_reward,
+    kind: current_app_config.kind,
+    increase: true,
+    gap: current_app_config.gap,
+    rr: current_app_config.rr,
+    price_places: current_app_config.price_places,
+    decimal_places: current_app_config.decimal_places,
+    use_kelly: kelly_config?.use_kelly,
+    kelly_confidence_factor: kelly_config?.kelly_confidence_factor,
+    kelly_minimum_risk: kelly_config?.kelly_minimum_risk,
+    kelly_prediction_model: kelly_config?.kelly_prediction_model,
+    kelly_func: kelly_config?.kelly_func,
+    distribution: settings.distribution
+  };
+  if (kind === "long" && entryNum <= stopNum) {
+    return [];
+  }
+  if (kind === "short" && entryNum >= stopNum) {
+    return [];
+  }
+  try {
+    const generatedTrades = sortedBuildConfig(current_app_config, options);
+    return generatedTrades ?? [];
+  } catch (error) {
+    console.error("Error generating orders:", error);
+    return [];
+  }
+}
+function generateSummary({
+  trades,
+  fee_percent = 0.05,
+  anchor
+}) {
+  const avg_entry = trades[0].avg_entry;
+  const avg_size = trades[0].avg_size;
+  const expected_fee = avg_entry * avg_size * fee_percent / 100;
+  return {
+    first_entry: trades.at(-1).entry,
+    last_entry: trades[0].entry,
+    quantity: avg_size,
+    entry: avg_entry,
+    loss: trades[0].neg_pnl,
+    number_of_trades: trades.length,
+    fee: to_f(expected_fee, "%.2f"),
+    anchor_pnl: anchor?.target_pnl
+  };
+}
+function helperFuncToBuildTrades({
+  custom_b_config,
+  symbol_config,
+  app_config_kind,
+  appConfig,
+  force_exact_risk = true
+}) {
+  const risk = custom_b_config.risk * (custom_b_config.risk_factor || 1);
+  let result = getRiskReward({
+    entry: custom_b_config.entry,
+    stop: custom_b_config.stop,
+    risk,
+    global_config: symbol_config,
+    force_exact_risk,
+    target_loss: custom_b_config.risk * (custom_b_config.risk_factor || 1),
+    distribution: custom_b_config.distribution
+  });
+  if (!force_exact_risk) {
+    result = {
+      risk_reward: result,
+      risk
+    };
+  }
+  const trades = result.risk_reward ? buildTrades({
+    appConfig: { [app_config_kind]: appConfig },
+    kind: app_config_kind,
+    settings: {
+      entry: custom_b_config.entry,
+      stop: custom_b_config.stop,
+      risk: result.risk || custom_b_config.risk,
+      risk_reward: result.risk_reward,
+      distribution: custom_b_config.distribution
+    }
+  }) : [];
+  const summary = trades.length > 0 ? generateSummary({ trades }) : {};
+  return { trades, result, summary };
+}
+function constructAppConfig2({
+  config: config2,
+  global_config
+}) {
+  const options = {
+    entry: config2?.entry,
+    stop: config2?.stop,
+    risk_reward: config2?.risk_reward,
+    risk: config2?.risk,
+    symbol: config2.symbol
+  };
+  const { entries: _entries, ...appConfig } = buildAppConfig(global_config, options);
+  return appConfig;
+}
+function buildWithOptimumReward({
+  config: config2,
+  settings,
+  global_config
+}) {
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  let stop = settings.stop;
+  let entry = settings.entry;
+  const risk = settings.risk;
+  const stop_ratio = settings.stop_ratio || 1;
+  const distribution = settings.distribution || config2?.distribution;
+  const custom_b_config = {
+    entry,
+    stop,
+    risk,
+    distribution
+  };
+  const appConfig = constructAppConfig2({
+    config: config2,
+    global_config
+  });
+  const { trades, summary, result } = helperFuncToBuildTrades({
+    custom_b_config,
+    app_config_kind: kind,
+    appConfig,
+    symbol_config: global_config
+  });
+  const adjusted_size = summary.quantity;
+  const symbol_config = global_config;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, "%.2f"),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(adjusted_size, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(summary.loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    margin: to_f(summary.entry * adjusted_size / symbol_config.leverage, "%.2f")
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    config: {
+      ...custom_b_config,
+      ...result,
+      stop_ratio
+    },
+    stop_order: {
+      quantity: entryDetails.avg_size * stop_ratio,
+      price: entryDetails.stop
+    },
+    kind
+  };
+}
+function generateOppositeOptimum({
+  config: config2,
+  global_config,
+  settings,
+  ratio = 1,
+  distribution,
+  risk_factor = 1
+}) {
+  const configKind = config2.entry > config2.stop ? "long" : "short";
+  if (configKind === "long" && config2.entry > config2.stop) {
+    if (settings.stop <= settings.entry) {
+      throw new Error("Invalid input: For long config positions, opposite settings must have stop > entry");
+    }
+  } else if (configKind === "short" && config2.entry < config2.stop) {
+    if (settings.stop >= settings.entry) {
+      throw new Error("Invalid input: For short config positions, opposite settings must have stop < entry");
+    }
+  }
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const app_config_kind = kind === "long" ? "short" : "long";
+  let risk = settings.risk;
+  const custom_b_config = {
+    entry: settings.entry,
+    stop: settings.stop,
+    risk: risk * ratio,
+    distribution: distribution || "inverse-exponential",
+    risk_factor
+  };
+  const appConfig = constructAppConfig2({
+    config: {
+      ...config2,
+      ...custom_b_config
+    },
+    global_config
+  });
+  const { result, trades, summary } = helperFuncToBuildTrades({
+    custom_b_config,
+    symbol_config: global_config,
+    app_config_kind,
+    appConfig
+  });
+  if (Object.keys(summary).length === 0) {
+    return {
+      trades,
+      summary,
+      config: custom_b_config,
+      kind: app_config_kind
+    };
+  }
+  const symbol_config = global_config;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, "%.2f"),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(summary.quantity, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(summary.loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    defaultEntry: settings.entry ? to_f(settings.entry, symbol_config.price_places) : null
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    config: {
+      ...custom_b_config,
+      ...result
+    },
+    kind: app_config_kind
+  };
+}
+function defaultTradeFromCurrentState({
+  config: config2,
+  global_config
+}) {
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const settings = {
+    entry: config2?.entry,
+    stop: config2?.stop,
+    risk: config2?.risk,
+    distribution: config2?.distribution,
+    risk_reward: config2?.risk_reward
+  };
+  const appConfig = constructAppConfig2({
+    config: config2,
+    global_config
+  });
+  const trades = buildTrades({
+    appConfig: { [kind]: appConfig },
+    kind,
+    settings
+  });
+  return {
+    trades,
+    summary: generateSummary({
+      trades,
+      fee_percent: global_config.fee_percent
+    })
+  };
+}
+function increaseTradeHelper({
+  increase_qty,
+  stop,
+  config: config2,
+  global_config,
+  style,
+  entry,
+  position: position2,
+  stop_ratio = 1,
+  distribution: default_distribution
+}) {
+  const symbol_config = global_config;
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const distribution = default_distribution || config2.distribution || "inverse-exponential";
+  const appConfig = constructAppConfig2({
+    config: config2,
+    global_config
+  });
+  const currentState = defaultTradeFromCurrentState({
+    config: config2,
+    global_config
+  });
+  const { optimal_risk, neg_pnl } = getOptimumStopAndRisk(appConfig, {
+    max_size: increase_qty,
+    target_stop: stop,
+    distribution
+  });
+  if (neg_pnl === 0) {
+    return {
+      trades: [],
+      summary: {},
+      config: {},
+      kind,
+      current: currentState
+    };
+  }
+  const custom_b_config = {
+    entry,
+    stop,
+    risk: style === "minimum" ? Math.abs(neg_pnl) : optimal_risk,
+    distribution
+  };
+  const { result, trades, summary } = helperFuncToBuildTrades({
+    custom_b_config,
+    symbol_config,
+    appConfig,
+    app_config_kind: kind
+  });
+  if (Object.keys(summary).length === 0) {
+    return {
+      trades,
+      summary,
+      config: {
+        ...custom_b_config,
+        ...result
+      },
+      kind,
+      current: currentState
+    };
+  }
+  const new_avg_values = determine_average_entry_and_size([
+    {
+      price: position2.entry,
+      quantity: position2.quantity
+    },
+    {
+      price: summary?.entry,
+      quantity: summary?.quantity
+    }
+  ], symbol_config.decimal_places, symbol_config.price_places);
+  summary.entry = new_avg_values.entry;
+  summary.quantity = new_avg_values.quantity;
+  const loss = Math.abs(summary.entry - custom_b_config.stop) * summary.quantity;
+  const entryDetails = {
+    entry: to_f(custom_b_config.entry, symbol_config.price_places),
+    stop: to_f(custom_b_config.stop, symbol_config.price_places),
+    risk: to_f(result.risk, symbol_config.price_places),
+    risk_reward: result.risk_reward,
+    avg_entry: to_f(summary.entry, symbol_config.price_places),
+    avg_size: to_f(summary.quantity, symbol_config.decimal_places),
+    first_entry: to_f(summary.first_entry, symbol_config.price_places),
+    pnl: to_f(custom_b_config.risk, "%.2f"),
+    fee: to_f(summary.fee, "%.2f"),
+    loss: to_f(loss, "%.2f"),
+    last_entry: to_f(summary.last_entry, symbol_config.price_places),
+    margin: to_f(summary.entry * summary.quantity / global_config.leverage, "%.2f")
+  };
+  return {
+    trades,
+    summary: entryDetails,
+    stop_order: {
+      quantity: entryDetails.avg_size * stop_ratio,
+      price: entryDetails.stop
+    },
+    config: {
+      ...custom_b_config,
+      ...result
+    },
+    kind,
+    current: currentState
+  };
+}
+function generatePositionIncreaseTrade({
+  account,
+  zoneAccount,
+  ratio = 0.1,
+  config: config2,
+  global_config,
+  style = "minimum",
+  distribution = "inverse-exponential"
+}) {
+  const kind = config2.entry > config2.stop ? "long" : "short";
+  const target_max_quantity = kind === "long" ? account.short.quantity : account.long.quantity;
+  const increase_qty = target_max_quantity * ratio;
+  const entry = zoneAccount.entry;
+  const stop = zoneAccount.stop;
+  return increaseTradeHelper({
+    config: config2,
+    position: account[kind],
+    global_config,
+    entry,
+    stop,
+    style,
+    increase_qty,
+    distribution
+  });
+}
+var compoundAPI = {
+  buildWithOptimumReward,
+  constructAppConfig: constructAppConfig2,
+  generateOppositeOptimum,
+  increaseTradeHelper,
+  generatePositionIncreaseTrade
+};
 // src/types/index.ts
 class BaseExchange {
   client;