@gbozee/ultimate 0.0.2-192 → 0.0.2-194

package/dist/index.cjs

@@ -38677,20 +38677,20 @@ var require_axios2 = __commonJS((exports2, module2) => {
   var reduceDescriptors = (obj, reducer) => {
     const descriptors2 = Object.getOwnPropertyDescriptors(obj);
     const reducedDescriptors = {};
-    forEach2(descriptors2, (descriptor, name2) => {
+    forEach2(descriptors2, (descriptor, name3) => {
       let ret;
-      if ((ret = reducer(descriptor, name2, obj)) !== false) {
-        reducedDescriptors[name2] = ret || descriptor;
+      if ((ret = reducer(descriptor, name3, obj)) !== false) {
+        reducedDescriptors[name3] = ret || descriptor;
       }
     });
     Object.defineProperties(obj, reducedDescriptors);
   };
   var freezeMethods = (obj) => {
-    reduceDescriptors(obj, (descriptor, name2) => {
-      if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name2) !== -1) {
+    reduceDescriptors(obj, (descriptor, name3) => {
+      if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name3) !== -1) {
         return false;
       }
-      const value2 = obj[name2];
+      const value2 = obj[name3];
       if (!isFunction(value2))
         return;
       descriptor.enumerable = false;
@@ -38700,7 +38700,7 @@ var require_axios2 = __commonJS((exports2, module2) => {
       }
       if (!descriptor.set) {
         descriptor.set = () => {
-          throw Error("Can not rewrite read-only method '" + name2 + "'");
+          throw Error("Can not rewrite read-only method '" + name3 + "'");
         };
       }
     });
@@ -39008,8 +39008,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
     params && toFormData(params, this, options);
   }
   var prototype = AxiosURLSearchParams.prototype;
-  prototype.append = function append(name2, value2) {
-    this._pairs.push([name2, value2]);
+  prototype.append = function append(name3, value2) {
+    this._pairs.push([name3, value2]);
   };
   prototype.toString = function toString(encoder2) {
     const _encode = encoder2 ? function(value2) {
@@ -39145,8 +39145,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
       }
     }, options));
   }
-  function parsePropPath(name2) {
-    return utils$1.matchAll(/\w+|\[(\w*)]/g, name2).map((match) => {
+  function parsePropPath(name3) {
+    return utils$1.matchAll(/\w+|\[(\w*)]/g, name3).map((match) => {
       return match[0] === "[]" ? "" : match[1] || match[0];
     });
   }
@@ -39164,33 +39164,33 @@ var require_axios2 = __commonJS((exports2, module2) => {
   }
   function formDataToJSON(formData) {
     function buildPath(path, value2, target, index) {
-      let name2 = path[index++];
-      if (name2 === "__proto__")
+      let name3 = path[index++];
+      if (name3 === "__proto__")
         return true;
-      const isNumericKey = Number.isFinite(+name2);
+      const isNumericKey = Number.isFinite(+name3);
       const isLast = index >= path.length;
-      name2 = !name2 && utils$1.isArray(target) ? target.length : name2;
+      name3 = !name3 && utils$1.isArray(target) ? target.length : name3;
       if (isLast) {
-        if (utils$1.hasOwnProp(target, name2)) {
-          target[name2] = [target[name2], value2];
+        if (utils$1.hasOwnProp(target, name3)) {
+          target[name3] = [target[name3], value2];
         } else {
-          target[name2] = value2;
+          target[name3] = value2;
         }
         return !isNumericKey;
       }
-      if (!target[name2] || !utils$1.isObject(target[name2])) {
-        target[name2] = [];
+      if (!target[name3] || !utils$1.isObject(target[name3])) {
+        target[name3] = [];
       }
-      const result = buildPath(path, value2, target[name2], index);
-      if (result && utils$1.isArray(target[name2])) {
-        target[name2] = arrayToObject(target[name2]);
+      const result = buildPath(path, value2, target[name3], index);
+      if (result && utils$1.isArray(target[name3])) {
+        target[name3] = arrayToObject(target[name3]);
       }
       return !isNumericKey;
     }
     if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {
       const obj = {};
-      utils$1.forEachEntry(formData, (name2, value2) => {
-        buildPath(parsePropPath(name2), value2, obj, 0);
+      utils$1.forEachEntry(formData, (name3, value2) => {
+        buildPath(parsePropPath(name3), value2, obj, 0);
       });
       return obj;
     }
@@ -39769,10 +39769,10 @@ var require_axios2 = __commonJS((exports2, module2) => {
   var CRLF_BYTES_COUNT = 2;
 
   class FormDataPart {
-    constructor(name2, value2) {
+    constructor(name3, value2) {
       const { escapeName } = this.constructor;
       const isStringValue = utils$1.isString(value2);
-      let headers = `Content-Disposition: form-data; name="${escapeName(name2)}"${!isStringValue && value2.name ? `; filename="${escapeName(value2.name)}"` : ""}${CRLF}`;
+      let headers = `Content-Disposition: form-data; name="${escapeName(name3)}"${!isStringValue && value2.name ? `; filename="${escapeName(value2.name)}"` : ""}${CRLF}`;
       if (isStringValue) {
         value2 = textEncoder.encode(String(value2).replace(/\r?\n|\r\n?/g, CRLF));
       } else {
@@ -39781,7 +39781,7 @@ var require_axios2 = __commonJS((exports2, module2) => {
       this.headers = textEncoder.encode(headers + CRLF);
       this.contentLength = isStringValue ? value2.byteLength : value2.size;
       this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;
-      this.name = name2;
+      this.name = name3;
       this.value = value2;
     }
     async* encode() {
@@ -39794,8 +39794,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
       }
       yield CRLF_BYTES;
     }
-    static escapeName(name2) {
-      return String(name2).replace(/[\r\n"]/g, (match) => ({
+    static escapeName(name3) {
+      return String(name3).replace(/[\r\n"]/g, (match) => ({
         "\r": "%0D",
         "\n": "%0A",
         '"': "%22"
@@ -39817,8 +39817,8 @@ var require_axios2 = __commonJS((exports2, module2) => {
     const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
     const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF + CRLF);
     let contentLength = footerBytes.byteLength;
-    const parts = Array.from(form.entries()).map(([name2, value2]) => {
-      const part = new FormDataPart(name2, value2);
+    const parts = Array.from(form.entries()).map(([name3, value2]) => {
+      const part = new FormDataPart(name3, value2);
       contentLength += part.size;
       return part;
     });
@@ -40426,20 +40426,20 @@ var require_axios2 = __commonJS((exports2, module2) => {
     return origin2.protocol === url2.protocol && origin2.host === url2.host && (isMSIE || origin2.port === url2.port);
   })(new URL(platform.origin), platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)) : () => true;
   var cookies = platform.hasStandardBrowserEnv ? {
-    write(name2, value2, expires, path, domain, secure) {
-      const cookie = [name2 + "=" + encodeURIComponent(value2)];
+    write(name3, value2, expires, path, domain, secure) {
+      const cookie = [name3 + "=" + encodeURIComponent(value2)];
       utils$1.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString());
       utils$1.isString(path) && cookie.push("path=" + path);
       utils$1.isString(domain) && cookie.push("domain=" + domain);
       secure === true && cookie.push("secure");
       document.cookie = cookie.join("; ");
     },
-    read(name2) {
-      const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name2 + ")=([^;]*)"));
+    read(name3) {
+      const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name3 + ")=([^;]*)"));
       return match ? decodeURIComponent(match[3]) : null;
     },
-    remove(name2) {
-      this.write(name2, "", Date.now() - 86400000);
+    remove(name3) {
+      this.write(name3, "", Date.now() - 86400000);
     }
   } : {
     write() {},
@@ -44876,6 +44876,7 @@ var require_lib3 = __commonJS((exports2) => {
 var exports_src = {};
 __export(exports_src, {
   sortedBuildConfig: () => sortedBuildConfig,
+  name: () => name2,
   initialize: () => initialize,
   initApp: () => initApp,
   get_app_config_and_max_size: () => get_app_config_and_max_size,
@@ -54801,35 +54802,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({
@@ -55140,110 +55112,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({
@@ -58714,6 +58582,8 @@ class Strategy {
     };
   }
 }
+// src/helpers/compound.ts
+var name2 = "";
 // src/types/index.ts
 class BaseExchange {
   client;
@@ -60051,6 +59921,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 +60411,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 +60812,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
@@ -62480,9 +62682,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) {
@@ -64131,22 +64330,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) {