@strkfarm/sdk 2.0.0-dev.1 → 2.0.0-dev.2

package/dist/index.mjs

@@ -4400,6 +4400,7 @@ var EkuboQuoter = class _EkuboQuoter {
     return quote.splits.map((split) => {
       const isNegativeAmount = BigInt(split.amount_specified) <= 0n;
       const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
+      console.log("token for withdrawal", token, isNegativeAmount);
       return {
         route: split.route.map((_route) => ({
           pool_key: {
@@ -28021,6 +28022,7 @@ var vesu_multiple_abi_default = [
 var AVNU_API = "https://starknet.api.avnu.fi/swap/v2/quotes";
 var USDC_TOKEN_DECIMALS = 6;
 var USDC_TOKEN_ADDRESS = "0x053C91253BC9682c04929cA02ED00b3E423f6710D2ee7e0D5EBB06F3eCF368A8";
+var BUFFER_USDC_IN_WITHDRAWAL = 5;
 var WBTC_TOKEN_ADDRESS = "0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac";
 var WBTC_TOKEN_DECIMALS = 8;
 var MAINTENANCE_MARGIN = 0.01;
@@ -28112,8 +28114,8 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       logger.error("error getting extended positions");
       return null;
     }
-    const extendedBTCExposure = extendedPosition.length > 0 ? new Web3Number(extendedPosition[0].size, WBTC_TOKEN_DECIMALS) : new Web3Number(0, WBTC_TOKEN_DECIMALS);
-    const extendedExposureUSD = extendedBTCExposure.multipliedBy(collateralPrice);
+    const extendedExposureUSD = extendedPosition.length > 0 ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS) : new Web3Number(0, USDC_TOKEN_DECIMALS);
+    console.log("THe collateral is", collateralPrice, collateralUnits);
     const vesuExposureUSD = collateralUnits.multipliedBy(collateralPrice);
     if (vesuExposureUSD.lessThan(0)) {
       return {
@@ -28131,9 +28133,14 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
         vesu_leverage
       };
     }
+    console.log("the vesu exposure usd is", vesuExposureUSD.toNumber());
+    console.log("the extended exposure usd is", extendedExposureUSD.toNumber());
+    console.log("the amount in usdc is", amountInUsdc.toNumber());
+    console.log("the extended leverage is", extended_leverage);
+    console.log("the vesu leverage is", vesu_leverage);
     const numerator1 = amountInUsdc.multipliedBy(extended_leverage);
-    const numerator2 = vesuExposureUSD.multipliedBy(vesu_leverage);
-    const numerator3 = extendedExposureUSD.multipliedBy(extended_leverage).multipliedBy(-1);
+    const numerator2 = vesuExposureUSD;
+    const numerator3 = extendedExposureUSD.multipliedBy(-1);
     const finalNumerator = numerator1.plus(numerator2).plus(numerator3);
     const denominator = extended_leverage + vesu_leverage;
     const vesuAmountInUSDC = finalNumerator.dividedBy(denominator);
@@ -28143,6 +28150,7 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       "the extended amount in usdc is",
       extendedAmountInUSDC.toNumber()
     );
+    await new Promise((resolve) => setTimeout(resolve, 1e4));
     return {
       vesu_amount: vesuAmountInUSDC,
       extended_amount: extendedAmountInUSDC,
@@ -28583,7 +28591,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           this.config.debt.address.toBigInt(),
           this.config.vaultAllocator.toBigInt()
         ],
-        sanitizer: SIMPLE_SANITIZER_V2,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
         // vmw = vesu multiply withdraw
         id: `vmw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
       },
@@ -28732,7 +28740,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       },
       // Vesu multiply call
       {
-        sanitizer: SIMPLE_SANITIZER_V2,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
         call: {
           contractAddress: vesuMultiply,
           selector: hash5.getSelectorFromName("modify_lever"),
@@ -28820,19 +28828,13 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, debtToken, collateralToken);
           const MAX_SLIPPAGE = 2e-3;
           if (debtAmount.greaterThan(0)) {
-            console.log("debtAmountInCollateralUnits", debtAmountInCollateralUnits.toNumber());
-            leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(debtToken, collateralToken, debtAmount, MAX_SLIPPAGE);
-            const anotherleverSwapLimitAmount = debtAmount.multipliedBy(1 + MAX_SLIPPAGE);
-            console.log("anotherleverSwapLimitAmount", anotherleverSwapLimitAmount, leverSwapLimitAmount);
+            leverSwapLimitAmount = debtAmount.multipliedBy(1 + MAX_SLIPPAGE);
           } else if (debtAmount.lessThan(0)) {
-            leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(collateralToken, debtToken, debtAmountInCollateralUnits.multipliedBy(-1), MAX_SLIPPAGE);
-            const anotherleverSwapLimitAmount = debtAmount.abs().multipliedBy(1 - MAX_SLIPPAGE);
-            console.log("anotherleverSwapLimitAmount", anotherleverSwapLimitAmount, leverSwapLimitAmount);
+            leverSwapLimitAmount = debtAmount.abs().multipliedBy(1 - MAX_SLIPPAGE);
           } else {
             leverSwapLimitAmount = Web3Number.fromWei(0, this.config.debt.decimals);
           }
           await new Promise((resolve) => setTimeout(resolve, 1e4));
-          console.log("leverSwapLimitAmount", leverSwapLimitAmount);
         } else {
           throw new Error(`VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`);
         }
@@ -28902,26 +28904,23 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       debtPrice.price,
       debtToken.decimals
     );
-    console.log("debtAmountToRepay", debtAmountToRepay);
     if (!debtAmountToRepay) {
       throw new Error("error calculating debt amount to repay");
     }
     const ekuboQuoter = new EkuboQuoter(this.config.networkConfig, this.config.pricer);
     const debtInDebtUnits = new Web3Number(debtAmountToRepay, debtToken.decimals).dividedBy(debtPrice.price).multipliedBy(10 ** debtToken.decimals);
-    const debtInCollateralUnits = new Web3Number(debtAmountToRepay, debtToken.decimals).dividedBy(collateralPrice.price).multipliedBy(10 ** collateralToken.decimals);
     const swapQuote = await ekuboQuoter.getQuote(
       debtToken.address.address,
       collateralToken.address.address,
       debtInDebtUnits
     );
     const MAX_SLIPPAGE = 2e-3;
-    if (swapQuote.price_impact < 0.025) {
-      leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, debtToken, collateralToken);
+    if (swapQuote.price_impact < 25e-4) {
+      leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, collateralToken, debtToken);
     } else {
       logger.error(`VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`);
     }
-    const anotherLeverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(collateralToken, debtToken, debtInDebtUnits, MAX_SLIPPAGE);
-    leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(debtToken, collateralToken, debtInCollateralUnits, MAX_SLIPPAGE);
+    leverSwapLimitAmount = new Web3Number(debtAmountToRepay, debtToken.decimals).abs().multipliedBy(1 + MAX_SLIPPAGE);
     const multiplyParams = await this.getLeverParams(false, params, leverSwap, leverSwapLimitAmount);
     const call = multiplyContract.populate("modify_lever", {
       modify_lever_params: this.formatMultiplyParams(false, multiplyParams)
@@ -29493,6 +29492,41 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       }
     ];
   }
+  getSwapFromLegacyLeaf() {
+    const leafConfigs = this._getSwapFromLegacyLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      const leaf = this.constructSimpleLeafData({
+        id,
+        target,
+        method,
+        packedArguments
+      }, sanitizer);
+      return leaf;
+    });
+    return { leaves, callConstructor: this.getSwapFromLegacyCall.bind(this) };
+  }
+  _getSwapFromLegacyLeaf() {
+    const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
+    return [
+      {
+        target: usdceToken.address,
+        method: "approve",
+        packedArguments: [
+          AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()
+        ],
+        id: `extendedswaplegacyapprove_${usdceToken.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER
+      },
+      {
+        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+        method: "swap_to_new",
+        packedArguments: [],
+        id: `extended_swap_to_new_${usdceToken.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER
+      }
+    ];
+  }
   _getWithdrawLeaf() {
     return [];
   }
@@ -29573,6 +29607,70 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       return [];
     }
   }
+  getProofsForFromLegacySwap(tree) {
+    let proofGroups = [];
+    const ids = this.getSwapFromLegacyLeaf().leaves.map((l) => l.readableId);
+    for (const [i, v] of tree.entries()) {
+      if (ids.includes(v.readableId)) {
+        proofGroups.push(tree.getProof(i));
+      }
+    }
+    if (proofGroups.length != ids.length) {
+      throw new Error(`Not all proofs found for IDs: ${ids.join(", ")}`);
+    }
+    return {
+      proofs: proofGroups,
+      callConstructor: this.getSwapFromLegacyCall.bind(this)
+    };
+  }
+  async getSwapFromLegacyCall(params) {
+    try {
+      const usdcToken = this.config.supportedPositions[0].asset;
+      const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
+      const amount = uint25613.bnToUint256(params.amount.multipliedBy(10).toWei());
+      const quotes = await this.config.avnuAdapter.getQuotesAvnu(
+        usdceToken.address.toString(),
+        usdcToken.address.toString(),
+        params.amount.toNumber(),
+        this.config.avnuAdapter.config.vaultAllocator.address.toString(),
+        usdcToken.decimals,
+        false
+      );
+      if (!quotes) {
+        logger.error("error getting quotes from avnu");
+        return [];
+      }
+      const getCalldata = await this.config.avnuAdapter.getSwapCallData(quotes);
+      const swapCallData = getCalldata[0];
+      return [
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: usdceToken.address,
+            selector: hash6.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+              toBigInt(amount.low.toString()),
+              // amount low
+              toBigInt(amount.high.toString())
+              // amount high
+            ]
+          }
+        },
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+            selector: hash6.getSelectorFromName("swap_to_new"),
+            calldata: swapCallData
+          }
+        }
+      ];
+    } catch (error) {
+      logger.error(`Error creating Deposit Call: ${error}`);
+      return [];
+    }
+  }
   //Swap wbtc to usdc
   async getWithdrawCall(params) {
     try {
@@ -29590,10 +29688,10 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       if (!this.client) {
         throw new Error("Client not initialized");
       }
-      const withdrawalRequest = this.client.withdrawUSDC(amount.toString());
-      if ((await withdrawalRequest).status === "OK") {
-        console.log("Withdrawal request successful");
-        return true;
+      const withdrawalRequest = await this.client.withdrawUSDC(amount.toFixed(2));
+      if (withdrawalRequest.status === "OK") {
+        const withdrawalStatus = await this.getDepositOrWithdrawalStatus(withdrawalRequest.data, "WITHDRAWAL" /* WITHDRAWAL */);
+        return withdrawalStatus;
       }
       return false;
     } catch (error) {
@@ -29774,7 +29872,7 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       logger.error(`createShortOrder failed on attempt ${attempt}: ${err.message}`);
       if (attempt < maxAttempts) {
         const backoff = 1200 * attempt;
-        console.log(`Retrying after ${backoff}ms...`);
+        logger.info(`Retrying after ${backoff}ms...`);
         await new Promise((resolve) => setTimeout(resolve, backoff));
         return this.createOrder(
           leverage,
@@ -29805,7 +29903,7 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       }
       return null;
     } catch (err) {
-      console.log("Error opening short extended position", err);
+      logger.error(`Error opening short extended position, ${err}`);
       return null;
     }
   }
@@ -29815,17 +29913,16 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         operationsType: [operationsType],
         operationsStatus: ["COMPLETED" /* COMPLETED */]
       });
-      console.log("transferHistory", transferHistory);
       if (operationsType === "DEPOSIT" /* DEPOSIT */) {
         const myTransferStatus = transferHistory.data.find((operation) => operation.transactionHash === orderId);
         if (!myTransferStatus) {
-          return false;
+          return true;
         }
         return true;
       } else {
-        const myTransferStatus = transferHistory.data.find((operation) => operation.id === orderId);
+        const myTransferStatus = transferHistory.data.find((operation) => operation.id.toString() === orderId.toString());
         if (!myTransferStatus) {
-          return false;
+          return true;
         }
         return true;
       }
@@ -33414,7 +33511,7 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
         packedArguments: [
           fromToken.address.toBigInt(),
           //wbtc
-          fromToken.address.toBigInt(),
+          toToken.address.toBigInt(),
           //usdc
           vaultAllocator.toBigInt()
         ],
@@ -33428,13 +33525,11 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
   }
   async getDepositCall(params) {
     try {
-      console.log("params.amount", params.amount);
       const fromToken = this.config.supportedPositions[0].asset;
       const toToken = this.config.supportedPositions[1].asset;
       const vaultAllocator = ContractAddr.from(
         this.config.vaultAllocator.address
       );
-      console.log("vaultAllocator", vaultAllocator);
       const quote = await this.getQuotesAvnu(
         fromToken.address.toString(),
         toToken.address.toString(),
@@ -33490,7 +33585,6 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
       const vaultAllocator = ContractAddr.from(
         this.config.vaultAllocator.address
       );
-      console.log("params.amount", params.amount);
       const quote = await this.getQuotesAvnu(
         fromToken.address.toString(),
         toToken.address.toString(),
@@ -33509,8 +33603,6 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
       );
       const swapCallData = getCalldata[0];
       const amount = uint25614.bnToUint256(params.amount.toWei());
-      console.log("amount", amount);
-      console.log("swapCallData", swapCallData);
       return [
         {
           sanitizer: SIMPLE_SANITIZER,
@@ -33585,14 +33677,12 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
         return dataObject2;
       }
       const btcPrice = await this.getPriceOfToken(toToken.address.toString());
-      console.log("btcPrice", btcPrice);
       if (!btcPrice) {
         logger.error(`error getting btc price: ${btcPrice}`);
         return null;
       }
       const estimatedUsdcAmount = Math.floor(amount * btcPrice);
       const targetBtcBig = BigInt(returnFormattedAmount(amount, toTokenDecimals));
-      console.log("targetBtcBig", targetBtcBig);
       let low = BigInt(
         Math.floor(
           estimatedUsdcAmount * 10 ** fromToken.decimals * 0.9
@@ -33695,6 +33785,23 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       debtPrice
     };
   }
+  async getUnusedBalanceUSDCE() {
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
+    const balance = await new ERC20(this.config).balanceOf(
+      usdceToken.address,
+      WALLET_ADDRESS,
+      usdceToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdceToken.symbol);
+    const usdValue = Number(balance.toFixed(usdceToken.decimals)) * price.price;
+    return {
+      tokenInfo: usdceToken,
+      amount: balance,
+      usdValue
+    };
+  }
   async getUnusedBalanceWBTC() {
     const collateralToken = this.metadata.additionalInfo.borrowable_assets[0];
     const balance = await new ERC20(this.config).balanceOf(
@@ -33740,22 +33847,30 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     }
     return extendedAdapter.adapter;
   }
-  async moveAssetsToVaultAllocator(amount) {
+  async moveAssetsToVaultAllocator(amount, extendedAdapter) {
     try {
-      const usdcToken = Global.getDefaultTokens().find(
-        (token) => token.symbol === "USDC"
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
       );
       const approveCall = new ERC20(this.config).approve(
-        usdcToken.address,
+        usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
         amount
       );
       const transferCall = new ERC20(this.config).transfer(
-        usdcToken.address,
+        usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
         amount
       );
-      return [approveCall, transferCall];
+      const proofsInfo = extendedAdapter.getProofsForFromLegacySwap(
+        this.getMerkleTree()
+      );
+      const proofGroups = proofsInfo.proofs;
+      const call = this.getManageCall(
+        proofGroups,
+        await proofsInfo.callConstructor({ amount })
+      );
+      return [approveCall, transferCall, call];
     } catch (err) {
       logger.error(`error moving assets to vault allocator: ${err}`);
       return [];
@@ -33867,11 +33982,9 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         );
         return calls;
       }
-      console.log("extendedAmount", extendedAmount);
-      console.log("vesuAmount", vesuAmount);
       if (extendedAmount.lessThan(0)) {
         try {
-          const extendedCalls = await this.moveAssets(
+          const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
             {
               to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
@@ -33880,14 +33993,18 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             extendedAdapter,
             vesuAdapter
           );
-          calls.push(...extendedCalls);
+          if (extendedStatus) {
+            calls.push(...extendedCalls);
+          } else {
+            return [];
+          }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
       if (vesuAmount.lessThan(0)) {
         try {
-          const vesuCalls = await this.moveAssets(
+          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VESU.name,
@@ -33897,6 +34014,9 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             vesuAdapter
           );
           calls.push(...vesuCalls);
+          if (!vesuStatus) {
+            return [];
+          }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
         }
@@ -33912,7 +34032,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       );
       if (extendedAmount.minus(usdcAmountOnExtended).greaterThan(0)) {
         try {
-          const extendedCalls = await this.moveAssets(
+          const { calls: extendedCalls } = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VAULT.name,
@@ -33928,15 +34048,18 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       }
       if (vesuAmount.minus(usdcAmountInWallet).greaterThan(0)) {
         try {
-          const vesuCalls = await this.moveAssets(
+          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
             {
-              to: Protocols.VESU.name,
+              to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
               amount: vesuAmount.minus(usdcAmountInWallet)
             },
             extendedAdapter,
             vesuAdapter
           );
+          if (!vesuStatus) {
+            return [];
+          }
           calls.push(...vesuCalls);
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
@@ -33953,9 +34076,12 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return [];
+        return {
+          calls: [],
+          status: false
+        };
       }
-      logger.info("moveAssets params", params);
+      logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
       const {
         collateralPrice
@@ -33972,18 +34098,58 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return calls;
+        return {
+          calls: [call],
+          status: true
+        };
       } 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 {
+            calls: [],
+            status: false
+          };
+        }
+        const extendedHoldingAmount = new Web3Number(
+          extendedHoldings.availableForWithdrawal,
+          USDC_TOKEN_DECIMALS
+        );
+        const leftAmountAfterWithdrawalAmountInAccount = params.amount.minus(extendedHoldingAmount);
+        const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
+        const openLongPosition = await extendedAdapter.createOrder(
+          extendedLeverage.toString(),
+          btcAmount.toNumber(),
+          "BUY" /* BUY */
+        );
+        if (!openLongPosition) {
+          logger.error(`error opening long position: ${openLongPosition}`);
+          return {
+            calls: [],
+            status: false
+          };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 5e3));
         const withdrawalFromExtended = await extendedAdapter.withdrawFromExtended(params.amount);
         if (withdrawalFromExtended) {
-          const calls = await this.moveAssetsToVaultAllocator(params.amount);
+          const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
+          logger.info(`extendedHoldings after withdrawal ${extendedHoldings2}`);
+          await new Promise((resolve) => setTimeout(resolve, 1e4));
+          const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0) {
-            return calls;
+            return {
+              calls,
+              status: true
+            };
           }
         } else {
           logger.error("withdrawal from extended failed");
+          return {
+            calls: [],
+            status: false
+          };
         }
-        return [];
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -34004,7 +34170,10 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return calls;
+        return {
+          calls,
+          status: true
+        };
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -34035,13 +34204,21 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return calls;
+        return {
+          calls,
+          status: true
+        };
       }
-      console.warn("moveAssets received unsupported route:", params);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
   async handleDeposit() {
@@ -34100,8 +34277,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         collateralTokenAmount,
         collateralPrice.price
       );
-      console.log("vesuAmountInBTC", vesuAmountInBTC);
-      console.log("extendedAmountInBTC", extendedAmountInBTC);
+      logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
       let calls = [];
       if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
         const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
@@ -34114,7 +34290,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         );
         const { amount: wbtcAmountInVaultAllocator } = await this.getUnusedBalanceWBTC();
         if (wbtcAmountInVaultAllocator.lessThan(vesuAmountInBTC)) {
-          console.log("error wbtc amount in vault allocator is less than vesu amount in btc", wbtcAmountInVaultAllocator, vesuAmountInBTC);
+          logger.info(`WBTC amount in vault allocator is less than vesu amount required in WBTC thus swapping, wbtcAmountInVaultAllocator: ${wbtcAmountInVaultAllocator}, vesuAmountInBTC: ${vesuAmountInBTC}`);
           const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
           const swapProofGroups = swapProofsInfo.proofs;
           const swapCall = this.getManageCall(
@@ -34158,7 +34334,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       bid
     } = await extendedAdapter.fetchOrderBookBTCUSDC();
     const price = ask.plus(bid).dividedBy(2);
-    const btcToken = vesuAdapter.config.supportedPositions[1].asset;
+    const btcToken = vesuAdapter.config.supportedPositions[0].asset;
     const btcPriceAvnu = await avnuAdapter.getPriceOfToken(btcToken.address.toString());
     if (!btcPriceAvnu) {
       logger.error(`error getting btc price avnu: ${btcPriceAvnu}`);
@@ -34174,43 +34350,65 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
   async handleWithdraw(amount) {
     try {
       const usdcBalanceVaultAllocator = await this.getUnusedBalance();
-      const usdcBalanceDifference = amount.minus(usdcBalanceVaultAllocator.usdValue);
+      const usdcBalanceDifference = amount.plus(BUFFER_USDC_IN_WITHDRAWAL).minus(usdcBalanceVaultAllocator.usdValue);
       logger.info(`usdcBalanceDifference, ${usdcBalanceDifference.toNumber()}`);
+      let calls = [];
+      let status = true;
       if (usdcBalanceDifference.lessThan(0)) {
-        const withdrawCall = await this.getBringLiquidityCall({
-          amount
+        const withdrawCall2 = await this.getBringLiquidityCall({
+          amount: usdcBalanceVaultAllocator.amount
         });
-        logger.info("withdraw call", withdrawCall);
-        return [withdrawCall];
+        logger.info("withdraw call", withdrawCall2);
+        calls.push(withdrawCall2);
+        return {
+          calls,
+          status: true
+        };
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
       if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        status = false;
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return [];
+        return {
+          calls,
+          status
+        };
       }
       const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
       const {
         collateralPrice
       } = await this.getAssetPrices();
       const extendedPositon = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPositon) {
+        status = false;
+        logger.error("error getting extended position", extendedPositon);
+        return {
+          calls,
+          status
+        };
+      }
       const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
-        amount,
+        usdcBalanceDifference,
         collateralPrice.price,
         collateralTokenAmount,
         extendedPositon
       );
       if (!amountDistributionForWithdrawal) {
+        status = false;
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return [];
+        return {
+          calls,
+          status
+        };
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
-      if (vesu_amount.greaterThan(0)) {
-        const result = await this.moveAssets(
+      if (status && vesu_amount.greaterThan(0)) {
+        const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
@@ -34219,10 +34417,11 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedAdapter,
           vesuAdapter
         );
-        return result;
+        status = vesuStatus;
+        calls.push(...vesuCalls);
       }
-      if (extended_amount.greaterThan(0)) {
-        const result = await this.moveAssets(
+      if (status && extended_amount.greaterThan(0)) {
+        const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
@@ -34231,12 +34430,32 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedAdapter,
           vesuAdapter
         );
-        return result;
+        status = extendedStatus;
+        if (status) {
+          calls.push(...extendedCalls);
+        } else {
+          logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
+          return {
+            calls: [],
+            status
+          };
+        }
       }
-      return [];
+      const withdrawCall = await this.getBringLiquidityCall({
+        amount
+      });
+      logger.info("withdraw call", withdrawCall);
+      calls.push(withdrawCall);
+      return {
+        calls,
+        status
+      };
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
   async getAUM() {
@@ -34370,6 +34589,7 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     () => vesuMultiplyAdapter.getWithdrawLeaf()
   );
   vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(