@gbozee/ultimate 0.0.2-48 → 0.0.2-51

package/dist/frontend-index.d.ts

@@ -221,6 +221,7 @@ export type GlobalConfig = {
 	}[];
 	risk_reward: number;
 	reverse_factor: number;
+	leverage?: number;
 };
 export type AppConfig = {
 	fee: number;
@@ -350,5 +351,73 @@ export declare function determine_amount_to_buy(payload: {
 	position: any;
 	existingOrders: any[];
 }): any[];
+export declare function generateOptimumAppConfig(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	start_risk: number;
+	max_risk?: number;
+}, position: {
+	entry: number;
+	quantity: number;
+	kind: "long" | "short";
+}): AppConfig | null;
+export type StrategyPosition = {
+	entry: number;
+	quantity: number;
+};
+export type Config = {
+	leverage: number;
+	tp_percent: number;
+	short_tp_factor: number;
+	price_places: string;
+	decimal_places: string;
+	fee_percent?: number;
+	budget: number;
+	global_config: GlobalConfig;
+};
+export declare class Strategy {
+	position: {
+		long: StrategyPosition;
+		short: StrategyPosition;
+	};
+	config: Config;
+	constructor(payload: {
+		long: StrategyPosition;
+		short: StrategyPosition;
+		config: Config;
+	});
+	to_f(price: number): number;
+	to_df(quantity: number): number;
+	pnl(kind: "long" | "short"): number;
+	tp(kind: "long" | "short"): number;
+	calculate_fee(position: {
+		price: number;
+		quantity: number;
+	}): number;
+	get long_tp(): number;
+	get short_tp(): number;
+	generateGapClosingAlgorithm(payload: {
+		kind: "long" | "short";
+		risk_reward?: number;
+	}): {
+		[x: string]: any;
+		risk: number;
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+	};
+	runIterations(payload: {
+		kind: "long" | "short";
+		iterations: number;
+		risk_reward?: number;
+	}): {
+		[x: string]: any;
+		risk: number;
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+	}[];
+}
 
 export {};

package/dist/frontend-index.js

@@ -1519,6 +1519,321 @@ function determine_amount_to_buy(payload) {
   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;
+  console.log(`Starting risk search for ${position2.kind} position. Target Entry: ${position2.entry}, Initial Risk Range: [${low_risk}, ${high_risk}]`);
+  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
+    });
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, Low=${low_risk.toFixed(2)}, High=${high_risk.toFixed(2)}`);
+    if (full_trades.length === 0) {
+      console.log(`  -> No trades generated by sortedBuildConfig at Risk=${mid_risk.toFixed(2)}. Adjusting high_risk down.`);
+      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) {
+      console.log(`  -> No trades met quantity requirement after filtering at Risk=${mid_risk.toFixed(2)}. Adjusting low_risk up.`);
+      low_risk = mid_risk;
+      continue;
+    }
+    const last_trade = trades[trades.length - 1];
+    const last_entry = last_trade.entry;
+    console.log(`  -> Last Trade Entry (Filtered): ${last_entry.toFixed(4)}`);
+    if (position2.kind === "long") {
+      if (last_entry > position2.entry) {
+        console.log(`  -> Constraint VIOLATED (Long): last_entry (${last_entry.toFixed(4)}) > position.entry (${position2.entry.toFixed(4)}). Reducing high_risk.`);
+        high_risk = mid_risk;
+      } else {
+        console.log(`  -> Constraint MET (Long): last_entry (${last_entry.toFixed(4)}) <= position.entry (${position2.entry.toFixed(4)}). Storing as best, increasing low_risk.`);
+        best_risk = mid_risk;
+        best_app_config = current_app_config;
+        low_risk = mid_risk;
+      }
+    } else {
+      if (last_entry < position2.entry) {
+        console.log(`  -> Constraint VIOLATED (Short): last_entry (${last_entry.toFixed(4)}) < position.entry (${position2.entry.toFixed(4)}). Reducing high_risk.`);
+        high_risk = mid_risk;
+      } else {
+        console.log(`  -> Constraint MET (Short): last_entry (${last_entry.toFixed(4)}) >= position.entry (${position2.entry.toFixed(4)}). Storing as best, increasing low_risk.`);
+        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;
+}
+// src/helpers/strategy.ts
+class Strategy {
+  position;
+  config;
+  constructor(payload) {
+    this.position = {
+      long: payload.long,
+      short: payload.short
+    };
+    this.config = payload.config;
+    if (!this.config.fee_percent) {
+      this.config.fee_percent = 0.05;
+    }
+  }
+  to_f(price) {
+    return to_f(price, this.config.price_places);
+  }
+  to_df(quantity) {
+    return to_f(quantity, this.config.decimal_places);
+  }
+  pnl(kind) {
+    const position2 = 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) {
+    const position2 = this.position[kind];
+    const { entry, quantity } = position2;
+    const profit = this.pnl(kind);
+    const diff = profit / quantity;
+    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, risk_reward = 199 } = 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];
+    const second_payload = {
+      entry: this.tp(kind),
+      stop: this.tp(reverse_kind),
+      risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
+    const third_payload = {
+      entry,
+      quantity,
+      kind
+    };
+    console.log({ second_payload, third_payload });
+    const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
+    if (!app_config) {
+      return null;
+    }
+    const { entries, ...rest } = app_config;
+    const risk = this.to_f(rest.risk_per_trade);
+    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
+      }
+    ]), rest.decimal_places, rest.price_places);
+    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < reverse_position.entry;
+    }) : entries.filter((u) => {
+      return u.entry > reverse_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
+      }
+    ]), rest.decimal_places, rest.price_places);
+    const reverse_pnl = this.to_f((reverse_avg.price - second_payload.stop) * reverse_avg.quantity);
+    const fee_to_pay = this.calculate_fee({
+      price: avg.entry,
+      quantity: avg.quantity
+    }) + this.calculate_fee({
+      price: reverse_avg.entry,
+      quantity: reverse_avg.quantity
+    });
+    const net_reverse_pnl = reverse_pnl - fee_to_pay;
+    const ratio = net_reverse_pnl / focus_loss;
+    const quantity_to_sell = this.to_df(ratio * avg.quantity);
+    const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    return {
+      risk,
+      [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
+      },
+      [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)
+      },
+      last_entry: rest.last_value.entry,
+      first_entry: entries.at(-1).entry,
+      threshold
+    };
+  }
+  runIterations(payload) {
+    const { kind, iterations, risk_reward = 199 } = payload;
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const result = [];
+    let position2 = {
+      long: this.position.long,
+      short: this.position.short
+    };
+    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 + i * 4
+        }
+      });
+      const algorithm = instance.generateGapClosingAlgorithm({
+        kind,
+        risk_reward
+      });
+      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
+      };
+      position2[reverse_kind] = {
+        entry: algorithm[reverse_kind].tp,
+        quantity: algorithm[reverse_kind].re_entry_quantity
+      };
+    }
+    return result;
+  }
+}
 export {
   to_f,
   sortedBuildConfig,
@@ -1534,6 +1849,7 @@ export {
   getOptimumStopAndRisk,
   getDecimalPlaces,
   generate_config_params,
+  generateOptimumAppConfig,
   formatPrice,
   fibonacci_analysis,
   extractValue,
@@ -1552,5 +1868,6 @@ export {
   buildAppConfig,
   asCoins,
   allCoins,
+  Strategy,
   SpecialCoins
 };

package/dist/index.d.ts

@@ -123,6 +123,7 @@ export type GlobalConfig = {
 	}[];
 	risk_reward: number;
 	reverse_factor: number;
+	leverage?: number;
 };
 interface Position$1 {
 	id: number;
@@ -755,6 +756,17 @@ export declare function determine_amount_to_buy(payload: {
 	position: any;
 	existingOrders: any[];
 }): any[];
+export declare function generateOptimumAppConfig(config: GlobalConfig, payload: {
+	entry: number;
+	stop: number;
+	risk_reward: number;
+	start_risk: number;
+	max_risk?: number;
+}, position: {
+	entry: number;
+	quantity: number;
+	kind: "long" | "short";
+}): AppConfig | null;
 declare class ExchangePosition {
 	exchange: BaseExchange;
 	exchange_account: ExchangeAccount$1;
@@ -1418,6 +1430,63 @@ export declare function initialize(payload: {
 	ignore_proxy?: boolean;
 	canWithdraw?: boolean;
 }): Promise<App>;
+export type StrategyPosition = {
+	entry: number;
+	quantity: number;
+};
+export type Config = {
+	leverage: number;
+	tp_percent: number;
+	short_tp_factor: number;
+	price_places: string;
+	decimal_places: string;
+	fee_percent?: number;
+	budget: number;
+	global_config: GlobalConfig;
+};
+export declare class Strategy {
+	position: {
+		long: StrategyPosition;
+		short: StrategyPosition;
+	};
+	config: Config;
+	constructor(payload: {
+		long: StrategyPosition;
+		short: StrategyPosition;
+		config: Config;
+	});
+	to_f(price: number): number;
+	to_df(quantity: number): number;
+	pnl(kind: "long" | "short"): number;
+	tp(kind: "long" | "short"): number;
+	calculate_fee(position: {
+		price: number;
+		quantity: number;
+	}): number;
+	get long_tp(): number;
+	get short_tp(): number;
+	generateGapClosingAlgorithm(payload: {
+		kind: "long" | "short";
+		risk_reward?: number;
+	}): {
+		[x: string]: any;
+		risk: number;
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+	};
+	runIterations(payload: {
+		kind: "long" | "short";
+		iterations: number;
+		risk_reward?: number;
+	}): {
+		[x: string]: any;
+		risk: number;
+		last_entry: any;
+		first_entry: any;
+		threshold: any;
+	}[];
+}
 
 export {
 	ExchangeAccount$1 as ExchangeAccount,

package/dist/index.js

@@ -55418,6 +55418,124 @@ function determine_amount_to_buy(payload) {
   filteredOrders = filteredOrders.filter((k) => !existingOrders.map((j) => j.price).includes(k.price));
   return filteredOrders;
 }
+function generateOptimumAppConfig(config2, 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;
+  console.log(`Starting risk search for ${position2.kind} position. Target Entry: ${position2.entry}, Initial Risk Range: [${low_risk}, ${high_risk}]`);
+  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({
+      ...config2,
+      risk: mid_risk,
+      profit_percent: config2.profit_percent || 0,
+      profit: config2.profit || 500,
+      risk_reward: payload.risk_reward,
+      kind: position2.kind,
+      price_places: config2.price_places,
+      decimal_places: config2.decimal_places,
+      accounts: config2.accounts || [],
+      reduce_percent: config2.reduce_percent || 90,
+      reverse_factor: config2.reverse_factor || 1,
+      symbol: config2.symbol || "",
+      support: config2.support || 0,
+      resistance: config2.resistance || 0,
+      min_size: config2.min_size || 0,
+      stop_percent: config2.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
+    });
+    console.log(`Iteration ${iterations}: Risk=${mid_risk.toFixed(2)}, Low=${low_risk.toFixed(2)}, High=${high_risk.toFixed(2)}`);
+    if (full_trades.length === 0) {
+      console.log(`  -> No trades generated by sortedBuildConfig at Risk=${mid_risk.toFixed(2)}. Adjusting high_risk down.`);
+      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) {
+      console.log(`  -> No trades met quantity requirement after filtering at Risk=${mid_risk.toFixed(2)}. Adjusting low_risk up.`);
+      low_risk = mid_risk;
+      continue;
+    }
+    const last_trade = trades[trades.length - 1];
+    const last_entry = last_trade.entry;
+    console.log(`  -> Last Trade Entry (Filtered): ${last_entry.toFixed(4)}`);
+    if (position2.kind === "long") {
+      if (last_entry > position2.entry) {
+        console.log(`  -> Constraint VIOLATED (Long): last_entry (${last_entry.toFixed(4)}) > position.entry (${position2.entry.toFixed(4)}). Reducing high_risk.`);
+        high_risk = mid_risk;
+      } else {
+        console.log(`  -> Constraint MET (Long): last_entry (${last_entry.toFixed(4)}) <= position.entry (${position2.entry.toFixed(4)}). Storing as best, increasing low_risk.`);
+        best_risk = mid_risk;
+        best_app_config = current_app_config;
+        low_risk = mid_risk;
+      }
+    } else {
+      if (last_entry < position2.entry) {
+        console.log(`  -> Constraint VIOLATED (Short): last_entry (${last_entry.toFixed(4)}) < position.entry (${position2.entry.toFixed(4)}). Reducing high_risk.`);
+        high_risk = mid_risk;
+      } else {
+        console.log(`  -> Constraint MET (Short): last_entry (${last_entry.toFixed(4)}) >= position.entry (${position2.entry.toFixed(4)}). Storing as best, increasing low_risk.`);
+        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;
+}
 
 // src/position.ts
 class ExchangePosition {
@@ -57952,6 +58070,203 @@ async function initialize(payload) {
   });
   return app;
 }
+// src/helpers/strategy.ts
+class Strategy {
+  position;
+  config;
+  constructor(payload) {
+    this.position = {
+      long: payload.long,
+      short: payload.short
+    };
+    this.config = payload.config;
+    if (!this.config.fee_percent) {
+      this.config.fee_percent = 0.05;
+    }
+  }
+  to_f(price) {
+    return to_f(price, this.config.price_places);
+  }
+  to_df(quantity) {
+    return to_f(quantity, this.config.decimal_places);
+  }
+  pnl(kind) {
+    const position2 = 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) {
+    const position2 = this.position[kind];
+    const { entry, quantity } = position2;
+    const profit = this.pnl(kind);
+    const diff = profit / quantity;
+    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, risk_reward = 199 } = 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];
+    const second_payload = {
+      entry: this.tp(kind),
+      stop: this.tp(reverse_kind),
+      risk_reward,
+      start_risk: this.pnl(reverse_kind),
+      max_risk: this.config.budget
+    };
+    const third_payload = {
+      entry,
+      quantity,
+      kind
+    };
+    console.log({ second_payload, third_payload });
+    const app_config = generateOptimumAppConfig(this.config.global_config, second_payload, third_payload);
+    if (!app_config) {
+      return null;
+    }
+    const { entries, ...rest } = app_config;
+    const risk = this.to_f(rest.risk_per_trade);
+    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
+      }
+    ]), rest.decimal_places, rest.price_places);
+    const focus_loss = this.to_f((avg.price - second_payload.stop) * avg.quantity);
+    let below_reverse_entries = kind === "long" ? entries.filter((u) => {
+      return u.entry < reverse_position.entry;
+    }) : entries.filter((u) => {
+      return u.entry > reverse_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
+      }
+    ]), rest.decimal_places, rest.price_places);
+    const reverse_pnl = this.to_f((reverse_avg.price - second_payload.stop) * reverse_avg.quantity);
+    const fee_to_pay = this.calculate_fee({
+      price: avg.entry,
+      quantity: avg.quantity
+    }) + this.calculate_fee({
+      price: reverse_avg.entry,
+      quantity: reverse_avg.quantity
+    });
+    const net_reverse_pnl = reverse_pnl - fee_to_pay;
+    const ratio = net_reverse_pnl / focus_loss;
+    const quantity_to_sell = this.to_df(ratio * avg.quantity);
+    const remaining_quantity = this.to_df(avg.quantity - quantity_to_sell);
+    return {
+      risk,
+      [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
+      },
+      [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)
+      },
+      last_entry: rest.last_value.entry,
+      first_entry: entries.at(-1).entry,
+      threshold
+    };
+  }
+  runIterations(payload) {
+    const { kind, iterations, risk_reward = 199 } = payload;
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const result = [];
+    let position2 = {
+      long: this.position.long,
+      short: this.position.short
+    };
+    for (let i2 = 0;i2 < iterations; i2++) {
+      const instance = new Strategy({
+        long: position2.long,
+        short: position2.short,
+        config: {
+          ...this.config,
+          tp_percent: this.config.tp_percent + i2 * 4
+        }
+      });
+      const algorithm = instance.generateGapClosingAlgorithm({
+        kind,
+        risk_reward
+      });
+      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
+      };
+      position2[reverse_kind] = {
+        entry: algorithm[reverse_kind].tp,
+        quantity: algorithm[reverse_kind].re_entry_quantity
+      };
+    }
+    return result;
+  }
+}
 export {
   sortedBuildConfig,
   initialize,
@@ -57959,6 +58274,7 @@ export {
   get_app_config_and_max_size,
   getOptimumStopAndRisk,
   generate_config_params,
+  generateOptimumAppConfig,
   determine_break_even_price,
   determine_average_entry_and_size,
   determine_amount_to_buy,
@@ -57966,6 +58282,7 @@ export {
   buildConfig,
   buildAvg,
   buildAppConfig,
+  Strategy,
   ExchangeAccount,
   AppDatabase
 };

package/package.json

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