@gbozee/ultimate 0.0.2-191 → 0.0.2-193

package/dist/index.js

@@ -57427,7 +57427,8 @@ function determineOptimumReward(payload) {
     low_range = 1,
     high_range = 199,
     target_loss,
-    distribution
+    distribution,
+    max_size
   } = payload;
   const criterion = app_config.strategy || "quantity";
   const risk_rewards = createArray(low_range, high_range, 1);
@@ -57449,6 +57450,7 @@ function determineOptimumReward(payload) {
     let min = Infinity;
     let neg_pnl = trades[0]?.neg_pnl || 0;
     let entry = trades.at(-1)?.entry;
+    let avg_size = trades[0]?.avg_size || 0;
     if (!entry) {
       return null;
     }
@@ -57465,11 +57467,15 @@ function determineOptimumReward(payload) {
       risk_per_trade: app_config.risk_per_trade,
       max,
       min,
+      avg_size,
       neg_pnl,
       entry
     };
   });
   func = func.filter((r2) => Boolean(r2));
+  if (max_size !== undefined && max_size > 0) {
+    func = func.filter((r2) => r2.avg_size <= max_size);
+  }
   if (target_loss === undefined) {
     func = func.filter((r2) => {
       let foundIndex = r2?.result.findIndex((e2) => e2.quantity === r2.max);
@@ -57607,7 +57613,15 @@ function determineOptimumRisk(config2, payload, params) {
   };
 }
 function computeRiskReward(payload) {
-  const { app_config, entry, stop, risk_per_trade, target_loss, distribution } = payload;
+  const {
+    app_config,
+    entry,
+    stop,
+    risk_per_trade,
+    target_loss,
+    distribution,
+    max_size
+  } = payload;
   const kind = entry > stop ? "long" : "short";
   app_config.kind = kind;
   app_config.entry = entry;
@@ -57616,12 +57630,14 @@ function computeRiskReward(payload) {
   const result = determineOptimumReward({
     app_config,
     target_loss,
-    distribution
+    distribution,
+    max_size
   });
   return result;
 }
 function getRiskReward(payload) {
   const {
+    max_size,
     entry,
     stop,
     risk,
@@ -57644,7 +57660,8 @@ function getRiskReward(payload) {
     stop,
     risk_per_trade: risk,
     target_loss,
-    distribution
+    distribution,
+    max_size
   });
   if (force_exact_risk) {
     const new_risk_per_trade = determineOptimumRisk(global_config, {
@@ -59972,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();
@@ -60297,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) {
@@ -60693,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