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

package/dist/index.browser.global.js

@@ -28684,6 +28684,7 @@ ${r2}}` : "}", l2;
     OrderType: () => OrderType,
     PRICE_ROUTER: () => PRICE_ROUTER,
     PositionSide: () => PositionSide,
+    PositionTypeAvnuExtended: () => PositionTypeAvnuExtended,
     Pragma: () => Pragma,
     Pricer: () => Pricer,
     PricerBase: () => PricerBase,
@@ -55997,20 +55998,13 @@ ${JSON.stringify(data, null, 2)}`;
     async getDexPrice(baseToken, quoteToken, amount) {
       const lstTokenInfo = baseToken;
       const lstUnderlyingTokenInfo = quoteToken;
-      console.log("lstTokenInfo", lstTokenInfo);
-      console.log("lstUnderlyingTokenInfo", lstUnderlyingTokenInfo);
-      console.log("amount", amount);
       const quote = await this.getQuote(
         lstTokenInfo.address.address,
         lstUnderlyingTokenInfo.address.address,
         amount
       );
-      console.log("quote", quote);
       const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
-      console.log("outputAmount", outputAmount);
-      console.log("amount", amount);
       const price = outputAmount.toNumber() / amount.toNumber();
-      console.log("price", price);
       logger2.verbose(`${_EkuboQuoter.name}:: LST Dex Price: ${price}`);
       return price;
     }
@@ -56029,16 +56023,12 @@ ${JSON.stringify(data, null, 2)}`;
     // debt collateral 
     async getSwapLimitAmount(fromToken, toToken, amount, max_slippage = 2e-3) {
       const isExactAmountIn = amount.greaterThanOrEqualTo(0);
-      console.log("isExactAmountIn", isExactAmountIn);
       logger2.verbose(`${_EkuboQuoter.name}::getSwapLimitAmount isExactAmountIn: ${isExactAmountIn}, fromToken: ${fromToken.symbol}, toToken: ${toToken.symbol}, amount: ${amount}`);
       const isYieldToken = this.tokenMarketData.isAPYSupported(toToken);
       console.log("isYieldToken", isYieldToken);
       const baseToken = isExactAmountIn ? toToken : fromToken;
       const quoteToken = isExactAmountIn ? fromToken : toToken;
-      console.log("baseToken", baseToken);
-      console.log("quoteToken", quoteToken);
       const dexPrice = await this.getDexPrice(baseToken, quoteToken, amount);
-      console.log("dexPrice", dexPrice);
       const trueExchangeRate = isYieldToken ? await this.tokenMarketData.getTruePrice(baseToken) : dexPrice;
       console.log("trueExchangeRate", trueExchangeRate);
       if (isExactAmountIn) {
@@ -92375,6 +92365,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;
@@ -92390,7 +92381,8 @@ spurious results.`);
   var MAX_RETRIES = Number(process.env.MAX_RETRIES ?? 3);
   var MAX_DELAY = Number(process.env.MAX_DELAY ?? 100);
   var EXTEND_MARKET_NAME = "BTC-USD";
-  var LIMIT_BALANCE = Number(process.env.LIMIT_BALANCE ?? 10);
+  var LIMIT_BALANCE = Number(process.env.LIMIT_BALANCE ?? 0.05);
+  var LIMIT_BALANCE_VALUE = 10;
   var REBALANCER_INTERVAL = Number(process.env.REBALANCER_INTERVAL ?? 18e4);
   var WITHDRAWAL_INTERVAL = Number(process.env.WITHDRAWAL_INTERVAL ?? 18e6);
   var INVESTING_INTERVAL = Number(process.env.INVESTING_INTERVAL ?? 18e4);
@@ -92408,8 +92400,6 @@ spurious results.`);
   var MINIMUM_DEBT_AMOUNT_VESU_FOR_REBALANCING = Number(process.env.MINIMUM_DEBT_AMOUNT_VESU_FOR_REBALANCING ?? 1);
   var MINIMUM_EXTENDED_POSITION_SIZE = 1e-4;
   var MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP = 1e-5;
-  var MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED = 700;
-  var MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED = -100;
 
   // src/strategies/vesu-extended-strategy/utils/helper.ts
   var returnFormattedAmount = (amount, toTokenDecimals) => {
@@ -92429,8 +92419,7 @@ spurious results.`);
           vesu_leverage: 0
         };
       }
-      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, WBTC_TOKEN_DECIMALS) : new Web3Number(0, WBTC_TOKEN_DECIMALS);
       const vesuBTCExposureUSD = collateralUnits.multipliedBy(collateralPrice);
       const numerator1 = vesu_leverage * amount + vesuBTCExposureUSD.toNumber();
       const numerator2 = extendedExposureUSD.toNumber();
@@ -92466,8 +92455,7 @@ 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);
       const vesuExposureUSD = collateralUnits.multipliedBy(collateralPrice);
       if (vesuExposureUSD.lessThan(0)) {
         return {
@@ -92485,9 +92473,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 +92490,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,
@@ -92518,10 +92512,10 @@ spurious results.`);
     const extended_leverage_max = 1 / (MAINTENANCE_MARGIN + MAX_PRICE_DROP_PERCENTAGE);
     return Math.floor(extended_leverage_max);
   };
-  var calculateDebtAmount = (collateralAmount, debtAmount, debtPrice, maxLtv = MAX_LTV_BTC_USDC, addedAmount, collateralPrice, isDeposit) => {
+  var calculateDebtAmount = (collateralAmount, debtAmount, debtPrice, maxLtv = MAX_LIQUIDATION_RATIO, addedAmount, collateralPrice, isDeposit) => {
     try {
-      const marginAmount = addedAmount.multipliedBy(isDeposit ? 1 : -1);
-      const numerator1 = collateralAmount.plus(addedAmount).multipliedBy(collateralPrice).multipliedBy(maxLtv);
+      const addedCollateral = addedAmount.multipliedBy(isDeposit ? 1 : -1);
+      const numerator1 = collateralAmount.plus(addedCollateral).multipliedBy(collateralPrice).multipliedBy(maxLtv);
       const numerator2 = debtAmount.multipliedBy(debtPrice).multipliedBy(TARGET_HF);
       const denominator = TARGET_HF - maxLtv;
       const x_debt_usd = numerator1.minus(numerator2).dividedBy(denominator);
@@ -92556,16 +92550,16 @@ spurious results.`);
       const extendedHoldings = await client.getHoldings();
       const extended_leverage = calculateExtendedLevergae();
       const latestPosition = (await client.getPositions()).data.pop();
-      console.log("the latest position is", latestPosition, extendedHoldings);
       if (!extendedHoldings || !latestPosition) {
         logger2.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
         return null;
       }
-      const positionValueInUSD = latestPosition.value;
+      const positionValueInUSD = new Web3Number(latestPosition.value, USDC_TOKEN_DECIMALS);
       const equity = extendedHoldings.data.equity;
-      const deposit = Number(positionValueInUSD) / extended_leverage - Number(equity);
-      return new Web3Number(Math.floor(deposit / 0.2) * 0.2, USDC_TOKEN_DECIMALS);
+      const deposit = positionValueInUSD.dividedBy(extended_leverage).minus(equity).toFixed(2);
+      return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
     } catch (err2) {
+      logger2.error(`error calculating amount deposit on extended when incurring losses: ${err2}`);
       return null;
     }
   };
@@ -92643,21 +92637,36 @@ spurious results.`);
         vaultAllocator: config3.vaultAllocator,
         id: ""
       });
-      this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
+      this.minimumVesuMovementAmount = config3.minimumVesuMovementAmount ?? 5;
+      this.tokenMarketData = new TokenMarketData(
+        this.config.pricer,
+        this.config.networkConfig
+      );
     }
     async getAPY(supportedPosition) {
       const CACHE_KEY = `apy_${this.config.poolId.address}_${supportedPosition.asset.symbol}`;
       const cacheData = this.getCache(CACHE_KEY);
-      console.log(`${_VesuMultiplyAdapter.name}::getAPY cacheData: ${JSON.stringify(cacheData)}`, this.vesuAdapter.config.poolId.shortString(), this.vesuAdapter.config.collateral.symbol, this.vesuAdapter.config.debt.symbol);
+      console.log(
+        `${_VesuMultiplyAdapter.name}::getAPY cacheData: ${JSON.stringify(
+          cacheData
+        )}`,
+        this.vesuAdapter.config.poolId.shortString(),
+        this.vesuAdapter.config.collateral.symbol,
+        this.vesuAdapter.config.debt.symbol
+      );
       if (cacheData) {
         return cacheData;
       }
       try {
         const allVesuPools = await VesuAdapter.getVesuPools();
         const asset = supportedPosition.asset;
-        const pool = allVesuPools.pools.find((p) => this.vesuAdapter.config.poolId.eqString(num_exports.getHexString(p.id)));
+        const pool = allVesuPools.pools.find(
+          (p) => this.vesuAdapter.config.poolId.eqString(num_exports.getHexString(p.id))
+        );
         if (!pool) {
-          logger2.warn(`VesuMultiplyAdapter: Pool not found for token ${asset.symbol}`);
+          logger2.warn(
+            `VesuMultiplyAdapter: Pool not found for token ${asset.symbol}`
+          );
           return {
             apy: 0,
             type: "base" /* BASE */
@@ -92667,7 +92676,9 @@ spurious results.`);
           (a) => a.symbol.toLowerCase() === asset.symbol.toLowerCase()
         )?.stats;
         if (!assetStats) {
-          logger2.warn(`VesuMultiplyAdapter: Asset stats not found for token ${asset.symbol}`);
+          logger2.warn(
+            `VesuMultiplyAdapter: Asset stats not found for token ${asset.symbol}`
+          );
           return {
             apy: 0,
             type: "base" /* BASE */
@@ -92678,7 +92689,9 @@ spurious results.`);
           apy = Number(assetStats.borrowApr?.value || 0) / 1e18;
         } else {
           const isAssetBTC = asset.symbol.toLowerCase().includes("btc");
-          const baseAPY = Number(isAssetBTC ? assetStats.btcFiSupplyApr?.value + assetStats.supplyApy?.value : assetStats.supplyApy?.value || 0) / 1e18;
+          const baseAPY = Number(
+            isAssetBTC ? assetStats.btcFiSupplyApr?.value + assetStats.supplyApy?.value : assetStats.supplyApy?.value || 0
+          ) / 1e18;
           const rewardAPY = Number(assetStats.defiSpringSupplyApr?.value || "0") / 1e18;
           const isSupported = this.tokenMarketData.isAPYSupported(asset);
           apy = baseAPY + rewardAPY;
@@ -92694,7 +92707,10 @@ spurious results.`);
         this.setCache(CACHE_KEY, result2, 3e5);
         return result2;
       } catch (error2) {
-        logger2.error(`VesuMultiplyAdapter: Error getting APY for ${supportedPosition.asset.symbol}:`, error2);
+        logger2.error(
+          `VesuMultiplyAdapter: Error getting APY for ${supportedPosition.asset.symbol}:`,
+          error2
+        );
         throw error2;
       }
     }
@@ -92707,12 +92723,16 @@ spurious results.`);
       try {
         this.vesuAdapter.networkConfig = this.config.networkConfig;
         this.vesuAdapter.pricer = this.config.pricer;
-        const positions = await this.vesuAdapter.getPositions(this.config.networkConfig);
+        const positions = await this.vesuAdapter.getPositions(
+          this.config.networkConfig
+        );
         let position = positions.find(
           (p) => p.token.address.eq(supportedPosition.asset.address)
         );
         if (!position) {
-          logger2.warn(`VesuMultiplyAdapter: Position not found for token ${supportedPosition.asset.symbol}`);
+          logger2.warn(
+            `VesuMultiplyAdapter: Position not found for token ${supportedPosition.asset.symbol}`
+          );
           return {
             amount: new Web3Number("0", supportedPosition.asset.decimals),
             remarks: "Position not found"
@@ -92725,12 +92745,18 @@ spurious results.`);
         this.setCache(CACHE_KEY, position, 6e4);
         return position;
       } catch (error2) {
-        logger2.error(`VesuMultiplyAdapter: Error getting position for ${supportedPosition.asset.symbol}:`, error2);
+        logger2.error(
+          `VesuMultiplyAdapter: Error getting position for ${supportedPosition.asset.symbol}:`,
+          error2
+        );
         throw error2;
       }
     }
     async maxBorrowableAPY() {
-      const collateralAPY = await this.getAPY({ asset: this.config.collateral, isDebt: false });
+      const collateralAPY = await this.getAPY({
+        asset: this.config.collateral,
+        isDebt: false
+      });
       const apy = collateralAPY.apy * 0.8;
       return apy;
     }
@@ -92740,9 +92766,15 @@ spurious results.`);
       try {
         this.vesuAdapter.networkConfig = this.config.networkConfig;
         this.vesuAdapter.pricer = this.config.pricer;
-        const positions = await this.vesuAdapter.getPositions(this.config.networkConfig);
-        const collateralPosition = positions.find((p) => p.token.address.eq(collateral.address));
-        const debtPosition = positions.find((p) => p.token.address.eq(debt.address));
+        const positions = await this.vesuAdapter.getPositions(
+          this.config.networkConfig
+        );
+        const collateralPosition = positions.find(
+          (p) => p.token.address.eq(collateral.address)
+        );
+        const debtPosition = positions.find(
+          (p) => p.token.address.eq(debt.address)
+        );
         if (!collateralPosition || !debtPosition) {
           throw new Error("Could not find current positions");
         }
@@ -92752,13 +92784,23 @@ spurious results.`);
           debt,
           maxBorrowableAPY
         );
-        logger2.verbose(`VesuMultiplyAdapter: Max borrowable: ${maxBorrowable.toNumber()}`);
-        const debtCap = await this.vesuAdapter.getDebtCap(this.config.networkConfig);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Max borrowable: ${maxBorrowable.toNumber()}`
+        );
+        const debtCap = await this.vesuAdapter.getDebtCap(
+          this.config.networkConfig
+        );
         logger2.verbose(`VesuMultiplyAdapter: Debt cap: ${debtCap.toNumber()}`);
         const actualMaxBorrowable = maxBorrowable.minimum(debtCap);
-        logger2.verbose(`VesuMultiplyAdapter: Actual max borrowable: ${actualMaxBorrowable.toNumber()}`);
-        const maxLTV = await this.vesuAdapter.getLTVConfig(this.config.networkConfig);
-        const collateralPrice = await this.config.pricer.getPrice(collateral.symbol);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Actual max borrowable: ${actualMaxBorrowable.toNumber()}`
+        );
+        const maxLTV = await this.vesuAdapter.getLTVConfig(
+          this.config.networkConfig
+        );
+        const collateralPrice = await this.config.pricer.getPrice(
+          collateral.symbol
+        );
         if (collateralPrice.price === 0) {
           throw new Error("Collateral price is 0");
         }
@@ -92776,14 +92818,25 @@ spurious results.`);
         );
         const maxDepositAmount = amount ? amount.minimum(maxCollateralFromDebt) : maxCollateralFromDebt;
         const usdValue = await this.getUSDValue(collateral, maxDepositAmount);
-        logger2.verbose(`VesuMultiplyAdapter: Max deposit::USD value: ${usdValue}, amount: ${maxDepositAmount.toNumber()}`);
-        const apys = await Promise.all([this.getAPY({ asset: collateral, isDebt: false }), this.getAPY({ asset: debt, isDebt: true })]);
-        logger2.verbose(`VesuMultiplyAdapter: Apys: ${apys[0].apy}, ${apys[1].apy}`);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Max deposit::USD value: ${usdValue}, amount: ${maxDepositAmount.toNumber()}`
+        );
+        const apys = await Promise.all([
+          this.getAPY({ asset: collateral, isDebt: false }),
+          this.getAPY({ asset: debt, isDebt: true })
+        ]);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Apys: ${apys[0].apy}, ${apys[1].apy}`
+        );
         const borrowAmountUSD = actualMaxBorrowable.multipliedBy(debtPrice.price);
-        logger2.verbose(`VesuMultiplyAdapter: Borrow amount: ${actualMaxBorrowable.toNumber()}, borrow amount USD: ${borrowAmountUSD.toNumber()}`);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Borrow amount: ${actualMaxBorrowable.toNumber()}, borrow amount USD: ${borrowAmountUSD.toNumber()}`
+        );
         const netCollateralUSD = usdValue + borrowAmountUSD.toNumber();
         const netAPY = (apys[0].apy * netCollateralUSD + apys[1].apy * borrowAmountUSD.toNumber()) / usdValue;
-        logger2.verbose(`VesuMultiplyAdapter: Max deposit amount: ${maxDepositAmount.toNumber()}, netAPY: ${netAPY}`);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Max deposit amount: ${maxDepositAmount.toNumber()}, netAPY: ${netAPY}`
+        );
         return {
           tokenInfo: collateral,
           amount: maxDepositAmount,
@@ -92796,7 +92849,10 @@ spurious results.`);
           protocol: this.protocol
         };
       } catch (error2) {
-        logger2.error(`VesuMultiplyAdapter: Error calculating max deposit:`, error2);
+        logger2.error(
+          `VesuMultiplyAdapter: Error calculating max deposit:`,
+          error2
+        );
         throw error2;
       }
     }
@@ -92806,9 +92862,15 @@ spurious results.`);
       try {
         this.vesuAdapter.networkConfig = this.config.networkConfig;
         this.vesuAdapter.pricer = this.config.pricer;
-        const positions = await this.vesuAdapter.getPositions(this.config.networkConfig);
-        const collateralPosition = positions.find((p) => p.token.address.eq(collateral.address));
-        const debtPosition = positions.find((p) => p.token.address.eq(this.config.debt.address));
+        const positions = await this.vesuAdapter.getPositions(
+          this.config.networkConfig
+        );
+        const collateralPosition = positions.find(
+          (p) => p.token.address.eq(collateral.address)
+        );
+        const debtPosition = positions.find(
+          (p) => p.token.address.eq(this.config.debt.address)
+        );
         if (!collateralPosition || !debtPosition) {
           throw new Error("Could not find current positions");
         }
@@ -92818,11 +92880,20 @@ spurious results.`);
         const result2 = maxWithdrawable.greaterThan(0) ? maxWithdrawable : new Web3Number("0", collateral.decimals);
         const usdValue = await this.getUSDValue(collateral, result2);
         const debtUSD = debtPosition.usdValue;
-        logger2.verbose(`VesuMultiplyAdapter: Debt USD: ${debtUSD}, collateral USD: ${usdValue}`);
-        const apys = await Promise.all([this.getAPY({ asset: collateral, isDebt: false }), this.getAPY({ asset: debt, isDebt: true })]);
-        logger2.verbose(`VesuMultiplyAdapter: Apys: ${apys[0].apy}, ${apys[1].apy}`);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Debt USD: ${debtUSD}, collateral USD: ${usdValue}`
+        );
+        const apys = await Promise.all([
+          this.getAPY({ asset: collateral, isDebt: false }),
+          this.getAPY({ asset: debt, isDebt: true })
+        ]);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Apys: ${apys[0].apy}, ${apys[1].apy}`
+        );
         const netAPY = usdValue - debtUSD > 0 ? (apys[0].apy * usdValue + apys[1].apy * debtUSD) / (usdValue - debtUSD) : 0;
-        logger2.verbose(`VesuMultiplyAdapter: Max withdraw amount: ${result2.toNumber()}, netAPY: ${netAPY}`);
+        logger2.verbose(
+          `VesuMultiplyAdapter: Max withdraw amount: ${result2.toNumber()}, netAPY: ${netAPY}`
+        );
         return {
           tokenInfo: collateral,
           amount: result2,
@@ -92835,14 +92906,19 @@ spurious results.`);
           protocol: this.protocol
         };
       } catch (error2) {
-        logger2.error(`VesuMultiplyAdapter: Error calculating max withdraw:`, error2);
+        logger2.error(
+          `VesuMultiplyAdapter: Error calculating max withdraw:`,
+          error2
+        );
         throw error2;
       }
     }
     _getDepositLeaf() {
       const collateral = this.config.collateral;
       const debt = this.config.debt;
-      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
+      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(
+        this.config.poolId
+      );
       const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
       return [
         // Approval step for collateral
@@ -92906,7 +92982,9 @@ spurious results.`);
       ];
     }
     _getWithdrawLeaf() {
-      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
+      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(
+        this.config.poolId
+      );
       const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
       const collateral = this.config.collateral;
       const debt = this.config.debt;
@@ -92937,7 +93015,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}`
         },
@@ -92963,33 +93041,51 @@ spurious results.`);
       const leafConfigs = this._getDepositLeaf();
       const leaves = leafConfigs.map((config3) => {
         const { target, method, packedArguments, sanitizer, id } = config3;
-        const leaf = this.constructSimpleLeafData({
-          id,
-          target,
-          method,
-          packedArguments
-        }, sanitizer);
+        const leaf = this.constructSimpleLeafData(
+          {
+            id,
+            target,
+            method,
+            packedArguments
+          },
+          sanitizer
+        );
         return leaf;
       });
-      return { leaves, callConstructor: this.getDepositCall.bind(this) };
+      return {
+        leaves,
+        callConstructor: this.getDepositCall.bind(
+          this
+        )
+      };
     }
     getWithdrawAdapter() {
       const leafConfigs = this._getWithdrawLeaf();
       const leaves = leafConfigs.map((config3) => {
         const { target, method, packedArguments, sanitizer, id } = config3;
-        const leaf = this.constructSimpleLeafData({
-          id,
-          target,
-          method,
-          packedArguments
-        }, sanitizer);
+        const leaf = this.constructSimpleLeafData(
+          {
+            id,
+            target,
+            method,
+            packedArguments
+          },
+          sanitizer
+        );
         return leaf;
       });
-      return { leaves, callConstructor: this.getWithdrawCall.bind(this) };
+      return {
+        leaves,
+        callConstructor: this.getWithdrawCall.bind(
+          this
+        )
+      };
     }
     async getDepositCall(params) {
       const collateral = this.config.collateral;
-      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
+      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(
+        this.config.poolId
+      );
       const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
       const uint256MarginAmount = uint256_exports.bnToUint256(params.amount.toWei());
       return [
@@ -93061,7 +93157,9 @@ spurious results.`);
       ];
     }
     async getWithdrawCall(params) {
-      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
+      const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(
+        this.config.poolId
+      );
       const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
       return [
         // Switch delegation on
@@ -93086,7 +93184,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"),
@@ -93116,7 +93214,11 @@ spurious results.`);
       ];
     }
     async getMultiplyCallCalldata(params, isDeposit) {
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getMultiplyCallCalldata params: ${JSON.stringify(params)}, isDeposit: ${isDeposit}, collateral: ${this.config.collateral.symbol}, debt: ${this.config.debt.symbol}`);
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getMultiplyCallCalldata params: ${JSON.stringify(
+          params
+        )}, isDeposit: ${isDeposit}, collateral: ${this.config.collateral.symbol}, debt: ${this.config.debt.symbol}`
+      );
       const { isV2 } = getVesuSingletonAddress(this.config.poolId);
       const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
       const multiplyContract = new Contract({
@@ -93126,42 +93228,83 @@ spurious results.`);
       });
       let leverSwap = [];
       let leverSwapLimitAmount = Web3Number.fromWei(0, this.config.debt.decimals);
-      const existingPositions = await this.vesuAdapter.getPositions(this.config.networkConfig);
-      const collateralisation = await this.vesuAdapter.getCollateralization(this.config.networkConfig);
+      const existingPositions = await this.vesuAdapter.getPositions(
+        this.config.networkConfig
+      );
+      const collateralisation = await this.vesuAdapter.getCollateralization(
+        this.config.networkConfig
+      );
       const existingCollateralInfo = existingPositions[0];
       const existingDebtInfo = existingPositions[1];
       const isDexPriceRequired = existingDebtInfo.token.symbol !== "USDC";
-      logger2.debug(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
-    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+      logger2.debug(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(
+        existingCollateralInfo
+      )}, 
+    existingDebtInfo: ${JSON.stringify(
+        existingDebtInfo
+      )}, collateralisation: ${JSON.stringify(collateralisation)}`);
       const collateralPrice = collateralisation[0].usdValue > 0 ? collateralisation[0].usdValue / existingCollateralInfo.amount.toNumber() : (await this.config.pricer.getPrice(this.config.collateral.symbol)).price;
       const debtPrice = collateralisation[1].usdValue > 0 ? collateralisation[1].usdValue / existingDebtInfo.amount.toNumber() : (await this.config.pricer.getPrice(this.config.debt.symbol)).price;
-      logger2.debug(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
-      const legLTV = await this.vesuAdapter.getLTVConfig(this.config.networkConfig);
-      const ekuboQuoter = new EkuboQuoter(this.config.networkConfig, this.config.pricer);
-      const dexPrice = isDexPriceRequired ? await ekuboQuoter.getDexPrice(this.config.collateral, this.config.debt, this.config.quoteAmountToFetchPrice) : 1;
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall dexPrice: ${dexPrice}, ltv: ${legLTV}`);
+      logger2.debug(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`
+      );
+      const legLTV = await this.vesuAdapter.getLTVConfig(
+        this.config.networkConfig
+      );
+      const ekuboQuoter = new EkuboQuoter(
+        this.config.networkConfig,
+        this.config.pricer
+      );
+      const dexPrice = isDexPriceRequired ? await ekuboQuoter.getDexPrice(
+        this.config.collateral,
+        this.config.debt,
+        this.config.quoteAmountToFetchPrice
+      ) : 1;
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall dexPrice: ${dexPrice}, ltv: ${legLTV}`
+      );
       const addedCollateral = params.amount.multipliedBy(isDeposit ? 1 : -1);
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`
+      );
       const numeratorPart1 = existingCollateralInfo.amount.plus(addedCollateral).multipliedBy(collateralPrice).multipliedBy(legLTV);
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`);
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`
+      );
       const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.config.targetHealthFactor);
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`);
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`
+      );
       const denominatorPart = this.config.targetHealthFactor - legLTV / dexPrice;
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`);
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`
+      );
       const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
-      logger2.debug(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`);
-      let debtAmount = new Web3Number(x_debt_usd.dividedBy(debtPrice).toFixed(this.config.debt.decimals), this.config.debt.decimals);
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`
+      );
+      logger2.debug(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}, numeratorPart2: ${numeratorPart2}, denominatorPart: ${denominatorPart}`
+      );
+      let debtAmount = new Web3Number(
+        x_debt_usd.dividedBy(debtPrice).toFixed(this.config.debt.decimals),
+        this.config.debt.decimals
+      );
       const marginAmount = addedCollateral;
       const collateralToken = this.config.collateral;
       const debtToken = this.config.debt;
-      const debtAmountInCollateralUnits = new Web3Number(debtAmount.multipliedBy(debtPrice).dividedBy(collateralPrice).multipliedBy(10 ** collateralToken.decimals).toFixed(0), collateralToken.decimals);
+      const debtAmountInCollateralUnits = new Web3Number(
+        debtAmount.multipliedBy(debtPrice).dividedBy(collateralPrice).multipliedBy(10 ** collateralToken.decimals).toFixed(0),
+        collateralToken.decimals
+      );
       const isIncrease = debtAmount.greaterThanOrEqualTo(0);
       if (isIncrease && debtAmount.lessThan(0)) {
       } else if (!isIncrease && debtAmount.greaterThan(0)) {
         debtAmount = Web3Number.fromWei(0, this.config.debt.decimals);
       }
-      logger2.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
+      logger2.verbose(
+        `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`
+      );
       if (!debtAmount.isZero()) {
         try {
           const swapQuote = await ekuboQuoter.getQuote(
@@ -93171,32 +93314,49 @@ spurious results.`);
             // negative for exact amount out
           );
           if (swapQuote.price_impact < 0.01) {
-            leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, debtToken, collateralToken);
+            leverSwap = debtAmount.isNegative() ? ekuboQuoter.getVesuMultiplyQuote(
+              swapQuote,
+              collateralToken,
+              debtToken
+            ) : 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);
+              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`);
+            throw new Error(
+              `VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`
+            );
           }
         } catch (error2) {
-          throw new Error(`VesuMultiplyAdapter: Failed to get swap quote: ${error2}`);
+          throw new Error(
+            `VesuMultiplyAdapter: Failed to get swap quote: ${error2}`
+          );
         }
       }
-      const multiplyParams = await this.getLeverParams(isIncrease, params, leverSwap, leverSwapLimitAmount);
+      const multiplyParams = await this.getLeverParams(
+        isIncrease,
+        params,
+        leverSwap,
+        leverSwapLimitAmount
+      );
       const call = multiplyContract.populate("modify_lever", {
-        modify_lever_params: this.formatMultiplyParams(isIncrease, multiplyParams)
+        modify_lever_params: this.formatMultiplyParams(
+          isIncrease,
+          multiplyParams
+        )
       });
       return call.calldata;
     }
@@ -93210,7 +93370,10 @@ spurious results.`);
         add_margin: params.amount,
         // multiplied by collateral decimals in format
         margin_swap: [],
-        margin_swap_limit_amount: Web3Number.fromWei(0, this.config.collateral.decimals),
+        margin_swap_limit_amount: Web3Number.fromWei(
+          0,
+          this.config.collateral.decimals
+        ),
         lever_swap: leverSwap,
         lever_swap_limit_amount: leverSwapLimitAmount
       } : {
@@ -93224,7 +93387,10 @@ spurious results.`);
         lever_swap_limit_amount: leverSwapLimitAmount,
         lever_swap_weights: [],
         withdraw_swap: [],
-        withdraw_swap_limit_amount: Web3Number.fromWei(0, this.config.collateral.decimals),
+        withdraw_swap_limit_amount: Web3Number.fromWei(
+          0,
+          this.config.collateral.decimals
+        ),
         withdraw_swap_weights: [],
         close_position: false
       };
@@ -93240,12 +93406,16 @@ spurious results.`);
       });
       let leverSwap = [];
       let leverSwapLimitAmount = Web3Number.fromWei(0, this.config.debt.decimals);
-      const existingPositions = await this.vesuAdapter.getPositions(this.config.networkConfig);
+      const existingPositions = await this.vesuAdapter.getPositions(
+        this.config.networkConfig
+      );
       const existingCollateralInfo = existingPositions[0];
       const existingDebtInfo = existingPositions[1];
       const collateralToken = this.config.collateral;
       const debtToken = this.config.debt;
-      const collateralPrice = await this.config.pricer.getPrice(collateralToken.symbol);
+      const collateralPrice = await this.config.pricer.getPrice(
+        collateralToken.symbol
+      );
       const debtPrice = await this.config.pricer.getPrice(debtToken.symbol);
       const { deltadebtAmountUnits: debtAmountToRepay } = calculateDebtReductionAmountForWithdrawal(
         existingDebtInfo.amount,
@@ -93256,27 +93426,41 @@ 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 ekuboQuoter = new EkuboQuoter(
+        this.config.networkConfig,
+        this.config.pricer
+      );
+      const debtInDebtUnits = new Web3Number(
+        debtAmountToRepay,
+        debtToken.decimals
+      ).dividedBy(debtPrice.price).multipliedBy(10 ** debtToken.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`);
+        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);
-      const multiplyParams = await this.getLeverParams(false, params, leverSwap, leverSwapLimitAmount);
+      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)
       });
@@ -93286,100 +93470,132 @@ spurious results.`);
       if (isIncrease) {
         const _params2 = params;
         return {
-          action: new CairoCustomEnum({ IncreaseLever: {
-            pool_id: _params2.pool_id.toBigInt(),
-            collateral_asset: _params2.collateral_asset.toBigInt(),
-            debt_asset: _params2.debt_asset.toBigInt(),
-            user: _params2.user.toBigInt(),
-            add_margin: BigInt(_params2.add_margin.toWei()),
-            margin_swap: _params2.margin_swap.map((swap) => ({
+          action: new CairoCustomEnum({
+            IncreaseLever: {
+              pool_id: _params2.pool_id.toBigInt(),
+              collateral_asset: _params2.collateral_asset.toBigInt(),
+              debt_asset: _params2.debt_asset.toBigInt(),
+              user: _params2.user.toBigInt(),
+              add_margin: BigInt(_params2.add_margin.toWei()),
+              margin_swap: _params2.margin_swap.map((swap) => ({
+                route: swap.route.map((route) => ({
+                  pool_key: {
+                    token0: route.pool_key.token0.toBigInt(),
+                    token1: route.pool_key.token1.toBigInt(),
+                    fee: route.pool_key.fee,
+                    tick_spacing: route.pool_key.tick_spacing,
+                    extension: BigInt(
+                      num_exports.hexToDecimalString(route.pool_key.extension)
+                    )
+                  },
+                  sqrt_ratio_limit: uint256_exports.bnToUint256(
+                    route.sqrt_ratio_limit.toWei()
+                  ),
+                  skip_ahead: BigInt(100)
+                })),
+                token_amount: {
+                  token: swap.token_amount.token.toBigInt(),
+                  amount: swap.token_amount.amount.toI129()
+                }
+              })),
+              margin_swap_limit_amount: BigInt(
+                _params2.margin_swap_limit_amount.toWei()
+              ),
+              lever_swap: _params2.lever_swap.map((swap) => ({
+                route: swap.route.map((route) => ({
+                  pool_key: {
+                    token0: route.pool_key.token0.toBigInt(),
+                    token1: route.pool_key.token1.toBigInt(),
+                    fee: route.pool_key.fee,
+                    tick_spacing: route.pool_key.tick_spacing,
+                    extension: BigInt(
+                      num_exports.hexToDecimalString(route.pool_key.extension)
+                    )
+                  },
+                  sqrt_ratio_limit: uint256_exports.bnToUint256(
+                    route.sqrt_ratio_limit.toWei()
+                  ),
+                  skip_ahead: BigInt(0)
+                })),
+                token_amount: {
+                  token: swap.token_amount.token.toBigInt(),
+                  amount: swap.token_amount.amount.toI129()
+                }
+              })),
+              lever_swap_limit_amount: BigInt(
+                _params2.lever_swap_limit_amount.toWei()
+              )
+            }
+          })
+        };
+      }
+      const _params = params;
+      return {
+        action: new CairoCustomEnum({
+          DecreaseLever: {
+            pool_id: _params.pool_id.toBigInt(),
+            collateral_asset: _params.collateral_asset.toBigInt(),
+            debt_asset: _params.debt_asset.toBigInt(),
+            user: _params.user.toBigInt(),
+            sub_margin: BigInt(_params.sub_margin.toWei()),
+            recipient: _params.recipient.toBigInt(),
+            lever_swap: _params.lever_swap.map((swap) => ({
               route: swap.route.map((route) => ({
                 pool_key: {
                   token0: route.pool_key.token0.toBigInt(),
                   token1: route.pool_key.token1.toBigInt(),
                   fee: route.pool_key.fee,
                   tick_spacing: route.pool_key.tick_spacing,
-                  extension: BigInt(num_exports.hexToDecimalString(route.pool_key.extension))
+                  extension: ContractAddr.from(
+                    route.pool_key.extension
+                  ).toBigInt()
                 },
-                sqrt_ratio_limit: uint256_exports.bnToUint256(route.sqrt_ratio_limit.toWei()),
-                skip_ahead: BigInt(100)
+                sqrt_ratio_limit: uint256_exports.bnToUint256(
+                  route.sqrt_ratio_limit.toWei()
+                ),
+                skip_ahead: BigInt(route.skip_ahead.toWei())
               })),
               token_amount: {
                 token: swap.token_amount.token.toBigInt(),
                 amount: swap.token_amount.amount.toI129()
               }
             })),
-            margin_swap_limit_amount: BigInt(_params2.margin_swap_limit_amount.toWei()),
-            lever_swap: _params2.lever_swap.map((swap) => ({
+            lever_swap_limit_amount: BigInt(
+              _params.lever_swap_limit_amount.toWei()
+            ),
+            lever_swap_weights: _params.lever_swap_weights.map(
+              (weight) => BigInt(weight.toWei())
+            ),
+            withdraw_swap: _params.withdraw_swap.map((swap) => ({
               route: swap.route.map((route) => ({
                 pool_key: {
                   token0: route.pool_key.token0.toBigInt(),
                   token1: route.pool_key.token1.toBigInt(),
                   fee: route.pool_key.fee,
                   tick_spacing: route.pool_key.tick_spacing,
-                  extension: BigInt(num_exports.hexToDecimalString(route.pool_key.extension))
+                  extension: ContractAddr.from(
+                    route.pool_key.extension
+                  ).toBigInt()
                 },
-                sqrt_ratio_limit: uint256_exports.bnToUint256(route.sqrt_ratio_limit.toWei()),
-                skip_ahead: BigInt(0)
+                sqrt_ratio_limit: uint256_exports.bnToUint256(
+                  route.sqrt_ratio_limit.toWei()
+                ),
+                skip_ahead: BigInt(route.skip_ahead.toWei())
               })),
               token_amount: {
                 token: swap.token_amount.token.toBigInt(),
                 amount: swap.token_amount.amount.toI129()
               }
             })),
-            lever_swap_limit_amount: BigInt(_params2.lever_swap_limit_amount.toWei())
-          } })
-        };
-      }
-      const _params = params;
-      return {
-        action: new CairoCustomEnum({ DecreaseLever: {
-          pool_id: _params.pool_id.toBigInt(),
-          collateral_asset: _params.collateral_asset.toBigInt(),
-          debt_asset: _params.debt_asset.toBigInt(),
-          user: _params.user.toBigInt(),
-          sub_margin: BigInt(_params.sub_margin.toWei()),
-          recipient: _params.recipient.toBigInt(),
-          lever_swap: _params.lever_swap.map((swap) => ({
-            route: swap.route.map((route) => ({
-              pool_key: {
-                token0: route.pool_key.token0.toBigInt(),
-                token1: route.pool_key.token1.toBigInt(),
-                fee: route.pool_key.fee,
-                tick_spacing: route.pool_key.tick_spacing,
-                extension: ContractAddr.from(route.pool_key.extension).toBigInt()
-              },
-              sqrt_ratio_limit: uint256_exports.bnToUint256(route.sqrt_ratio_limit.toWei()),
-              skip_ahead: BigInt(route.skip_ahead.toWei())
-            })),
-            token_amount: {
-              token: swap.token_amount.token.toBigInt(),
-              amount: swap.token_amount.amount.toI129()
-            }
-          })),
-          lever_swap_limit_amount: BigInt(_params.lever_swap_limit_amount.toWei()),
-          lever_swap_weights: _params.lever_swap_weights.map((weight) => BigInt(weight.toWei())),
-          withdraw_swap: _params.withdraw_swap.map((swap) => ({
-            route: swap.route.map((route) => ({
-              pool_key: {
-                token0: route.pool_key.token0.toBigInt(),
-                token1: route.pool_key.token1.toBigInt(),
-                fee: route.pool_key.fee,
-                tick_spacing: route.pool_key.tick_spacing,
-                extension: ContractAddr.from(route.pool_key.extension).toBigInt()
-              },
-              sqrt_ratio_limit: uint256_exports.bnToUint256(route.sqrt_ratio_limit.toWei()),
-              skip_ahead: BigInt(route.skip_ahead.toWei())
-            })),
-            token_amount: {
-              token: swap.token_amount.token.toBigInt(),
-              amount: swap.token_amount.amount.toI129()
-            }
-          })),
-          withdraw_swap_limit_amount: BigInt(_params.withdraw_swap_limit_amount.toWei()),
-          withdraw_swap_weights: _params.withdraw_swap_weights.map((weight) => BigInt(weight.toWei())),
-          close_position: _params.close_position
-        } })
+            withdraw_swap_limit_amount: BigInt(
+              _params.withdraw_swap_limit_amount.toWei()
+            ),
+            withdraw_swap_weights: _params.withdraw_swap_weights.map(
+              (weight) => BigInt(weight.toWei())
+            ),
+            close_position: _params.close_position
+          }
+        })
       };
     }
     async getHealthFactor() {
@@ -93388,11 +93604,15 @@ spurious results.`);
     }
     async getNetAPY() {
       const positions = await this.getPositions();
-      logger2.verbose(`${this.name}::getNetAPY: positions: ${JSON.stringify(positions)}`);
+      logger2.verbose(
+        `${this.name}::getNetAPY: positions: ${JSON.stringify(positions)}`
+      );
       const allZero = positions.every((p) => p.usdValue === 0);
       if (allZero) {
         const collateralUSD = 1e3;
-        const maxLTV = await this.vesuAdapter.getLTVConfig(this.config.networkConfig);
+        const maxLTV = await this.vesuAdapter.getLTVConfig(
+          this.config.networkConfig
+        );
         const targetHF = this.config.targetHealthFactor;
         const maxDebt = HealthFactorMath.getMaxDebtAmountOnLooping(
           new Web3Number(collateralUSD, this.config.collateral.decimals),
@@ -93426,12 +93646,17 @@ spurious results.`);
         timeout: this.config.extendedTimeout,
         retries: this.config.extendedRetries
       });
+      this.minimumExtendedMovementAmount = this.config.minimumExtendedMovementAmount ?? 5;
       this.client = client;
+      this.retryDelayForOrderStatus = this.config.retryDelayForOrderStatus ?? 3e3;
     }
     //abstract means the method has no implementation in this class; instead, child classes must implement it.
     async getAPY(supportedPosition) {
       const side = supportedPosition.isDebt ? "LONG" : "SHORT";
-      const fundingRates = await this.client.getFundingRates(this.config.extendedMarketName, side);
+      const fundingRates = await this.client.getFundingRates(
+        this.config.extendedMarketName,
+        side
+      );
       if (fundingRates.status !== "OK") {
         logger2.error("error getting funding rates", fundingRates);
         return { apy: 0, type: "base" /* BASE */ };
@@ -93475,14 +93700,14 @@ spurious results.`);
       });
     }
     _getDepositLeaf() {
-      const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
+      );
       return [
         {
           target: this.config.supportedPositions[0].asset.address,
           method: "approve",
-          packedArguments: [
-            AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()
-          ],
+          packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
           id: `extended_approve_${this.config.supportedPositions[0].asset.symbol}`,
           sanitizer: AVNU_LEGACY_SANITIZER
         },
@@ -93509,17 +93734,62 @@ 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 [];
     }
     async getDepositCall(params) {
       try {
         const usdcToken = this.config.supportedPositions[0].asset;
-        const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
-        const salt = Math.floor(
-          Math.random() * 10 ** usdcToken.decimals
+        const usdceToken = Global.getDefaultTokens().find(
+          (token) => token.symbol === "USDCe"
+        );
+        const salt = Math.floor(Math.random() * 10 ** usdcToken.decimals);
+        const amount = uint256_exports.bnToUint256(
+          params.amount.multipliedBy(10).toWei()
         );
-        const amount = uint256_exports.bnToUint256(params.amount.multipliedBy(10).toWei());
         const quotes = await this.config.avnuAdapter.getQuotesAvnu(
           usdcToken.address.toString(),
           usdceToken.address.toString(),
@@ -93532,7 +93802,9 @@ spurious results.`);
           logger2.error("error getting quotes from avnu");
           return [];
         }
-        const getCalldata = await this.config.avnuAdapter.getSwapCallData(quotes);
+        const getCalldata = await this.config.avnuAdapter.getSwapCallData(
+          quotes
+        );
         const swapCallData = getCalldata[0];
         return [
           {
@@ -93589,6 +93861,76 @@ 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 {
@@ -93604,13 +93946,60 @@ spurious results.`);
     async withdrawFromExtended(amount) {
       try {
         if (!this.client) {
-          throw new Error("Client not initialized");
+          logger2.error("Client not initialized");
+          return false;
         }
-        const withdrawalRequest = this.client.withdrawUSDC(amount.toString());
-        if ((await withdrawalRequest).status === "OK") {
-          console.log("Withdrawal request successful");
-          return true;
+        if (amount.lessThanOrEqualTo(0)) {
+          logger2.error(
+            `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+          );
+          return false;
+        }
+        if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
+          logger2.warn(
+            `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
+          );
+          return false;
+        }
+        const holdings = await this.getExtendedDepositAmount();
+        if (!holdings) {
+          logger2.error(
+            "Cannot get holdings - unable to validate withdrawal amount"
+          );
+          return false;
         }
+        const availableForWithdrawal = parseFloat(
+          holdings.availableForWithdrawal
+        );
+        if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+          logger2.error(
+            `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
+          );
+          return false;
+        }
+        const withdrawalAmount = amount.toNumber();
+        if (withdrawalAmount > availableForWithdrawal) {
+          logger2.error(
+            `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
+          );
+          return false;
+        }
+        logger2.info(
+          `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
+        );
+        const withdrawalRequest = await this.client.withdrawUSDC(
+          amount.toFixed(2)
+        );
+        if (withdrawalRequest.status === "OK") {
+          const withdrawalStatus = await this.getDepositOrWithdrawalStatus(
+            withdrawalRequest.data,
+            "WITHDRAWAL" /* WITHDRAWAL */
+          );
+          return withdrawalStatus;
+        }
+        logger2.error(
+          `Withdrawal request failed with status: ${withdrawalRequest.status}`
+        );
         return false;
       } catch (error2) {
         logger2.error(`Error creating Withdraw Call: ${error2}`);
@@ -93621,21 +94010,44 @@ spurious results.`);
       return Promise.resolve(1);
     }
     async getExtendedDepositAmount() {
-      if (this.client === null) {
-        logger2.error("error initializing client");
-        return void 0;
-      }
-      const result2 = await this.client.getHoldings();
-      if (!result2) {
-        logger2.error(`error getting holdings: ${result2}`);
-        return void 0;
-      }
-      const holdings = result2.data;
-      if (!holdings) {
-        logger2.error(`error getting holdings: ${holdings}`);
+      try {
+        if (this.client === null) {
+          logger2.error("error initializing client - client is null");
+          return void 0;
+        }
+        const result2 = await this.client.getHoldings();
+        if (!result2) {
+          logger2.error("error getting holdings - API returned null/undefined");
+          return void 0;
+        }
+        if (result2.status && result2.status !== "OK") {
+          logger2.error(
+            `error getting holdings - API returned status: ${result2.status}`
+          );
+          return void 0;
+        }
+        const holdings = result2.data;
+        if (!holdings) {
+          logger2.warn(
+            "holdings data is null/undefined - treating as zero balance"
+          );
+          return {
+            collateral_name: "",
+            balance: "0",
+            equity: "0",
+            availableForTrade: "0",
+            availableForWithdrawal: "0",
+            unrealisedPnl: "0",
+            initialMargin: "0",
+            marginRatio: "0",
+            updatedTime: Date.now()
+          };
+        }
+        return holdings;
+      } catch (error2) {
+        logger2.error(`error getting holdings - exception: ${error2}`);
         return void 0;
       }
-      return holdings;
     }
     async setLeverage(leverage, marketName) {
       if (this.client === null) {
@@ -93677,21 +94089,24 @@ spurious results.`);
       return result2.data;
     }
     async getOrderStatus(orderId, marketName) {
-      if (this.client === null) {
-        logger2.error("error initializing client");
-        return null;
-      }
-      const orderhistory = await this.getOrderHistory(marketName);
-      if (!orderhistory || orderhistory.length === 0) {
-        logger2.error(`error getting order: ${orderId}`);
+      try {
+        if (this.client === null) {
+          logger2.error("error initializing client");
+          return null;
+        }
+        const orderhistory = await this.getOrderHistory(marketName);
+        if (!orderhistory || orderhistory.length === 0) {
+          return null;
+        }
+        const order = orderhistory.slice(0, 20).find((order2) => order2.id.toString() === orderId);
+        if (order) {
+          return order;
+        }
         return null;
-      }
-      const order = orderhistory.slice(0, 3).find((order2) => order2.id.toString() === orderId);
-      if (!order) {
-        logger2.error(`error getting order: ${order}`);
+      } catch (error2) {
+        logger2.error(`error getting order status: ${error2}`);
         return null;
       }
-      return order;
     }
     async fetchOrderBookBTCUSDC() {
       try {
@@ -93742,14 +94157,40 @@ spurious results.`);
           logger2.error("error depositing or setting leverage");
           return null;
         }
-        const positions = await this.getAllOpenPositions();
-        if (positions === null) {
+        const { ask, bid } = await this.fetchOrderBookBTCUSDC();
+        if (!ask || !bid || ask.lessThanOrEqualTo(0) || bid.lessThanOrEqualTo(0)) {
+          logger2.error(
+            `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`
+          );
           return null;
         }
-        const { ask, bid } = await this.fetchOrderBookBTCUSDC();
         const spread3 = ask.minus(bid);
-        let price = ask.plus(bid).div(2);
-        side === "SELL" /* SELL */ ? price = price.minus(spread3.times(0.2 * attempt)) : price = price.plus(spread3.times(0.2 * attempt));
+        const midPrice = ask.plus(bid).div(2);
+        const MAX_PRICE_DEVIATION_MULTIPLIER = 0.5;
+        const priceAdjustmentMultiplier = Math.min(
+          0.2 * attempt,
+          MAX_PRICE_DEVIATION_MULTIPLIER
+        );
+        const priceAdjustment = spread3.times(priceAdjustmentMultiplier);
+        let price = midPrice;
+        if (side === "SELL" /* SELL */) {
+          price = midPrice.minus(priceAdjustment);
+        } else {
+          price = midPrice.plus(priceAdjustment);
+        }
+        const maxDeviation = midPrice.times(0.5);
+        if (price.minus(midPrice).abs().greaterThan(maxDeviation)) {
+          logger2.error(
+            `Price deviation too large on attempt ${attempt}: price=${price.toNumber()}, midPrice=${midPrice.toNumber()}, deviation=${price.minus(midPrice).abs().toNumber()}`
+          );
+          if (attempt >= maxAttempts) {
+            return null;
+          }
+          price = side === "SELL" /* SELL */ ? midPrice.minus(maxDeviation) : midPrice.plus(maxDeviation);
+        }
+        logger2.info(
+          `createOrder attempt ${attempt}/${maxAttempts}: side=${side}, midPrice=${midPrice.toNumber()}, adjustedPrice=${price.toNumber()}, adjustment=${priceAdjustmentMultiplier * 100}%`
+        );
         const amount_in_token = (btcAmount * parseInt(leverage)).toFixed(
           this.config.extendedPrecision
         );
@@ -93760,14 +94201,57 @@ spurious results.`);
           price.toFixed(0),
           side
         );
-        if (!result2) {
+        if (!result2 || !result2.position_id) {
+          logger2.error("Failed to create order - no position_id returned");
           return null;
         }
-        await new Promise((resolve) => setTimeout(resolve, 5e3));
-        const openOrder = await this.getOrderStatus(result2.position_id, this.config.extendedMarketName);
-        if (!openOrder || openOrder.status !== "FILLED" /* FILLED */) {
+        const positionId = result2.position_id;
+        logger2.info(
+          `Order created with position_id: ${positionId}. Waiting for API to update...`
+        );
+        let openOrder = await this.getOrderStatus(
+          positionId,
+          this.config.extendedMarketName
+        );
+        const maxStatusRetries = 3;
+        const statusRetryDelay = 5e3;
+        if (!openOrder) {
+          logger2.warn(
+            `Order ${positionId} not found in API yet. Retrying status fetch (max ${maxStatusRetries} times)...`
+          );
+          for (let statusRetry = 1; statusRetry <= maxStatusRetries; statusRetry++) {
+            await new Promise((resolve) => setTimeout(resolve, statusRetryDelay));
+            openOrder = await this.getOrderStatus(
+              positionId,
+              this.config.extendedMarketName
+            );
+            if (openOrder) {
+              logger2.info(
+                `Order ${positionId} found after ${statusRetry} status retry(ies)`
+              );
+              break;
+            }
+            logger2.warn(
+              `Order ${positionId} still not found after ${statusRetry}/${maxStatusRetries} status retries`
+            );
+          }
+        }
+        if (openOrder && openOrder.status === "FILLED" /* FILLED */) {
+          logger2.info(
+            `Order ${positionId} successfully filled with quantity ${openOrder.qty}`
+          );
+          return {
+            position_id: positionId,
+            btc_exposure: openOrder.qty
+          };
+        } else if (openOrder && openOrder.status !== "FILLED" /* FILLED */) {
+          logger2.warn(
+            `Order ${positionId} found but status is ${openOrder.status}, not FILLED. Retrying order creation...`
+          );
           if (attempt >= maxAttempts) {
-            logger2.error("Max retries reached \u2014 could not verify open position");
+            logger2.error(
+              `Max retries reached \u2014 order ${positionId} status is ${openOrder.status}, not FILLED`
+            );
             return null;
           } else {
             const backoff = 2e3 * attempt;
@@ -93781,16 +94265,21 @@ spurious results.`);
             );
           }
         } else {
+          logger2.warn(
+            `Order ${positionId} not found in API after ${maxStatusRetries} status retries (API update delayed ~30s). We got position_id from creation, so order exists. Returning position_id - status will be checked in next loop iteration.`
+          );
           return {
-            position_id: result2.position_id,
-            btc_exposure: openOrder.qty
+            position_id: positionId,
+            btc_exposure: amount_in_token
           };
         }
       } catch (err2) {
-        logger2.error(`createShortOrder failed on attempt ${attempt}: ${err2.message}`);
+        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,34 +94310,106 @@ spurious results.`);
         }
         return null;
       } catch (err2) {
-        console.log("Error opening short extended position", err2);
+        logger2.error(`Error opening short extended position, ${err2}`);
         return null;
       }
     }
     async getDepositOrWithdrawalStatus(orderId, operationsType) {
-      try {
-        let transferHistory = await this.client.getAssetOperations({
-          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;
+      const maxAttempts = 15;
+      const retryDelayMs = 3e4;
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+          let transferHistory = await this.client.getAssetOperations({
+            operationsType: [operationsType],
+            operationsStatus: ["COMPLETED" /* COMPLETED */]
+          });
+          if (operationsType === "DEPOSIT" /* DEPOSIT */) {
+            const myTransferStatus = transferHistory.data.find(
+              (operation) => operation.transactionHash === orderId
+            );
+            if (!myTransferStatus) {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+              );
+              return false;
+            }
+            if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+              logger2.info(
+                `Deposit operation ${orderId} completed successfully`
+              );
+              return true;
+            } else {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+              );
+              return false;
+            }
+          } else {
+            const myTransferStatus = transferHistory.data.find(
+              (operation) => operation.id.toString() === orderId.toString()
+            );
+            if (!myTransferStatus) {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+              );
+              return false;
+            }
+            if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+              logger2.info(
+                `Withdrawal operation ${orderId} completed successfully`
+              );
+              return true;
+            } else {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+              );
+              return false;
+            }
           }
-          return true;
-        } else {
-          const myTransferStatus = transferHistory.data.find((operation) => operation.id === orderId);
-          if (!myTransferStatus) {
-            return false;
+        } catch (err2) {
+          logger2.error(
+            `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err2}`
+          );
+          if (attempt < maxAttempts) {
+            logger2.info(`Retrying after ${retryDelayMs}ms...`);
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            continue;
           }
-          return true;
+          logger2.error(
+            `Max retry attempts reached for getDepositOrWithdrawalStatus`
+          );
+          return false;
         }
-      } catch (err2) {
-        logger2.error(`error getting deposit or withdrawal status: ${err2}`);
-        return false;
       }
+      return false;
     }
   };
 
@@ -93934,6 +94495,11 @@ spurious results.`);
     AUMTypes2["DEFISPRING"] = "defispring";
     return AUMTypes2;
   })(AUMTypes || {});
+  var PositionTypeAvnuExtended = /* @__PURE__ */ ((PositionTypeAvnuExtended2) => {
+    PositionTypeAvnuExtended2["OPEN"] = "open";
+    PositionTypeAvnuExtended2["CLOSE"] = "close";
+    return PositionTypeAvnuExtended2;
+  })(PositionTypeAvnuExtended || {});
   var UNIVERSAL_MANAGE_IDS = /* @__PURE__ */ ((UNIVERSAL_MANAGE_IDS2) => {
     UNIVERSAL_MANAGE_IDS2["FLASH_LOAN"] = "flash_loan_init";
     UNIVERSAL_MANAGE_IDS2["VESU_LEG1"] = "vesu_leg1";
@@ -97111,7 +97677,8 @@ spurious results.`);
       minHealthFactor: vaultSettings.minHealthFactor,
       quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
       ...baseAdapterConfig,
-      supportedPositions: [{ asset: lstToken, isDebt: false }, { asset: Global.getDefaultTokens().find((token) => token.symbol === position), isDebt: true }]
+      supportedPositions: [{ asset: lstToken, isDebt: false }, { asset: Global.getDefaultTokens().find((token) => token.symbol === position), isDebt: true }],
+      minimumVesuMovementAmount: 0
     }));
     const unusedBalanceAdapter = new UnusedBalanceAdapter({
       ...baseAdapterConfig
@@ -97425,7 +97992,7 @@ spurious results.`);
           packedArguments: [
             fromToken.address.toBigInt(),
             //wbtc
-            fromToken.address.toBigInt(),
+            toToken.address.toBigInt(),
             //usdc
             vaultAllocator.toBigInt()
           ],
@@ -97439,13 +98006,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 +98066,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 +98084,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,
@@ -97575,7 +98137,7 @@ spurious results.`);
       }
       throw new Error("Failed to fetch quote after retries");
     }
-    async getQuotesAvnu(from_token_address, to_token_address, amount, takerAddress, toTokenDecimals, usdcToBtc, maxIterations = 5, tolerance = 1e4) {
+    async getQuotesAvnu(from_token_address, to_token_address, amount, takerAddress, toTokenDecimals, usdcToBtc, maxIterations = 5, tolerance = 5e3) {
       try {
         const fromToken = this.config.supportedPositions[0].asset;
         const toToken = this.config.supportedPositions[1].asset;
@@ -97596,14 +98158,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 +98266,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 +98328,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 [];
@@ -97774,11 +98359,27 @@ spurious results.`);
     }
     async shouldInvest() {
       try {
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest starting`);
         const vesuAdapter = await this.getVesuAdapter();
         const extendedAdapter = await this.getExtendedAdapter();
-        if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
+        if (!vesuAdapter) {
           logger2.error(
-            `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
+            `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0
+          };
+        }
+        if (!extendedAdapter) {
+          logger2.error(
+            `Extended adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
           );
           return {
             shouldInvest: false,
@@ -97790,10 +98391,73 @@ spurious results.`);
             vesuLeverage: 0
           };
         }
+        if (!extendedAdapter.client) {
+          logger2.error(
+            `Extended adapter client not initialized. This may be a temporary initialization failure - check network connectivity and API availability.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0
+          };
+        }
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
         const balance = await this.getUnusedBalance();
+        if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
+          logger2.error(
+            `Invalid balance.usdValue: ${balance.usdValue}. Expected a finite, non-negative number.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0
+          };
+        }
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`);
         const usdcBalanceOnExtended = await extendedAdapter.getExtendedDepositAmount();
-        const amountToInvest = balance.amount.plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).minus(LIMIT_BALANCE);
-        if (amountToInvest.lessThan(0)) {
+        if (usdcBalanceOnExtended) {
+          const availableForWithdrawal = parseFloat(usdcBalanceOnExtended.availableForWithdrawal);
+          if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+            logger2.error(
+              `Invalid usdcBalanceOnExtended.availableForWithdrawal: ${usdcBalanceOnExtended.availableForWithdrawal}. Expected a finite, non-negative number.`
+            );
+            return {
+              shouldInvest: false,
+              vesuAmount: new Web3Number(0, 0),
+              extendedAmount: new Web3Number(0, 0),
+              extendedLeverage: 0,
+              collateralPrice: 0,
+              debtPrice: 0,
+              vesuLeverage: 0
+            };
+          }
+        }
+        const amountToInvest = new Web3Number(balance.usdValue, USDC_TOKEN_DECIMALS).plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).multipliedBy(1 - LIMIT_BALANCE);
+        const amountToInvestNumber = amountToInvest.toNumber();
+        if (!Number.isFinite(amountToInvestNumber)) {
+          logger2.error(
+            `Invalid amountToInvest calculation result: ${amountToInvestNumber}. Calculation may have produced NaN or Infinity.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0
+          };
+        }
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
+        if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
           return {
             shouldInvest: false,
             vesuAmount: new Web3Number(0, 0),
@@ -97822,6 +98486,34 @@ spurious results.`);
           collateralPrice,
           debtPrice
         } = await this.getAssetPrices();
+        if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+          logger2.error(
+            `Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0
+          };
+        }
+        if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
+          logger2.error(
+            `Invalid debtPrice: ${debtPrice.price}. Expected a finite, positive number.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0
+          };
+        }
         const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } = await calculateAmountDistribution(
           amountToInvest.toNumber(),
           extendedAdapter.client,
@@ -97845,6 +98537,7 @@ spurious results.`);
             vesuLeverage: 0
           };
         }
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`);
         return {
           shouldInvest: true,
           vesuAmount: vesu_amount,
@@ -97871,18 +98564,48 @@ spurious results.`);
       try {
         const vesuAdapter = await this.getVesuAdapter();
         const extendedAdapter = await this.getExtendedAdapter();
-        let calls = [];
         if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
           logger2.error(
             `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
           );
-          return calls;
+          return [];
         }
-        console.log("extendedAmount", extendedAmount);
-        console.log("vesuAmount", vesuAmount);
-        if (extendedAmount.lessThan(0)) {
+        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+        if (!extendedHoldings) {
+          logger2.error(`error getting extended holdings: ${extendedHoldings}`);
+          return [];
+        }
+        const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
+        const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
+          extendedHoldings.availableForWithdrawal
+        );
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForWithdrawal}, 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());
+        }
+        const extendedTargetAmount = extendedAmount.abs();
+        let projectedExtendedBalance = usdcAmountOnExtendedAvailableForWithdrawal;
+        if (extendedAmount.isNegative()) {
+          projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
+        }
+        const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
+        const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
+        if (extendedAmountDifference.lessThan(0)) {
+          totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmountDifferenceAbs);
+        } else if (extendedAmountDifference.greaterThan(0)) {
+          totalExtendedDeposit = totalExtendedDeposit.plus(extendedAmountDifference);
+        }
+        const vesuTargetAmount = vesuAmount.abs();
+        const projectedWalletBalance = usdcAmountInWallet.plus(totalExtendedWithdrawal).minus(totalExtendedDeposit);
+        let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
+        const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
+        logger2.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 calls = [];
+        if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
           try {
-            const extendedCalls = await this.moveAssets(
+            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
@@ -97891,14 +98614,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)) {
+        if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
           try {
-            const vesuCalls = await this.moveAssets(
+            const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
               {
                 to: Protocols.EXTENDED.name,
                 from: Protocols.VESU.name,
@@ -97908,49 +98635,83 @@ spurious results.`);
               vesuAdapter
             );
             calls.push(...vesuCalls);
+            if (!vesuStatus) {
+              return [];
+            }
           } catch (err2) {
             logger2.error(`Failed moving assets to vault: ${err2}`);
           }
         }
-        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-        if (!extendedHoldings) {
-          logger2.error(`error getting extended holdings: ${extendedHoldings}`);
-          return calls;
-        }
-        const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
-        const usdcAmountOnExtended = parseFloat(
-          extendedHoldings.availableForWithdrawal
-        );
-        if (extendedAmount.minus(usdcAmountOnExtended).greaterThan(0)) {
-          try {
-            const extendedCalls = await this.moveAssets(
-              {
-                to: Protocols.EXTENDED.name,
-                from: Protocols.VAULT.name,
-                amount: extendedAmount.minus(usdcAmountOnExtended)
-              },
-              extendedAdapter,
-              vesuAdapter
-            );
-            calls.push(...extendedCalls);
-          } catch (err2) {
-            logger2.error(`Failed moving assets to extended: ${err2}`);
+        if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+          if (extendedAmountDifference.greaterThan(0)) {
+            try {
+              const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+                {
+                  to: Protocols.EXTENDED.name,
+                  from: Protocols.VAULT.name,
+                  amount: extendedAmountDifference
+                },
+                extendedAdapter,
+                vesuAdapter
+              );
+              if (extendedStatus) {
+                calls.push(...extendedCalls);
+              } else {
+                logger2.error(`Failed to move assets to extended - operation returned false status`);
+                return [];
+              }
+            } catch (err2) {
+              logger2.error(`Failed moving assets to extended: ${err2}`);
+              return [];
+            }
+          } else if (extendedAmountDifference.lessThan(0)) {
+            try {
+              const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+                {
+                  to: Protocols.VAULT.name,
+                  from: Protocols.EXTENDED.name,
+                  amount: extendedAmountDifferenceAbs
+                },
+                extendedAdapter,
+                vesuAdapter
+              );
+              if (extendedStatus) {
+                calls.push(...extendedCalls);
+              } else {
+                logger2.error(`Failed to withdraw from extended - operation returned false status`);
+                return [];
+              }
+            } catch (err2) {
+              logger2.error(`Failed moving assets from extended to vault: ${err2}`);
+              return [];
+            }
           }
         }
-        if (vesuAmount.minus(usdcAmountInWallet).greaterThan(0)) {
-          try {
-            const vesuCalls = await this.moveAssets(
-              {
-                to: Protocols.VESU.name,
-                from: Protocols.EXTENDED.name,
-                amount: vesuAmount.minus(usdcAmountInWallet)
-              },
-              extendedAdapter,
-              vesuAdapter
+        if (vesuAmountDifferenceAbs.greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+          if (vesuAmountDifference.lessThanOrEqualTo(0)) {
+            logger2.warn(
+              `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
             );
-            calls.push(...vesuCalls);
-          } catch (err2) {
-            logger2.error(`Failed moving assets to vault: ${err2}`);
+          } else {
+            try {
+              const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+                {
+                  to: Protocols.VAULT.name,
+                  from: Protocols.EXTENDED.name,
+                  amount: vesuAmountDifference
+                },
+                extendedAdapter,
+                vesuAdapter
+              );
+              if (!vesuStatus) {
+                logger2.error(`Failed to move assets to vesu - operation returned false status`);
+                return [];
+              }
+              calls.push(...vesuCalls);
+            } catch (err2) {
+              logger2.error(`Failed moving assets to vault: ${err2}`);
+              return [];
+            }
           }
         }
         return calls;
@@ -97961,12 +98722,47 @@ spurious results.`);
     }
     async moveAssets(params, extendedAdapter, vesuAdapter) {
       try {
+        if (params.amount.lessThanOrEqualTo(0)) {
+          logger2.error(
+            `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
+          );
+          return {
+            calls: [],
+            status: false
+          };
+        }
+        const amountAbs = params.amount.abs();
+        if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
+          if (amountAbs.lessThanOrEqualTo(extendedAdapter.minimumExtendedMovementAmount)) {
+            logger2.warn(
+              `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
+            );
+            return {
+              calls: [],
+              status: false
+            };
+          }
+        }
+        if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
+          if (amountAbs.lessThanOrEqualTo(vesuAdapter.minimumVesuMovementAmount)) {
+            logger2.warn(
+              `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
+            );
+            return {
+              calls: [],
+              status: false
+            };
+          }
+        }
         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,19 +98779,76 @@ 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
+          );
+          logger2.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`);
+          if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
+            const leftAmountAfterWithdrawalAmountInAccount = params.amount.abs().minus(extendedHoldingAmount);
+            logger2.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`);
+            const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
+            const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
+              extendedLeverage.toString(),
+              btcAmount.toNumber(),
+              "BUY" /* BUY */
+            ) : await extendedAdapter.createOrder(
+              extendedLeverage.toString(),
+              35e-6,
+              // just in case amount falls short then we need to create a withdrawal
+              "BUY" /* BUY */
+            );
+            if (!openLongPosition) {
+              logger2.error(`error opening long position: ${openLongPosition}`);
+            }
+            const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
+            if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
+              logger2.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
+              return { calls: [], status: false };
+            }
+          }
           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?.availableForWithdrawal}`);
+            await new Promise((resolve) => setTimeout(resolve, 5e3));
+            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 isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
+          if (!isPriceDifferenceBetweenAvnuAndExtended) {
+            logger2.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+            return {
+              calls: [],
+              status: false
+            };
+          }
           const vesuAmountInBTC = new Web3Number(
             params.amount.dividedBy(collateralPrice.price).toNumber(),
             collateralToken.decimals
@@ -98015,8 +98868,19 @@ 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 isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
+          if (!isPriceDifferenceBetweenAvnuAndExtended) {
+            logger2.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+            return {
+              calls: [],
+              status: false
+            };
+          }
           const vesuAmountInBTC = new Web3Number(
             params.amount.dividedBy(collateralPrice.price).toNumber(),
             collateralToken.decimals
@@ -98046,13 +98910,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() {
@@ -98072,7 +98944,7 @@ spurious results.`);
           };
         }
         const extendedLeverage = calculateExtendedLevergae();
-        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter);
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "open" /* OPEN */);
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
           logger2.error("price difference between avnu and extended doesn't fit the range");
           return {
@@ -98089,6 +98961,7 @@ spurious results.`);
           };
         }
         const extendedPositionValue = position.length > 0 ? parseFloat(position[0].value) : 0;
+        const BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE = BUFFER_USDC_IN_WITHDRAWAL;
         const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
         if (!extendedHoldings) {
           logger2.error(`error getting extended holdings: ${extendedHoldings}`);
@@ -98107,12 +98980,11 @@ spurious results.`);
         const { collateralPrice } = await this.getAssetPrices();
         const { vesuAmountInBTC, extendedAmountInBTC } = calculateVesUPositionSizeGivenExtended(
           extendedPositionValue,
-          extendedHoldingAmount,
+          extendedHoldingAmount.minus(BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE),
           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 +98997,6 @@ 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);
             const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
             const swapProofGroups = swapProofsInfo.proofs;
             const swapCall = this.getManageCall(
@@ -98160,68 +99031,98 @@ spurious results.`);
           extendedAmountInBTC: new Web3Number(0, 0),
           calls: []
         };
-        ;
       }
     }
-    async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter) {
+    async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, positionType) {
       const {
         ask,
         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}`);
         return false;
       }
-      const priceDifference = price.minus(btcPriceAvnu).toNumber();
-      if (priceDifference < MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED && priceDifference > MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED) {
-        return true;
+      const priceDifference = new Web3Number(price.minus(btcPriceAvnu).toFixed(2), 0);
+      if (priceDifference.isNegative()) {
+        return false;
+      }
+      if (positionType === "open" /* OPEN */) {
+        logger2.info(`price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`);
+        const result2 = priceDifference.greaterThanOrEqualTo(avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen);
+        logger2.info(`result: ${result2}`);
+        return result2;
+      } else {
+        logger2.info(`price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+        const result2 = priceDifference.lessThanOrEqualTo(avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing);
+        logger2.info(`result: ${result2}`);
+        return result2;
       }
-      logger2.error(`price difference between avnu and extended doesn't fit the range, priceDifference: ${priceDifference}`);
-      return false;
     }
     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 +99131,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 +99144,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() {
@@ -98295,7 +99217,7 @@ spurious results.`);
       };
     }
   };
-  function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended) {
+  function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
     vaultSettings.leafAdapters = [];
     const wbtcToken = Global.getDefaultTokens().find(
       (token) => token.symbol === lstSymbol
@@ -98319,7 +99241,9 @@ spurious results.`);
       ...baseAdapterConfig,
       avnuContract: AVNU_MIDDLEWARE,
       slippage: 0.01,
-      baseUrl: AVNU_QUOTE_URL
+      baseUrl: AVNU_QUOTE_URL,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing
     });
     const extendedAdapter = new ExtendedAdapter({
       ...baseAdapterConfig,
@@ -98335,7 +99259,10 @@ spurious results.`);
       extendedBaseUrl: "https://api.starknet.extended.exchange",
       extendedMarketName: "BTC-USD",
       extendedPrecision: 5,
-      avnuAdapter
+      avnuAdapter,
+      retryDelayForOrderStatus: minimumExtendedRetriesDelayForOrderStatus ?? 3e3,
+      minimumExtendedMovementAmount: minimumExtendedMovementAmount ?? 5
+      //5 usdcs
     });
     const vesuMultiplyAdapter = new VesuMultiplyAdapter({
       poolId: pool1,
@@ -98348,7 +99275,9 @@ spurious results.`);
       supportedPositions: [
         { asset: wbtcToken, isDebt: false },
         { asset: usdcToken, isDebt: true }
-      ]
+      ],
+      minimumVesuMovementAmount: minimumVesuMovementAmount ?? 5
+      //5 usdc
     });
     const unusedBalanceAdapter = new UnusedBalanceAdapter({
       ...baseAdapterConfig
@@ -98381,6 +99310,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(
@@ -98462,12 +99392,12 @@ spurious results.`);
     borrowable_assets: [Global.getDefaultTokens().find((token) => token.symbol === "WBTC")],
     minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP
   };
-  var VesuExtendedTestStrategies = (extendedBackendUrl, extendedApiKey, vaultIdExtended) => {
+  var VesuExtendedTestStrategies = (extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) => {
     return [
-      getStrategySettingsVesuExtended("WBTC", "USDC", re7UsdcPrimeDevansh, false, false, extendedBackendUrl, extendedApiKey, vaultIdExtended)
+      getStrategySettingsVesuExtended("WBTC", "USDC", re7UsdcPrimeDevansh, false, false, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing)
     ];
   };
-  function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses, isPreview = false, isLST, extendedBackendUrl, extendedApiKey, vaultIdExtended) {
+  function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses, isPreview = false, isLST, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
     return {
       name: `Extended Test ${underlyingSymbol}`,
       description: getDescription2(lstSymbol, underlyingSymbol),
@@ -98475,7 +99405,7 @@ spurious results.`);
       launchBlock: 0,
       type: "Other",
       depositTokens: [Global.getDefaultTokens().find((token) => token.symbol === underlyingSymbol)],
-      additionalInfo: getLooperSettings2(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7USDCPrime, extendedBackendUrl, extendedApiKey, vaultIdExtended),
+      additionalInfo: getLooperSettings2(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7USDCPrime, extendedBackendUrl, extendedApiKey, 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),