@strkfarm/sdk 2.0.0-dev.22 → 2.0.0-dev.24

package/dist/index.mjs

@@ -28135,7 +28135,9 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       vesu_leverage
     };
   } catch (err) {
-    logger.error(`error calculating amount distribution for withdrawal: ${err}`);
+    logger.error(
+      `error calculating amount distribution for withdrawal: ${err}`
+    );
     return null;
   }
 };
@@ -28188,15 +28190,22 @@ var calculateAmountDepositOnExtendedWhenIncurringLosses = async (client) => {
     const extended_leverage = calculateExtendedLevergae();
     const latestPosition = (await client.getPositions()).data.pop();
     if (!extendedHoldings || !latestPosition) {
-      logger.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+      logger.error(
+        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`
+      );
       return null;
     }
-    const positionValueInUSD = new Web3Number(latestPosition.value, USDC_TOKEN_DECIMALS);
+    const positionValueInUSD = new Web3Number(
+      latestPosition.value,
+      USDC_TOKEN_DECIMALS
+    );
     const equity = extendedHoldings.data.equity;
     const deposit = positionValueInUSD.dividedBy(extended_leverage).minus(equity).toFixed(2);
     return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
   } catch (err) {
-    logger.error(`error calculating amount deposit on extended when incurring losses: ${err}`);
+    logger.error(
+      `error calculating amount deposit on extended when incurring losses: ${err}`
+    );
     return null;
   }
 };
@@ -28222,14 +28231,14 @@ var calculateExposureDelta = (exposure_extended, exposure_vesu) => {
 var calculateBTCPriceDelta = (btcPrice, lastBtcPrice) => {
   return (btcPrice - lastBtcPrice) / lastBtcPrice * 100;
 };
-var calculateVesUPositionSizeGivenExtended = (extendedPositonValue, extendedHoldingAmount, collateralAmount, collateralPrice) => {
+var calculateVesUPositionSizeGivenExtended = (extendedPositonValue, extendedHoldingAmount, collateralAmount, collateralPrice, vesuDebtAmountToBeRepaid) => {
   const extendedLeverage = calculateExtendedLevergae();
   const vesuLeverage = calculateVesuLeverage();
   const extendedAmount = extendedHoldingAmount;
   const extendedAmountInBTC = extendedAmount.dividedBy(collateralPrice);
   const numerator1 = extendedAmount.multipliedBy(extendedLeverage).plus(extendedPositonValue);
   const numerator2 = collateralAmount.multipliedBy(collateralPrice).multipliedBy(-1);
-  const vesuAmountInUsd = numerator1.plus(numerator2).dividedBy(vesuLeverage);
+  const vesuAmountInUsd = numerator1.plus(numerator2).dividedBy(vesuLeverage).plus(vesuDebtAmountToBeRepaid);
   const vesuAmountInBTC = vesuAmountInUsd.dividedBy(collateralPrice).toFixed(WBTC_TOKEN_DECIMALS);
   return {
     vesuAmountInUsd: vesuAmountInUsd.toFixed(2),
@@ -28237,6 +28246,41 @@ var calculateVesUPositionSizeGivenExtended = (extendedPositonValue, extendedHold
     extendedAmountInBTC
   };
 };
+var calculateDeltaDebtAmount = (maxLtv = MAX_LTV_BTC_USDC, existingVesuCollateral, existingVesuDebt, collateralPrice, debtPrice, targetHf = TARGET_HF) => {
+  try {
+    const term1 = existingVesuCollateral.multipliedBy(collateralPrice).multipliedBy(maxLtv).dividedBy(targetHf);
+    const term2 = existingVesuDebt.multipliedBy(debtPrice).multipliedBy(targetHf).multipliedBy(-1);
+    const debtAmountToBeRepaid = term1.plus(term2).dividedBy(targetHf);
+    return debtAmountToBeRepaid;
+  } catch (err) {
+    logger.error(`error calculating delta position: ${err}`);
+    return null;
+  }
+};
+var calculatePositionToCloseToWithdrawAmount = async (extendedBalance, extendedPositions, amountToWithdraw) => {
+  try {
+    const extendedPosition = extendedPositions.value;
+    const unrealisedPnl = new Web3Number(
+      extendedBalance.unrealisedPnl,
+      USDC_TOKEN_DECIMALS
+    );
+    const availableForWithdrawal = new Web3Number(
+      extendedBalance.availableForWithdrawal,
+      USDC_TOKEN_DECIMALS
+    );
+    const netAmount = amountToWithdraw.minus(availableForWithdrawal);
+    const upnlPercent = unrealisedPnl.dividedBy(extendedPosition);
+    console.log(`upnlPercent: ${upnlPercent}`);
+    const denm = upnlPercent.multipliedBy(3).plus(1);
+    const amountToClose = netAmount.multipliedBy(3).dividedBy(denm);
+    return new Web3Number(Math.ceil(amountToClose.toNumber()), USDC_TOKEN_DECIMALS);
+  } catch (err) {
+    logger.error(
+      `error calculating position to close to withdraw amount: ${err}`
+    );
+    return new Web3Number(0, USDC_TOKEN_DECIMALS);
+  }
+};
 
 // src/utils/health-factor-math.ts
 var HealthFactorMath = class {
@@ -30659,6 +30703,8 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
         quote,
         vaultAllocator.address
       );
+      const dataObject = quote;
+      logger.info(`${_AvnuAdapter.name}::getQuotesAvnu finalAmountOfWbtcOut : ${dataObject.avnuFees} ${parseInt(dataObject.buyAmount.toString(), 16)} ${parseInt(dataObject.sellAmount.toString(), 16)} ${parseInt(dataObject.sellAmount.toString(), 16)}`);
       const swapCallData = getCalldata[0];
       const amount = uint25614.bnToUint256(quote.sellAmountInUsd * 10 ** 7);
       return [
@@ -34405,11 +34451,17 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         WALLET_ADDRESS,
         usdceToken.decimals
       );
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator walletBalance: ${walletBalance}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator walletBalance: ${walletBalance}`
+      );
       const amountToBeTransferred = amount.minimum(walletBalance);
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred: ${amountToBeTransferred.toNumber()}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred: ${amountToBeTransferred.toNumber()}`
+      );
       if (amountToBeTransferred.lessThan(0)) {
-        logger.error(`${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred is less than 0: ${amountToBeTransferred.toNumber()}`);
+        logger.error(
+          `${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred is less than 0: ${amountToBeTransferred.toNumber()}`
+        );
         return {
           calls: [],
           status: false
@@ -34447,10 +34499,14 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
   }
   async shouldInvest() {
     try {
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest starting`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldInvest starting`
+      );
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`
+      );
       if (!vesuAdapter) {
         logger.error(
           `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
@@ -34462,7 +34518,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
       if (!extendedAdapter) {
@@ -34476,7 +34533,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
       if (!extendedAdapter.client) {
@@ -34490,10 +34548,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`
+      );
       const balance = await this.getUnusedBalance();
       if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
         logger.error(
@@ -34506,13 +34567,18 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`
+      );
       const usdcBalanceOnExtended = await extendedAdapter.getExtendedDepositAmount();
       if (usdcBalanceOnExtended) {
-        const availableForWithdrawal = parseFloat(usdcBalanceOnExtended.availableForWithdrawal);
+        const availableForWithdrawal = parseFloat(
+          usdcBalanceOnExtended.availableForWithdrawal
+        );
         if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
           logger.error(
             `Invalid usdcBalanceOnExtended.availableForWithdrawal: ${usdcBalanceOnExtended.availableForWithdrawal}. Expected a finite, non-negative number.`
@@ -34524,11 +34590,15 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             extendedLeverage: 0,
             collateralPrice: 0,
             debtPrice: 0,
-            vesuLeverage: 0
+            vesuLeverage: 0,
+            debtAmountToBeRepaid: new Web3Number(0, 0)
           };
         }
       }
-      const amountToInvest = new Web3Number(balance.usdValue, USDC_TOKEN_DECIMALS).plus(usdcBalanceOnExtended?.availableForTrade ?? 0).multipliedBy(1 - LIMIT_BALANCE);
+      const amountToInvest = new Web3Number(
+        balance.usdValue,
+        USDC_TOKEN_DECIMALS
+      ).plus(usdcBalanceOnExtended?.availableForTrade ?? 0).multipliedBy(1 - LIMIT_BALANCE);
       const amountToInvestNumber = amountToInvest.toNumber();
       if (!Number.isFinite(amountToInvestNumber)) {
         logger.error(
@@ -34541,10 +34611,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`
+      );
       if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
         return {
           shouldInvest: false,
@@ -34553,7 +34626,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
       const extendedPositon = await extendedAdapter.getAllOpenPositions();
@@ -34566,14 +34640,12 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
-      const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
-      const {
-        collateralPrice,
-        debtPrice
-      } = await this.getAssetPrices();
+      const { collateralTokenAmount, debtTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
+      const { collateralPrice, debtPrice } = await this.getAssetPrices();
       if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
         logger.error(
           `Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
@@ -34585,7 +34657,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
       if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
@@ -34599,11 +34672,34 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
+      const debtAmountToBeRepaid = calculateDeltaDebtAmount(
+        MAX_LTV_BTC_USDC,
+        collateralTokenAmount,
+        debtTokenAmount,
+        collateralPrice.price,
+        debtPrice.price,
+        this.metadata.additionalInfo.targetHealthFactor
+      );
+      if (!debtAmountToBeRepaid) {
+        logger.error("error calculating debt amount to be repaid");
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
+        };
+      }
+      const amountToInvestAfterRepayingDebt = amountToInvest.minus(debtAmountToBeRepaid);
       const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } = await calculateAmountDistribution(
-        amountToInvest.toNumber(),
+        amountToInvestAfterRepayingDebt.toNumber(),
         extendedAdapter.client,
         extendedAdapter.config.extendedMarketName,
         collateralPrice.price,
@@ -34622,10 +34718,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedLeverage: 0,
           collateralPrice: 0,
           debtPrice: 0,
-          vesuLeverage: 0
+          vesuLeverage: 0,
+          debtAmountToBeRepaid: new Web3Number(0, 0)
         };
       }
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`
+      );
       return {
         shouldInvest: true,
         vesuAmount: vesu_amount,
@@ -34633,7 +34732,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         extendedLeverage: extended_leverage,
         vesuLeverage: vesu_leverage,
         collateralPrice: collateralPrice.price,
-        debtPrice: debtPrice.price
+        debtPrice: debtPrice.price,
+        debtAmountToBeRepaid
       };
     } catch (err) {
       logger.error(`error deciding invest: ${err}`);
@@ -34644,7 +34744,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         extendedLeverage: 0,
         collateralPrice: 0,
         debtPrice: 0,
-        vesuLeverage: 0
+        vesuLeverage: 0,
+        debtAmountToBeRepaid: new Web3Number(0, 0)
       };
     }
   }
@@ -34667,33 +34768,49 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       const usdcAmountOnExtendedAvailableForTrade = parseFloat(
         extendedHoldings.availableForTrade
       );
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForTrade}, Wallet: ${usdcAmountInWallet.toNumber()}, Target Extended: ${extendedAmount.toNumber()}, Target Vesu: ${vesuAmount.toNumber()}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForTrade}, Wallet: ${usdcAmountInWallet.toNumber()}, Target Extended: ${extendedAmount.toNumber()}, Target Vesu: ${vesuAmount.toNumber()}`
+      );
       let totalExtendedWithdrawal = new Web3Number(0, USDC_TOKEN_DECIMALS);
       let totalExtendedDeposit = new Web3Number(0, USDC_TOKEN_DECIMALS);
       if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
-        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmount.abs());
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(
+          extendedAmount.abs()
+        );
       }
       const extendedTargetAmount = extendedAmount.abs();
       let projectedExtendedBalance = usdcAmountOnExtendedAvailableForTrade;
       if (extendedAmount.isNegative()) {
         projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
       }
-      const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
+      const extendedAmountDifference = extendedTargetAmount.minus(
+        projectedExtendedBalance
+      );
       const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
       if (extendedAmountDifference.lessThan(0)) {
-        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmountDifferenceAbs);
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(
+          extendedAmountDifferenceAbs
+        );
       } else if (extendedAmountDifference.greaterThan(0)) {
-        totalExtendedDeposit = totalExtendedDeposit.plus(extendedAmountDifference);
+        totalExtendedDeposit = totalExtendedDeposit.plus(
+          extendedAmountDifference
+        );
       }
       const vesuTargetAmount = vesuAmount.abs();
       const projectedWalletBalance = usdcAmountInWallet.plus(totalExtendedWithdrawal).minus(totalExtendedDeposit);
       let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
       const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
-      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`);
+      logger.info(
+        `${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`
+      );
       let transactionResults = [];
       if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         try {
-          const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+          const {
+            calls: extendedCalls,
+            status: extendedStatus,
+            transactionMetadata: extendedTransactionMetadata
+          } = await this.moveAssets(
             {
               to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
@@ -34713,16 +34830,44 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
               }
             });
           } else {
-            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.EXTENDED.name,
+                  to: Protocols.VAULT.name,
+                  amount: extendedAmount.abs()
+                },
+                "NONE",
+                "INVESTMENT" /* INVESTMENT */
+              )
+            ];
           }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
-          return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+          return [
+            this.createTransactionResult(
+              [],
+              false,
+              {
+                from: Protocols.EXTENDED.name,
+                to: Protocols.VAULT.name,
+                amount: extendedAmount.abs()
+              },
+              "NONE",
+              "INVESTMENT" /* INVESTMENT */
+            )
+          ];
         }
       }
       if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
         try {
-          const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+          const {
+            calls: vesuCalls,
+            status: vesuStatus,
+            transactionMetadata: vesuTransactionMetadata
+          } = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VESU.name,
@@ -34733,7 +34878,19 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             vesuAdapter
           );
           if (!vesuStatus) {
-            return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.VESU.name,
+                  to: Protocols.EXTENDED.name,
+                  amount: vesuAmount.abs()
+                },
+                "NONE",
+                "INVESTMENT" /* INVESTMENT */
+              )
+            ];
           }
           transactionResults.push({
             status: vesuStatus,
@@ -34744,14 +34901,34 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             }
           });
         } catch (err) {
-          logger.error(`Failed moving assets to extended via vault allocator: ${err}`);
-          return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+          logger.error(
+            `Failed moving assets to extended via vault allocator: ${err}`
+          );
+          return [
+            this.createTransactionResult(
+              [],
+              false,
+              {
+                from: Protocols.VESU.name,
+                to: Protocols.EXTENDED.name,
+                amount: vesuAmount.abs()
+              },
+              "NONE",
+              "INVESTMENT" /* INVESTMENT */
+            )
+          ];
         }
       }
-      if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+      if (extendedAmountDifferenceAbs.greaterThan(
+        extendedAdapter.minimumExtendedMovementAmount
+      )) {
         if (extendedAmountDifference.greaterThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+            const {
+              calls: extendedCalls,
+              status: extendedStatus,
+              transactionMetadata: extendedTransactionMetadata
+            } = await this.moveAssets(
               {
                 to: Protocols.EXTENDED.name,
                 from: Protocols.VAULT.name,
@@ -34768,16 +34945,46 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
                 transactionMetadata: extendedTransactionMetadata
               });
             } else {
-              logger.error(`Failed to move assets to extended - operation returned false status`);
-              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+              logger.error(
+                `Failed to move assets to extended - operation returned false status`
+              );
+              return [
+                this.createTransactionResult(
+                  [],
+                  false,
+                  {
+                    from: Protocols.VAULT.name,
+                    to: Protocols.EXTENDED.name,
+                    amount: extendedAmountDifference
+                  },
+                  "NONE",
+                  "INVESTMENT" /* INVESTMENT */
+                )
+              ];
             }
           } catch (err) {
             logger.error(`Failed moving assets to extended: ${err}`);
-            return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.VAULT.name,
+                  to: Protocols.EXTENDED.name,
+                  amount: extendedAmountDifference
+                },
+                "NONE",
+                "INVESTMENT" /* INVESTMENT */
+              )
+            ];
           }
         } else if (extendedAmountDifference.lessThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+            const {
+              calls: extendedCalls,
+              status: extendedStatus,
+              transactionMetadata: extendedTransactionMetadata
+            } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
@@ -34797,23 +35004,55 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
                 }
               });
             } else {
-              logger.error(`Failed to withdraw from extended - operation returned false status`);
-              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+              logger.error(
+                `Failed to withdraw from extended - operation returned false status`
+              );
+              return [
+                this.createTransactionResult(
+                  [],
+                  false,
+                  {
+                    from: Protocols.EXTENDED.name,
+                    to: Protocols.VAULT.name,
+                    amount: extendedAmountDifferenceAbs
+                  },
+                  "NONE",
+                  "INVESTMENT" /* INVESTMENT */
+                )
+              ];
             }
           } catch (err) {
             logger.error(`Failed moving assets from extended to vault: ${err}`);
-            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.EXTENDED.name,
+                  to: Protocols.VAULT.name,
+                  amount: extendedAmountDifferenceAbs
+                },
+                "NONE",
+                "INVESTMENT" /* INVESTMENT */
+              )
+            ];
           }
         }
       }
-      if (vesuAmountDifferenceAbs.greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+      if (vesuAmountDifferenceAbs.greaterThan(
+        vesuAdapter.minimumVesuMovementAmount
+      )) {
         if (vesuAmountDifference.lessThanOrEqualTo(0)) {
           logger.warn(
             `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
           );
         } else {
           try {
-            const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+            const {
+              calls: vesuCalls,
+              status: vesuStatus,
+              transactionMetadata: vesuTransactionMetadata
+            } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
@@ -34824,8 +35063,22 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
               vesuAdapter
             );
             if (!vesuStatus) {
-              logger.error(`Failed to move assets to vesu - operation returned false status`);
-              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+              logger.error(
+                `Failed to move assets to vesu - operation returned false status`
+              );
+              return [
+                this.createTransactionResult(
+                  [],
+                  false,
+                  {
+                    from: Protocols.EXTENDED.name,
+                    to: Protocols.VAULT.name,
+                    amount: vesuAmountDifference
+                  },
+                  "NONE",
+                  "INVESTMENT" /* INVESTMENT */
+                )
+              ];
             }
             transactionResults.push({
               status: vesuStatus,
@@ -34837,14 +35090,38 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             });
           } catch (err) {
             logger.error(`Failed moving assets to vault: ${err}`);
-            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            return [
+              this.createTransactionResult(
+                [],
+                false,
+                {
+                  from: Protocols.EXTENDED.name,
+                  to: Protocols.VAULT.name,
+                  amount: vesuAmountDifference
+                },
+                "NONE",
+                "INVESTMENT" /* INVESTMENT */
+              )
+            ];
           }
         }
       }
       return transactionResults;
     } catch (err) {
       logger.error(`Failed moving assets to vesu: ${err}`);
-      return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: new Web3Number(0, USDC_TOKEN_DECIMALS) }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+      return [
+        this.createTransactionResult(
+          [],
+          false,
+          {
+            from: Protocols.EXTENDED.name,
+            to: Protocols.VAULT.name,
+            amount: new Web3Number(0, USDC_TOKEN_DECIMALS)
+          },
+          "NONE",
+          "INVESTMENT" /* INVESTMENT */
+        )
+      ];
     }
   }
   /**
@@ -34865,7 +35142,18 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         }
       };
     }
-    return { calls: [], status: false, transactionMetadata: { protocolFrom: "", protocolTo: "", transactionType: "DEPOSIT", usdAmount: "0", status: "FAILED", cycleType } };
+    return {
+      calls: [],
+      status: false,
+      transactionMetadata: {
+        protocolFrom: "",
+        protocolTo: "",
+        transactionType: "DEPOSIT",
+        usdAmount: "0",
+        status: "FAILED",
+        cycleType
+      }
+    };
   }
   /**
    * This method is used to move assets between protocols
@@ -34873,7 +35161,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
    * @param extendedAdapter - The extended adapter
    * @param vesuAdapter - The vesu adapter
    * @returns The transaction result
-   * If Extended amount is greater than amount of withdrawal from extended, then we need to open a long position 
+   * If Extended amount is greater than amount of withdrawal from extended, then we need to open a long position
    * so that the amount of withdrawal from extended is fullfilled
    */
   async moveAssets(params, extendedAdapter, vesuAdapter) {
@@ -34882,18 +35170,28 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
         );
-        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        return this.createTransactionResult(
+          [],
+          false,
+          params,
+          "NONE",
+          params.cycleType
+        );
       }
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        return this.createTransactionResult(
+          [],
+          false,
+          params,
+          "NONE",
+          params.cycleType
+        );
       }
       logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
-      const {
-        collateralPrice
-      } = await this.getAssetPrices();
+      const { collateralPrice } = await this.getAssetPrices();
       if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VAULT.name) {
         const proofsInfo = extendedAdapter.getProofs(
           true,
@@ -34906,28 +35204,58 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
+        return this.createTransactionResult(
+          calls,
+          true,
+          params,
+          "DEPOSIT",
+          params.cycleType
+        );
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
         const extendedLeverage = calculateExtendedLevergae();
         const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
         if (!extendedHoldings) {
           logger.error(`error getting extended holdings: ${extendedHoldings}`);
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
         const extendedHoldingAmount = new Web3Number(
           extendedHoldings.availableForWithdrawal,
           USDC_TOKEN_DECIMALS
         );
-        logger.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`);
+        logger.info(
+          `${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
+        );
+        const extendedPositions = await extendedAdapter.getAllOpenPositions();
+        if (!extendedPositions) {
+          logger.error(`error getting extended positions: ${extendedPositions} while moving assets from extended to vault`);
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
+        }
         if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
-          const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(Math.ceil(params.amount.abs().minus(extendedHoldingAmount).toNumber()), USDC_TOKEN_DECIMALS);
-          logger.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`);
+          const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
+            Math.ceil(
+              params.amount.abs().minus(extendedHoldingAmount).toNumber()
+            ),
+            USDC_TOKEN_DECIMALS
+          );
+          const positionAmountToClose = await calculatePositionToCloseToWithdrawAmount(extendedHoldings, extendedPositions[0], params.amount);
+          logger.info(`positionAmountToClose: ${positionAmountToClose.toNumber()}`);
+          logger.info(
+            `${_VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`
+          );
           let priceOfBTC;
-          const {
-            ask,
-            bid,
-            status
-          } = await extendedAdapter.fetchOrderBookBTCUSDC();
+          const { ask, bid, status } = await extendedAdapter.fetchOrderBookBTCUSDC();
           const price = ask.plus(bid).dividedBy(2);
           if (status) {
             priceOfBTC = price;
@@ -34935,7 +35263,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             logger.error(`error fetching order book btc usdc: ${status}`);
             priceOfBTC = collateralPrice.price;
           }
-          const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(priceOfBTC);
+          const btcAmount = positionAmountToClose.dividedBy(priceOfBTC);
           const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
             extendedLeverage.toString(),
             btcAmount.toNumber(),
@@ -34950,38 +35278,95 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             logger.error(`error opening long position: ${openLongPosition}`);
           }
           const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
-          if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
-            logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
-            return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          if (!updatedHoldings || new Web3Number(
+            updatedHoldings.availableForWithdrawal,
+            USDC_TOKEN_DECIMALS
+          ).lessThan(params.amount.abs())) {
+            logger.error(
+              `Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`
+            );
+            return this.createTransactionResult(
+              [],
+              false,
+              params,
+              "NONE",
+              params.cycleType
+            );
           }
         }
         const {
           status: withdrawalFromExtendedStatus,
           receivedTxnHash: withdrawalFromExtendedTxnHash
         } = await extendedAdapter.withdrawFromExtended(params.amount);
-        logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+        logger.info(
+          `withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`
+        );
         if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
-          logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
+          logger.info(
+            `extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`
+          );
           await new Promise((resolve) => setTimeout(resolve, 5e3));
-          const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+          const { calls, status } = await this.moveAssetsToVaultAllocator(
+            params.amount,
+            extendedAdapter
+          );
           if (calls.length > 0 && status) {
-            return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
+            return this.createTransactionResult(
+              calls,
+              true,
+              params,
+              "WITHDRAWAL",
+              params.cycleType
+            );
           } else {
-            return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
+            return this.createTransactionResult(
+              [],
+              true,
+              params,
+              "WITHDRAWAL",
+              params.cycleType
+            );
           }
         } else if (withdrawalFromExtendedStatus && !withdrawalFromExtendedTxnHash) {
-          logger.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
-          return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
+          logger.error(
+            "withdrawal from extended successful, but funds didn't get transferred to the wallet"
+          );
+          return this.createTransactionResult(
+            [],
+            true,
+            params,
+            "WITHDRAWAL",
+            params.cycleType
+          );
         } else {
           logger.error("withdrawal from extended failed");
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
-        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(
+          extendedAdapter,
+          vesuAdapter,
+          avnuAdapter,
+          "close" /* CLOSE */
+        );
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
-          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          logger.warn(
+            `price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
@@ -34995,19 +35380,41 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(call);
-        const swapProofsInfo = avnuAdapter.getProofs(false, this.getMerkleTree());
+        const swapProofsInfo = avnuAdapter.getProofs(
+          false,
+          this.getMerkleTree()
+        );
         const swapProofGroups = swapProofsInfo.proofs;
         const swapCall = this.getManageCall(
           swapProofGroups,
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
+        return this.createTransactionResult(
+          calls,
+          true,
+          params,
+          "WITHDRAWAL",
+          params.cycleType
+        );
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
-        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(
+          extendedAdapter,
+          vesuAdapter,
+          avnuAdapter,
+          "close" /* CLOSE */
+        );
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
-          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          logger.warn(
+            `price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
         }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -35021,7 +35428,10 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(call);
-        const swapProofsInfo = avnuAdapter.getProofs(false, this.getMerkleTree());
+        const swapProofsInfo = avnuAdapter.getProofs(
+          false,
+          this.getMerkleTree()
+        );
         const swapProofGroups = swapProofsInfo.proofs;
         const swapCall = this.getManageCall(
           swapProofGroups,
@@ -35038,21 +35448,61 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
+        return this.createTransactionResult(
+          calls,
+          true,
+          params,
+          "DEPOSIT",
+          params.cycleType
+        );
       }
-      logger.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
-      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      logger.error(
+        `Unsupported assets movement: ${params.from} to ${params.to}`
+      );
+      return this.createTransactionResult(
+        [],
+        false,
+        params,
+        "NONE",
+        params.cycleType
+      );
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      return this.createTransactionResult(
+        [],
+        false,
+        params,
+        "NONE",
+        params.cycleType
+      );
     }
   }
   async handleDeposit() {
     try {
-      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", "INVESTMENT" /* INVESTMENT */);
+      return this.createTransactionResult(
+        [],
+        false,
+        {
+          from: Protocols.VAULT.name,
+          to: Protocols.VAULT.name,
+          amount: new Web3Number(0, 0)
+        },
+        "NONE",
+        "INVESTMENT" /* INVESTMENT */
+      );
     } catch (err) {
       logger.error(`error handling deposit: ${err}`);
-      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", "INVESTMENT" /* INVESTMENT */);
+      return this.createTransactionResult(
+        [],
+        false,
+        {
+          from: Protocols.VAULT.name,
+          to: Protocols.VAULT.name,
+          amount: new Web3Number(0, 0)
+        },
+        "NONE",
+        "INVESTMENT" /* INVESTMENT */
+      );
     }
   }
   /**
@@ -35064,32 +35514,42 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
    * @returns true if the price difference is within the acceptable range, false otherwise
    */
   async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, positionType) {
-    const {
-      ask,
-      bid
-    } = await extendedAdapter.fetchOrderBookBTCUSDC();
+    const { ask, bid } = await extendedAdapter.fetchOrderBookBTCUSDC();
     const price = ask.plus(bid).dividedBy(2);
     const btcToken = vesuAdapter.config.supportedPositions[0].asset;
-    const btcPriceAvnu = await avnuAdapter.getPriceOfToken(btcToken.address.toString());
+    const btcPriceAvnu = await avnuAdapter.getPriceOfToken(
+      btcToken.address.toString()
+    );
     if (!btcPriceAvnu) {
       logger.error(`error getting btc price avnu: ${btcPriceAvnu}`);
       return false;
     }
     logger.info(`price: ${price}`);
     logger.info(`btcPriceAvnu: ${btcPriceAvnu}`);
-    const priceDifference = new Web3Number(price.minus(btcPriceAvnu).toFixed(2), 0);
+    const priceDifference = new Web3Number(
+      price.minus(btcPriceAvnu).toFixed(2),
+      0
+    );
     logger.info(`priceDifference: ${priceDifference}`);
     if (priceDifference.isNegative()) {
       return false;
     }
     if (positionType === "open" /* OPEN */) {
-      logger.info(`price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`);
-      const result = priceDifference.greaterThanOrEqualTo(avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen);
+      logger.info(
+        `price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`
+      );
+      const result = priceDifference.greaterThanOrEqualTo(
+        avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen
+      );
       logger.info(`result: ${result}`);
       return result;
     } else {
-      logger.info(`price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-      const result = priceDifference.lessThanOrEqualTo(avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing);
+      logger.info(
+        `price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`
+      );
+      const result = priceDifference.lessThanOrEqualTo(
+        avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing
+      );
       logger.info(`result: ${result}`);
       return result;
     }
@@ -35111,7 +35571,19 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           amount: usdcBalanceVaultAllocator.amount
         });
         calls.push(withdrawCall2);
-        return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "WITHDRAWAL", "WITHDRAWAL" /* WITHDRAWAL */)];
+        return [
+          this.createTransactionResult(
+            calls,
+            true,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount
+            },
+            "WITHDRAWAL",
+            "WITHDRAWAL" /* WITHDRAWAL */
+          )
+        ];
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -35120,18 +35592,40 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
+        return [
+          this.createTransactionResult(
+            calls,
+            status,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount
+            },
+            "NONE",
+            "WITHDRAWAL" /* WITHDRAWAL */
+          )
+        ];
       }
       let transactionResults = [];
       const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
-      const {
-        collateralPrice
-      } = await this.getAssetPrices();
+      const { collateralPrice } = await this.getAssetPrices();
       const extendedPositon = await extendedAdapter.getAllOpenPositions();
       if (!extendedPositon) {
         status = false;
         logger.error("error getting extended position", extendedPositon);
-        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
+        return [
+          this.createTransactionResult(
+            calls,
+            status,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount
+            },
+            "NONE",
+            "WITHDRAWAL" /* WITHDRAWAL */
+          )
+        ];
       }
       const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
         usdcBalanceDifference,
@@ -35144,11 +35638,27 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
+        return [
+          this.createTransactionResult(
+            calls,
+            status,
+            {
+              from: Protocols.VAULT.name,
+              to: Protocols.NONE.name,
+              amount
+            },
+            "NONE",
+            "WITHDRAWAL" /* WITHDRAWAL */
+          )
+        ];
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
       if (status && vesu_amount.greaterThan(0)) {
-        const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+        const {
+          calls: vesuCalls,
+          status: vesuStatus,
+          transactionMetadata: vesuTransactionMetadata
+        } = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
@@ -35166,7 +35676,11 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         });
       }
       if (status && extended_amount.greaterThan(0)) {
-        const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+        const {
+          calls: extendedCalls,
+          status: extendedStatus,
+          transactionMetadata: extendedTransactionMetadata
+        } = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
@@ -35184,8 +35698,22 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             transactionMetadata: extendedTransactionMetadata
           });
         } else {
-          logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
-          return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
+          logger.error(
+            "error moving assets to vault: extendedStatus: ${extendedStatus}"
+          );
+          return [
+            this.createTransactionResult(
+              [],
+              status,
+              {
+                from: Protocols.VAULT.name,
+                to: Protocols.NONE.name,
+                amount
+              },
+              "NONE",
+              "WITHDRAWAL" /* WITHDRAWAL */
+            )
+          ];
         }
       }
       const withdrawCall = await this.getBringLiquidityCall({
@@ -35207,7 +35735,19 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       return transactionResults;
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
+      return [
+        this.createTransactionResult(
+          [],
+          false,
+          {
+            from: Protocols.VAULT.name,
+            to: Protocols.NONE.name,
+            amount
+          },
+          "NONE",
+          "WITHDRAWAL" /* WITHDRAWAL */
+        )
+      ];
     }
   }
   async getAUM() {
@@ -35259,8 +35799,12 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       const txnsToBeExecuted = txnData.filter((txn) => {
         return txn.transactionMetadata.transactionType !== "NONE" && txn.transactionMetadata.protocolFrom !== "" && txn.transactionMetadata.protocolTo !== "";
       });
-      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap((txn) => txn.calls);
-      const txnMetadata = txnsToBeExecuted.map((txn) => txn.transactionMetadata);
+      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap(
+        (txn) => txn.calls
+      );
+      const txnMetadata = txnsToBeExecuted.map(
+        (txn) => txn.transactionMetadata
+      );
       return { callsToBeExecutedFinal, txnMetadata };
     } catch (err) {
       logger.error(`error processing transaction data from SDK: ${err}`);
@@ -35290,23 +35834,42 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     if (!vesuAdapter || !extendedAdapter) {
       return new Web3Number(0, 0);
     }
-    const extendedFundingRate = new Web3Number((await extendedAdapter.getNetAPY()).toFixed(4), 0);
+    const extendedFundingRate = new Web3Number(
+      (await extendedAdapter.getNetAPY()).toFixed(4),
+      0
+    );
     const extendedPositions = await extendedAdapter.getAllOpenPositions();
     if (!extendedPositions || extendedPositions.length === 0) {
       logger.info(`no extended positions found`);
       return new Web3Number(0, 0);
     }
-    const extendePositionSizeUSD = new Web3Number(extendedPositions[0].value || 0, 0);
+    const extendePositionSizeUSD = new Web3Number(
+      extendedPositions[0].value || 0,
+      0
+    );
     const vesuPositions = await vesuAdapter.getPositions();
     const vesuSupplyApy = vesuPositions[0].apy.apy;
-    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
-    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    const vesuCollateralSizeUSD = new Web3Number(
+      vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS
+    );
+    const vesuDebtSizeUSD = new Web3Number(
+      vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS
+    );
     const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
     const num22 = vesuCollateralSizeUSD.multipliedBy(vesuSupplyApy);
     const num32 = vesuDebtSizeUSD.abs();
     const maxBorrowApy = num1.plus(num22).minus(0.1).dividedBy(num32);
-    const vesuMaxBorrowableAmount = await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxBorrowApy.toNumber());
-    return new Web3Number(vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    const vesuMaxBorrowableAmount = await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(
+      this.config,
+      vesuAdapter.config.debt,
+      maxBorrowApy.toNumber()
+    );
+    return new Web3Number(
+      vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS
+    );
   }
   async getVesuHealthFactors() {
     const vesuAdapter = await this.getVesuAdapter();
@@ -35315,18 +35878,33 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       return [0, 0];
     }
     const vesuPositions = await vesuAdapter.getPositions();
-    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
-    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const vesuCollateralSizeUSD = new Web3Number(
+      vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      0
+    );
+    const vesuDebtSizeUSD = new Web3Number(
+      vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS),
+      0
+    );
     const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
     logger.info(`actualLtv: ${actualLtv.toNumber()}`);
-    const maxLtv = new Web3Number(await vesuAdapter.vesuAdapter.getLTVConfig(this.config), 4);
-    const healthFactor = new Web3Number(maxLtv.dividedBy(actualLtv).toFixed(4), 4);
+    const maxLtv = new Web3Number(
+      await vesuAdapter.vesuAdapter.getLTVConfig(this.config),
+      4
+    );
+    const healthFactor = new Web3Number(
+      maxLtv.dividedBy(actualLtv).toFixed(4),
+      4
+    );
     logger.info(`healthFactor: ${healthFactor.toNumber()}`);
     const extendedBalance = await extendedAdapter.getExtendedDepositAmount();
     if (!extendedBalance) {
       return [0, 0];
     }
-    const extendedLeverage = new Web3Number((Number(extendedBalance.marginRatio) * 100).toFixed(4), 4);
+    const extendedLeverage = new Web3Number(
+      (Number(extendedBalance.marginRatio) * 100).toFixed(4),
+      4
+    );
     logger.info(`extendedLeverage: ${extendedLeverage.toNumber()}`);
     return [healthFactor.toNumber(), extendedLeverage.toNumber()];
   }
@@ -35347,12 +35925,16 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         splits: []
       };
     }
-    let vesuPositions = allPositions.filter((item) => item.protocol === Protocols.VESU);
+    let vesuPositions = allPositions.filter(
+      (item) => item.protocol === Protocols.VESU
+    );
     vesuPositions.map((item) => {
       item.apy.apy = item.apy.apy * 0.1;
     });
     const extendedPositions = await extendedAdapter.getAllOpenPositions();
-    const usdcToken = Global.getDefaultTokens().find((token) => token.symbol === "USDC");
+    const usdcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC"
+    );
     if (!extendedPositions || !usdcToken) {
       return {
         net: 0,
@@ -35365,7 +35947,10 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) + Number(extendedEquity);
     console.log(totalHoldingsUSDValue);
     const extendedPositionSizeMultipliedByApy = Number(extendedPosition.value) * extendedApy;
-    let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) + extendedPositionSizeMultipliedByApy;
+    let weightedAPYs = allPositions.reduce(
+      (acc, curr) => acc + curr.apy.apy * curr.usdValue,
+      0
+    ) + extendedPositionSizeMultipliedByApy;
     console.log(weightedAPYs);
     const netAPY = weightedAPYs / totalHoldingsUSDValue;
     console.log(netAPY);
@@ -35379,13 +35964,22 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     });
     return {
       net: netAPY,
-      splits: allPositions.map((p) => ({ apy: p.apy.apy, id: p.remarks ?? "" }))
+      splits: allPositions.map((p) => ({
+        apy: p.apy.apy,
+        id: p.remarks ?? ""
+      }))
     };
   }
   async getWalletHoldings() {
-    const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
-    const wbtcToken = Global.getDefaultTokens().find((token) => token.symbol === "WBTC");
-    const usdcToken = Global.getDefaultTokens().find((token) => token.symbol === "USDC");
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
+    const wbtcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "WBTC"
+    );
+    const usdcToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDC"
+    );
     if (!usdceToken || !wbtcToken || !usdcToken) {
       return [];
     }
@@ -35459,9 +36053,7 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
   });
   const extendedAdapter = new ExtendedAdapter({
     ...baseAdapterConfig,
-    supportedPositions: [
-      { asset: usdcToken, isDebt: true }
-    ],
+    supportedPositions: [{ asset: usdcToken, isDebt: true }],
     vaultIdExtended,
     extendedContract: EXTENDED_CONTRACT,
     extendedBackendWriteUrl,
@@ -35518,11 +36110,11 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     asset: wbtcToken.address
   });
   vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(
-    () => vesuMultiplyAdapter.getWithdrawLeaf()
+    () => extendedAdapter.getSwapFromLegacyLeaf()
   );
-  vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
-  vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(
@@ -35567,29 +36159,70 @@ function VaultDescription2(lstSymbol, underlyingSymbol) {
       " to create leverage. Depositors receive vault shares that represent a proportional claim on the underlying assets and accrued yield."
     ] }),
     /* @__PURE__ */ jsxs4("p", { style: { fontSize: "14px", lineHeight: "1.5", marginBottom: "16px" }, children: [
-      "This vault uses Vesu for lending and borrowing. The oracle used by this pool is a ",
-      highlightTextWithLinks("conversion rate oracle", [{ highlight: "conversion rate oracle", link: "https://docs.pragma.build/starknet/development#conversion-rate" }]),
+      "This vault uses Vesu for lending and borrowing. The oracle used by this pool is a",
+      " ",
+      highlightTextWithLinks("conversion rate oracle", [
+        {
+          highlight: "conversion rate oracle",
+          link: "https://docs.pragma.build/starknet/development#conversion-rate"
+        }
+      ]),
       " ",
       "which is resilient to liquidity issues and price volatility, hence reducing the risk of liquidation. However, overtime, if left un-monitored, debt can increase enough to trigger a liquidation. But no worries, our continuous monitoring systems look for situations with reduced health factor and balance collateral/debt to bring it back to safe levels. With Troves, you can have a peaceful sleep."
     ] }),
-    /* @__PURE__ */ jsx5("div", { style: { backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }, children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
-      /* @__PURE__ */ jsx5("strong", { children: "Withdrawals:" }),
-      " Requests can take up to ",
-      /* @__PURE__ */ jsx5("strong", { children: "1-2 hours" }),
-      " to process as the vault unwinds and settles routing."
-    ] }) }),
-    /* @__PURE__ */ jsx5("div", { style: { backgroundColor: "#222", padding: "10px", borderRadius: "8px", marginBottom: "20px", border: "1px solid #444" }, children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
-      /* @__PURE__ */ jsx5("strong", { children: "Debt limits:" }),
-      " Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited Tokens remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on Yield token's APY, its only on added gain."
-    ] }) })
+    /* @__PURE__ */ jsx5(
+      "div",
+      {
+        style: {
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444"
+        },
+        children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
+          /* @__PURE__ */ jsx5("strong", { children: "Withdrawals:" }),
+          " Requests can take up to",
+          " ",
+          /* @__PURE__ */ jsx5("strong", { children: "1-2 hours" }),
+          " to process as the vault unwinds and settles routing."
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      "div",
+      {
+        style: {
+          backgroundColor: "#222",
+          padding: "10px",
+          borderRadius: "8px",
+          marginBottom: "20px",
+          border: "1px solid #444"
+        },
+        children: /* @__PURE__ */ jsxs4("p", { style: { fontSize: "13px", color: "#ccc" }, children: [
+          /* @__PURE__ */ jsx5("strong", { children: "Debt limits:" }),
+          " Pools on Vesu have debt caps that are gradually increased over time. Until caps are raised, deposited Tokens remain in the vault, generating a shared net return for all depositors. There is no additional fee taken by Troves on Yield token's APY, its only on added gain."
+        ] })
+      }
+    )
   ] });
 }
 var re7UsdcPrimeDevansh = {
-  vaultAddress: ContractAddr.from("0x058905be22d6a81792df79425dc9641cf3e1b77f36748631b7d7e5d713a32b55"),
-  manager: ContractAddr.from("0x02648d703783feb2d967cf0520314cb5aa800d69a9426f3e3b317395af44de16"),
-  vaultAllocator: ContractAddr.from("0x07d533c838eab6a4d854dd3aea96a55993fccd35821921970d00bde946b63b6f"),
-  redeemRequestNFT: ContractAddr.from("0x01ef91f08fb99729c00f82fc6e0ece37917bcc43952596c19996259dc8adbbba"),
-  aumOracle: ContractAddr.from("0x030b6acfec162f5d6e72b8a4d2798aedce78fb39de78a8f549f7cd277ae8bc8d"),
+  vaultAddress: ContractAddr.from(
+    "0x058905be22d6a81792df79425dc9641cf3e1b77f36748631b7d7e5d713a32b55"
+  ),
+  manager: ContractAddr.from(
+    "0x02648d703783feb2d967cf0520314cb5aa800d69a9426f3e3b317395af44de16"
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x07d533c838eab6a4d854dd3aea96a55993fccd35821921970d00bde946b63b6f"
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x01ef91f08fb99729c00f82fc6e0ece37917bcc43952596c19996259dc8adbbba"
+  ),
+  aumOracle: ContractAddr.from(
+    "0x030b6acfec162f5d6e72b8a4d2798aedce78fb39de78a8f549f7cd277ae8bc8d"
+  ),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.4,
@@ -35601,13 +36234,29 @@ var re7UsdcPrimeDevansh = {
     "0.001",
     Global.getDefaultTokens().find((token) => token.symbol === "WBTC").decimals
   ),
-  borrowable_assets: [Global.getDefaultTokens().find((token) => token.symbol === "WBTC")],
+  borrowable_assets: [
+    Global.getDefaultTokens().find((token) => token.symbol === "WBTC")
+  ],
   minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
   walletAddress: WALLET_ADDRESS
 };
 var VesuExtendedTestStrategies = (extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) => {
   return [
-    getStrategySettingsVesuExtended("WBTC", "USDC", re7UsdcPrimeDevansh, false, false, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing)
+    getStrategySettingsVesuExtended(
+      "WBTC",
+      "USDC",
+      re7UsdcPrimeDevansh,
+      false,
+      false,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing
+    )
   ];
 };
 function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses, isPreview = false, isLST, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
@@ -35617,8 +36266,25 @@ function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses,
     address: addresses.vaultAddress,
     launchBlock: 0,
     type: "Other",
-    depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === underlyingSymbol)],
-    additionalInfo: getLooperSettings2(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7USDCPrime, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
+    depositTokens: [
+      Global.getDefaultTokens().find(
+        (token) => token.symbol === underlyingSymbol
+      )
+    ],
+    additionalInfo: getLooperSettings2(
+      lstSymbol,
+      underlyingSymbol,
+      addresses,
+      VesuPools.Re7USDCPrime,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing
+    ),
     risk: {
       riskFactor: _riskFactor3,
       netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
@@ -39942,8 +40608,10 @@ export {
   calculateBTCPriceDelta,
   calculateDebtAmount,
   calculateDebtReductionAmountForWithdrawal,
+  calculateDeltaDebtAmount,
   calculateExposureDelta,
   calculateExtendedLevergae,
+  calculatePositionToCloseToWithdrawAmount,
   calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage,
   calculateWBTCAmountToMaintainLTV,