@gbozee/ultimate 0.0.2-192 → 0.0.2-194

package/dist/mcp-server.cjs

@@ -61495,35 +61495,6 @@ class AppDatabase {
     }
     return null;
   }
-  async getRunningInstanceFromDB(account, symbol, options) {
-    const { delay = 60 * 1000 } = options || {
-      delay: 60 * 1000
-    };
-    const running_instance = await this.pb.collection("trade_block_tracking").getFirstListItem(`account.owner = "${account.owner}" && account.exchange = "${account.exchange}" && symbol = "${symbol}"`, {
-      expand: "account"
-    });
-    if (!running_instance) {
-      let account_instance = await this.pb.collection("exchange_accounts").getFirstListItem(`owner = "${account.owner}" && exchange = "${account.exchange}"`);
-      return await this.pb.collection("trade_block_tracking").create({
-        account: account_instance.id,
-        symbol,
-        running: false
-      });
-    }
-    const updatedAt = new Date(running_instance.updated);
-    const now = new Date;
-    const diffInMinutes = (now.getTime() - updatedAt.getTime()) / delay;
-    if (diffInMinutes >= 1) {
-      await this.updateRunningInstance(running_instance.id, false);
-      running_instance.running = false;
-    }
-    return running_instance;
-  }
-  async updateRunningInstance(id, running) {
-    return await this.pb.collection("trade_block_tracking").update(id, {
-      running
-    });
-  }
   async getOrders(account, options) {
     const { symbol, kind } = options;
     const db_orders = await this.pb.collection("orders").getFullList({
@@ -61834,110 +61805,6 @@ class AppDatabase {
     }
     return null;
   }
-  async getBotViewInstance(payload) {
-    const { asset, main_account } = payload;
-    const bot_instances = await this.pb.collection("bot_view").getFullList({
-      filter: `asset:lower="${asset.toLowerCase()}" && main_account.owner:lower="${main_account.owner.toLowerCase()}" && main_account.exchange:lower="${main_account.exchange.toLowerCase()}"`,
-      expand: "main_account,secondary_account,main_long_strategy,main_short_strategy,secondary_long_strategy,secondary_short_strategy"
-    });
-    if (bot_instances.length > 0) {
-      const instance = bot_instances[0];
-      const {
-        main_account: main_account2,
-        secondary_account,
-        main_long_strategy,
-        main_short_strategy,
-        secondary_long_strategy,
-        secondary_short_strategy
-      } = instance.expand;
-      const update_boolean = (value) => {
-        if (!value) {
-          return value;
-        }
-        return {
-          ...value,
-          follow: Boolean(value.follow),
-          place_tp: Boolean(value.place_tp),
-          pause_tp: Boolean(value.pause_tp)
-        };
-      };
-      return {
-        ...instance,
-        main: {
-          account: main_account2,
-          symbol: instance.main_symbol,
-          strategy: {
-            long: main_long_strategy,
-            short: main_short_strategy
-          },
-          position: {
-            long: instance.main_long_position,
-            short: instance.main_short_position
-          },
-          config: {
-            long: update_boolean(instance.main_long_config),
-            short: update_boolean(instance.main_short_config)
-          }
-        },
-        secondary: {
-          account: secondary_account,
-          symbol: instance.secondary_symbol,
-          strategy: {
-            long: secondary_long_strategy,
-            short: secondary_short_strategy
-          },
-          position: {
-            long: instance.secondary_long_position,
-            short: instance.secondary_short_position
-          },
-          config: {
-            long: update_boolean(instance.secondary_long_config),
-            short: update_boolean(instance.secondary_short_config)
-          }
-        }
-      };
-    }
-    return null;
-  }
-  async getBotInstance(payload) {
-    const { asset, main_account } = payload;
-    const bot_instances = await this.pb.collection("bot_instances").getFullList({
-      filter: `asset:lower="${asset.toLowerCase()}" && main_account.owner:lower="${main_account.owner.toLowerCase()}" && main_account.exchange:lower="${main_account.exchange.toLowerCase()}"`
-    });
-    if (bot_instances.length > 0) {
-      return bot_instances[0];
-    }
-    return null;
-  }
-  async getBotState(payload) {
-    const { asset, main_account, running } = payload;
-    let filter = `bot.asset:lower="${asset.toLowerCase()}" && bot.main_account.owner:lower="${main_account.owner.toLowerCase()}" && bot.main_account.exchange:lower="${main_account.exchange.toLowerCase()}"`;
-    if (running !== undefined) {
-      filter += ` && running=${running}`;
-    }
-    const bot_states = await this.pb.collection("bot_states").getFullList({
-      filter
-    });
-    return bot_states;
-  }
-  async getBotOrderHistories(payload) {
-    const { asset, main_account, symbol, kind, type } = payload;
-    let filter = `field.bot.asset:lower="${asset.toLowerCase()}" && field.bot.main_account.owner:lower="${main_account.owner.toLowerCase()}" && field.bot.main_account.exchange:lower="${main_account.exchange.toLowerCase()}"`;
-    if (symbol) {
-      filter += ` && symbol:lower="${symbol.toLowerCase()}"`;
-    }
-    if (kind) {
-      filter += ` && kind="${kind}"`;
-    }
-    if (type) {
-      filter += ` && type="${type}"`;
-    }
-    const bot_order_histories = await this.pb.collection("bot_order_history").getFullList({
-      filter,
-      sort: "-created"
-    });
-    return bot_order_histories;
-  }
   async createOrUpdateWindingDownMarket(payload) {
     const { symbol, risk_reward = 30 } = payload;
     const existing_winding_down_market = await this.pb.collection("winding_down_markets").getFullList({
@@ -66627,6 +66494,171 @@ class BinanceExchange extends BaseExchange {
   async forceClosePosition(symbol, options) {
     return await forceClosePosition(this.client, symbol, options);
   }
+  async getTransferableAmount(options) {
+    const { asset, maxTransferLimit } = options;
+    try {
+      const futuresBalance = await getWalletBalance(this.client, asset);
+      const allPositions = await this.client.getPositionsV3();
+      const activePositions = allPositions.filter((pos) => Math.abs(pos.positionAmt) > 0);
+      let totalMarginUsed = 0;
+      let totalUnrealizedPnl = 0;
+      for (const position2 of activePositions) {
+        const positionValue = Math.abs(position2.positionAmt) * position2.markPrice;
+        const leverage = await getLeverage(this.client, position2.symbol);
+        const marginForPosition = positionValue / (leverage || 1);
+        console.log({ leverage });
+        totalMarginUsed += marginForPosition;
+        totalUnrealizedPnl += position2.unRealizedProfit || 0;
+      }
+      const safetyMarginPercent = 0.2;
+      const requiredMargin = totalMarginUsed * (1 + safetyMarginPercent);
+      const adjustedBalance = futuresBalance + totalUnrealizedPnl;
+      const availableForTransfer = Math.max(0, adjustedBalance - requiredMargin);
+      let maxTransferableAmount = availableForTransfer;
+      let appliedLimit;
+      if (maxTransferLimit && maxTransferLimit > 0) {
+        maxTransferableAmount = Math.min(availableForTransfer, maxTransferLimit);
+        appliedLimit = maxTransferLimit;
+      }
+      const recommendedTransferAmount = maxTransferableAmount * 0.8;
+      const marginUtilization = adjustedBalance > 0 ? requiredMargin / adjustedBalance * 100 : 0;
+      return {
+        asset,
+        totalBalance: futuresBalance,
+        availableForTransfer,
+        reservedForMargin: requiredMargin,
+        maxTransferableAmount,
+        appliedLimit,
+        recommendedTransferAmount,
+        marginUtilization,
+        safetyMargin: safetyMarginPercent * 100
+      };
+    } catch (error) {
+      console.error(`Error analyzing transferable amount for ${asset}:`, error);
+      throw new Error(`Failed to analyze transferable funds: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async previewTransfer(options) {
+    const { asset, amount } = options;
+    const warnings = [];
+    const errors = [];
+    try {
+      const analysis = await this.getTransferableAmount({ asset });
+      let isValid3 = true;
+      if (amount <= 0) {
+        errors.push("Transfer amount must be greater than zero");
+        isValid3 = false;
+      }
+      if (amount > analysis.maxTransferableAmount) {
+        errors.push(`Transfer amount (${amount}) exceeds maximum transferable amount (${analysis.maxTransferableAmount})`);
+        isValid3 = false;
+      }
+      if (amount > analysis.recommendedTransferAmount) {
+        warnings.push(`Transfer amount exceeds recommended amount (${analysis.recommendedTransferAmount.toFixed(4)}). Consider transferring a smaller amount for safety.`);
+      }
+      if (analysis.marginUtilization > 70) {
+        warnings.push(`High margin utilization (${analysis.marginUtilization.toFixed(1)}%). Transferring funds may increase liquidation risk.`);
+      }
+      const balanceAfterTransfer = analysis.totalBalance - amount;
+      const marginRequirementAfterTransfer = analysis.reservedForMargin;
+      if (isValid3 && balanceAfterTransfer < marginRequirementAfterTransfer) {
+        errors.push("Transfer would result in insufficient margin for existing positions");
+        isValid3 = false;
+      }
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: isValid3,
+        balanceAfterTransfer,
+        marginRequirementAfterTransfer,
+        warnings,
+        errors
+      };
+    } catch (error) {
+      console.error(`Error previewing transfer for ${asset}:`, error);
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: false,
+        balanceAfterTransfer: 0,
+        marginRequirementAfterTransfer: 0,
+        warnings,
+        errors: [`Failed to preview transfer: ${error instanceof Error ? error.message : error}`]
+      };
+    }
+  }
+  async executeFutureToSpotTransfer(options) {
+    const { asset, amount, confirm, symbol = "BTCUSDT" } = options;
+    try {
+      if (!confirm) {
+        return {
+          success: false,
+          asset,
+          amount,
+          fromWallet: "futures",
+          toWallet: "spot",
+          balanceAfterTransfer: 0,
+          timestamp: new Date().toISOString(),
+          error: "Transfer not confirmed. Set confirm: true to execute transfer."
+        };
+      }
+      const preview = await this.previewTransfer({ asset, amount });
+      if (!preview.isValid) {
+        return {
+          success: false,
+          asset,
+          amount,
+          fromWallet: "futures",
+          toWallet: "spot",
+          balanceAfterTransfer: 0,
+          timestamp: new Date().toISOString(),
+          error: `Transfer validation failed: ${preview.errors.join("; ")}`
+        };
+      }
+      const is_coin = !["USDT", "USDC", "BUSD"].includes(asset.toUpperCase());
+      const transferType = is_coin ? CONSTANTS.COIN_FUTURE_TO_SPOT : CONSTANTS.USDT_FUTURE_TO_SPOT;
+      if (!this.main_client) {
+        throw new Error("Main client not available for transfers");
+      }
+      const transferClient = this.main_client;
+      const transferResult = await transferClient.submitUniversalTransfer({
+        asset: asset.toUpperCase(),
+        amount,
+        type: transferType,
+        fromSymbol: symbol,
+        toSymbol: symbol
+      });
+      const balanceAfterTransfer = await getWalletBalance(this.client, asset);
+      return {
+        success: true,
+        transactionId: transferResult.tranId?.toString(),
+        asset,
+        amount,
+        fromWallet: "futures",
+        toWallet: "spot",
+        balanceAfterTransfer,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error(`Error executing transfer for ${asset}:`, error);
+      let currentBalance = 0;
+      try {
+        currentBalance = await getWalletBalance(this.client, asset);
+      } catch (balanceError) {
+        console.warn("Could not fetch balance for error response:", balanceError);
+      }
+      return {
+        success: false,
+        asset,
+        amount,
+        fromWallet: "futures",
+        toWallet: "spot",
+        balanceAfterTransfer: currentBalance,
+        timestamp: new Date().toISOString(),
+        error: `Transfer execution failed: ${error instanceof Error ? error.message : error}`
+      };
+    }
+  }
 }
 function getPricePlaces(target) {
   const numStr = target.toString();
@@ -66952,6 +66984,11 @@ async function placeStopOrder2(client, payload) {
     stop: payload.final_stop,
     is_market: !payload.is_limit
   };
+  if (payload.hedge) {
+    let reverse_kind = payload.kind === "long" ? "short" : "long";
+    order.kind = reverse_kind;
+    order.is_market = false;
+  }
   return createLimitPurchaseOrders(client, symbol, price_places, decimal_places, [order]);
 }
 async function getOpenOrders2(client, symbol, type) {
@@ -67348,6 +67385,168 @@ class BybitExchange extends BaseExchange {
     return getOpenOrders2(this.client, payload.symbol);
   }
   async placeBadStopEntry(payload) {}
+  async getTransferableAmount(options) {
+    const { asset, maxTransferLimit } = options;
+    try {
+      const unifiedBalance = await getWalletBalance2(this.client, asset);
+      const allPositions = await this.client.getPositionInfo({
+        category: "linear",
+        settleCoin: asset
+      });
+      const activePositions = (allPositions.result.list || []).filter((pos) => Math.abs(parseFloat(pos.size || "0")) > 0);
+      let totalMarginUsed = 0;
+      let totalUnrealizedPnl = 0;
+      for (const position2 of activePositions) {
+        const positionSize = Math.abs(parseFloat(position2.size || "0"));
+        const markPrice = parseFloat(position2.markPrice || "0");
+        const leverage = parseFloat(position2.leverage || "1");
+        const positionValue = positionSize * markPrice;
+        const marginForPosition = positionValue / leverage;
+        totalMarginUsed += marginForPosition;
+        totalUnrealizedPnl += parseFloat(position2.unrealisedPnl || "0");
+      }
+      const safetyMarginPercent = 0.2;
+      const requiredMargin = totalMarginUsed * (1 + safetyMarginPercent);
+      const adjustedBalance = unifiedBalance + totalUnrealizedPnl;
+      const availableForTransfer = Math.max(0, adjustedBalance - requiredMargin);
+      let maxTransferableAmount = availableForTransfer;
+      let appliedLimit;
+      if (maxTransferLimit && maxTransferLimit > 0) {
+        maxTransferableAmount = Math.min(availableForTransfer, maxTransferLimit);
+        appliedLimit = maxTransferLimit;
+      }
+      const recommendedTransferAmount = maxTransferableAmount * 0.8;
+      const marginUtilization = adjustedBalance > 0 ? requiredMargin / adjustedBalance * 100 : 0;
+      return {
+        asset,
+        totalBalance: unifiedBalance,
+        availableForTransfer,
+        reservedForMargin: requiredMargin,
+        maxTransferableAmount,
+        appliedLimit,
+        recommendedTransferAmount,
+        marginUtilization,
+        safetyMargin: safetyMarginPercent * 100
+      };
+    } catch (error) {
+      console.error(`Error analyzing transferable amount for ${asset}:`, error);
+      throw new Error(`Failed to analyze transferable funds: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  async previewTransfer(options) {
+    const { asset, amount } = options;
+    const warnings = [];
+    const errors = [];
+    try {
+      const analysis = await this.getTransferableAmount({ asset });
+      let isValid3 = true;
+      if (amount <= 0) {
+        errors.push("Transfer amount must be greater than zero");
+        isValid3 = false;
+      }
+      if (amount > analysis.maxTransferableAmount) {
+        errors.push(`Transfer amount (${amount}) exceeds maximum transferable amount (${analysis.maxTransferableAmount})`);
+        isValid3 = false;
+      }
+      if (amount > analysis.recommendedTransferAmount) {
+        warnings.push(`Transfer amount exceeds recommended amount (${analysis.recommendedTransferAmount.toFixed(4)}). Consider transferring a smaller amount for safety.`);
+      }
+      if (analysis.marginUtilization > 70) {
+        warnings.push(`High margin utilization (${analysis.marginUtilization.toFixed(1)}%). Transferring funds may increase liquidation risk.`);
+      }
+      const balanceAfterTransfer = analysis.totalBalance - amount;
+      const marginRequirementAfterTransfer = analysis.reservedForMargin;
+      if (isValid3 && balanceAfterTransfer < marginRequirementAfterTransfer) {
+        errors.push("Transfer would result in insufficient margin for existing positions");
+        isValid3 = false;
+      }
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: isValid3,
+        balanceAfterTransfer,
+        marginRequirementAfterTransfer,
+        warnings,
+        errors
+      };
+    } catch (error) {
+      console.error(`Error previewing transfer for ${asset}:`, error);
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: false,
+        balanceAfterTransfer: 0,
+        marginRequirementAfterTransfer: 0,
+        warnings,
+        errors: [
+          `Failed to preview transfer: ${error instanceof Error ? error.message : error}`
+        ]
+      };
+    }
+  }
+  async executeUnifiedToFundingTransfer(options) {
+    const { asset, amount, confirm } = options;
+    try {
+      if (!confirm) {
+        return {
+          success: false,
+          asset,
+          amount,
+          fromWallet: "unified",
+          toWallet: "funding",
+          balanceAfterTransfer: 0,
+          timestamp: new Date().toISOString(),
+          error: "Transfer not confirmed. Set confirm: true to execute transfer."
+        };
+      }
+      const preview = await this.previewTransfer({ asset, amount });
+      if (!preview.isValid) {
+        return {
+          success: false,
+          asset,
+          amount,
+          fromWallet: "unified",
+          toWallet: "funding",
+          balanceAfterTransfer: 0,
+          timestamp: new Date().toISOString(),
+          error: `Transfer validation failed: ${preview.errors.join("; ")}`
+        };
+      }
+      const transferResult = await this.client.createInternalTransfer(`bybit_transfer_${Date.now()}`, asset.toUpperCase(), amount.toString(), "UNIFIED", "FUND");
+      if (transferResult.retCode !== 0) {
+        throw new Error(`Bybit transfer failed: ${transferResult.retMsg} (code: ${transferResult.retCode})`);
+      }
+      const balanceAfterTransfer = await getWalletBalance2(this.client, asset);
+      return {
+        success: true,
+        transactionId: transferResult.result?.transferId,
+        asset,
+        amount,
+        fromWallet: "unified",
+        toWallet: "funding",
+        balanceAfterTransfer,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error(`Error executing transfer for ${asset}:`, error);
+      let currentBalance = 0;
+      try {
+        currentBalance = await getWalletBalance2(this.client, asset);
+      } catch (balanceError) {
+        console.warn("Could not fetch balance for error response:", balanceError);
+      }
+      return {
+        success: false,
+        asset,
+        amount,
+        fromWallet: "unified",
+        toWallet: "funding",
+        balanceAfterTransfer: currentBalance,
+        timestamp: new Date().toISOString(),
+        error: `Transfer execution failed: ${error instanceof Error ? error.message : error}`
+      };
+    }
+  }
 }
 
 // src/helpers/accounts.ts
@@ -69056,9 +69255,6 @@ class ExchangeAccount {
     }
     return db_positions;
   }
-  async getRunningInstanceFromDB(symbol) {
-    return await this.app_db.getRunningInstanceFromDB(this.instance, symbol);
-  }
   async syncOrders(options) {
     const { symbol, update = false, kind } = options;
     if (!update && kind) {
@@ -70707,22 +70903,11 @@ class App {
   }
   async syncOrders(payload) {
     const exchange_account = await this.getExchangeAccount(payload.account);
-    const db_running_instance = await exchange_account.getRunningInstanceFromDB(payload.symbol);
-    if (db_running_instance.running) {
-      return {
-        new_config: null,
-        position: null,
-        config: null,
-        error: "Already running"
-      };
-    }
-    await this.app_db.updateRunningInstance(db_running_instance.id, true);
     await exchange_account.syncAccount({
       symbol: payload.symbol,
       kind: payload.kind,
       update: true
     });
-    await this.app_db.updateRunningInstance(db_running_instance.id, false);
     return true;
   }
   async cancelOrders(payload) {