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

package/dist/index.browser.global.js

@@ -56069,6 +56069,7 @@ ${JSON.stringify(data, null, 2)}`;
       return quote.splits.map((split2) => {
         const isNegativeAmount = BigInt(split2.amount_specified) <= 0n;
         const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
+        console.log("token for withdrawal", token, isNegativeAmount);
         return {
           route: split2.route.map((_route) => ({
             pool_key: {
@@ -92375,6 +92376,7 @@ spurious results.`);
   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;
@@ -92466,8 +92468,8 @@ spurious results.`);
         logger2.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 {
@@ -92485,9 +92487,14 @@ spurious results.`);
           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);
@@ -92497,6 +92504,7 @@ spurious results.`);
         "the extended amount in usdc is",
         extendedAmountInUSDC.toNumber()
       );
+      await new Promise((resolve) => setTimeout(resolve, 1e4));
       return {
         vesu_amount: vesuAmountInUSDC,
         extended_amount: extendedAmountInUSDC,
@@ -92937,7 +92945,7 @@ spurious results.`);
             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}`
         },
@@ -93086,7 +93094,7 @@ spurious results.`);
         },
         // Vesu multiply call
         {
-          sanitizer: SIMPLE_SANITIZER_V2,
+          sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
           call: {
             contractAddress: vesuMultiply,
             selector: hash_exports.getSelectorFromName("modify_lever"),
@@ -93174,19 +93182,13 @@ spurious results.`);
             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`);
           }
@@ -93256,26 +93258,23 @@ spurious results.`);
         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 {
         logger2.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)
@@ -93509,6 +93508,41 @@ spurious results.`);
         }
       ];
     }
+    getSwapFromLegacyLeaf() {
+      const leafConfigs = this._getSwapFromLegacyLeaf();
+      const leaves = leafConfigs.map((config3) => {
+        const { target, method, packedArguments, sanitizer, id } = config3;
+        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 [];
     }
@@ -93589,6 +93623,70 @@ spurious results.`);
         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 = uint256_exports.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) {
+          logger2.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: hash_exports.getSelectorFromName("approve"),
+              calldata: [
+                AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+                toBigInt3(amount.low.toString()),
+                // amount low
+                toBigInt3(amount.high.toString())
+                // amount high
+              ]
+            }
+          },
+          {
+            sanitizer: AVNU_LEGACY_SANITIZER,
+            call: {
+              contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+              selector: hash_exports.getSelectorFromName("swap_to_new"),
+              calldata: swapCallData
+            }
+          }
+        ];
+      } catch (error2) {
+        logger2.error(`Error creating Deposit Call: ${error2}`);
+        return [];
+      }
+    }
     //Swap wbtc to usdc
     async getWithdrawCall(params) {
       try {
@@ -93606,10 +93704,10 @@ spurious results.`);
         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 (error2) {
@@ -93790,7 +93888,7 @@ spurious results.`);
         logger2.error(`createShortOrder failed on attempt ${attempt}: ${err2.message}`);
         if (attempt < maxAttempts) {
           const backoff = 1200 * attempt;
-          console.log(`Retrying after ${backoff}ms...`);
+          logger2.info(`Retrying after ${backoff}ms...`);
           await new Promise((resolve) => setTimeout(resolve, backoff));
           return this.createOrder(
             leverage,
@@ -93821,7 +93919,7 @@ spurious results.`);
         }
         return null;
       } catch (err2) {
-        console.log("Error opening short extended position", err2);
+        logger2.error(`Error opening short extended position, ${err2}`);
         return null;
       }
     }
@@ -93831,17 +93929,16 @@ spurious results.`);
           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;
         }
@@ -97425,7 +97522,7 @@ spurious results.`);
           packedArguments: [
             fromToken.address.toBigInt(),
             //wbtc
-            fromToken.address.toBigInt(),
+            toToken.address.toBigInt(),
             //usdc
             vaultAllocator.toBigInt()
           ],
@@ -97439,13 +97536,11 @@ spurious results.`);
     }
     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(),
@@ -97501,7 +97596,6 @@ spurious results.`);
         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(),
@@ -97520,8 +97614,6 @@ spurious results.`);
         );
         const swapCallData = getCalldata[0];
         const amount = uint256_exports.bnToUint256(params.amount.toWei());
-        console.log("amount", amount);
-        console.log("swapCallData", swapCallData);
         return [
           {
             sanitizer: SIMPLE_SANITIZER,
@@ -97596,14 +97688,12 @@ spurious results.`);
           return dataObject2;
         }
         const btcPrice = await this.getPriceOfToken(toToken.address.toString());
-        console.log("btcPrice", btcPrice);
         if (!btcPrice) {
           logger2.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
@@ -97706,6 +97796,23 @@ spurious results.`);
         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(
@@ -97751,22 +97858,30 @@ spurious results.`);
       }
       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 (err2) {
         logger2.error(`error moving assets to vault allocator: ${err2}`);
         return [];
@@ -97878,11 +97993,9 @@ spurious results.`);
           );
           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,
@@ -97891,14 +98004,18 @@ spurious results.`);
               extendedAdapter,
               vesuAdapter
             );
-            calls.push(...extendedCalls);
+            if (extendedStatus) {
+              calls.push(...extendedCalls);
+            } else {
+              return [];
+            }
           } catch (err2) {
             logger2.error(`Failed moving assets to vault: ${err2}`);
           }
         }
         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,
@@ -97908,6 +98025,9 @@ spurious results.`);
               vesuAdapter
             );
             calls.push(...vesuCalls);
+            if (!vesuStatus) {
+              return [];
+            }
           } catch (err2) {
             logger2.error(`Failed moving assets to vault: ${err2}`);
           }
@@ -97923,7 +98043,7 @@ spurious results.`);
         );
         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,
@@ -97939,15 +98059,18 @@ spurious results.`);
         }
         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 (err2) {
             logger2.error(`Failed moving assets to vault: ${err2}`);
@@ -97964,9 +98087,12 @@ spurious results.`);
         const avnuAdapter = await this.getAvnuAdapter();
         if (!avnuAdapter) {
           logger2.error(`avnu adapter not found: ${avnuAdapter}`);
-          return [];
+          return {
+            calls: [],
+            status: false
+          };
         }
-        logger2.info("moveAssets params", params);
+        logger2.info(`moveAssets params, ${JSON.stringify(params)}`);
         const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
         const {
           collateralPrice
@@ -97983,18 +98109,58 @@ spurious results.`);
             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) {
+            logger2.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) {
+            logger2.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();
+            logger2.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 {
             logger2.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(),
@@ -98015,7 +98181,10 @@ spurious results.`);
             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(),
@@ -98046,13 +98215,21 @@ spurious results.`);
             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 (err2) {
         logger2.error(`error moving assets: ${err2}`);
-        return [];
+        return {
+          calls: [],
+          status: false
+        };
       }
     }
     async handleDeposit() {
@@ -98111,8 +98288,7 @@ spurious results.`);
           collateralTokenAmount,
           collateralPrice.price
         );
-        console.log("vesuAmountInBTC", vesuAmountInBTC);
-        console.log("extendedAmountInBTC", extendedAmountInBTC);
+        logger2.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
         let calls = [];
         if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
           const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
@@ -98125,7 +98301,7 @@ spurious results.`);
           );
           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);
+            logger2.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(
@@ -98169,7 +98345,7 @@ spurious results.`);
         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) {
         logger2.error(`error getting btc price avnu: ${btcPriceAvnu}`);
@@ -98185,43 +98361,65 @@ spurious results.`);
     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);
         logger2.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
           });
-          logger2.info("withdraw call", withdrawCall);
-          return [withdrawCall];
+          logger2.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;
           logger2.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;
+          logger2.error("error getting extended position", extendedPositon);
+          return {
+            calls,
+            status
+          };
+        }
         const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
-          amount,
+          usdcBalanceDifference,
           collateralPrice.price,
           collateralTokenAmount,
           extendedPositon
         );
         if (!amountDistributionForWithdrawal) {
+          status = false;
           logger2.error(
             `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
           );
-          return [];
+          return {
+            calls,
+            status
+          };
         }
         const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
-        if (vesu_amount.greaterThan(0)) {
-          const result2 = await this.moveAssets(
+        if (status && vesu_amount.greaterThan(0)) {
+          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
             {
               amount: vesu_amount,
               from: Protocols.VESU.name,
@@ -98230,10 +98428,11 @@ spurious results.`);
             extendedAdapter,
             vesuAdapter
           );
-          return result2;
+          status = vesuStatus;
+          calls.push(...vesuCalls);
         }
-        if (extended_amount.greaterThan(0)) {
-          const result2 = await this.moveAssets(
+        if (status && extended_amount.greaterThan(0)) {
+          const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
             {
               amount: extended_amount,
               from: Protocols.EXTENDED.name,
@@ -98242,12 +98441,32 @@ spurious results.`);
             extendedAdapter,
             vesuAdapter
           );
-          return result2;
+          status = extendedStatus;
+          if (status) {
+            calls.push(...extendedCalls);
+          } else {
+            logger2.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
+            return {
+              calls: [],
+              status
+            };
+          }
         }
-        return [];
+        const withdrawCall = await this.getBringLiquidityCall({
+          amount
+        });
+        logger2.info("withdraw call", withdrawCall);
+        calls.push(withdrawCall);
+        return {
+          calls,
+          status
+        };
       } catch (err2) {
         logger2.error(`error handling withdrawal: ${err2}`);
-        return [];
+        return {
+          calls: [],
+          status: false
+        };
       }
     }
     async getAUM() {
@@ -98381,6 +98600,7 @@ spurious results.`);
       () => 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(