@gbozee/ultimate 0.0.2-100 → 0.0.2-101

package/dist/frontend-index.d.ts

@@ -716,6 +716,43 @@ export declare class Strategy {
 		price_places: string;
 		decimal_places: string;
 	};
+	simulateGapReduction(payload: {
+		factor: number;
+		kind: "long" | "short";
+		sell_factor?: number;
+	}): {
+		results: {
+			profit_percent: {
+				long: number;
+				short: number;
+			};
+			risk: {
+				short: number;
+				long: number;
+			};
+			take_profit: {
+				long: number;
+				short: number;
+			};
+			sell_quantity: {
+				short: number;
+				long: number;
+			};
+			gap_loss: number;
+			position: {
+				long: {
+					entry: number;
+					quantity: number;
+				};
+				short: {
+					entry: number;
+					quantity: number;
+				};
+			};
+		}[];
+		quantity: number;
+		counter: number;
+	};
 }
 
 export {};

package/dist/frontend-index.js

@@ -2291,6 +2291,61 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const { factor, kind, sell_factor = 1 } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    let counter = 1;
+    while (true) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = kind == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[kind] = {
+        entry: take_profit[kind],
+        quantity: remaining
+      };
+      counter++;
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[kind];
+    const entry = this.position[kind].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity,
+      counter
+    };
+  }
 }
 export {
   to_f,

package/dist/index.cjs

@@ -54303,6 +54303,61 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const { factor, kind, sell_factor = 1 } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    let counter = 1;
+    while (true) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = kind == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[kind] = {
+        entry: take_profit[kind],
+        quantity: remaining
+      };
+      counter++;
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[kind];
+    const entry = this.position[kind].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity,
+      counter
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -58199,19 +58254,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -59056,6 +59116,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/dist/index.d.ts

@@ -805,6 +805,43 @@ export declare class Strategy {
 		price_places: string;
 		decimal_places: string;
 	};
+	simulateGapReduction(payload: {
+		factor: number;
+		kind: "long" | "short";
+		sell_factor?: number;
+	}): {
+		results: {
+			profit_percent: {
+				long: number;
+				short: number;
+			};
+			risk: {
+				short: number;
+				long: number;
+			};
+			take_profit: {
+				long: number;
+				short: number;
+			};
+			sell_quantity: {
+				short: number;
+				long: number;
+			};
+			gap_loss: number;
+			position: {
+				long: {
+					entry: number;
+					quantity: number;
+				};
+				short: {
+					entry: number;
+					quantity: number;
+				};
+			};
+		}[];
+		quantity: number;
+		counter: number;
+	};
 }
 export type SignalConfigType = {
 	focus: number;

package/dist/index.js

@@ -54252,6 +54252,61 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const { factor, kind, sell_factor = 1 } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    let counter = 1;
+    while (true) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = kind == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[kind] = {
+        entry: take_profit[kind],
+        quantity: remaining
+      };
+      counter++;
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[kind];
+    const entry = this.position[kind].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity,
+      counter
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -58148,19 +58203,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -59005,6 +59065,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/dist/mcp-server.cjs

@@ -60990,6 +60990,61 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const { factor, kind, sell_factor = 1 } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    let counter = 1;
+    while (true) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = kind == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[kind] = {
+        entry: take_profit[kind],
+        quantity: remaining
+      };
+      counter++;
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[kind];
+    const entry = this.position[kind].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity,
+      counter
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -64886,19 +64941,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -65743,6 +65803,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/dist/mcp-server.js

@@ -60963,6 +60963,61 @@ class Strategy {
     });
     return result;
   }
+  simulateGapReduction(payload) {
+    const { factor, kind, sell_factor = 1 } = payload;
+    const results = [];
+    let params = {
+      long: this.position.long,
+      short: this.position.short,
+      config: this.config
+    };
+    let counter = 1;
+    while (true) {
+      const instance = new Strategy(params);
+      const { profit_percent, risk, take_profit, sell_quantity, gap_loss } = instance.identifyGapConfig({
+        factor,
+        sell_factor
+      });
+      const to_add = {
+        profit_percent,
+        risk,
+        take_profit,
+        sell_quantity,
+        gap_loss,
+        position: {
+          long: {
+            entry: this.to_f(params.long.entry),
+            quantity: this.to_df(params.long.quantity)
+          },
+          short: {
+            entry: this.to_f(params.short.entry),
+            quantity: this.to_df(params.short.quantity)
+          }
+        }
+      };
+      results.push(to_add);
+      const sell_kind = kind == "long" ? "short" : "long";
+      const remaining = this.to_df(params[sell_kind].quantity - sell_quantity[sell_kind]);
+      if (remaining <= 0) {
+        break;
+      }
+      params[sell_kind].quantity = remaining;
+      params[kind] = {
+        entry: take_profit[kind],
+        quantity: remaining
+      };
+      counter++;
+    }
+    const last_gap_loss = results.at(-1)?.gap_loss;
+    const last_tp = results.at(-1)?.take_profit[kind];
+    const entry = this.position[kind].entry;
+    const quantity = this.to_df(Math.abs(last_tp - entry) / last_gap_loss);
+    return {
+      results,
+      quantity,
+      counter
+    };
+  }
 }
 
 // src/exchanges/binance.ts
@@ -64859,19 +64914,24 @@ class ExchangeAccount {
       kind,
       raw: true
     });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
-    });
-    if (place && result?.kind) {
-      const _symbol = place_symbol || symbol;
-      await this.placeOppositeTradeAction({
-        symbol: _symbol,
-        kind: result.kind,
-        data: result
-      });
+    try {
+      const result = strategy.generateOppositeTrades({
+        kind,
+        avg_entry: strategy.position[kind].avg_price
+      });
+      if (place && result?.kind) {
+        const _symbol = place_symbol || symbol;
+        await this.placeOppositeTradeAction({
+          symbol: _symbol,
+          kind: result.kind,
+          data: result
+        });
+      }
+      return result;
+    } catch (error) {
+      console.log("Error in buildOppositeTrades", error);
+      return null;
     }
-    return result;
   }
   async runSimulation(payload) {
     const { symbol, kind, iterations = 2, raw = false } = payload;
@@ -65716,6 +65776,9 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      if (!reverse_action) {
+        return;
+      }
       console.log("Updating config for ", symbol, reverse_action.kind);
       await this.getPositionConfig({
         symbol,

package/package.json

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