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

package/dist/mcp-server.cjs

@@ -76510,7 +76510,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 {
@@ -77014,17 +77014,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) {
@@ -78370,24 +78370,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,
@@ -78400,7 +78401,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) {
@@ -78457,14 +78459,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,
@@ -78472,7 +78472,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
       })));
@@ -78494,50 +78494,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 ? {
@@ -78547,12 +78617,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,
@@ -82047,6 +82117,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;
@@ -82143,8 +82283,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
@@ -82278,6 +82416,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);
   }
@@ -82562,8 +82826,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
       });
     }