@gbozee/ultimate 0.0.2-192 → 0.0.2-193

package/dist/index.cjs

@@ -60051,6 +60051,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 isValid2 = true;
+      if (amount <= 0) {
+        errors.push("Transfer amount must be greater than zero");
+        isValid2 = false;
+      }
+      if (amount > analysis.maxTransferableAmount) {
+        errors.push(`Transfer amount (${amount}) exceeds maximum transferable amount (${analysis.maxTransferableAmount})`);
+        isValid2 = 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 (isValid2 && balanceAfterTransfer < marginRequirementAfterTransfer) {
+        errors.push("Transfer would result in insufficient margin for existing positions");
+        isValid2 = false;
+      }
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: isValid2,
+        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();
@@ -60376,6 +60541,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) {
@@ -60772,6 +60942,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 isValid2 = true;
+      if (amount <= 0) {
+        errors.push("Transfer amount must be greater than zero");
+        isValid2 = false;
+      }
+      if (amount > analysis.maxTransferableAmount) {
+        errors.push(`Transfer amount (${amount}) exceeds maximum transferable amount (${analysis.maxTransferableAmount})`);
+        isValid2 = 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 (isValid2 && balanceAfterTransfer < marginRequirementAfterTransfer) {
+        errors.push("Transfer would result in insufficient margin for existing positions");
+        isValid2 = false;
+      }
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: isValid2,
+        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

package/dist/index.js

@@ -59989,6 +59989,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 isValid2 = true;
+      if (amount <= 0) {
+        errors.push("Transfer amount must be greater than zero");
+        isValid2 = false;
+      }
+      if (amount > analysis.maxTransferableAmount) {
+        errors.push(`Transfer amount (${amount}) exceeds maximum transferable amount (${analysis.maxTransferableAmount})`);
+        isValid2 = 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 (isValid2 && balanceAfterTransfer < marginRequirementAfterTransfer) {
+        errors.push("Transfer would result in insufficient margin for existing positions");
+        isValid2 = false;
+      }
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: isValid2,
+        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();
@@ -60314,6 +60479,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) {
@@ -60710,6 +60880,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 isValid2 = true;
+      if (amount <= 0) {
+        errors.push("Transfer amount must be greater than zero");
+        isValid2 = false;
+      }
+      if (amount > analysis.maxTransferableAmount) {
+        errors.push(`Transfer amount (${amount}) exceeds maximum transferable amount (${analysis.maxTransferableAmount})`);
+        isValid2 = 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 (isValid2 && balanceAfterTransfer < marginRequirementAfterTransfer) {
+        errors.push("Transfer would result in insufficient margin for existing positions");
+        isValid2 = false;
+      }
+      return {
+        asset,
+        requestedAmount: amount,
+        isValid: isValid2,
+        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