@gbozee/ultimate 0.0.2-next.74 → 0.0.2-next.77

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
 });
 
@@ -72788,7 +72790,7 @@ function buildSpotMarginHedgePlan(options) {
   const margin_orders_to_create = options.placement_overrides?.margin || default_margin_orders_to_create;
   const borrow_delta = roundNumber2(Math.max(0, options.borrow_amount - options.snapshot.borrowed_quote_amount));
   const spot_long_notional = sumNotional(spot_long_orders);
-  const transfer_to_spot_amount = roundNumber2(Math.max(0, spot_long_notional - options.snapshot.spot_quote_free));
+  const transfer_to_spot_amount = roundNumber2(Math.max(0, options.margin_type === "cross" ? options.borrow_amount : spot_long_notional - options.snapshot.spot_quote_free));
   const short_quantity = sumQuantity(short_orders);
   const transfer_base_to_spot_amount = roundNumber2(Math.max(0, short_quantity - options.snapshot.spot_base_free));
   return {
@@ -73292,17 +73294,17 @@ async function createMarginLimitOrdersParallel(client, symbol, priceFormat, quan
     return Object.fromEntries(Object.entries(v).filter(([, value2]) => value2 !== undefined));
   };
   const newOrders = orders.map(createMarginOrder);
-  const limit = import_p_limit.default(ORDERS_PER_SECOND);
-  const results = await Promise.all(newOrders.map((orderPayload) => limit(async () => {
+  const results = [];
+  for (const orderPayload of newOrders) {
     try {
       const result = await client.marginAccountNewOrder(orderPayload);
       console.log("Margin order result:", result);
-      return result;
+      results.push(result);
     } catch (error) {
       console.error("Error processing margin order:", error);
       throw error;
     }
-  })));
+  }
   return results;
 }
 async function getIsolatedMarginAccountInfo(client, symbol) {
@@ -74648,24 +74650,25 @@ class BinanceExchange extends BaseExchange {
     if (!this.main_client) {
       throw new Error("Main client not available for spot and margin trading");
     }
-    if (payload.margin_type !== "isolated") {
-      throw new Error(`Unsupported margin type: ${payload.margin_type}. Only isolated is supported for replay right now.`);
-    }
     const symbol = payload.symbol.toUpperCase();
     const quoteAssets = ["USDT", "USDC", "BUSD", "BTC", "ETH"];
     const quoteAsset = quoteAssets.find((asset) => symbol.endsWith(asset)) || symbol.slice(-4);
     const baseAsset = symbol.slice(0, symbol.length - quoteAsset.length);
-    const [spot_orders, margin_orders, spot_balances, isolated_margin_position] = await Promise.all([
+    const is_isolated = payload.margin_type === "isolated";
+    const [spot_orders, margin_orders, spot_balances, margin_account] = await Promise.all([
       this.getSpotOpenOrders(symbol),
-      this.getMarginOpenOrders(symbol, true),
+      this.getMarginOpenOrders(symbol, is_isolated),
       this.getSpotBalances([baseAsset, quoteAsset]),
-      this.getIsolatedMarginPosition(symbol)
+      is_isolated ? this.getIsolatedMarginPosition(symbol) : this.getCrossMarginAccount()
     ]);
     const current_price = await this.getSpotCurrentPrice(symbol);
     const spot_quote_balance = spot_balances.find((balance) => balance.asset.toUpperCase() === quoteAsset);
     const spot_base_balance = spot_balances.find((balance) => balance.asset.toUpperCase() === baseAsset);
-    const isolated_asset = isolated_margin_position?.assets?.[0];
-    const borrowed_quote_amount = parseFloat(isolated_asset?.quoteAsset?.borrowed?.toString?.() || "0");
+    const isolated_margin_account = is_isolated ? margin_account : undefined;
+    const cross_margin_account = !is_isolated ? margin_account : undefined;
+    const isolated_asset = isolated_margin_account?.assets?.[0];
+    const cross_quote_asset = !is_isolated ? cross_margin_account?.userAssets?.find((asset) => asset.asset?.toUpperCase?.() === quoteAsset) : undefined;
+    const borrowed_quote_amount = parseFloat(isolated_asset?.quoteAsset?.borrowed?.toString?.() || cross_quote_asset?.borrowed?.toString?.() || "0");
     return {
       symbol,
       margin_type: payload.margin_type,
@@ -74678,7 +74681,8 @@ class BinanceExchange extends BaseExchange {
       margin_orders,
       current_price,
       spot_balances,
-      isolated_margin_position
+      isolated_margin_position: isolated_margin_account,
+      cross_margin_account
     };
   }
   async previewSpotMarginHedge(payload) {
@@ -74735,14 +74739,12 @@ class BinanceExchange extends BaseExchange {
     if (!this.main_client) {
       throw new Error("Main client not available for spot and margin trading");
     }
-    if (payload.margin_type !== "isolated") {
-      throw new Error(`Unsupported margin type: ${payload.margin_type}. Only isolated placement is supported right now.`);
-    }
     const symbol = payload.symbol.toUpperCase();
     const quoteAssets = ["USDT", "USDC", "BUSD", "BTC", "ETH"];
     const quote_asset = quoteAssets.find((asset) => symbol.endsWith(asset)) || symbol.slice(-4);
     const base_asset = symbol.slice(0, symbol.length - quote_asset.length);
     const requested_input = preview.requested_input;
+    const is_isolated = payload.margin_type === "isolated";
     if (preview.snapshot.spot_orders.length > 0) {
       await this.cancelSpotOrders(symbol, preview.snapshot.spot_orders.map((order) => ({
         orderId: order.orderId || order.order_id || order.id,
@@ -74750,7 +74752,7 @@ class BinanceExchange extends BaseExchange {
       })));
     }
     if (preview.snapshot.margin_orders.length > 0) {
-      await this.cancelMarginOrders(symbol, true, preview.snapshot.margin_orders.map((order) => ({
+      await this.cancelMarginOrders(symbol, is_isolated, preview.snapshot.margin_orders.map((order) => ({
         orderId: order.orderId || order.order_id || order.id,
         origClientOrderId: order.origClientOrderId
       })));
@@ -74772,50 +74774,120 @@ class BinanceExchange extends BaseExchange {
     });
     let borrow_result = null;
     if (execution_plan.borrow_delta > 0) {
-      borrow_result = await this.main_client.submitMarginAccountBorrowRepay({
+      const borrow_payload = {
         asset: quote_asset,
         amount: execution_plan.borrow_delta,
-        isIsolated: "TRUE",
-        symbol,
         type: "BORROW"
+      };
+      if (is_isolated) {
+        borrow_payload.isIsolated = "TRUE";
+        borrow_payload.symbol = symbol;
+      }
+      borrow_result = await this.main_client.submitMarginAccountBorrowRepay(borrow_payload);
+    }
+    async function getCrossTransferAmount(asset, amount) {
+      if (is_isolated) {
+        return amount;
+      }
+      if (!this.main_client || typeof this.main_client.queryMaxTransferOutAmount !== "function") {
+        return amount;
+      }
+      const response = await this.main_client.queryMaxTransferOutAmount({
+        asset
       });
+      const allowed_amount = parseFloat(response?.amount?.toString?.() || "0");
+      if (!Number.isFinite(allowed_amount)) {
+        return amount;
+      }
+      return Math.max(0, Math.min(amount, allowed_amount));
     }
     let quote_transfer_result = null;
+    let quote_transfer_amount = execution_plan.transfer_to_spot_amount;
     if (execution_plan.transfer_to_spot_amount > 0) {
-      quote_transfer_result = await this.main_client.isolatedMarginAccountTransfer({
-        asset: quote_asset,
-        amount: execution_plan.transfer_to_spot_amount,
-        symbol,
-        transFrom: "ISOLATED_MARGIN",
-        transTo: "SPOT"
-      });
+      quote_transfer_amount = await getCrossTransferAmount.call(this, quote_asset, execution_plan.transfer_to_spot_amount);
+      if (quote_transfer_amount > 0) {
+        quote_transfer_result = is_isolated ? await this.main_client.isolatedMarginAccountTransfer({
+          asset: quote_asset,
+          amount: quote_transfer_amount,
+          symbol,
+          transFrom: "ISOLATED_MARGIN",
+          transTo: "SPOT"
+        }) : await this.main_client.submitUniversalTransfer({
+          type: "MARGIN_MAIN",
+          asset: quote_asset,
+          amount: quote_transfer_amount
+        });
+      }
     }
     let base_transfer_result = null;
+    let base_transfer_amount = execution_plan.transfer_base_to_spot_amount;
     if (execution_plan.transfer_base_to_spot_amount > 0) {
-      base_transfer_result = await this.main_client.isolatedMarginAccountTransfer({
-        asset: base_asset,
-        amount: execution_plan.transfer_base_to_spot_amount,
-        symbol,
-        transFrom: "ISOLATED_MARGIN",
-        transTo: "SPOT"
-      });
+      base_transfer_amount = await getCrossTransferAmount.call(this, base_asset, execution_plan.transfer_base_to_spot_amount);
+      if (base_transfer_amount > 0) {
+        base_transfer_result = is_isolated ? await this.main_client.isolatedMarginAccountTransfer({
+          asset: base_asset,
+          amount: base_transfer_amount,
+          symbol,
+          transFrom: "ISOLATED_MARGIN",
+          transTo: "SPOT"
+        }) : await this.main_client.submitUniversalTransfer({
+          type: "MARGIN_MAIN",
+          asset: base_asset,
+          amount: base_transfer_amount
+        });
+      }
     }
-    const spot_result = execution_plan.orders_to_create.spot.length > 0 ? await this.createSpotLimitOrders({
+    const spot_quote_available = refreshed_snapshot.spot_quote_free + quote_transfer_amount;
+    const requested_max_spot_buy_orders = requested_input.max_spot_buy_orders ?? 5;
+    const sorted_long_orders = [...requested_input.long_orders].sort((a, b) => a.price - b.price);
+    let affordable_spot_buy_orders = 0;
+    let affordable_spot_buy_notional = 0;
+    for (const order of sorted_long_orders.slice(0, requested_max_spot_buy_orders)) {
+      const next_notional = affordable_spot_buy_notional + order.price * order.quantity;
+      if (next_notional <= spot_quote_available + 0.00000001) {
+        affordable_spot_buy_orders += 1;
+        affordable_spot_buy_notional = next_notional;
+      } else {
+        break;
+      }
+    }
+    const placement_plan = buildSpotMarginHedgePlan({
+      borrow_amount: requested_input.borrow_amount,
+      symbol: requested_input.symbol,
+      margin_type: requested_input.margin_type,
+      long_orders: requested_input.long_orders,
+      short_orders: requested_input.short_orders,
+      current_price: refreshed_snapshot.current_price,
+      max_spot_buy_orders: affordable_spot_buy_orders,
+      snapshot: {
+        ...refreshed_snapshot,
+        borrowed_quote_amount: refreshed_snapshot.borrowed_quote_amount + execution_plan.borrow_delta,
+        spot_quote_free: spot_quote_available,
+        spot_base_free: refreshed_snapshot.spot_base_free + base_transfer_amount
+      }
+    });
+    const spot_result = placement_plan.orders_to_create.spot.length > 0 ? await this.createSpotLimitOrders({
       symbol,
-      orders: execution_plan.orders_to_create.spot,
+      orders: placement_plan.orders_to_create.spot,
       price_places: symbol_formats.price_places,
       decimal_places: symbol_formats.decimal_places
     }) : [];
-    const margin_result = execution_plan.orders_to_create.margin.length > 0 ? await this.createMarginLimitOrders({
+    const margin_result = placement_plan.orders_to_create.margin.length > 0 ? await this.createMarginLimitOrders({
       symbol,
-      orders: execution_plan.orders_to_create.margin,
-      isIsolated: true,
+      orders: placement_plan.orders_to_create.margin,
+      isIsolated: is_isolated,
       price_places: symbol_formats.price_places,
       decimal_places: symbol_formats.decimal_places
     }) : [];
     return {
       ...preview,
-      execution_plan,
+      execution_plan: {
+        ...placement_plan,
+        borrow_amount: execution_plan.borrow_amount,
+        borrow_delta: execution_plan.borrow_delta,
+        transfer_to_spot_amount: quote_transfer_amount,
+        transfer_base_to_spot_amount: base_transfer_amount
+      },
       refreshed_snapshot,
       execution: {
         borrow: borrow_result ? {
@@ -74825,12 +74897,12 @@ class BinanceExchange extends BaseExchange {
         } : null,
         quote_transfer: quote_transfer_result ? {
           asset: quote_asset,
-          amount: execution_plan.transfer_to_spot_amount,
+          amount: quote_transfer_amount,
           response: quote_transfer_result
         } : null,
         base_transfer: base_transfer_result ? {
           asset: base_asset,
-          amount: execution_plan.transfer_base_to_spot_amount,
+          amount: base_transfer_amount,
           response: base_transfer_result
         } : null,
         spot_orders: spot_result,
@@ -78325,6 +78397,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;
@@ -78421,8 +78563,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
@@ -78556,6 +78696,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);
   }
@@ -78840,8 +79106,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 };