@gbozee/ultimate 0.0.2-130 → 0.0.2-132

package/dist/frontend-index.d.ts

@@ -599,6 +599,33 @@ export declare function getOptimumHedgeFactor(payload: {
 	iterations: number;
 	converged: boolean;
 };
+export type CType = {
+	next_order: number;
+	take_profit: number;
+};
+export declare function determineCompoundLongTrade(payload: {
+	focus_short_position: CType;
+	focus_long_position: CType;
+	shortConfig: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		symbol: string;
+		profit_percent: number;
+	};
+	rr?: number;
+	global_config: GlobalConfig;
+}): {
+	start_risk: number;
+	short_profit: number;
+	support: number;
+	resistance: number;
+	long_v: any;
+	profit_percent: number;
+	result: any;
+	short_max_size: any;
+};
 export type StrategyPosition = {
 	entry: number;
 	quantity: number;

package/dist/frontend-index.js

@@ -2132,6 +2132,54 @@ function getOptimumHedgeFactor(payload) {
     converged: best_diff <= tolerance
   };
 }
+function determineCompoundLongTrade(payload) {
+  const {
+    focus_short_position,
+    focus_long_position,
+    shortConfig,
+    global_config,
+    rr = 1
+  } = payload;
+  const short_app_config = buildAppConfig(global_config, {
+    entry: shortConfig.entry,
+    stop: shortConfig.stop,
+    risk_reward: shortConfig.risk_reward,
+    risk: shortConfig.risk,
+    symbol: shortConfig.symbol
+  });
+  const short_max_size = short_app_config.last_value.avg_size;
+  const start_risk = Math.abs(short_app_config.last_value.neg_pnl) * rr;
+  const short_profit = short_app_config.last_value.avg_size * short_app_config.last_value.avg_entry * shortConfig.profit_percent / 100;
+  const diff = short_profit * rr / short_app_config.last_value.avg_size;
+  const support = Math.abs(short_app_config.last_value.avg_entry - diff);
+  const resistance = focus_short_position.next_order || focus_long_position.take_profit;
+  console.log({ support, resistance, short_profit });
+  const result = getRiskReward({
+    entry: resistance,
+    stop: support,
+    risk: start_risk,
+    global_config,
+    force_exact_risk: true
+  });
+  const long_app_config = buildAppConfig(global_config, {
+    entry: resistance,
+    stop: support,
+    risk_reward: result.risk_reward,
+    risk: result.risk,
+    symbol: shortConfig.symbol
+  });
+  const long_profit_percent = start_risk * 2 * 100 / (long_app_config.last_value.avg_size * long_app_config.last_value.avg_entry);
+  return {
+    start_risk,
+    short_profit,
+    support: to_f(support, global_config.price_places),
+    resistance: to_f(resistance, global_config.price_places),
+    long_v: long_app_config.last_value,
+    profit_percent: to_f(long_profit_percent, "%.3f"),
+    result,
+    short_max_size
+  };
+}
 // src/helpers/strategy.ts
 class Strategy {
   position;
@@ -2665,6 +2713,7 @@ export {
   determineRewardFactor,
   determineOptimumRisk,
   determineOptimumReward,
+  determineCompoundLongTrade,
   createGapPairs,
   createArray,
   computeTotalAverageForEachTrade,

package/dist/index.cjs

@@ -41963,6 +41963,7 @@ __export(exports_src, {
   determineRewardFactor: () => determineRewardFactor,
   determineOptimumRisk: () => determineOptimumRisk,
   determineOptimumReward: () => determineOptimumReward,
+  determineCompoundLongTrade: () => determineCompoundLongTrade,
   database: () => exports_database,
   createArray: () => createArray,
   computeRiskReward: () => computeRiskReward,
@@ -52484,6 +52485,37 @@ class AppDatabase {
     });
     return result;
   }
+  async getPositionWithLowestNextOrder(options) {
+    const { symbol, kind, asset, exclude } = options;
+    try {
+      let filter = `kind="${kind}" && next_order != null`;
+      if (asset) {
+        filter += ` && symbol ~ "${asset.toUpperCase()}%"`;
+      } else if (symbol) {
+        filter += ` && symbol:lower="${symbol.toLowerCase()}"`;
+      } else {
+        throw new Error("Either symbol or asset must be provided");
+      }
+      if (exclude && exclude.length > 0) {
+        const excludeConditions = exclude.map((acc) => `(p_account.owner:lower != "${acc.owner.toLowerCase()}" || p_account.exchange:lower != "${acc.exchange.toLowerCase()}")`).join(" && ");
+        filter += ` && (${excludeConditions})`;
+      }
+      const sortDirection = kind === "short" ? "+" : "-";
+      const positions = await this.pb.collection("positions_view").getList(1, 1, {
+        filter,
+        sort: `${sortDirection}next_order`,
+        expand: "p_account"
+      });
+      if (positions.items.length > 0) {
+        return positions.items[0];
+      }
+      return null;
+    } catch (error) {
+      const identifier = asset ? `asset ${asset}` : `symbol ${symbol}`;
+      console.error(`Error fetching position with ${kind === "short" ? "lowest" : "highest"} next_order for ${identifier} ${kind}:`, error);
+      return null;
+    }
+  }
   async hasExistingOrders(symbol) {
     const result = await this.pb.collection("orders").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}"`
@@ -54437,6 +54469,54 @@ function getOptimumHedgeFactor(payload) {
     converged: best_diff <= tolerance
   };
 }
+function determineCompoundLongTrade(payload) {
+  const {
+    focus_short_position,
+    focus_long_position,
+    shortConfig,
+    global_config,
+    rr = 1
+  } = payload;
+  const short_app_config = buildAppConfig(global_config, {
+    entry: shortConfig.entry,
+    stop: shortConfig.stop,
+    risk_reward: shortConfig.risk_reward,
+    risk: shortConfig.risk,
+    symbol: shortConfig.symbol
+  });
+  const short_max_size = short_app_config.last_value.avg_size;
+  const start_risk = Math.abs(short_app_config.last_value.neg_pnl) * rr;
+  const short_profit = short_app_config.last_value.avg_size * short_app_config.last_value.avg_entry * shortConfig.profit_percent / 100;
+  const diff = short_profit * rr / short_app_config.last_value.avg_size;
+  const support = Math.abs(short_app_config.last_value.avg_entry - diff);
+  const resistance = focus_short_position.next_order || focus_long_position.take_profit;
+  console.log({ support, resistance, short_profit });
+  const result = getRiskReward({
+    entry: resistance,
+    stop: support,
+    risk: start_risk,
+    global_config,
+    force_exact_risk: true
+  });
+  const long_app_config = buildAppConfig(global_config, {
+    entry: resistance,
+    stop: support,
+    risk_reward: result.risk_reward,
+    risk: result.risk,
+    symbol: shortConfig.symbol
+  });
+  const long_profit_percent = start_risk * 2 * 100 / (long_app_config.last_value.avg_size * long_app_config.last_value.avg_entry);
+  return {
+    start_risk,
+    short_profit,
+    support: to_f2(support, global_config.price_places),
+    resistance: to_f2(resistance, global_config.price_places),
+    long_v: long_app_config.last_value,
+    profit_percent: to_f2(long_profit_percent, "%.3f"),
+    result,
+    short_max_size
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -58520,6 +58600,10 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      await this.updateRiskOnEmpty({
+        symbol,
+        kind
+      });
     }
     const long_config = await this.getPositionConfig({
       symbol,
@@ -59011,17 +59095,53 @@ class ExchangeAccount {
     if (position2?.expand?.config) {
       const config2 = position2.expand.config;
       let _profit = config2.profit;
+      let risk = config2.risk;
+      let next_risk = position2.next_risk;
       let _profit_percent = config2?.profit_percent;
       if (_profit_percent && (position2?.quantity || 0) > 0) {
         _profit = to_f2(position2.quantity * _profit_percent * position2.entry / 100);
+        next_risk = risk + _profit;
       }
       await this.app_db.update_db_position(position2, {
-        target_pnl: _profit
+        target_pnl: _profit,
+        next_risk
       });
       return _profit;
     }
     return 0;
   }
+  async updateRiskOnEmpty(payload) {
+    const { symbol, kind } = payload;
+    const position2 = await this.syncAccount({
+      symbol,
+      kind
+    });
+    if (position2 && position2.quantity === 0) {
+      if (position2.next_risk && position2.next_risk > 0) {
+        await this.getPositionConfig({
+          symbol,
+          kind,
+          params: {
+            risk: position2.next_risk
+          }
+        });
+        console.log(`Updated ${kind} position config for ${symbol}: risk = ${position2.next_risk}`);
+        return {
+          updated: true,
+          symbol,
+          kind,
+          old_risk: position2.expand?.config?.risk,
+          new_risk: position2.next_risk
+        };
+      }
+    }
+    return {
+      updated: false,
+      symbol,
+      kind,
+      reason: position2 ? position2.quantity > 0 ? "Position not empty" : "No next_risk available" : "Position not found"
+    };
+  }
   async updateGoodHedgeConfig(payload) {
     const {
       params,
@@ -60077,6 +60197,38 @@ class ExchangeAccount {
       decimal_places: symbol_config.decimal_places
     });
   }
+  async placeCompoundShortTrade(payload) {
+  }
+  async placeCompoundLongTrade(payload) {
+    const { symbol, params, place = false } = payload;
+    if (place) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          entry: params.resistance,
+          stop: params.support,
+          risk_reward: params.risk_reward,
+          risk: params.risk,
+          profit_percent: params.profit_percent
+        }
+      });
+      const short_position = await this.syncAccount({
+        symbol,
+        kind: "short",
+        as_view: true
+      });
+      if (short_position.quantity >= short_position.avg_qty) {
+        await this.placeTrade({
+          symbol,
+          kind: "long",
+          ignore_config: true,
+          limit: true,
+          place: true
+        });
+      }
+    }
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
@@ -60417,6 +60569,43 @@ class App {
     });
     return result;
   }
+  async compoundLongTrade(payload) {
+    const { main_account, focus_account, rr, place } = payload;
+    const main_exchange_account = await this.getExchangeAccount(main_account);
+    const focus_exchange_account = await this.getExchangeAccount(focus_account);
+    const focus_position = await focus_exchange_account.syncAccount({
+      symbol: focus_account.symbol,
+      as_view: true
+    });
+    const focus_long_position = focus_position.find((k) => k.kind === "long");
+    const focus_short_position = focus_position.find((k) => k.kind === "short");
+    const shortConfig = await main_exchange_account.getPositionConfig({
+      symbol: main_account.symbol,
+      kind: "short"
+    });
+    const symbol_config = await focus_exchange_account.recomputeSymbolConfig({
+      symbol: focus_account.symbol
+    });
+    const result = determineCompoundLongTrade({
+      focus_short_position,
+      focus_long_position,
+      shortConfig,
+      global_config: symbol_config,
+      rr
+    });
+    await main_exchange_account.placeCompoundLongTrade({
+      symbol: main_account.symbol,
+      params: {
+        resistance: result.resistance,
+        support: result.support,
+        profit_percent: result.profit_percent,
+        risk_reward: result.result.risk_reward,
+        risk: result.result.risk
+      },
+      place
+    });
+    return result;
+  }
   async reduceExistingPosition(payload) {
     const {
       main_account,

package/dist/index.d.ts

@@ -128,6 +128,7 @@ export interface PositionsView {
 		price: number;
 		quantity: number;
 	};
+	next_risk?: number;
 }
 export interface BullishMarket extends RecordModel {
 	id: string;
@@ -777,6 +778,12 @@ export declare class AppDatabase {
 	} | SymbolConfig[]>;
 	unwindSymbolFromDB(symbol: string): Promise<boolean>;
 	hasExistingPosition(symbol: string): Promise<import("pocketbase").RecordModel[]>;
+	getPositionWithLowestNextOrder(options: {
+		symbol?: string;
+		kind: "long" | "short";
+		asset?: string;
+		exclude?: ExchangeType[];
+	}): Promise<PositionsView | null>;
 	hasExistingOrders(symbol: string): Promise<import("pocketbase").RecordModel[]>;
 	removeSymbolFromUnwindingMarkets(symbol: string): Promise<boolean>;
 	removePosition(position: any): Promise<void>;
@@ -1528,6 +1535,33 @@ export declare function getOptimumHedgeFactor(payload: {
 	iterations: number;
 	converged: boolean;
 };
+export type CType = {
+	next_order: number;
+	take_profit: number;
+};
+export declare function determineCompoundLongTrade(payload: {
+	focus_short_position: CType;
+	focus_long_position: CType;
+	shortConfig: {
+		entry: number;
+		stop: number;
+		risk_reward: number;
+		risk: number;
+		symbol: string;
+		profit_percent: number;
+	};
+	rr?: number;
+	global_config: GlobalConfig;
+}): {
+	start_risk: number;
+	short_profit: number;
+	support: number;
+	resistance: number;
+	long_v: any;
+	profit_percent: number;
+	result: any;
+	short_max_size: any;
+};
 declare class ExchangePosition {
 	exchange: BaseExchange;
 	exchange_account: ExchangeAccount$1;
@@ -2015,6 +2049,32 @@ declare class ExchangeAccount$1 {
 		symbol: string;
 		kind: "long" | "short";
 	}): Promise<number>;
+	/**
+	 * Updates the risk configuration for an empty position using the next_risk value.
+	 * This implements progressive risk management where successful trades increase future risk tolerance.
+	 *
+	 * @param payload.symbol - The trading symbol (e.g., "BTCUSDT")
+	 * @param payload.kind - Position type: "long" or "short"
+	 * @returns Object indicating if update was successful with old/new risk values
+	 */
+	updateRiskOnEmpty(payload: {
+		symbol: string;
+		kind: "long" | "short";
+	}): Promise<{
+		updated: boolean;
+		symbol: string;
+		kind: "long" | "short";
+		old_risk: number;
+		new_risk: number;
+		reason?: undefined;
+	} | {
+		updated: boolean;
+		symbol: string;
+		kind: "long" | "short";
+		reason: string;
+		old_risk?: undefined;
+		new_risk?: undefined;
+	}>;
 	updateGoodHedgeConfig(payload: {
 		symbol: string;
 		params?: {
@@ -2336,6 +2396,18 @@ declare class ExchangeAccount$1 {
 		price_places: string;
 		decimal_places: string;
 	}>;
+	placeCompoundShortTrade(payload: {}): Promise<void>;
+	placeCompoundLongTrade(payload: {
+		symbol: string;
+		params: {
+			resistance: number;
+			support: number;
+			profit_percent: number;
+			risk_reward: number;
+			risk: number;
+		};
+		place?: boolean;
+	}): Promise<void>;
 }
 declare function getExchangeAccount(payload: {
 	account: ExchangeType;
@@ -2530,6 +2602,25 @@ declare class App {
 			pnl: number;
 		};
 	}>;
+	compoundLongTrade(payload: {
+		main_account: ExchangeType & {
+			symbol: string;
+		};
+		focus_account: ExchangeType & {
+			symbol: string;
+		};
+		place?: boolean;
+		rr?: number;
+	}): Promise<{
+		start_risk: number;
+		short_profit: number;
+		support: number;
+		resistance: number;
+		long_v: any;
+		profit_percent: number;
+		result: any;
+		short_max_size: any;
+	}>;
 	reduceExistingPosition(payload: {
 		main_account: ExchangeType & {
 			symbol: string;

package/dist/index.js

@@ -52433,6 +52433,37 @@ class AppDatabase {
     });
     return result;
   }
+  async getPositionWithLowestNextOrder(options) {
+    const { symbol, kind, asset, exclude } = options;
+    try {
+      let filter = `kind="${kind}" && next_order != null`;
+      if (asset) {
+        filter += ` && symbol ~ "${asset.toUpperCase()}%"`;
+      } else if (symbol) {
+        filter += ` && symbol:lower="${symbol.toLowerCase()}"`;
+      } else {
+        throw new Error("Either symbol or asset must be provided");
+      }
+      if (exclude && exclude.length > 0) {
+        const excludeConditions = exclude.map((acc) => `(p_account.owner:lower != "${acc.owner.toLowerCase()}" || p_account.exchange:lower != "${acc.exchange.toLowerCase()}")`).join(" && ");
+        filter += ` && (${excludeConditions})`;
+      }
+      const sortDirection = kind === "short" ? "+" : "-";
+      const positions = await this.pb.collection("positions_view").getList(1, 1, {
+        filter,
+        sort: `${sortDirection}next_order`,
+        expand: "p_account"
+      });
+      if (positions.items.length > 0) {
+        return positions.items[0];
+      }
+      return null;
+    } catch (error) {
+      const identifier = asset ? `asset ${asset}` : `symbol ${symbol}`;
+      console.error(`Error fetching position with ${kind === "short" ? "lowest" : "highest"} next_order for ${identifier} ${kind}:`, error);
+      return null;
+    }
+  }
   async hasExistingOrders(symbol) {
     const result = await this.pb.collection("orders").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}"`
@@ -54386,6 +54417,54 @@ function getOptimumHedgeFactor(payload) {
     converged: best_diff <= tolerance
   };
 }
+function determineCompoundLongTrade(payload) {
+  const {
+    focus_short_position,
+    focus_long_position,
+    shortConfig,
+    global_config,
+    rr = 1
+  } = payload;
+  const short_app_config = buildAppConfig(global_config, {
+    entry: shortConfig.entry,
+    stop: shortConfig.stop,
+    risk_reward: shortConfig.risk_reward,
+    risk: shortConfig.risk,
+    symbol: shortConfig.symbol
+  });
+  const short_max_size = short_app_config.last_value.avg_size;
+  const start_risk = Math.abs(short_app_config.last_value.neg_pnl) * rr;
+  const short_profit = short_app_config.last_value.avg_size * short_app_config.last_value.avg_entry * shortConfig.profit_percent / 100;
+  const diff = short_profit * rr / short_app_config.last_value.avg_size;
+  const support = Math.abs(short_app_config.last_value.avg_entry - diff);
+  const resistance = focus_short_position.next_order || focus_long_position.take_profit;
+  console.log({ support, resistance, short_profit });
+  const result = getRiskReward({
+    entry: resistance,
+    stop: support,
+    risk: start_risk,
+    global_config,
+    force_exact_risk: true
+  });
+  const long_app_config = buildAppConfig(global_config, {
+    entry: resistance,
+    stop: support,
+    risk_reward: result.risk_reward,
+    risk: result.risk,
+    symbol: shortConfig.symbol
+  });
+  const long_profit_percent = start_risk * 2 * 100 / (long_app_config.last_value.avg_size * long_app_config.last_value.avg_entry);
+  return {
+    start_risk,
+    short_profit,
+    support: to_f2(support, global_config.price_places),
+    resistance: to_f2(resistance, global_config.price_places),
+    long_v: long_app_config.last_value,
+    profit_percent: to_f2(long_profit_percent, "%.3f"),
+    result,
+    short_max_size
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -58469,6 +58548,10 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      await this.updateRiskOnEmpty({
+        symbol,
+        kind
+      });
     }
     const long_config = await this.getPositionConfig({
       symbol,
@@ -58960,17 +59043,53 @@ class ExchangeAccount {
     if (position2?.expand?.config) {
       const config2 = position2.expand.config;
       let _profit = config2.profit;
+      let risk = config2.risk;
+      let next_risk = position2.next_risk;
       let _profit_percent = config2?.profit_percent;
       if (_profit_percent && (position2?.quantity || 0) > 0) {
         _profit = to_f2(position2.quantity * _profit_percent * position2.entry / 100);
+        next_risk = risk + _profit;
       }
       await this.app_db.update_db_position(position2, {
-        target_pnl: _profit
+        target_pnl: _profit,
+        next_risk
       });
       return _profit;
     }
     return 0;
   }
+  async updateRiskOnEmpty(payload) {
+    const { symbol, kind } = payload;
+    const position2 = await this.syncAccount({
+      symbol,
+      kind
+    });
+    if (position2 && position2.quantity === 0) {
+      if (position2.next_risk && position2.next_risk > 0) {
+        await this.getPositionConfig({
+          symbol,
+          kind,
+          params: {
+            risk: position2.next_risk
+          }
+        });
+        console.log(`Updated ${kind} position config for ${symbol}: risk = ${position2.next_risk}`);
+        return {
+          updated: true,
+          symbol,
+          kind,
+          old_risk: position2.expand?.config?.risk,
+          new_risk: position2.next_risk
+        };
+      }
+    }
+    return {
+      updated: false,
+      symbol,
+      kind,
+      reason: position2 ? position2.quantity > 0 ? "Position not empty" : "No next_risk available" : "Position not found"
+    };
+  }
   async updateGoodHedgeConfig(payload) {
     const {
       params,
@@ -60026,6 +60145,38 @@ class ExchangeAccount {
       decimal_places: symbol_config.decimal_places
     });
   }
+  async placeCompoundShortTrade(payload) {
+  }
+  async placeCompoundLongTrade(payload) {
+    const { symbol, params, place = false } = payload;
+    if (place) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          entry: params.resistance,
+          stop: params.support,
+          risk_reward: params.risk_reward,
+          risk: params.risk,
+          profit_percent: params.profit_percent
+        }
+      });
+      const short_position = await this.syncAccount({
+        symbol,
+        kind: "short",
+        as_view: true
+      });
+      if (short_position.quantity >= short_position.avg_qty) {
+        await this.placeTrade({
+          symbol,
+          kind: "long",
+          ignore_config: true,
+          limit: true,
+          place: true
+        });
+      }
+    }
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
@@ -60366,6 +60517,43 @@ class App {
     });
     return result;
   }
+  async compoundLongTrade(payload) {
+    const { main_account, focus_account, rr, place } = payload;
+    const main_exchange_account = await this.getExchangeAccount(main_account);
+    const focus_exchange_account = await this.getExchangeAccount(focus_account);
+    const focus_position = await focus_exchange_account.syncAccount({
+      symbol: focus_account.symbol,
+      as_view: true
+    });
+    const focus_long_position = focus_position.find((k) => k.kind === "long");
+    const focus_short_position = focus_position.find((k) => k.kind === "short");
+    const shortConfig = await main_exchange_account.getPositionConfig({
+      symbol: main_account.symbol,
+      kind: "short"
+    });
+    const symbol_config = await focus_exchange_account.recomputeSymbolConfig({
+      symbol: focus_account.symbol
+    });
+    const result = determineCompoundLongTrade({
+      focus_short_position,
+      focus_long_position,
+      shortConfig,
+      global_config: symbol_config,
+      rr
+    });
+    await main_exchange_account.placeCompoundLongTrade({
+      symbol: main_account.symbol,
+      params: {
+        resistance: result.resistance,
+        support: result.support,
+        profit_percent: result.profit_percent,
+        risk_reward: result.result.risk_reward,
+        risk: result.result.risk
+      },
+      place
+    });
+    return result;
+  }
   async reduceExistingPosition(payload) {
     const {
       main_account,
@@ -60507,6 +60695,7 @@ export {
   determineRewardFactor,
   determineOptimumRisk,
   determineOptimumReward,
+  determineCompoundLongTrade,
   exports_database as database,
   createArray,
   computeRiskReward,

package/dist/mcp-server.cjs

@@ -59187,6 +59187,37 @@ class AppDatabase {
     });
     return result;
   }
+  async getPositionWithLowestNextOrder(options) {
+    const { symbol, kind, asset, exclude } = options;
+    try {
+      let filter = `kind="${kind}" && next_order != null`;
+      if (asset) {
+        filter += ` && symbol ~ "${asset.toUpperCase()}%"`;
+      } else if (symbol) {
+        filter += ` && symbol:lower="${symbol.toLowerCase()}"`;
+      } else {
+        throw new Error("Either symbol or asset must be provided");
+      }
+      if (exclude && exclude.length > 0) {
+        const excludeConditions = exclude.map((acc) => `(p_account.owner:lower != "${acc.owner.toLowerCase()}" || p_account.exchange:lower != "${acc.exchange.toLowerCase()}")`).join(" && ");
+        filter += ` && (${excludeConditions})`;
+      }
+      const sortDirection = kind === "short" ? "+" : "-";
+      const positions = await this.pb.collection("positions_view").getList(1, 1, {
+        filter,
+        sort: `${sortDirection}next_order`,
+        expand: "p_account"
+      });
+      if (positions.items.length > 0) {
+        return positions.items[0];
+      }
+      return null;
+    } catch (error) {
+      const identifier = asset ? `asset ${asset}` : `symbol ${symbol}`;
+      console.error(`Error fetching position with ${kind === "short" ? "lowest" : "highest"} next_order for ${identifier} ${kind}:`, error);
+      return null;
+    }
+  }
   async hasExistingOrders(symbol) {
     const result = await this.pb.collection("orders").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}"`
@@ -61114,6 +61145,54 @@ function getOptimumHedgeFactor(payload) {
     converged: best_diff <= tolerance
   };
 }
+function determineCompoundLongTrade(payload) {
+  const {
+    focus_short_position,
+    focus_long_position,
+    shortConfig,
+    global_config,
+    rr = 1
+  } = payload;
+  const short_app_config = buildAppConfig(global_config, {
+    entry: shortConfig.entry,
+    stop: shortConfig.stop,
+    risk_reward: shortConfig.risk_reward,
+    risk: shortConfig.risk,
+    symbol: shortConfig.symbol
+  });
+  const short_max_size = short_app_config.last_value.avg_size;
+  const start_risk = Math.abs(short_app_config.last_value.neg_pnl) * rr;
+  const short_profit = short_app_config.last_value.avg_size * short_app_config.last_value.avg_entry * shortConfig.profit_percent / 100;
+  const diff = short_profit * rr / short_app_config.last_value.avg_size;
+  const support = Math.abs(short_app_config.last_value.avg_entry - diff);
+  const resistance = focus_short_position.next_order || focus_long_position.take_profit;
+  console.log({ support, resistance, short_profit });
+  const result = getRiskReward({
+    entry: resistance,
+    stop: support,
+    risk: start_risk,
+    global_config,
+    force_exact_risk: true
+  });
+  const long_app_config = buildAppConfig(global_config, {
+    entry: resistance,
+    stop: support,
+    risk_reward: result.risk_reward,
+    risk: result.risk,
+    symbol: shortConfig.symbol
+  });
+  const long_profit_percent = start_risk * 2 * 100 / (long_app_config.last_value.avg_size * long_app_config.last_value.avg_entry);
+  return {
+    start_risk,
+    short_profit,
+    support: to_f2(support, global_config.price_places),
+    resistance: to_f2(resistance, global_config.price_places),
+    long_v: long_app_config.last_value,
+    profit_percent: to_f2(long_profit_percent, "%.3f"),
+    result,
+    short_max_size
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -65197,6 +65276,10 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      await this.updateRiskOnEmpty({
+        symbol,
+        kind
+      });
     }
     const long_config = await this.getPositionConfig({
       symbol,
@@ -65688,17 +65771,53 @@ class ExchangeAccount {
     if (position2?.expand?.config) {
       const config2 = position2.expand.config;
       let _profit = config2.profit;
+      let risk = config2.risk;
+      let next_risk = position2.next_risk;
       let _profit_percent = config2?.profit_percent;
       if (_profit_percent && (position2?.quantity || 0) > 0) {
         _profit = to_f2(position2.quantity * _profit_percent * position2.entry / 100);
+        next_risk = risk + _profit;
       }
       await this.app_db.update_db_position(position2, {
-        target_pnl: _profit
+        target_pnl: _profit,
+        next_risk
       });
       return _profit;
     }
     return 0;
   }
+  async updateRiskOnEmpty(payload) {
+    const { symbol, kind } = payload;
+    const position2 = await this.syncAccount({
+      symbol,
+      kind
+    });
+    if (position2 && position2.quantity === 0) {
+      if (position2.next_risk && position2.next_risk > 0) {
+        await this.getPositionConfig({
+          symbol,
+          kind,
+          params: {
+            risk: position2.next_risk
+          }
+        });
+        console.log(`Updated ${kind} position config for ${symbol}: risk = ${position2.next_risk}`);
+        return {
+          updated: true,
+          symbol,
+          kind,
+          old_risk: position2.expand?.config?.risk,
+          new_risk: position2.next_risk
+        };
+      }
+    }
+    return {
+      updated: false,
+      symbol,
+      kind,
+      reason: position2 ? position2.quantity > 0 ? "Position not empty" : "No next_risk available" : "Position not found"
+    };
+  }
   async updateGoodHedgeConfig(payload) {
     const {
       params,
@@ -66754,6 +66873,38 @@ class ExchangeAccount {
       decimal_places: symbol_config.decimal_places
     });
   }
+  async placeCompoundShortTrade(payload) {
+  }
+  async placeCompoundLongTrade(payload) {
+    const { symbol, params, place = false } = payload;
+    if (place) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          entry: params.resistance,
+          stop: params.support,
+          risk_reward: params.risk_reward,
+          risk: params.risk,
+          profit_percent: params.profit_percent
+        }
+      });
+      const short_position = await this.syncAccount({
+        symbol,
+        kind: "short",
+        as_view: true
+      });
+      if (short_position.quantity >= short_position.avg_qty) {
+        await this.placeTrade({
+          symbol,
+          kind: "long",
+          ignore_config: true,
+          limit: true,
+          place: true
+        });
+      }
+    }
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
@@ -67094,6 +67245,43 @@ class App {
     });
     return result;
   }
+  async compoundLongTrade(payload) {
+    const { main_account, focus_account, rr, place } = payload;
+    const main_exchange_account = await this.getExchangeAccount(main_account);
+    const focus_exchange_account = await this.getExchangeAccount(focus_account);
+    const focus_position = await focus_exchange_account.syncAccount({
+      symbol: focus_account.symbol,
+      as_view: true
+    });
+    const focus_long_position = focus_position.find((k) => k.kind === "long");
+    const focus_short_position = focus_position.find((k) => k.kind === "short");
+    const shortConfig = await main_exchange_account.getPositionConfig({
+      symbol: main_account.symbol,
+      kind: "short"
+    });
+    const symbol_config = await focus_exchange_account.recomputeSymbolConfig({
+      symbol: focus_account.symbol
+    });
+    const result = determineCompoundLongTrade({
+      focus_short_position,
+      focus_long_position,
+      shortConfig,
+      global_config: symbol_config,
+      rr
+    });
+    await main_exchange_account.placeCompoundLongTrade({
+      symbol: main_account.symbol,
+      params: {
+        resistance: result.resistance,
+        support: result.support,
+        profit_percent: result.profit_percent,
+        risk_reward: result.result.risk_reward,
+        risk: result.result.risk
+      },
+      place
+    });
+    return result;
+  }
   async reduceExistingPosition(payload) {
     const {
       main_account,

package/dist/mcp-server.js

@@ -59164,6 +59164,37 @@ class AppDatabase {
     });
     return result;
   }
+  async getPositionWithLowestNextOrder(options) {
+    const { symbol, kind, asset, exclude } = options;
+    try {
+      let filter = `kind="${kind}" && next_order != null`;
+      if (asset) {
+        filter += ` && symbol ~ "${asset.toUpperCase()}%"`;
+      } else if (symbol) {
+        filter += ` && symbol:lower="${symbol.toLowerCase()}"`;
+      } else {
+        throw new Error("Either symbol or asset must be provided");
+      }
+      if (exclude && exclude.length > 0) {
+        const excludeConditions = exclude.map((acc) => `(p_account.owner:lower != "${acc.owner.toLowerCase()}" || p_account.exchange:lower != "${acc.exchange.toLowerCase()}")`).join(" && ");
+        filter += ` && (${excludeConditions})`;
+      }
+      const sortDirection = kind === "short" ? "+" : "-";
+      const positions = await this.pb.collection("positions_view").getList(1, 1, {
+        filter,
+        sort: `${sortDirection}next_order`,
+        expand: "p_account"
+      });
+      if (positions.items.length > 0) {
+        return positions.items[0];
+      }
+      return null;
+    } catch (error) {
+      const identifier = asset ? `asset ${asset}` : `symbol ${symbol}`;
+      console.error(`Error fetching position with ${kind === "short" ? "lowest" : "highest"} next_order for ${identifier} ${kind}:`, error);
+      return null;
+    }
+  }
   async hasExistingOrders(symbol) {
     const result = await this.pb.collection("orders").getFullList({
       filter: `symbol:lower="${symbol.toLowerCase()}"`
@@ -61091,6 +61122,54 @@ function getOptimumHedgeFactor(payload) {
     converged: best_diff <= tolerance
   };
 }
+function determineCompoundLongTrade(payload) {
+  const {
+    focus_short_position,
+    focus_long_position,
+    shortConfig,
+    global_config,
+    rr = 1
+  } = payload;
+  const short_app_config = buildAppConfig(global_config, {
+    entry: shortConfig.entry,
+    stop: shortConfig.stop,
+    risk_reward: shortConfig.risk_reward,
+    risk: shortConfig.risk,
+    symbol: shortConfig.symbol
+  });
+  const short_max_size = short_app_config.last_value.avg_size;
+  const start_risk = Math.abs(short_app_config.last_value.neg_pnl) * rr;
+  const short_profit = short_app_config.last_value.avg_size * short_app_config.last_value.avg_entry * shortConfig.profit_percent / 100;
+  const diff = short_profit * rr / short_app_config.last_value.avg_size;
+  const support = Math.abs(short_app_config.last_value.avg_entry - diff);
+  const resistance = focus_short_position.next_order || focus_long_position.take_profit;
+  console.log({ support, resistance, short_profit });
+  const result = getRiskReward({
+    entry: resistance,
+    stop: support,
+    risk: start_risk,
+    global_config,
+    force_exact_risk: true
+  });
+  const long_app_config = buildAppConfig(global_config, {
+    entry: resistance,
+    stop: support,
+    risk_reward: result.risk_reward,
+    risk: result.risk,
+    symbol: shortConfig.symbol
+  });
+  const long_profit_percent = start_risk * 2 * 100 / (long_app_config.last_value.avg_size * long_app_config.last_value.avg_entry);
+  return {
+    start_risk,
+    short_profit,
+    support: to_f2(support, global_config.price_places),
+    resistance: to_f2(resistance, global_config.price_places),
+    long_v: long_app_config.last_value,
+    profit_percent: to_f2(long_profit_percent, "%.3f"),
+    result,
+    short_max_size
+  };
+}
 
 // src/helpers/strategy.ts
 class Strategy {
@@ -65174,6 +65253,10 @@ class ExchangeAccount {
         symbol,
         kind
       });
+      await this.updateRiskOnEmpty({
+        symbol,
+        kind
+      });
     }
     const long_config = await this.getPositionConfig({
       symbol,
@@ -65665,17 +65748,53 @@ class ExchangeAccount {
     if (position2?.expand?.config) {
       const config2 = position2.expand.config;
       let _profit = config2.profit;
+      let risk = config2.risk;
+      let next_risk = position2.next_risk;
       let _profit_percent = config2?.profit_percent;
       if (_profit_percent && (position2?.quantity || 0) > 0) {
         _profit = to_f2(position2.quantity * _profit_percent * position2.entry / 100);
+        next_risk = risk + _profit;
       }
       await this.app_db.update_db_position(position2, {
-        target_pnl: _profit
+        target_pnl: _profit,
+        next_risk
       });
       return _profit;
     }
     return 0;
   }
+  async updateRiskOnEmpty(payload) {
+    const { symbol, kind } = payload;
+    const position2 = await this.syncAccount({
+      symbol,
+      kind
+    });
+    if (position2 && position2.quantity === 0) {
+      if (position2.next_risk && position2.next_risk > 0) {
+        await this.getPositionConfig({
+          symbol,
+          kind,
+          params: {
+            risk: position2.next_risk
+          }
+        });
+        console.log(`Updated ${kind} position config for ${symbol}: risk = ${position2.next_risk}`);
+        return {
+          updated: true,
+          symbol,
+          kind,
+          old_risk: position2.expand?.config?.risk,
+          new_risk: position2.next_risk
+        };
+      }
+    }
+    return {
+      updated: false,
+      symbol,
+      kind,
+      reason: position2 ? position2.quantity > 0 ? "Position not empty" : "No next_risk available" : "Position not found"
+    };
+  }
   async updateGoodHedgeConfig(payload) {
     const {
       params,
@@ -66731,6 +66850,38 @@ class ExchangeAccount {
       decimal_places: symbol_config.decimal_places
     });
   }
+  async placeCompoundShortTrade(payload) {
+  }
+  async placeCompoundLongTrade(payload) {
+    const { symbol, params, place = false } = payload;
+    if (place) {
+      await this.getPositionConfig({
+        symbol,
+        kind: "long",
+        params: {
+          entry: params.resistance,
+          stop: params.support,
+          risk_reward: params.risk_reward,
+          risk: params.risk,
+          profit_percent: params.profit_percent
+        }
+      });
+      const short_position = await this.syncAccount({
+        symbol,
+        kind: "short",
+        as_view: true
+      });
+      if (short_position.quantity >= short_position.avg_qty) {
+        await this.placeTrade({
+          symbol,
+          kind: "long",
+          ignore_config: true,
+          limit: true,
+          place: true
+        });
+      }
+    }
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
@@ -67071,6 +67222,43 @@ class App {
     });
     return result;
   }
+  async compoundLongTrade(payload) {
+    const { main_account, focus_account, rr, place } = payload;
+    const main_exchange_account = await this.getExchangeAccount(main_account);
+    const focus_exchange_account = await this.getExchangeAccount(focus_account);
+    const focus_position = await focus_exchange_account.syncAccount({
+      symbol: focus_account.symbol,
+      as_view: true
+    });
+    const focus_long_position = focus_position.find((k) => k.kind === "long");
+    const focus_short_position = focus_position.find((k) => k.kind === "short");
+    const shortConfig = await main_exchange_account.getPositionConfig({
+      symbol: main_account.symbol,
+      kind: "short"
+    });
+    const symbol_config = await focus_exchange_account.recomputeSymbolConfig({
+      symbol: focus_account.symbol
+    });
+    const result = determineCompoundLongTrade({
+      focus_short_position,
+      focus_long_position,
+      shortConfig,
+      global_config: symbol_config,
+      rr
+    });
+    await main_exchange_account.placeCompoundLongTrade({
+      symbol: main_account.symbol,
+      params: {
+        resistance: result.resistance,
+        support: result.support,
+        profit_percent: result.profit_percent,
+        risk_reward: result.result.risk_reward,
+        risk: result.result.risk
+      },
+      place
+    });
+    return result;
+  }
   async reduceExistingPosition(payload) {
     const {
       main_account,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gbozee/ultimate",
   "type": "module",
-  "version": "0.0.2-130",
+  "version": "0.0.2-132",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -35,6 +35,7 @@
     "build": "bun run build.ts",
     "prepublishOnly": "bun run build",
     "test": "bun test --timeout 300000 test",
+    "test:unit": "bun test --timeout 300000 tests/unit-tests",
     "mcp:client": "bun run tests/mcp-client.js dist/mcp-server.js",
     "npm:publish": "npm publish --access public --registry=https://registry.npmjs.org/"
   },