@gbozee/ultimate 0.0.2-76 → 0.0.2-78

package/dist/index.cjs

@@ -58001,43 +58001,59 @@ class ExchangeAccount {
     }
     return 0;
   }
-  async buildOppositeTrades(payload) {
-    const { symbol, kind, place } = payload;
-    const strategy = await this.runSimulation({
+  async placeOppositeTradeAction(payload) {
+    const { symbol, kind, data } = payload;
+    const position2 = await this.syncAccount({
       symbol,
       kind,
-      raw: true
-    });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
+      as_view: true
     });
-    if (place && result?.kind) {
+    if (position2.avg_qty !== data.avg.quantity) {
       const config2 = await this.getPositionConfig({
         symbol,
-        kind: result.kind
+        kind
       });
       await this.app_db.updateScheduledTrade(config2.id, {
-        entry: result.entry,
-        stop: result.stop,
-        risk: result.risk_per_trade,
-        profit_percent: result.profit_percent,
-        risk_reward: result.risk_reward
+        entry: data.entry,
+        stop: data.stop,
+        risk: data.risk_per_trade,
+        profit_percent: data.profit_percent,
+        risk_reward: data.risk_reward
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         ignore_config: true
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         stop: true,
         ignore_config: true
       });
     }
+  }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place, place_symbol } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      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
+      });
+    }
     return result;
   }
   async runSimulation(payload) {

package/dist/index.d.ts

@@ -1494,10 +1494,26 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<number>;
+	placeOppositeTradeAction(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		data: {
+			avg: {
+				quantity: number;
+				price: number;
+			};
+			entry: number;
+			stop: number;
+			risk_per_trade: number;
+			profit_percent: number;
+			risk_reward: number;
+		};
+	}): Promise<void>;
 	buildOppositeTrades(payload: {
 		symbol: string;
 		kind: "long" | "short";
 		place?: boolean;
+		place_symbol?: string;
 	}): Promise<{
 		avg: {
 			entry: number;

package/dist/index.js

@@ -57956,43 +57956,59 @@ class ExchangeAccount {
     }
     return 0;
   }
-  async buildOppositeTrades(payload) {
-    const { symbol, kind, place } = payload;
-    const strategy = await this.runSimulation({
+  async placeOppositeTradeAction(payload) {
+    const { symbol, kind, data } = payload;
+    const position2 = await this.syncAccount({
       symbol,
       kind,
-      raw: true
-    });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
+      as_view: true
     });
-    if (place && result?.kind) {
+    if (position2.avg_qty !== data.avg.quantity) {
       const config2 = await this.getPositionConfig({
         symbol,
-        kind: result.kind
+        kind
       });
       await this.app_db.updateScheduledTrade(config2.id, {
-        entry: result.entry,
-        stop: result.stop,
-        risk: result.risk_per_trade,
-        profit_percent: result.profit_percent,
-        risk_reward: result.risk_reward
+        entry: data.entry,
+        stop: data.stop,
+        risk: data.risk_per_trade,
+        profit_percent: data.profit_percent,
+        risk_reward: data.risk_reward
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         ignore_config: true
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         stop: true,
         ignore_config: true
       });
     }
+  }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place, place_symbol } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      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
+      });
+    }
     return result;
   }
   async runSimulation(payload) {

package/dist/mcp-server.cjs

@@ -64692,43 +64692,59 @@ class ExchangeAccount {
     }
     return 0;
   }
-  async buildOppositeTrades(payload) {
-    const { symbol, kind, place } = payload;
-    const strategy = await this.runSimulation({
+  async placeOppositeTradeAction(payload) {
+    const { symbol, kind, data } = payload;
+    const position2 = await this.syncAccount({
       symbol,
       kind,
-      raw: true
-    });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
+      as_view: true
     });
-    if (place && result?.kind) {
+    if (position2.avg_qty !== data.avg.quantity) {
       const config2 = await this.getPositionConfig({
         symbol,
-        kind: result.kind
+        kind
       });
       await this.app_db.updateScheduledTrade(config2.id, {
-        entry: result.entry,
-        stop: result.stop,
-        risk: result.risk_per_trade,
-        profit_percent: result.profit_percent,
-        risk_reward: result.risk_reward
+        entry: data.entry,
+        stop: data.stop,
+        risk: data.risk_per_trade,
+        profit_percent: data.profit_percent,
+        risk_reward: data.risk_reward
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         ignore_config: true
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         stop: true,
         ignore_config: true
       });
     }
+  }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place, place_symbol } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      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
+      });
+    }
     return result;
   }
   async runSimulation(payload) {

package/dist/mcp-server.js

@@ -64669,43 +64669,59 @@ class ExchangeAccount {
     }
     return 0;
   }
-  async buildOppositeTrades(payload) {
-    const { symbol, kind, place } = payload;
-    const strategy = await this.runSimulation({
+  async placeOppositeTradeAction(payload) {
+    const { symbol, kind, data } = payload;
+    const position2 = await this.syncAccount({
       symbol,
       kind,
-      raw: true
-    });
-    const result = strategy.generateOppositeTrades({
-      kind,
-      avg_entry: strategy.position[kind].avg_price
+      as_view: true
     });
-    if (place && result?.kind) {
+    if (position2.avg_qty !== data.avg.quantity) {
       const config2 = await this.getPositionConfig({
         symbol,
-        kind: result.kind
+        kind
       });
       await this.app_db.updateScheduledTrade(config2.id, {
-        entry: result.entry,
-        stop: result.stop,
-        risk: result.risk_per_trade,
-        profit_percent: result.profit_percent,
-        risk_reward: result.risk_reward
+        entry: data.entry,
+        stop: data.stop,
+        risk: data.risk_per_trade,
+        profit_percent: data.profit_percent,
+        risk_reward: data.risk_reward
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         ignore_config: true
       });
       await this.placeTrade({
         symbol,
-        kind: result.kind,
+        kind,
         place: true,
         stop: true,
         ignore_config: true
       });
     }
+  }
+  async buildOppositeTrades(payload) {
+    const { symbol, kind, place, place_symbol } = payload;
+    const strategy = await this.runSimulation({
+      symbol,
+      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
+      });
+    }
     return result;
   }
   async runSimulation(payload) {

package/package.json

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