@gbozee/ultimate 0.0.2-64 → 0.0.2-67

package/dist/frontend-index.d.ts

@@ -367,6 +367,31 @@ export declare function generateOptimumAppConfig(config: GlobalConfig, payload:
 	quantity: number;
 	kind: "long" | "short";
 }): AppConfig | null;
+export declare function determineOptimumReward(app_config: AppConfig, increase?: boolean, low_range?: number, high_range?: number): number | {
+	result: any[];
+	value: number;
+	total: number;
+	risk_per_trade: number;
+	max: number;
+	min: number;
+	neg_pnl: any;
+	entry: any;
+};
+export declare function computeRiskReward(payload: {
+	app_config: AppConfig;
+	entry: number;
+	stop: number;
+	risk_per_trade: number;
+}): number | {
+	result: any[];
+	value: number;
+	total: number;
+	risk_per_trade: number;
+	max: number;
+	min: number;
+	neg_pnl: any;
+	entry: any;
+};
 export type StrategyPosition = {
 	entry: number;
 	quantity: number;

package/dist/frontend-index.js

@@ -1644,6 +1644,113 @@ function generateOptimumAppConfig(config, payload, position2) {
   });
   return best_app_config;
 }
+function determineOptimumReward(app_config, increase = true, low_range = 30, high_range = 199) {
+  const criterion = app_config.strategy || "quantity";
+  const risk_rewards = createArray(low_range, high_range, 1);
+  let func = risk_rewards.map((trade_no) => {
+    let trades = sortedBuildConfig(app_config, {
+      take_profit: app_config.take_profit,
+      entry: app_config.entry,
+      stop: app_config.stop,
+      no_of_trades: trade_no,
+      risk_reward: trade_no,
+      increase,
+      kind: app_config.kind,
+      gap: app_config.gap,
+      decimal_places: app_config.decimal_places
+    });
+    let total = 0;
+    let max = -Infinity;
+    let min = Infinity;
+    let neg_pnl = trades[0]?.neg_pnl || 0;
+    let entry = trades.at(-1)?.entry;
+    if (!entry) {
+      return null;
+    }
+    for (let trade of trades) {
+      total += trade.quantity;
+      max = Math.max(max, trade.quantity);
+      min = Math.min(min, trade.quantity);
+      entry = app_config.kind === "long" ? Math.max(entry, trade.entry) : Math.min(entry, trade.entry);
+    }
+    return {
+      result: trades,
+      value: trade_no,
+      total,
+      risk_per_trade: app_config.risk_per_trade,
+      max,
+      min,
+      neg_pnl,
+      entry
+    };
+  });
+  func = func.filter((r) => Boolean(r)).filter((r) => {
+    let foundIndex = r?.result.findIndex((e) => e.quantity === r.max);
+    return criterion === "quantity" ? foundIndex === 0 : true;
+  });
+  const highest = criterion === "quantity" ? Math.max(...func.map((o) => o.max)) : Math.min(...func.map((o) => o.entry));
+  const key = criterion === "quantity" ? "max" : "entry";
+  const index = findIndexByCondition(func, app_config.kind, (x) => x[key] == highest, criterion);
+  if (app_config.raw) {
+    return func[index];
+  }
+  return func[index]?.value;
+}
+function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
+  const found = [];
+  let max_new_diff = 0;
+  let new_lst = lst.map((i, j) => ({
+    ...i,
+    net_diff: lst[j].neg_pnl + lst[j].risk_per_trade
+  }));
+  new_lst.forEach((item, index) => {
+    if (item.net_diff > 0) {
+      found.push(index);
+    }
+  });
+  if (found.length === 0) {
+    max_new_diff = Math.max(...new_lst.map((e) => e.net_diff));
+    found.push(new_lst.findIndex((e) => e.net_diff === max_new_diff));
+  }
+  const sortedFound = found.map((o, index) => ({ ...new_lst[o], index: o })).filter((j) => max_new_diff === 0 ? j.net_diff > 0 : j.net_diff >= max_new_diff).sort((a, b) => {
+    if (a.total !== b.total) {
+      return b.total - a.total;
+      return b.net_diff - a.net_diff;
+      return a.net_diff - b.net_diff;
+    } else {
+      return b.net_diff - a.net_diff;
+    }
+  });
+  if (defaultKey === "quantity") {
+    return sortedFound[0].index;
+  }
+  if (found.length === 1) {
+    return found[0];
+  }
+  if (found.length === 0) {
+    return -1;
+  }
+  const entryCondition = (a, b) => {
+    if (kind == "long") {
+      return a.entry > b.entry;
+    }
+    return a.entry < b.entry;
+  };
+  const maximum = found.reduce((maxIndex, currentIndex) => {
+    return new_lst[currentIndex]["net_diff"] < new_lst[maxIndex]["net_diff"] && entryCondition(new_lst[currentIndex], new_lst[maxIndex]) ? currentIndex : maxIndex;
+  }, found[0]);
+  return maximum;
+}
+function computeRiskReward(payload) {
+  const { app_config, entry, stop, risk_per_trade } = 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);
+  return result;
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -1940,10 +2047,12 @@ export {
   determine_average_entry_and_size,
   determine_amount_to_sell2 as determine_amount_to_sell,
   determine_amount_to_buy,
+  determineOptimumReward,
   createGapPairs,
   createArray,
   computeTotalAverageForEachTrade,
   computeSellZones,
+  computeRiskReward,
   buildConfig,
   buildAvg,
   buildAppConfig,

package/dist/index.cjs

@@ -41746,8 +41746,10 @@ __export(exports_src, {
   determine_break_even_price: () => determine_break_even_price,
   determine_average_entry_and_size: () => determine_average_entry_and_size,
   determine_amount_to_buy: () => determine_amount_to_buy,
+  determineOptimumReward: () => determineOptimumReward,
   database: () => exports_database,
   createArray: () => createArray,
+  computeRiskReward: () => computeRiskReward,
   buildConfig: () => buildConfig,
   buildAvg: () => buildAvg,
   buildAppConfig: () => buildAppConfig,
@@ -53543,6 +53545,113 @@ function generateOptimumAppConfig(config2, payload, position2) {
   });
   return best_app_config;
 }
+function determineOptimumReward(app_config, increase = true, low_range = 30, high_range = 199) {
+  const criterion = app_config.strategy || "quantity";
+  const risk_rewards = createArray(low_range, high_range, 1);
+  let func = risk_rewards.map((trade_no) => {
+    let trades = sortedBuildConfig(app_config, {
+      take_profit: app_config.take_profit,
+      entry: app_config.entry,
+      stop: app_config.stop,
+      no_of_trades: trade_no,
+      risk_reward: trade_no,
+      increase,
+      kind: app_config.kind,
+      gap: app_config.gap,
+      decimal_places: app_config.decimal_places
+    });
+    let total = 0;
+    let max = -Infinity;
+    let min = Infinity;
+    let neg_pnl = trades[0]?.neg_pnl || 0;
+    let entry = trades.at(-1)?.entry;
+    if (!entry) {
+      return null;
+    }
+    for (let trade of trades) {
+      total += trade.quantity;
+      max = Math.max(max, trade.quantity);
+      min = Math.min(min, trade.quantity);
+      entry = app_config.kind === "long" ? Math.max(entry, trade.entry) : Math.min(entry, trade.entry);
+    }
+    return {
+      result: trades,
+      value: trade_no,
+      total,
+      risk_per_trade: app_config.risk_per_trade,
+      max,
+      min,
+      neg_pnl,
+      entry
+    };
+  });
+  func = func.filter((r2) => Boolean(r2)).filter((r2) => {
+    let foundIndex = r2?.result.findIndex((e2) => e2.quantity === r2.max);
+    return criterion === "quantity" ? foundIndex === 0 : true;
+  });
+  const highest = criterion === "quantity" ? Math.max(...func.map((o) => o.max)) : Math.min(...func.map((o) => o.entry));
+  const key = criterion === "quantity" ? "max" : "entry";
+  const index = findIndexByCondition(func, app_config.kind, (x) => x[key] == highest, criterion);
+  if (app_config.raw) {
+    return func[index];
+  }
+  return func[index]?.value;
+}
+function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
+  const found = [];
+  let max_new_diff = 0;
+  let new_lst = lst.map((i2, j) => ({
+    ...i2,
+    net_diff: lst[j].neg_pnl + lst[j].risk_per_trade
+  }));
+  new_lst.forEach((item, index) => {
+    if (item.net_diff > 0) {
+      found.push(index);
+    }
+  });
+  if (found.length === 0) {
+    max_new_diff = Math.max(...new_lst.map((e2) => e2.net_diff));
+    found.push(new_lst.findIndex((e2) => e2.net_diff === max_new_diff));
+  }
+  const sortedFound = found.map((o, index) => ({ ...new_lst[o], index: o })).filter((j) => max_new_diff === 0 ? j.net_diff > 0 : j.net_diff >= max_new_diff).sort((a, b) => {
+    if (a.total !== b.total) {
+      return b.total - a.total;
+      return b.net_diff - a.net_diff;
+      return a.net_diff - b.net_diff;
+    } else {
+      return b.net_diff - a.net_diff;
+    }
+  });
+  if (defaultKey === "quantity") {
+    return sortedFound[0].index;
+  }
+  if (found.length === 1) {
+    return found[0];
+  }
+  if (found.length === 0) {
+    return -1;
+  }
+  const entryCondition = (a, b) => {
+    if (kind == "long") {
+      return a.entry > b.entry;
+    }
+    return a.entry < b.entry;
+  };
+  const maximum = found.reduce((maxIndex, currentIndex) => {
+    return new_lst[currentIndex]["net_diff"] < new_lst[maxIndex]["net_diff"] && entryCondition(new_lst[currentIndex], new_lst[maxIndex]) ? currentIndex : maxIndex;
+  }, found[0]);
+  return maximum;
+}
+function computeRiskReward(payload) {
+  const { app_config, entry, stop, risk_per_trade } = 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);
+  return result;
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -56603,6 +56712,64 @@ class ExchangeAccount {
     });
     return app_config;
   }
+  async justInTimeProfit(payload) {
+    const { symbol, target_pnl, kind, refresh, place, take_profit, pause_tp } = payload;
+    if (refresh) {
+      await this.syncAccount({
+        symbol,
+        live_refresh: true,
+        update: true
+      });
+    }
+    const position2 = await this.syncAccount({
+      symbol,
+      kind,
+      as_view: true
+    });
+    const current_price = take_profit || position2.current_price;
+    const notional_value = position2.quantity * position2.entry;
+    const current_pnl = to_f2(Math.abs(current_price - position2.entry) * position2.quantity, "%.2f");
+    const profit_percent = current_pnl * 100 / notional_value;
+    const sell_ratio = target_pnl / current_pnl;
+    if (place) {
+      const existing_config = await this.getPositionConfig({
+        symbol,
+        kind
+      });
+      if (existing_config) {
+        const trigger2 = place;
+        const config2 = await this.buildReduceConfig({
+          symbol,
+          as_dict: true,
+          trigger: {
+            long: trigger2 || false,
+            short: trigger2 || false
+          },
+          kind,
+          target_pnl: current_pnl
+        });
+        config2[kind].sell_ratio = sell_ratio;
+        if (trigger2) {
+          await this.app_db.updateScheduledTrade(existing_config.id, {
+            pause_tp
+          });
+          await this.reduceMajorPositionEntry({
+            symbol,
+            long: config2.long,
+            short: config2.short,
+            trigger: config2.trigger
+          });
+        }
+      }
+    }
+    return {
+      sell_ratio,
+      current_pnl,
+      profit_percent,
+      current_price,
+      notional_value
+    };
+  }
   async buildTrades(payload) {
     const { symbol, kind, risk } = payload;
     const config2 = await this.getPositionConfig({
@@ -57061,7 +57228,17 @@ class ExchangeAccount {
         kind
       });
     }
-    if (payload.trigger) {
+    const long_config = await this.getPositionConfig({
+      symbol,
+      kind: "long"
+    });
+    const short_config = await this.getPositionConfig({
+      symbol,
+      kind: "short"
+    });
+    const long_pause_tp = long_config?.pause_tp;
+    const short_pause_tp = short_config?.pause_tp;
+    if (payload.trigger && !long_pause_tp && !short_pause_tp) {
       return await this.reduceMajorPositionEntry({
         symbol,
         long: config2.long,

package/dist/index.d.ts

@@ -70,6 +70,7 @@ export interface ScheduledTrade extends BaseSystemFields {
 	reduce_ratio?: number;
 	sell_ratio?: number;
 	threshold_qty?: number;
+	pause_tp?: boolean;
 }
 export interface AccountStrategy extends BaseSystemFields {
 	account: string;
@@ -117,6 +118,7 @@ export interface PositionsView {
 	sell_ratio?: number;
 	threshold_qty?: number;
 	follow?: boolean | 1 | 0;
+	current_price?: number;
 }
 export interface BullishMarket extends RecordModel {
 	id: string;
@@ -898,6 +900,31 @@ export declare function generateOptimumAppConfig(config: GlobalConfig, payload:
 	quantity: number;
 	kind: "long" | "short";
 }): AppConfig | null;
+export declare function determineOptimumReward(app_config: AppConfig, increase?: boolean, low_range?: number, high_range?: number): number | {
+	result: any[];
+	value: number;
+	total: number;
+	risk_per_trade: number;
+	max: number;
+	min: number;
+	neg_pnl: any;
+	entry: any;
+};
+export declare function computeRiskReward(payload: {
+	app_config: AppConfig;
+	entry: number;
+	stop: number;
+	risk_per_trade: number;
+}): number | {
+	result: any[];
+	value: number;
+	total: number;
+	risk_per_trade: number;
+	max: number;
+	min: number;
+	neg_pnl: any;
+	entry: any;
+};
 declare class ExchangePosition {
 	exchange: BaseExchange;
 	exchange_account: ExchangeAccount$1;
@@ -1147,6 +1174,21 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<AppConfig>;
+	justInTimeProfit(payload: {
+		symbol: string;
+		target_pnl: number;
+		kind: "long" | "short";
+		refresh?: boolean;
+		place?: boolean;
+		take_profit?: number;
+		pause_tp?: boolean;
+	}): Promise<{
+		sell_ratio: number;
+		current_pnl: number;
+		profit_percent: number;
+		current_price: number;
+		notional_value: number;
+	}>;
 	buildTrades(payload: {
 		symbol: string;
 		kind: "long" | "short";

package/dist/index.js

@@ -53501,6 +53501,113 @@ function generateOptimumAppConfig(config2, payload, position2) {
   });
   return best_app_config;
 }
+function determineOptimumReward(app_config, increase = true, low_range = 30, high_range = 199) {
+  const criterion = app_config.strategy || "quantity";
+  const risk_rewards = createArray(low_range, high_range, 1);
+  let func = risk_rewards.map((trade_no) => {
+    let trades = sortedBuildConfig(app_config, {
+      take_profit: app_config.take_profit,
+      entry: app_config.entry,
+      stop: app_config.stop,
+      no_of_trades: trade_no,
+      risk_reward: trade_no,
+      increase,
+      kind: app_config.kind,
+      gap: app_config.gap,
+      decimal_places: app_config.decimal_places
+    });
+    let total = 0;
+    let max = -Infinity;
+    let min = Infinity;
+    let neg_pnl = trades[0]?.neg_pnl || 0;
+    let entry = trades.at(-1)?.entry;
+    if (!entry) {
+      return null;
+    }
+    for (let trade of trades) {
+      total += trade.quantity;
+      max = Math.max(max, trade.quantity);
+      min = Math.min(min, trade.quantity);
+      entry = app_config.kind === "long" ? Math.max(entry, trade.entry) : Math.min(entry, trade.entry);
+    }
+    return {
+      result: trades,
+      value: trade_no,
+      total,
+      risk_per_trade: app_config.risk_per_trade,
+      max,
+      min,
+      neg_pnl,
+      entry
+    };
+  });
+  func = func.filter((r2) => Boolean(r2)).filter((r2) => {
+    let foundIndex = r2?.result.findIndex((e2) => e2.quantity === r2.max);
+    return criterion === "quantity" ? foundIndex === 0 : true;
+  });
+  const highest = criterion === "quantity" ? Math.max(...func.map((o) => o.max)) : Math.min(...func.map((o) => o.entry));
+  const key = criterion === "quantity" ? "max" : "entry";
+  const index = findIndexByCondition(func, app_config.kind, (x) => x[key] == highest, criterion);
+  if (app_config.raw) {
+    return func[index];
+  }
+  return func[index]?.value;
+}
+function findIndexByCondition(lst, kind, condition, defaultKey = "neg_pnl") {
+  const found = [];
+  let max_new_diff = 0;
+  let new_lst = lst.map((i2, j) => ({
+    ...i2,
+    net_diff: lst[j].neg_pnl + lst[j].risk_per_trade
+  }));
+  new_lst.forEach((item, index) => {
+    if (item.net_diff > 0) {
+      found.push(index);
+    }
+  });
+  if (found.length === 0) {
+    max_new_diff = Math.max(...new_lst.map((e2) => e2.net_diff));
+    found.push(new_lst.findIndex((e2) => e2.net_diff === max_new_diff));
+  }
+  const sortedFound = found.map((o, index) => ({ ...new_lst[o], index: o })).filter((j) => max_new_diff === 0 ? j.net_diff > 0 : j.net_diff >= max_new_diff).sort((a, b) => {
+    if (a.total !== b.total) {
+      return b.total - a.total;
+      return b.net_diff - a.net_diff;
+      return a.net_diff - b.net_diff;
+    } else {
+      return b.net_diff - a.net_diff;
+    }
+  });
+  if (defaultKey === "quantity") {
+    return sortedFound[0].index;
+  }
+  if (found.length === 1) {
+    return found[0];
+  }
+  if (found.length === 0) {
+    return -1;
+  }
+  const entryCondition = (a, b) => {
+    if (kind == "long") {
+      return a.entry > b.entry;
+    }
+    return a.entry < b.entry;
+  };
+  const maximum = found.reduce((maxIndex, currentIndex) => {
+    return new_lst[currentIndex]["net_diff"] < new_lst[maxIndex]["net_diff"] && entryCondition(new_lst[currentIndex], new_lst[maxIndex]) ? currentIndex : maxIndex;
+  }, found[0]);
+  return maximum;
+}
+function computeRiskReward(payload) {
+  const { app_config, entry, stop, risk_per_trade } = 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);
+  return result;
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -56561,6 +56668,64 @@ class ExchangeAccount {
     });
     return app_config;
   }
+  async justInTimeProfit(payload) {
+    const { symbol, target_pnl, kind, refresh, place, take_profit, pause_tp } = payload;
+    if (refresh) {
+      await this.syncAccount({
+        symbol,
+        live_refresh: true,
+        update: true
+      });
+    }
+    const position2 = await this.syncAccount({
+      symbol,
+      kind,
+      as_view: true
+    });
+    const current_price = take_profit || position2.current_price;
+    const notional_value = position2.quantity * position2.entry;
+    const current_pnl = to_f2(Math.abs(current_price - position2.entry) * position2.quantity, "%.2f");
+    const profit_percent = current_pnl * 100 / notional_value;
+    const sell_ratio = target_pnl / current_pnl;
+    if (place) {
+      const existing_config = await this.getPositionConfig({
+        symbol,
+        kind
+      });
+      if (existing_config) {
+        const trigger2 = place;
+        const config2 = await this.buildReduceConfig({
+          symbol,
+          as_dict: true,
+          trigger: {
+            long: trigger2 || false,
+            short: trigger2 || false
+          },
+          kind,
+          target_pnl: current_pnl
+        });
+        config2[kind].sell_ratio = sell_ratio;
+        if (trigger2) {
+          await this.app_db.updateScheduledTrade(existing_config.id, {
+            pause_tp
+          });
+          await this.reduceMajorPositionEntry({
+            symbol,
+            long: config2.long,
+            short: config2.short,
+            trigger: config2.trigger
+          });
+        }
+      }
+    }
+    return {
+      sell_ratio,
+      current_pnl,
+      profit_percent,
+      current_price,
+      notional_value
+    };
+  }
   async buildTrades(payload) {
     const { symbol, kind, risk } = payload;
     const config2 = await this.getPositionConfig({
@@ -57019,7 +57184,17 @@ class ExchangeAccount {
         kind
       });
     }
-    if (payload.trigger) {
+    const long_config = await this.getPositionConfig({
+      symbol,
+      kind: "long"
+    });
+    const short_config = await this.getPositionConfig({
+      symbol,
+      kind: "short"
+    });
+    const long_pause_tp = long_config?.pause_tp;
+    const short_pause_tp = short_config?.pause_tp;
+    if (payload.trigger && !long_pause_tp && !short_pause_tp) {
       return await this.reduceMajorPositionEntry({
         symbol,
         long: config2.long,
@@ -58581,8 +58756,10 @@ export {
   determine_break_even_price,
   determine_average_entry_and_size,
   determine_amount_to_buy,
+  determineOptimumReward,
   exports_database as database,
   createArray,
+  computeRiskReward,
   buildConfig,
   buildAvg,
   buildAppConfig,

package/package.json

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