@gbozee/ultimate 0.0.2-next.75 → 0.0.2-next.78

package/dist/index.cjs

@@ -67566,6 +67566,8 @@ class AppDatabase {
 var exports_exchange_account = {};
 __export(exports_exchange_account, {
   getExchangeAccount: () => getExchangeAccount,
+  TakeProfitReplaceRollbackSucceededError: () => TakeProfitReplaceRollbackSucceededError,
+  TakeProfitReplaceRollbackFailedError: () => TakeProfitReplaceRollbackFailedError,
   ExchangeAccount: () => ExchangeAccount
 });
 
@@ -73726,7 +73728,13 @@ function buildPosition(position2, orders, options) {
     { price: entry, quantity },
     ...limitOrders.map((o) => ({ price: o.price, quantity: o.qty }))
   ], decimal_places, price_places);
-  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop)[0];
+  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop).sort((a, b) => {
+    if (kind === "long") {
+      return b.triggerPrice - a.triggerPrice;
+    } else {
+      return a.triggerPrice - b.triggerPrice;
+    }
+  })[0];
   const tpOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((x) => x.kind === "long" ? x.side === "sell" : x.side === "buy")[0];
   const avg_entry = avg.entry;
   const stop_loss = stopOrders?.triggerPrice || 0;
@@ -78395,6 +78403,76 @@ async function forceClosePosition2(client, symbol, options) {
 }
 
 // src/exchange-account.ts
+function getFormatPrecision(places) {
+  if (!places) {
+    return 0;
+  }
+  const match = places.match(/%\.(\d+)f/);
+  return match ? Number(match[1]) : 0;
+}
+function floorToFormat(value2, places) {
+  if (!Number.isFinite(value2) || value2 <= 0) {
+    return 0;
+  }
+  const precision = getFormatPrecision(places);
+  const factor = 10 ** precision;
+  return Math.floor((value2 + Number.EPSILON) * factor) / factor;
+}
+
+class TakeProfitReplaceRollbackSucceededError extends Error {
+  status = "rollback_succeeded";
+  restored = true;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit was restored");
+    this.name = "TakeProfitReplaceRollbackSucceededError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
+class TakeProfitReplaceRollbackFailedError extends Error {
+  status = "rollback_failed";
+  restored = false;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit could not be restored");
+    this.name = "TakeProfitReplaceRollbackFailedError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
 class ExchangeAccount {
   instance;
   exchange;
@@ -78491,8 +78569,6 @@ class ExchangeAccount {
       refresh
     });
     const raw_active_account = live_exchange_instance.data;
-    console.log("raw_active", raw_active_account);
-    console.log("symbol_config", symbol_config);
     const _all = get_active_accounts({
       active_account: raw_active_account,
       symbol_config
@@ -78508,7 +78584,6 @@ class ExchangeAccount {
       refresh: live_refresh,
       symbol
     });
-    console.log("active_accounts", active_account, live_refresh);
     if (leverage) {
       this.exchange.setLeverage({ symbol, leverage });
     }
@@ -78626,6 +78701,132 @@ class ExchangeAccount {
     });
     return await focus_position.cancelOrders(payload);
   }
+  async replaceTakeProfitForPosition(payload) {
+    const { symbol, kind, takeProfitPrice, quantity } = payload;
+    const focusPosition = await this.getFocusPosition({
+      symbol,
+      kind,
+      update: true
+    });
+    const position2 = focusPosition.getInstance();
+    const symbol_config = focusPosition.symbol_config;
+    if (!symbol_config) {
+      throw new Error(`Missing symbol config for ${symbol}`);
+    }
+    const normalizedQuantity = floorToFormat(quantity, symbol_config.decimal_places);
+    const minSize = Number(symbol_config.min_size || 0);
+    const previousTakeProfitPrice = Number(position2?.take_profit || 0);
+    const previousQuantity = floorToFormat(Number(position2?.tp_quantity || 0), symbol_config.decimal_places);
+    if (normalizedQuantity <= 0) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: 0,
+        minSize,
+        reason: "quantity_floored_to_zero"
+      };
+    }
+    if (minSize > 0 && normalizedQuantity < minSize) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        minSize,
+        reason: "below_venue_minimum"
+      };
+    }
+    const exchangeSeams = this.exchange;
+    if (exchangeSeams.replaceTakeProfitForPosition) {
+      await exchangeSeams.replaceTakeProfitForPosition({
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places,
+        previousTakeProfitPrice,
+        previousQuantity
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false,
+        via: "native_replace"
+      };
+    }
+    const placeTpWithoutCancelling = exchangeSeams._placeTpOrder;
+    if (!placeTpWithoutCancelling) {
+      throw new Error(`Exchange ${this.instance.exchange} does not expose a TP replace or raw TP placement path`);
+    }
+    if (previousTakeProfitPrice > 0) {
+      await this.cancelOrders({
+        symbol,
+        kind,
+        price: previousTakeProfitPrice
+      });
+    }
+    try {
+      await placeTpWithoutCancelling.call(this.exchange, {
+        symbol,
+        tp: takeProfitPrice,
+        kind,
+        quantity: normalizedQuantity,
+        cancel: false,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false
+      };
+    } catch (cause) {
+      const metadata3 = {
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: previousTakeProfitPrice > 0 && previousQuantity > 0,
+        cause
+      };
+      if (!metadata3.restoreAttempted) {
+        throw new TakeProfitReplaceRollbackFailedError(metadata3);
+      }
+      try {
+        await placeTpWithoutCancelling.call(this.exchange, {
+          symbol,
+          tp: previousTakeProfitPrice,
+          kind,
+          quantity: previousQuantity,
+          cancel: false,
+          price_places: symbol_config.price_places,
+          decimal_places: symbol_config.decimal_places
+        });
+      } catch (rollbackError) {
+        throw new TakeProfitReplaceRollbackFailedError({
+          ...metadata3,
+          rollbackError
+        });
+      }
+      throw new TakeProfitReplaceRollbackSucceededError(metadata3);
+    }
+  }
   async cancelExchangeOrders(payload) {
     return this.exchange.cancelOrders(payload);
   }
@@ -78910,8 +79111,8 @@ class ExchangeAccount {
     if (payload.trigger && !long_pause_tp && !short_pause_tp && config2) {
       return await this.reduceMajorPositionEntry({
         symbol,
-        long: config2.long,
-        short: config2.short,
+        long: kind === "long" ? config2.long : undefined,
+        short: kind === "short" ? config2.short : undefined,
         trigger: config2.trigger
       });
     }

package/dist/index.d.ts

@@ -7212,6 +7212,47 @@ export declare class ExchangePosition {
 	}, isIsolated?: boolean): Promise<void>;
 	buildMarginData(place?: boolean): Promise<any | null>;
 }
+export type TakeProfitReplaceMetadata = {
+	status: "rollback_succeeded" | "rollback_failed";
+	restored: boolean;
+	symbol: string;
+	kind: "long" | "short";
+	takeProfitPrice: number;
+	quantity: number;
+	previousTakeProfitPrice: number;
+	previousQuantity: number;
+	restoreAttempted: boolean;
+	cause: unknown;
+	rollbackError?: unknown;
+};
+declare class TakeProfitReplaceRollbackSucceededError extends Error implements TakeProfitReplaceMetadata {
+	status: "rollback_succeeded";
+	restored: true;
+	symbol: string;
+	kind: "long" | "short";
+	takeProfitPrice: number;
+	quantity: number;
+	previousTakeProfitPrice: number;
+	previousQuantity: number;
+	restoreAttempted: boolean;
+	cause: unknown;
+	rollbackError?: unknown;
+	constructor(metadata: Omit<TakeProfitReplaceMetadata, "status" | "restored">);
+}
+declare class TakeProfitReplaceRollbackFailedError extends Error implements TakeProfitReplaceMetadata {
+	status: "rollback_failed";
+	restored: false;
+	symbol: string;
+	kind: "long" | "short";
+	takeProfitPrice: number;
+	quantity: number;
+	previousTakeProfitPrice: number;
+	previousQuantity: number;
+	restoreAttempted: boolean;
+	cause: unknown;
+	rollbackError?: unknown;
+	constructor(metadata: Omit<TakeProfitReplaceMetadata, "status" | "restored">);
+}
 declare class ExchangeAccount$1 {
 	instance: {
 		owner: string;
@@ -7398,6 +7439,60 @@ declare class ExchangeAccount$1 {
 		message?: undefined;
 		exchange_result?: undefined;
 	}>;
+	replaceTakeProfitForPosition(payload: {
+		symbol: string;
+		kind: "long" | "short";
+		takeProfitPrice: number;
+		quantity: number;
+	}): Promise<{
+		status: "below_min_lot";
+		symbol: string;
+		kind: "long" | "short";
+		takeProfitPrice: number;
+		quantity: number;
+		minSize: number;
+		reason: "quantity_floored_to_zero";
+		previousTakeProfitPrice?: undefined;
+		previousQuantity?: undefined;
+		restoreAttempted?: undefined;
+		via?: undefined;
+	} | {
+		status: "below_min_lot";
+		symbol: string;
+		kind: "long" | "short";
+		takeProfitPrice: number;
+		quantity: number;
+		minSize: number;
+		reason: "below_venue_minimum";
+		previousTakeProfitPrice?: undefined;
+		previousQuantity?: undefined;
+		restoreAttempted?: undefined;
+		via?: undefined;
+	} | {
+		status: "replaced";
+		symbol: string;
+		kind: "long" | "short";
+		takeProfitPrice: number;
+		quantity: number;
+		previousTakeProfitPrice: number;
+		previousQuantity: number;
+		restoreAttempted: boolean;
+		via: "native_replace";
+		minSize?: undefined;
+		reason?: undefined;
+	} | {
+		status: "replaced";
+		symbol: string;
+		kind: "long" | "short";
+		takeProfitPrice: number;
+		quantity: number;
+		previousTakeProfitPrice: number;
+		previousQuantity: number;
+		restoreAttempted: boolean;
+		minSize?: undefined;
+		reason?: undefined;
+		via?: undefined;
+	}>;
 	cancelExchangeOrders(payload: {
 		symbol: string;
 		orders: number[];
@@ -8327,7 +8422,7 @@ declare namespace database {
 	export { AppDatabase, ExchangeType, decryptObject, encryptObject, initPocketBaseClient };
 }
 declare namespace exchange_account {
-	export { ExchangeAccount$1 as ExchangeAccount, getExchangeAccount };
+	export { ExchangeAccount$1 as ExchangeAccount, TakeProfitReplaceRollbackFailedError, TakeProfitReplaceRollbackSucceededError, getExchangeAccount };
 }
 declare namespace app {
 	export { App, getCredentials, initApp, initialize };

package/dist/index.js

@@ -67464,6 +67464,8 @@ class AppDatabase {
 var exports_exchange_account = {};
 __export(exports_exchange_account, {
   getExchangeAccount: () => getExchangeAccount,
+  TakeProfitReplaceRollbackSucceededError: () => TakeProfitReplaceRollbackSucceededError,
+  TakeProfitReplaceRollbackFailedError: () => TakeProfitReplaceRollbackFailedError,
   ExchangeAccount: () => ExchangeAccount
 });
 
@@ -73624,7 +73626,13 @@ function buildPosition(position2, orders, options) {
     { price: entry, quantity },
     ...limitOrders.map((o) => ({ price: o.price, quantity: o.qty }))
   ], decimal_places, price_places);
-  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop)[0];
+  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop).sort((a, b) => {
+    if (kind === "long") {
+      return b.triggerPrice - a.triggerPrice;
+    } else {
+      return a.triggerPrice - b.triggerPrice;
+    }
+  })[0];
   const tpOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((x) => x.kind === "long" ? x.side === "sell" : x.side === "buy")[0];
   const avg_entry = avg.entry;
   const stop_loss = stopOrders?.triggerPrice || 0;
@@ -78293,6 +78301,76 @@ async function forceClosePosition2(client, symbol, options) {
 }
 
 // src/exchange-account.ts
+function getFormatPrecision(places) {
+  if (!places) {
+    return 0;
+  }
+  const match = places.match(/%\.(\d+)f/);
+  return match ? Number(match[1]) : 0;
+}
+function floorToFormat(value2, places) {
+  if (!Number.isFinite(value2) || value2 <= 0) {
+    return 0;
+  }
+  const precision = getFormatPrecision(places);
+  const factor = 10 ** precision;
+  return Math.floor((value2 + Number.EPSILON) * factor) / factor;
+}
+
+class TakeProfitReplaceRollbackSucceededError extends Error {
+  status = "rollback_succeeded";
+  restored = true;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit was restored");
+    this.name = "TakeProfitReplaceRollbackSucceededError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
+class TakeProfitReplaceRollbackFailedError extends Error {
+  status = "rollback_failed";
+  restored = false;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit could not be restored");
+    this.name = "TakeProfitReplaceRollbackFailedError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
 class ExchangeAccount {
   instance;
   exchange;
@@ -78389,8 +78467,6 @@ class ExchangeAccount {
       refresh
     });
     const raw_active_account = live_exchange_instance.data;
-    console.log("raw_active", raw_active_account);
-    console.log("symbol_config", symbol_config);
     const _all = get_active_accounts({
       active_account: raw_active_account,
       symbol_config
@@ -78406,7 +78482,6 @@ class ExchangeAccount {
       refresh: live_refresh,
       symbol
     });
-    console.log("active_accounts", active_account, live_refresh);
     if (leverage) {
       this.exchange.setLeverage({ symbol, leverage });
     }
@@ -78524,6 +78599,132 @@ class ExchangeAccount {
     });
     return await focus_position.cancelOrders(payload);
   }
+  async replaceTakeProfitForPosition(payload) {
+    const { symbol, kind, takeProfitPrice, quantity } = payload;
+    const focusPosition = await this.getFocusPosition({
+      symbol,
+      kind,
+      update: true
+    });
+    const position2 = focusPosition.getInstance();
+    const symbol_config = focusPosition.symbol_config;
+    if (!symbol_config) {
+      throw new Error(`Missing symbol config for ${symbol}`);
+    }
+    const normalizedQuantity = floorToFormat(quantity, symbol_config.decimal_places);
+    const minSize = Number(symbol_config.min_size || 0);
+    const previousTakeProfitPrice = Number(position2?.take_profit || 0);
+    const previousQuantity = floorToFormat(Number(position2?.tp_quantity || 0), symbol_config.decimal_places);
+    if (normalizedQuantity <= 0) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: 0,
+        minSize,
+        reason: "quantity_floored_to_zero"
+      };
+    }
+    if (minSize > 0 && normalizedQuantity < minSize) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        minSize,
+        reason: "below_venue_minimum"
+      };
+    }
+    const exchangeSeams = this.exchange;
+    if (exchangeSeams.replaceTakeProfitForPosition) {
+      await exchangeSeams.replaceTakeProfitForPosition({
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places,
+        previousTakeProfitPrice,
+        previousQuantity
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false,
+        via: "native_replace"
+      };
+    }
+    const placeTpWithoutCancelling = exchangeSeams._placeTpOrder;
+    if (!placeTpWithoutCancelling) {
+      throw new Error(`Exchange ${this.instance.exchange} does not expose a TP replace or raw TP placement path`);
+    }
+    if (previousTakeProfitPrice > 0) {
+      await this.cancelOrders({
+        symbol,
+        kind,
+        price: previousTakeProfitPrice
+      });
+    }
+    try {
+      await placeTpWithoutCancelling.call(this.exchange, {
+        symbol,
+        tp: takeProfitPrice,
+        kind,
+        quantity: normalizedQuantity,
+        cancel: false,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false
+      };
+    } catch (cause) {
+      const metadata3 = {
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: previousTakeProfitPrice > 0 && previousQuantity > 0,
+        cause
+      };
+      if (!metadata3.restoreAttempted) {
+        throw new TakeProfitReplaceRollbackFailedError(metadata3);
+      }
+      try {
+        await placeTpWithoutCancelling.call(this.exchange, {
+          symbol,
+          tp: previousTakeProfitPrice,
+          kind,
+          quantity: previousQuantity,
+          cancel: false,
+          price_places: symbol_config.price_places,
+          decimal_places: symbol_config.decimal_places
+        });
+      } catch (rollbackError) {
+        throw new TakeProfitReplaceRollbackFailedError({
+          ...metadata3,
+          rollbackError
+        });
+      }
+      throw new TakeProfitReplaceRollbackSucceededError(metadata3);
+    }
+  }
   async cancelExchangeOrders(payload) {
     return this.exchange.cancelOrders(payload);
   }
@@ -78808,8 +79009,8 @@ class ExchangeAccount {
     if (payload.trigger && !long_pause_tp && !short_pause_tp && config2) {
       return await this.reduceMajorPositionEntry({
         symbol,
-        long: config2.long,
-        short: config2.short,
+        long: kind === "long" ? config2.long : undefined,
+        short: kind === "short" ? config2.short : undefined,
         trigger: config2.trigger
       });
     }

package/dist/mcp-server.cjs

@@ -77448,7 +77448,13 @@ function buildPosition(position2, orders, options) {
     { price: entry, quantity },
     ...limitOrders.map((o) => ({ price: o.price, quantity: o.qty }))
   ], decimal_places, price_places);
-  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop)[0];
+  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop).sort((a, b) => {
+    if (kind === "long") {
+      return b.triggerPrice - a.triggerPrice;
+    } else {
+      return a.triggerPrice - b.triggerPrice;
+    }
+  })[0];
   const tpOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((x) => x.kind === "long" ? x.side === "sell" : x.side === "buy")[0];
   const avg_entry = avg.entry;
   const stop_loss = stopOrders?.triggerPrice || 0;
@@ -82117,6 +82123,76 @@ async function forceClosePosition2(client, symbol, options) {
 }
 
 // src/exchange-account.ts
+function getFormatPrecision(places) {
+  if (!places) {
+    return 0;
+  }
+  const match = places.match(/%\.(\d+)f/);
+  return match ? Number(match[1]) : 0;
+}
+function floorToFormat(value2, places) {
+  if (!Number.isFinite(value2) || value2 <= 0) {
+    return 0;
+  }
+  const precision = getFormatPrecision(places);
+  const factor = 10 ** precision;
+  return Math.floor((value2 + Number.EPSILON) * factor) / factor;
+}
+
+class TakeProfitReplaceRollbackSucceededError extends Error {
+  status = "rollback_succeeded";
+  restored = true;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit was restored");
+    this.name = "TakeProfitReplaceRollbackSucceededError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
+class TakeProfitReplaceRollbackFailedError extends Error {
+  status = "rollback_failed";
+  restored = false;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit could not be restored");
+    this.name = "TakeProfitReplaceRollbackFailedError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
 class ExchangeAccount {
   instance;
   exchange;
@@ -82213,8 +82289,6 @@ class ExchangeAccount {
       refresh
     });
     const raw_active_account = live_exchange_instance.data;
-    console.log("raw_active", raw_active_account);
-    console.log("symbol_config", symbol_config);
     const _all = get_active_accounts({
       active_account: raw_active_account,
       symbol_config
@@ -82230,7 +82304,6 @@ class ExchangeAccount {
       refresh: live_refresh,
       symbol
     });
-    console.log("active_accounts", active_account, live_refresh);
     if (leverage) {
       this.exchange.setLeverage({ symbol, leverage });
     }
@@ -82348,6 +82421,132 @@ class ExchangeAccount {
     });
     return await focus_position.cancelOrders(payload);
   }
+  async replaceTakeProfitForPosition(payload) {
+    const { symbol, kind, takeProfitPrice, quantity } = payload;
+    const focusPosition = await this.getFocusPosition({
+      symbol,
+      kind,
+      update: true
+    });
+    const position2 = focusPosition.getInstance();
+    const symbol_config = focusPosition.symbol_config;
+    if (!symbol_config) {
+      throw new Error(`Missing symbol config for ${symbol}`);
+    }
+    const normalizedQuantity = floorToFormat(quantity, symbol_config.decimal_places);
+    const minSize = Number(symbol_config.min_size || 0);
+    const previousTakeProfitPrice = Number(position2?.take_profit || 0);
+    const previousQuantity = floorToFormat(Number(position2?.tp_quantity || 0), symbol_config.decimal_places);
+    if (normalizedQuantity <= 0) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: 0,
+        minSize,
+        reason: "quantity_floored_to_zero"
+      };
+    }
+    if (minSize > 0 && normalizedQuantity < minSize) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        minSize,
+        reason: "below_venue_minimum"
+      };
+    }
+    const exchangeSeams = this.exchange;
+    if (exchangeSeams.replaceTakeProfitForPosition) {
+      await exchangeSeams.replaceTakeProfitForPosition({
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places,
+        previousTakeProfitPrice,
+        previousQuantity
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false,
+        via: "native_replace"
+      };
+    }
+    const placeTpWithoutCancelling = exchangeSeams._placeTpOrder;
+    if (!placeTpWithoutCancelling) {
+      throw new Error(`Exchange ${this.instance.exchange} does not expose a TP replace or raw TP placement path`);
+    }
+    if (previousTakeProfitPrice > 0) {
+      await this.cancelOrders({
+        symbol,
+        kind,
+        price: previousTakeProfitPrice
+      });
+    }
+    try {
+      await placeTpWithoutCancelling.call(this.exchange, {
+        symbol,
+        tp: takeProfitPrice,
+        kind,
+        quantity: normalizedQuantity,
+        cancel: false,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false
+      };
+    } catch (cause) {
+      const metadata3 = {
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: previousTakeProfitPrice > 0 && previousQuantity > 0,
+        cause
+      };
+      if (!metadata3.restoreAttempted) {
+        throw new TakeProfitReplaceRollbackFailedError(metadata3);
+      }
+      try {
+        await placeTpWithoutCancelling.call(this.exchange, {
+          symbol,
+          tp: previousTakeProfitPrice,
+          kind,
+          quantity: previousQuantity,
+          cancel: false,
+          price_places: symbol_config.price_places,
+          decimal_places: symbol_config.decimal_places
+        });
+      } catch (rollbackError) {
+        throw new TakeProfitReplaceRollbackFailedError({
+          ...metadata3,
+          rollbackError
+        });
+      }
+      throw new TakeProfitReplaceRollbackSucceededError(metadata3);
+    }
+  }
   async cancelExchangeOrders(payload) {
     return this.exchange.cancelOrders(payload);
   }
@@ -82632,8 +82831,8 @@ class ExchangeAccount {
     if (payload.trigger && !long_pause_tp && !short_pause_tp && config2) {
       return await this.reduceMajorPositionEntry({
         symbol,
-        long: config2.long,
-        short: config2.short,
+        long: kind === "long" ? config2.long : undefined,
+        short: kind === "short" ? config2.short : undefined,
         trigger: config2.trigger
       });
     }

package/dist/mcp-server.js

@@ -77407,7 +77407,13 @@ function buildPosition(position2, orders, options) {
     { price: entry, quantity },
     ...limitOrders.map((o) => ({ price: o.price, quantity: o.qty }))
   ], decimal_places, price_places);
-  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop)[0];
+  const stopOrders = orders.filter((x) => x.kind === kind && x.isStop).sort((a, b) => {
+    if (kind === "long") {
+      return b.triggerPrice - a.triggerPrice;
+    } else {
+      return a.triggerPrice - b.triggerPrice;
+    }
+  })[0];
   const tpOrders = orders.filter((x) => x.kind === kind && !x.isStop).filter((x) => x.kind === "long" ? x.side === "sell" : x.side === "buy")[0];
   const avg_entry = avg.entry;
   const stop_loss = stopOrders?.triggerPrice || 0;
@@ -82076,6 +82082,76 @@ async function forceClosePosition2(client, symbol, options) {
 }
 
 // src/exchange-account.ts
+function getFormatPrecision(places) {
+  if (!places) {
+    return 0;
+  }
+  const match = places.match(/%\.(\d+)f/);
+  return match ? Number(match[1]) : 0;
+}
+function floorToFormat(value2, places) {
+  if (!Number.isFinite(value2) || value2 <= 0) {
+    return 0;
+  }
+  const precision = getFormatPrecision(places);
+  const factor = 10 ** precision;
+  return Math.floor((value2 + Number.EPSILON) * factor) / factor;
+}
+
+class TakeProfitReplaceRollbackSucceededError extends Error {
+  status = "rollback_succeeded";
+  restored = true;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit was restored");
+    this.name = "TakeProfitReplaceRollbackSucceededError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
+class TakeProfitReplaceRollbackFailedError extends Error {
+  status = "rollback_failed";
+  restored = false;
+  symbol;
+  kind;
+  takeProfitPrice;
+  quantity;
+  previousTakeProfitPrice;
+  previousQuantity;
+  restoreAttempted;
+  cause;
+  rollbackError;
+  constructor(metadata3) {
+    super("Take profit replacement failed and previous take profit could not be restored");
+    this.name = "TakeProfitReplaceRollbackFailedError";
+    this.symbol = metadata3.symbol;
+    this.kind = metadata3.kind;
+    this.takeProfitPrice = metadata3.takeProfitPrice;
+    this.quantity = metadata3.quantity;
+    this.previousTakeProfitPrice = metadata3.previousTakeProfitPrice;
+    this.previousQuantity = metadata3.previousQuantity;
+    this.restoreAttempted = metadata3.restoreAttempted;
+    this.cause = metadata3.cause;
+    this.rollbackError = metadata3.rollbackError;
+  }
+}
+
 class ExchangeAccount {
   instance;
   exchange;
@@ -82172,8 +82248,6 @@ class ExchangeAccount {
       refresh
     });
     const raw_active_account = live_exchange_instance.data;
-    console.log("raw_active", raw_active_account);
-    console.log("symbol_config", symbol_config);
     const _all = get_active_accounts({
       active_account: raw_active_account,
       symbol_config
@@ -82189,7 +82263,6 @@ class ExchangeAccount {
       refresh: live_refresh,
       symbol
     });
-    console.log("active_accounts", active_account, live_refresh);
     if (leverage) {
       this.exchange.setLeverage({ symbol, leverage });
     }
@@ -82307,6 +82380,132 @@ class ExchangeAccount {
     });
     return await focus_position.cancelOrders(payload);
   }
+  async replaceTakeProfitForPosition(payload) {
+    const { symbol, kind, takeProfitPrice, quantity } = payload;
+    const focusPosition = await this.getFocusPosition({
+      symbol,
+      kind,
+      update: true
+    });
+    const position2 = focusPosition.getInstance();
+    const symbol_config = focusPosition.symbol_config;
+    if (!symbol_config) {
+      throw new Error(`Missing symbol config for ${symbol}`);
+    }
+    const normalizedQuantity = floorToFormat(quantity, symbol_config.decimal_places);
+    const minSize = Number(symbol_config.min_size || 0);
+    const previousTakeProfitPrice = Number(position2?.take_profit || 0);
+    const previousQuantity = floorToFormat(Number(position2?.tp_quantity || 0), symbol_config.decimal_places);
+    if (normalizedQuantity <= 0) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: 0,
+        minSize,
+        reason: "quantity_floored_to_zero"
+      };
+    }
+    if (minSize > 0 && normalizedQuantity < minSize) {
+      return {
+        status: "below_min_lot",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        minSize,
+        reason: "below_venue_minimum"
+      };
+    }
+    const exchangeSeams = this.exchange;
+    if (exchangeSeams.replaceTakeProfitForPosition) {
+      await exchangeSeams.replaceTakeProfitForPosition({
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places,
+        previousTakeProfitPrice,
+        previousQuantity
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false,
+        via: "native_replace"
+      };
+    }
+    const placeTpWithoutCancelling = exchangeSeams._placeTpOrder;
+    if (!placeTpWithoutCancelling) {
+      throw new Error(`Exchange ${this.instance.exchange} does not expose a TP replace or raw TP placement path`);
+    }
+    if (previousTakeProfitPrice > 0) {
+      await this.cancelOrders({
+        symbol,
+        kind,
+        price: previousTakeProfitPrice
+      });
+    }
+    try {
+      await placeTpWithoutCancelling.call(this.exchange, {
+        symbol,
+        tp: takeProfitPrice,
+        kind,
+        quantity: normalizedQuantity,
+        cancel: false,
+        price_places: symbol_config.price_places,
+        decimal_places: symbol_config.decimal_places
+      });
+      return {
+        status: "replaced",
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: false
+      };
+    } catch (cause) {
+      const metadata3 = {
+        symbol,
+        kind,
+        takeProfitPrice,
+        quantity: normalizedQuantity,
+        previousTakeProfitPrice,
+        previousQuantity,
+        restoreAttempted: previousTakeProfitPrice > 0 && previousQuantity > 0,
+        cause
+      };
+      if (!metadata3.restoreAttempted) {
+        throw new TakeProfitReplaceRollbackFailedError(metadata3);
+      }
+      try {
+        await placeTpWithoutCancelling.call(this.exchange, {
+          symbol,
+          tp: previousTakeProfitPrice,
+          kind,
+          quantity: previousQuantity,
+          cancel: false,
+          price_places: symbol_config.price_places,
+          decimal_places: symbol_config.decimal_places
+        });
+      } catch (rollbackError) {
+        throw new TakeProfitReplaceRollbackFailedError({
+          ...metadata3,
+          rollbackError
+        });
+      }
+      throw new TakeProfitReplaceRollbackSucceededError(metadata3);
+    }
+  }
   async cancelExchangeOrders(payload) {
     return this.exchange.cancelOrders(payload);
   }
@@ -82591,8 +82790,8 @@ class ExchangeAccount {
     if (payload.trigger && !long_pause_tp && !short_pause_tp && config2) {
       return await this.reduceMajorPositionEntry({
         symbol,
-        long: config2.long,
-        short: config2.short,
+        long: kind === "long" ? config2.long : undefined,
+        short: kind === "short" ? config2.short : undefined,
         trigger: config2.trigger
       });
     }

package/package.json

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