@gbozee/ultimate 0.0.2-56 → 0.0.2-58

package/dist/frontend-index.d.ts

@@ -372,6 +372,7 @@ export type Config = {
 	fee_percent?: number;
 	budget: number;
 	risk_reward: number;
+	reduce_ratio: number;
 	global_config: GlobalConfig;
 };
 export declare class Strategy {
@@ -389,7 +390,7 @@ export declare class Strategy {
 	get decimal_places(): string;
 	to_f(price: number): number;
 	to_df(quantity: number): number;
-	pnl(kind: "long" | "short"): number;
+	pnl(kind: "long" | "short", _position?: StrategyPosition): number;
 	tp(kind: "long" | "short"): number;
 	calculate_fee(position: {
 		price: number;
@@ -419,6 +420,41 @@ export declare class Strategy {
 		first_entry: any;
 		threshold: any;
 	}[];
+	getPositionAfterTp(payload: {
+		kind: "long" | "short";
+		include_fees?: boolean;
+	}): {
+		[x: string]: number | {
+			entry: number;
+			quantity: number;
+		} | {
+			[x: string]: number;
+			entry?: undefined;
+			quantity?: undefined;
+		};
+		pnl: {
+			[x: string]: number;
+		};
+		spread: number;
+	};
+	getPositionAfterIteration(payload: {
+		kind: "long" | "short";
+		iterations: number;
+		with_fees?: boolean;
+	}): {
+		[x: string]: number | {
+			entry: number;
+			quantity: number;
+		} | {
+			[x: string]: number;
+			entry?: undefined;
+			quantity?: undefined;
+		};
+		pnl: {
+			[x: string]: number;
+		};
+		spread: number;
+	}[];
 }
 
 export {};

package/dist/frontend-index.js

@@ -1663,8 +1663,8 @@ class Strategy {
   to_df(quantity) {
     return to_f(quantity, this.decimal_places);
   }
-  pnl(kind) {
-    const position2 = this.position[kind];
+  pnl(kind, _position) {
+    const position2 = _position || this.position[kind];
     const { entry, quantity } = position2;
     const notional = entry * quantity;
     let tp_percent = this.config.tp_percent;
@@ -1675,10 +1675,14 @@ class Strategy {
     return this.to_f(profit);
   }
   tp(kind) {
-    const position2 = this.position[kind];
+    let position2 = this.position[kind];
+    if (position2.quantity == 0) {
+      const reverse_kind = kind == "long" ? "short" : "long";
+      position2 = this.position[reverse_kind];
+    }
     const { entry, quantity } = position2;
-    const profit = this.pnl(kind);
-    const diff = profit / quantity;
+    const profit = this.pnl(kind, position2);
+    const diff = profit / (quantity || 1);
     return this.to_f(kind == "long" ? entry + diff : entry - diff);
   }
   calculate_fee(position2) {
@@ -1744,9 +1748,9 @@ class Strategy {
     ]), 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;
+      return u.entry < (reverse_position.entry || focus_position.entry);
     }) : entries.filter((u) => {
-      return u.entry > reverse_position.entry;
+      return u.entry > (reverse_position.entry || focus_position.entry);
     });
     const threshold = below_reverse_entries.at(-1);
     let adjusted_reverse_entries = entries.map((entry2) => {
@@ -1844,6 +1848,62 @@ class Strategy {
     }
     return result;
   }
+  getPositionAfterTp(payload) {
+    const { kind, include_fees = false } = payload;
+    const focus_position = this.position[kind];
+    const reverse_kind = kind == "long" ? "short" : "long";
+    const reverse_position = this.position[reverse_kind];
+    const focus_tp = this.tp(kind);
+    const focus_pnl = this.pnl(kind);
+    const fees = include_fees ? this.calculate_fee({
+      price: focus_tp,
+      quantity: focus_position.quantity
+    }) * 2 : 0;
+    const expected_loss = (focus_pnl - fees) * this.config.reduce_ratio;
+    const actual_loss = Math.abs(focus_tp - reverse_position.entry) * reverse_position.quantity;
+    const ratio = expected_loss / actual_loss;
+    const loss_quantity = this.to_df(ratio * reverse_position.quantity);
+    const remaining_quantity = this.to_df(reverse_position.quantity - loss_quantity);
+    return {
+      [kind]: {
+        entry: focus_tp,
+        quantity: remaining_quantity
+      },
+      [reverse_kind]: {
+        entry: reverse_position.entry,
+        quantity: remaining_quantity
+      },
+      pnl: {
+        [kind]: focus_pnl,
+        [reverse_kind]: -expected_loss
+      },
+      spread: this.to_f(Math.abs(focus_tp - reverse_position.entry) * remaining_quantity)
+    };
+  }
+  getPositionAfterIteration(payload) {
+    const { kind, iterations, with_fees = false } = payload;
+    let _result = this.getPositionAfterTp({
+      kind,
+      include_fees: with_fees
+    });
+    const result = [_result];
+    for (let i = 0;i < iterations - 1; i++) {
+      const instance = new Strategy({
+        long: _result.long,
+        short: _result.short,
+        config: {
+          ...this.config,
+          tp_percent: this.config.tp_percent + (i + 1) * 0.3
+        }
+      });
+      _result = instance.getPositionAfterTp({
+        kind,
+        include_fees: with_fees
+      });
+      result.push(_result);
+    }
+    return result;
+  }
 }
 export {
   to_f,