@gbozee/ultimate 0.0.2-174 → 0.0.2-176

package/dist/frontend-index.d.ts

@@ -703,6 +703,34 @@ export declare function generateGapTp(payload: {
 	gap: number;
 	gap_loss: number;
 };
+export declare function calculateFactorFromTakeProfit(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	knownTp: number;
+	tpType: "long" | "short";
+	price_places?: string;
+}): number;
+export declare function calculateFactorFromSellQuantity(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	knownSellQuantity: number;
+	sellType: "long" | "short";
+	sell_factor?: number;
+	price_places?: string;
+	decimal_places?: string;
+}): number;
 export declare function determineRewardFactor(payload: {
 	quantity: number;
 	avg_qty: number;

package/dist/frontend-index.js

@@ -2299,6 +2299,98 @@ function calculate_factor(payload) {
   calculated_factor = to_f(calculated_factor, places);
   return calculated_factor;
 }
+function calculateFactorFromTakeProfit(payload) {
+  const { long, short, knownTp, tpType, price_places = "%.4f" } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let factor;
+  if (tpType === "long") {
+    const longPercent = knownTp / long.entry - 1;
+    factor = longPercent * short.entry * short.quantity / gapLoss;
+  } else {
+    const shortPercent = short.entry / knownTp - 1;
+    factor = shortPercent * long.entry * long.quantity / gapLoss;
+  }
+  return to_f(factor, price_places);
+}
+function calculateFactorFromSellQuantity(payload) {
+  const {
+    long,
+    short,
+    knownSellQuantity,
+    sellType,
+    sell_factor = 1,
+    price_places = "%.4f"
+  } = payload;
+  if (knownSellQuantity < 0.00001) {
+    return 0;
+  }
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let low_factor = 0.001;
+  let high_factor = 1;
+  let best_factor = 0;
+  let best_diff = Infinity;
+  const tolerance = 0.00001;
+  const max_iterations = 150;
+  let expansions = 0;
+  const max_expansions = 15;
+  let iterations = 0;
+  while (iterations < max_iterations) {
+    iterations++;
+    const mid_factor = (low_factor + high_factor) / 2;
+    const testResult = generateGapTp({
+      long,
+      short,
+      factor: mid_factor,
+      sell_factor,
+      price_places: "%.8f",
+      decimal_places: "%.8f"
+    });
+    const testSellQty = sellType === "long" ? testResult.sell_quantity.long : testResult.sell_quantity.short;
+    const diff = Math.abs(testSellQty - knownSellQuantity);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff < tolerance) {
+      return to_f(mid_factor, price_places);
+    }
+    if (testSellQty < knownSellQuantity) {
+      low_factor = mid_factor;
+      if (mid_factor > high_factor * 0.9 && expansions < max_expansions) {
+        const ratio = knownSellQuantity / testSellQty;
+        if (ratio > 2) {
+          high_factor = high_factor * Math.min(ratio, 10);
+        } else {
+          high_factor = high_factor * 2;
+        }
+        expansions++;
+        continue;
+      }
+    } else {
+      high_factor = mid_factor;
+    }
+    if (Math.abs(high_factor - low_factor) < 0.00001 && diff > tolerance) {
+      if (testSellQty < knownSellQuantity && expansions < max_expansions) {
+        high_factor = high_factor * 1.1;
+        expansions++;
+        continue;
+      } else {
+        break;
+      }
+    }
+  }
+  return to_f(best_factor, price_places);
+}
 function determineRewardFactor(payload) {
   const { quantity, avg_qty, minimum_pnl, risk } = payload;
   const reward_factor = minimum_pnl / risk;
@@ -3084,6 +3176,8 @@ export {
   computeSellZones,
   computeRiskReward,
   computeProfitDetail,
+  calculateFactorFromTakeProfit,
+  calculateFactorFromSellQuantity,
   buildConfig,
   buildAvg,
   buildAppConfig,

package/dist/index.cjs

@@ -44901,6 +44901,8 @@ __export(exports_src, {
   constructAppConfig: () => constructAppConfig,
   computeRiskReward: () => computeRiskReward,
   computeProfitDetail: () => computeProfitDetail,
+  calculateFactorFromTakeProfit: () => calculateFactorFromTakeProfit,
+  calculateFactorFromSellQuantity: () => calculateFactorFromSellQuantity,
   buildConfig: () => buildConfig,
   buildAvg: () => buildAvg,
   buildAppConfig: () => buildAppConfig,
@@ -55515,6 +55517,33 @@ class AppDatabase {
       parent: config_id
     });
   }
+  async getCompoundInstance(payload) {
+    const { position } = payload;
+    const found = await this.pb.collection("compound_instances").getFullList({
+      filter: `position.id = "${position.id}"`,
+      expand: `ref`
+    });
+    if (found.length == 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async getSupportTable(payload) {
+    const { symbol, kind } = payload;
+    const found = await this.pb.collection("support_table").getFullList({
+      filter: `symbol = "${symbol}" && kind = "${kind}"`
+    });
+    if (found.length === 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async updateCompoundInstance(payload) {
+    const { id, params } = payload;
+    return await this.pb.collection("compound_instances").update(id, params);
+  }
 }
 
 // src/exchange-account.ts
@@ -57617,6 +57646,98 @@ function calculate_factor(payload) {
   calculated_factor = to_f(calculated_factor, places);
   return calculated_factor;
 }
+function calculateFactorFromTakeProfit(payload) {
+  const { long, short, knownTp, tpType, price_places = "%.4f" } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let factor;
+  if (tpType === "long") {
+    const longPercent = knownTp / long.entry - 1;
+    factor = longPercent * short.entry * short.quantity / gapLoss;
+  } else {
+    const shortPercent = short.entry / knownTp - 1;
+    factor = shortPercent * long.entry * long.quantity / gapLoss;
+  }
+  return to_f(factor, price_places);
+}
+function calculateFactorFromSellQuantity(payload) {
+  const {
+    long,
+    short,
+    knownSellQuantity,
+    sellType,
+    sell_factor = 1,
+    price_places = "%.4f"
+  } = payload;
+  if (knownSellQuantity < 0.00001) {
+    return 0;
+  }
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let low_factor = 0.001;
+  let high_factor = 1;
+  let best_factor = 0;
+  let best_diff = Infinity;
+  const tolerance = 0.00001;
+  const max_iterations = 150;
+  let expansions = 0;
+  const max_expansions = 15;
+  let iterations = 0;
+  while (iterations < max_iterations) {
+    iterations++;
+    const mid_factor = (low_factor + high_factor) / 2;
+    const testResult = generateGapTp({
+      long,
+      short,
+      factor: mid_factor,
+      sell_factor,
+      price_places: "%.8f",
+      decimal_places: "%.8f"
+    });
+    const testSellQty = sellType === "long" ? testResult.sell_quantity.long : testResult.sell_quantity.short;
+    const diff = Math.abs(testSellQty - knownSellQuantity);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff < tolerance) {
+      return to_f(mid_factor, price_places);
+    }
+    if (testSellQty < knownSellQuantity) {
+      low_factor = mid_factor;
+      if (mid_factor > high_factor * 0.9 && expansions < max_expansions) {
+        const ratio = knownSellQuantity / testSellQty;
+        if (ratio > 2) {
+          high_factor = high_factor * Math.min(ratio, 10);
+        } else {
+          high_factor = high_factor * 2;
+        }
+        expansions++;
+        continue;
+      }
+    } else {
+      high_factor = mid_factor;
+    }
+    if (Math.abs(high_factor - low_factor) < 0.00001 && diff > tolerance) {
+      if (testSellQty < knownSellQuantity && expansions < max_expansions) {
+        high_factor = high_factor * 1.1;
+        expansions++;
+        continue;
+      } else {
+        break;
+      }
+    }
+  }
+  return to_f(best_factor, price_places);
+}
 function determineRewardFactor(payload) {
   const { quantity, avg_qty, minimum_pnl, risk } = payload;
   const reward_factor = minimum_pnl / risk;
@@ -60790,7 +60911,6 @@ async function reduceMajorPositionEntry(input, accountInfo, trigger2, exchange_i
 // src/position.ts
 var import_https_proxy_agent2 = __toESM(require_dist2());
 var import_socks_proxy_agent2 = __toESM(require_dist3());
-
 class ExchangePosition {
   exchange;
   symbol_config;
@@ -61835,6 +61955,53 @@ class ExchangePosition {
       increase: false
     });
   }
+  async isActiveTrade() {
+    const config2 = await this.getConfig();
+    const supportTable = await this.app_db.getSupportTable({
+      symbol: this.symbol,
+      kind: this.kind
+    });
+    return {
+      config: config2,
+      condition: supportTable?.price === config2.stop,
+      supportTable
+    };
+  }
+  async updateCompound(payload) {
+    const pb = this.app_db.pb;
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const {
+      expand: { ref }
+    } = item;
+    const risk = item.risk;
+    const percent = ref.profit_percent / 100;
+    const new_risk = risk * (1 + percent);
+    const { condition, supportTable, config: config2 } = await this.isActiveTrade();
+    if (payload?.place && condition) {
+      await pb.collection("compound_instances").update(item.id, {
+        risk: new_risk
+      });
+      await pb.collection("scheduled_trades").update(config2.id, {
+        profit: to_f(new_risk * percent, "%.3f")
+      });
+    }
+    return {
+      support: supportTable.price,
+      counter: supportTable.counter,
+      new_risk
+    };
+  }
+  async cleanOnActiveCompoundInstance() {
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const { condition } = await this.isActiveTrade();
+    if (item && condition && this.instance.quantity === 0) {
+      await this.cancelOrders({ limit: true });
+    }
+  }
 }
 function convert_to_exchange_order(order) {
   return {

package/dist/index.d.ts

@@ -155,6 +155,28 @@ export interface WindingDownMarket extends RecordModel {
 	symbol: string;
 	risk_reward: number;
 }
+export interface Compounder extends BaseSystemFields {
+	risk?: number;
+	profit_percent?: number;
+	owner?: string;
+	completed?: boolean;
+	start_balance?: number;
+	starting_risk?: number;
+	fee_rate?: number;
+}
+export interface CompoundInstance extends BaseSystemFields {
+	ref?: string;
+	position?: string;
+	risk?: number;
+	hedged?: boolean;
+}
+export interface SupportTable extends BaseSystemFields {
+	symbol?: string;
+	price?: number;
+	counter?: number;
+	last_updated?: string;
+	kind?: "long" | "short";
+}
 export interface BotInstance extends BaseSystemFields {
 	asset: string;
 	main_account?: string;
@@ -848,6 +870,21 @@ export declare class AppDatabase {
 			profit_percent: number;
 		};
 	}): Promise<void>;
+	getCompoundInstance(payload: {
+		position: Position$1;
+	}): Promise<CompoundInstance & {
+		expand: {
+			ref: Compounder;
+		};
+	}>;
+	getSupportTable(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<SupportTable>;
+	updateCompoundInstance(payload: {
+		id: string;
+		params: any;
+	}): Promise<import("pocketbase").RecordModel>;
 }
 export type StrategyPosition = {
 	entry: number;
@@ -1596,6 +1633,34 @@ export declare function generateGapTp(payload: {
 	gap: number;
 	gap_loss: number;
 };
+export declare function calculateFactorFromTakeProfit(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	knownTp: number;
+	tpType: "long" | "short";
+	price_places?: string;
+}): number;
+export declare function calculateFactorFromSellQuantity(payload: {
+	long: {
+		entry: number;
+		quantity: number;
+	};
+	short: {
+		entry: number;
+		quantity: number;
+	};
+	knownSellQuantity: number;
+	sellType: "long" | "short";
+	sell_factor?: number;
+	price_places?: string;
+	decimal_places?: string;
+}): number;
 export declare function determineRewardFactor(payload: {
 	quantity: number;
 	avg_qty: number;
@@ -2115,6 +2180,19 @@ export declare class ExchangePosition {
 		fee_percent?: number;
 		place?: boolean;
 	}): Promise<any>;
+	isActiveTrade(): Promise<{
+		config: import("pocketbase").RecordModel | ScheduledTrade;
+		condition: boolean;
+		supportTable: SupportTable;
+	}>;
+	updateCompound(payload?: {
+		place?: boolean;
+	}): Promise<{
+		support: number;
+		counter: number;
+		new_risk: number;
+	}>;
+	cleanOnActiveCompoundInstance(): Promise<void>;
 }
 declare class ExchangeAccount$1 {
 	instance: {

package/dist/index.js

@@ -55455,6 +55455,33 @@ class AppDatabase {
       parent: config_id
     });
   }
+  async getCompoundInstance(payload) {
+    const { position } = payload;
+    const found = await this.pb.collection("compound_instances").getFullList({
+      filter: `position.id = "${position.id}"`,
+      expand: `ref`
+    });
+    if (found.length == 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async getSupportTable(payload) {
+    const { symbol, kind } = payload;
+    const found = await this.pb.collection("support_table").getFullList({
+      filter: `symbol = "${symbol}" && kind = "${kind}"`
+    });
+    if (found.length === 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async updateCompoundInstance(payload) {
+    const { id, params } = payload;
+    return await this.pb.collection("compound_instances").update(id, params);
+  }
 }
 
 // src/exchange-account.ts
@@ -57557,6 +57584,98 @@ function calculate_factor(payload) {
   calculated_factor = to_f(calculated_factor, places);
   return calculated_factor;
 }
+function calculateFactorFromTakeProfit(payload) {
+  const { long, short, knownTp, tpType, price_places = "%.4f" } = payload;
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let factor;
+  if (tpType === "long") {
+    const longPercent = knownTp / long.entry - 1;
+    factor = longPercent * short.entry * short.quantity / gapLoss;
+  } else {
+    const shortPercent = short.entry / knownTp - 1;
+    factor = shortPercent * long.entry * long.quantity / gapLoss;
+  }
+  return to_f(factor, price_places);
+}
+function calculateFactorFromSellQuantity(payload) {
+  const {
+    long,
+    short,
+    knownSellQuantity,
+    sellType,
+    sell_factor = 1,
+    price_places = "%.4f"
+  } = payload;
+  if (knownSellQuantity < 0.00001) {
+    return 0;
+  }
+  const gap = Math.abs(long.entry - short.entry);
+  const max_quantity = Math.max(long.quantity, short.quantity);
+  const gapLoss = gap * max_quantity;
+  if (gapLoss === 0) {
+    return 0;
+  }
+  let low_factor = 0.001;
+  let high_factor = 1;
+  let best_factor = 0;
+  let best_diff = Infinity;
+  const tolerance = 0.00001;
+  const max_iterations = 150;
+  let expansions = 0;
+  const max_expansions = 15;
+  let iterations = 0;
+  while (iterations < max_iterations) {
+    iterations++;
+    const mid_factor = (low_factor + high_factor) / 2;
+    const testResult = generateGapTp({
+      long,
+      short,
+      factor: mid_factor,
+      sell_factor,
+      price_places: "%.8f",
+      decimal_places: "%.8f"
+    });
+    const testSellQty = sellType === "long" ? testResult.sell_quantity.long : testResult.sell_quantity.short;
+    const diff = Math.abs(testSellQty - knownSellQuantity);
+    if (diff < best_diff) {
+      best_diff = diff;
+      best_factor = mid_factor;
+    }
+    if (diff < tolerance) {
+      return to_f(mid_factor, price_places);
+    }
+    if (testSellQty < knownSellQuantity) {
+      low_factor = mid_factor;
+      if (mid_factor > high_factor * 0.9 && expansions < max_expansions) {
+        const ratio = knownSellQuantity / testSellQty;
+        if (ratio > 2) {
+          high_factor = high_factor * Math.min(ratio, 10);
+        } else {
+          high_factor = high_factor * 2;
+        }
+        expansions++;
+        continue;
+      }
+    } else {
+      high_factor = mid_factor;
+    }
+    if (Math.abs(high_factor - low_factor) < 0.00001 && diff > tolerance) {
+      if (testSellQty < knownSellQuantity && expansions < max_expansions) {
+        high_factor = high_factor * 1.1;
+        expansions++;
+        continue;
+      } else {
+        break;
+      }
+    }
+  }
+  return to_f(best_factor, price_places);
+}
 function determineRewardFactor(payload) {
   const { quantity, avg_qty, minimum_pnl, risk } = payload;
   const reward_factor = minimum_pnl / risk;
@@ -60730,7 +60849,6 @@ async function reduceMajorPositionEntry(input, accountInfo, trigger2, exchange_i
 // src/position.ts
 var import_https_proxy_agent2 = __toESM(require_dist2(), 1);
 var import_socks_proxy_agent2 = __toESM(require_dist3(), 1);
-
 class ExchangePosition {
   exchange;
   symbol_config;
@@ -61775,6 +61893,53 @@ class ExchangePosition {
       increase: false
     });
   }
+  async isActiveTrade() {
+    const config2 = await this.getConfig();
+    const supportTable = await this.app_db.getSupportTable({
+      symbol: this.symbol,
+      kind: this.kind
+    });
+    return {
+      config: config2,
+      condition: supportTable?.price === config2.stop,
+      supportTable
+    };
+  }
+  async updateCompound(payload) {
+    const pb = this.app_db.pb;
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const {
+      expand: { ref }
+    } = item;
+    const risk = item.risk;
+    const percent = ref.profit_percent / 100;
+    const new_risk = risk * (1 + percent);
+    const { condition, supportTable, config: config2 } = await this.isActiveTrade();
+    if (payload?.place && condition) {
+      await pb.collection("compound_instances").update(item.id, {
+        risk: new_risk
+      });
+      await pb.collection("scheduled_trades").update(config2.id, {
+        profit: to_f(new_risk * percent, "%.3f")
+      });
+    }
+    return {
+      support: supportTable.price,
+      counter: supportTable.counter,
+      new_risk
+    };
+  }
+  async cleanOnActiveCompoundInstance() {
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const { condition } = await this.isActiveTrade();
+    if (item && condition && this.instance.quantity === 0) {
+      await this.cancelOrders({ limit: true });
+    }
+  }
 }
 function convert_to_exchange_order(order) {
   return {
@@ -64060,6 +64225,8 @@ export {
   constructAppConfig,
   computeRiskReward,
   computeProfitDetail,
+  calculateFactorFromTakeProfit,
+  calculateFactorFromSellQuantity,
   buildConfig,
   buildAvg,
   buildAppConfig,

package/dist/mcp-server.cjs

@@ -62211,6 +62211,33 @@ class AppDatabase {
       parent: config_id
     });
   }
+  async getCompoundInstance(payload) {
+    const { position } = payload;
+    const found = await this.pb.collection("compound_instances").getFullList({
+      filter: `position.id = "${position.id}"`,
+      expand: `ref`
+    });
+    if (found.length == 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async getSupportTable(payload) {
+    const { symbol, kind } = payload;
+    const found = await this.pb.collection("support_table").getFullList({
+      filter: `symbol = "${symbol}" && kind = "${kind}"`
+    });
+    if (found.length === 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async updateCompoundInstance(payload) {
+    const { id, params } = payload;
+    return await this.pb.collection("compound_instances").update(id, params);
+  }
 }
 
 // src/exchanges/binance/index.ts
@@ -67460,7 +67487,6 @@ async function reduceMajorPositionEntry(input, accountInfo, trigger2, exchange_i
 // src/position.ts
 var import_https_proxy_agent2 = __toESM(require_dist2());
 var import_socks_proxy_agent2 = __toESM(require_dist3());
-
 class ExchangePosition {
   exchange;
   symbol_config;
@@ -68505,6 +68531,53 @@ class ExchangePosition {
       increase: false
     });
   }
+  async isActiveTrade() {
+    const config2 = await this.getConfig();
+    const supportTable = await this.app_db.getSupportTable({
+      symbol: this.symbol,
+      kind: this.kind
+    });
+    return {
+      config: config2,
+      condition: supportTable?.price === config2.stop,
+      supportTable
+    };
+  }
+  async updateCompound(payload) {
+    const pb = this.app_db.pb;
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const {
+      expand: { ref }
+    } = item;
+    const risk = item.risk;
+    const percent = ref.profit_percent / 100;
+    const new_risk = risk * (1 + percent);
+    const { condition, supportTable, config: config2 } = await this.isActiveTrade();
+    if (payload?.place && condition) {
+      await pb.collection("compound_instances").update(item.id, {
+        risk: new_risk
+      });
+      await pb.collection("scheduled_trades").update(config2.id, {
+        profit: to_f(new_risk * percent, "%.3f")
+      });
+    }
+    return {
+      support: supportTable.price,
+      counter: supportTable.counter,
+      new_risk
+    };
+  }
+  async cleanOnActiveCompoundInstance() {
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const { condition } = await this.isActiveTrade();
+    if (item && condition && this.instance.quantity === 0) {
+      await this.cancelOrders({ limit: true });
+    }
+  }
 }
 function convert_to_exchange_order(order) {
   return {

package/dist/mcp-server.js

@@ -62184,6 +62184,33 @@ class AppDatabase {
       parent: config_id
     });
   }
+  async getCompoundInstance(payload) {
+    const { position } = payload;
+    const found = await this.pb.collection("compound_instances").getFullList({
+      filter: `position.id = "${position.id}"`,
+      expand: `ref`
+    });
+    if (found.length == 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async getSupportTable(payload) {
+    const { symbol, kind } = payload;
+    const found = await this.pb.collection("support_table").getFullList({
+      filter: `symbol = "${symbol}" && kind = "${kind}"`
+    });
+    if (found.length === 0) {
+      return;
+    }
+    const item = found[0];
+    return item;
+  }
+  async updateCompoundInstance(payload) {
+    const { id, params } = payload;
+    return await this.pb.collection("compound_instances").update(id, params);
+  }
 }
 
 // src/exchanges/binance/index.ts
@@ -67433,7 +67460,6 @@ async function reduceMajorPositionEntry(input, accountInfo, trigger2, exchange_i
 // src/position.ts
 var import_https_proxy_agent2 = __toESM(require_dist2(), 1);
 var import_socks_proxy_agent2 = __toESM(require_dist3(), 1);
-
 class ExchangePosition {
   exchange;
   symbol_config;
@@ -68478,6 +68504,53 @@ class ExchangePosition {
       increase: false
     });
   }
+  async isActiveTrade() {
+    const config2 = await this.getConfig();
+    const supportTable = await this.app_db.getSupportTable({
+      symbol: this.symbol,
+      kind: this.kind
+    });
+    return {
+      config: config2,
+      condition: supportTable?.price === config2.stop,
+      supportTable
+    };
+  }
+  async updateCompound(payload) {
+    const pb = this.app_db.pb;
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const {
+      expand: { ref }
+    } = item;
+    const risk = item.risk;
+    const percent = ref.profit_percent / 100;
+    const new_risk = risk * (1 + percent);
+    const { condition, supportTable, config: config2 } = await this.isActiveTrade();
+    if (payload?.place && condition) {
+      await pb.collection("compound_instances").update(item.id, {
+        risk: new_risk
+      });
+      await pb.collection("scheduled_trades").update(config2.id, {
+        profit: to_f(new_risk * percent, "%.3f")
+      });
+    }
+    return {
+      support: supportTable.price,
+      counter: supportTable.counter,
+      new_risk
+    };
+  }
+  async cleanOnActiveCompoundInstance() {
+    const item = await this.app_db.getCompoundInstance({
+      position: this.instance
+    });
+    const { condition } = await this.isActiveTrade();
+    if (item && condition && this.instance.quantity === 0) {
+      await this.cancelOrders({ limit: true });
+    }
+  }
 }
 function convert_to_exchange_order(order) {
   return {

package/package.json

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