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

package/dist/index.js

@@ -76,6 +76,7 @@ __export(index_exports, {
   PRICE_ROUTER: () => PRICE_ROUTER,
   PasswordJsonCryptoUtil: () => PasswordJsonCryptoUtil,
   PositionSide: () => PositionSide,
+  PositionTypeAvnuExtended: () => PositionTypeAvnuExtended,
   Pragma: () => Pragma,
   Pricer: () => Pricer,
   PricerBase: () => PricerBase,
@@ -4474,20 +4475,13 @@ var EkuboQuoter = class _EkuboQuoter {
   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);
     logger.verbose(`${_EkuboQuoter.name}:: LST Dex Price: ${price}`);
     return price;
   }
@@ -4506,16 +4500,12 @@ var EkuboQuoter = class _EkuboQuoter {
   // debt collateral 
   async getSwapLimitAmount(fromToken, toToken, amount, max_slippage = 2e-3) {
     const isExactAmountIn = amount.greaterThanOrEqualTo(0);
-    console.log("isExactAmountIn", isExactAmountIn);
     logger.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) {
@@ -28163,6 +28153,7 @@ var vesu_multiple_abi_default = [
 var AVNU_API = "https://starknet.api.avnu.fi/swap/v2/quotes";
 var USDC_TOKEN_DECIMALS = 6;
 var USDC_TOKEN_ADDRESS = "0x053C91253BC9682c04929cA02ED00b3E423f6710D2ee7e0D5EBB06F3eCF368A8";
+var BUFFER_USDC_IN_WITHDRAWAL = 5;
 var WBTC_TOKEN_ADDRESS = "0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac";
 var WBTC_TOKEN_DECIMALS = 8;
 var MAINTENANCE_MARGIN = 0.01;
@@ -28178,7 +28169,8 @@ var STRK_API_RPC = process.env.STRK_API_RPC ?? "https://mainnet.starknet.a5a.ch"
 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);
@@ -28196,8 +28188,6 @@ var PRICE_MAX_SLIPPAGE_EKUBO = Number(process.env.PRICE_MAX_SLIPPAGE_EKUBO ?? 5e
 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) => {
@@ -28217,8 +28207,7 @@ var calculateAmountDistribution = async (amount, client, marketName, collateralP
         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();
@@ -28254,8 +28243,7 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       logger.error("error getting extended positions");
       return null;
     }
-    const extendedBTCExposure = extendedPosition.length > 0 ? new Web3Number(extendedPosition[0].size, WBTC_TOKEN_DECIMALS) : new Web3Number(0, WBTC_TOKEN_DECIMALS);
-    const extendedExposureUSD = extendedBTCExposure.multipliedBy(collateralPrice);
+    const extendedExposureUSD = extendedPosition.length > 0 ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS) : new Web3Number(0, USDC_TOKEN_DECIMALS);
     const vesuExposureUSD = collateralUnits.multipliedBy(collateralPrice);
     if (vesuExposureUSD.lessThan(0)) {
       return {
@@ -28273,9 +28261,14 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
         vesu_leverage
       };
     }
+    console.log("the vesu exposure usd is", vesuExposureUSD.toNumber());
+    console.log("the extended exposure usd is", extendedExposureUSD.toNumber());
+    console.log("the amount in usdc is", amountInUsdc.toNumber());
+    console.log("the extended leverage is", extended_leverage);
+    console.log("the vesu leverage is", vesu_leverage);
     const numerator1 = amountInUsdc.multipliedBy(extended_leverage);
-    const numerator2 = vesuExposureUSD.multipliedBy(vesu_leverage);
-    const numerator3 = extendedExposureUSD.multipliedBy(extended_leverage).multipliedBy(-1);
+    const numerator2 = vesuExposureUSD;
+    const numerator3 = extendedExposureUSD.multipliedBy(-1);
     const finalNumerator = numerator1.plus(numerator2).plus(numerator3);
     const denominator = extended_leverage + vesu_leverage;
     const vesuAmountInUSDC = finalNumerator.dividedBy(denominator);
@@ -28285,6 +28278,7 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       "the extended amount in usdc is",
       extendedAmountInUSDC.toNumber()
     );
+    await new Promise((resolve) => setTimeout(resolve, 1e4));
     return {
       vesu_amount: vesuAmountInUSDC,
       extended_amount: extendedAmountInUSDC,
@@ -28306,10 +28300,10 @@ var calculateExtendedLevergae = () => {
   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);
@@ -28344,16 +28338,16 @@ var calculateAmountDepositOnExtendedWhenIncurringLosses = async (client) => {
     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) {
       logger.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 (err) {
+    logger.error(`error calculating amount deposit on extended when incurring losses: ${err}`);
     return null;
   }
 };
@@ -28431,21 +28425,36 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       vaultAllocator: config.vaultAllocator,
       id: ""
     });
-    this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
+    this.minimumVesuMovementAmount = config.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(import_starknet21.num.getHexString(p.id)));
+      const pool = allVesuPools.pools.find(
+        (p) => this.vesuAdapter.config.poolId.eqString(import_starknet21.num.getHexString(p.id))
+      );
       if (!pool) {
-        logger.warn(`VesuMultiplyAdapter: Pool not found for token ${asset.symbol}`);
+        logger.warn(
+          `VesuMultiplyAdapter: Pool not found for token ${asset.symbol}`
+        );
         return {
           apy: 0,
           type: "base" /* BASE */
@@ -28455,7 +28464,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         (a) => a.symbol.toLowerCase() === asset.symbol.toLowerCase()
       )?.stats;
       if (!assetStats) {
-        logger.warn(`VesuMultiplyAdapter: Asset stats not found for token ${asset.symbol}`);
+        logger.warn(
+          `VesuMultiplyAdapter: Asset stats not found for token ${asset.symbol}`
+        );
         return {
           apy: 0,
           type: "base" /* BASE */
@@ -28466,7 +28477,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         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;
@@ -28482,7 +28495,10 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       this.setCache(CACHE_KEY, result, 3e5);
       return result;
     } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error getting APY for ${supportedPosition.asset.symbol}:`, error);
+      logger.error(
+        `VesuMultiplyAdapter: Error getting APY for ${supportedPosition.asset.symbol}:`,
+        error
+      );
       throw error;
     }
   }
@@ -28495,12 +28511,16 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     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) {
-        logger.warn(`VesuMultiplyAdapter: Position not found for token ${supportedPosition.asset.symbol}`);
+        logger.warn(
+          `VesuMultiplyAdapter: Position not found for token ${supportedPosition.asset.symbol}`
+        );
         return {
           amount: new Web3Number("0", supportedPosition.asset.decimals),
           remarks: "Position not found"
@@ -28513,12 +28533,18 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       this.setCache(CACHE_KEY, position, 6e4);
       return position;
     } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error getting position for ${supportedPosition.asset.symbol}:`, error);
+      logger.error(
+        `VesuMultiplyAdapter: Error getting position for ${supportedPosition.asset.symbol}:`,
+        error
+      );
       throw error;
     }
   }
   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;
   }
@@ -28528,9 +28554,15 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     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");
       }
@@ -28540,13 +28572,23 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         debt,
         maxBorrowableAPY
       );
-      logger.verbose(`VesuMultiplyAdapter: Max borrowable: ${maxBorrowable.toNumber()}`);
-      const debtCap = await this.vesuAdapter.getDebtCap(this.config.networkConfig);
+      logger.verbose(
+        `VesuMultiplyAdapter: Max borrowable: ${maxBorrowable.toNumber()}`
+      );
+      const debtCap = await this.vesuAdapter.getDebtCap(
+        this.config.networkConfig
+      );
       logger.verbose(`VesuMultiplyAdapter: Debt cap: ${debtCap.toNumber()}`);
       const actualMaxBorrowable = maxBorrowable.minimum(debtCap);
-      logger.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);
+      logger.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");
       }
@@ -28564,14 +28606,25 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       );
       const maxDepositAmount = amount ? amount.minimum(maxCollateralFromDebt) : maxCollateralFromDebt;
       const usdValue = await this.getUSDValue(collateral, maxDepositAmount);
-      logger.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 })]);
-      logger.verbose(`VesuMultiplyAdapter: Apys: ${apys[0].apy}, ${apys[1].apy}`);
+      logger.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 })
+      ]);
+      logger.verbose(
+        `VesuMultiplyAdapter: Apys: ${apys[0].apy}, ${apys[1].apy}`
+      );
       const borrowAmountUSD = actualMaxBorrowable.multipliedBy(debtPrice.price);
-      logger.verbose(`VesuMultiplyAdapter: Borrow amount: ${actualMaxBorrowable.toNumber()}, borrow amount USD: ${borrowAmountUSD.toNumber()}`);
+      logger.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;
-      logger.verbose(`VesuMultiplyAdapter: Max deposit amount: ${maxDepositAmount.toNumber()}, netAPY: ${netAPY}`);
+      logger.verbose(
+        `VesuMultiplyAdapter: Max deposit amount: ${maxDepositAmount.toNumber()}, netAPY: ${netAPY}`
+      );
       return {
         tokenInfo: collateral,
         amount: maxDepositAmount,
@@ -28584,7 +28637,10 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         protocol: this.protocol
       };
     } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error calculating max deposit:`, error);
+      logger.error(
+        `VesuMultiplyAdapter: Error calculating max deposit:`,
+        error
+      );
       throw error;
     }
   }
@@ -28594,9 +28650,15 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     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");
       }
@@ -28606,11 +28668,20 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       const result = maxWithdrawable.greaterThan(0) ? maxWithdrawable : new Web3Number("0", collateral.decimals);
       const usdValue = await this.getUSDValue(collateral, result);
       const debtUSD = debtPosition.usdValue;
-      logger.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 })]);
-      logger.verbose(`VesuMultiplyAdapter: Apys: ${apys[0].apy}, ${apys[1].apy}`);
+      logger.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 })
+      ]);
+      logger.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;
-      logger.verbose(`VesuMultiplyAdapter: Max withdraw amount: ${result.toNumber()}, netAPY: ${netAPY}`);
+      logger.verbose(
+        `VesuMultiplyAdapter: Max withdraw amount: ${result.toNumber()}, netAPY: ${netAPY}`
+      );
       return {
         tokenInfo: collateral,
         amount: result,
@@ -28623,14 +28694,19 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         protocol: this.protocol
       };
     } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error calculating max withdraw:`, error);
+      logger.error(
+        `VesuMultiplyAdapter: Error calculating max withdraw:`,
+        error
+      );
       throw error;
     }
   }
   _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
@@ -28694,7 +28770,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     ];
   }
   _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;
@@ -28725,7 +28803,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           this.config.debt.address.toBigInt(),
           this.config.vaultAllocator.toBigInt()
         ],
-        sanitizer: SIMPLE_SANITIZER_V2,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
         // vmw = vesu multiply withdraw
         id: `vmw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
       },
@@ -28751,33 +28829,51 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     const leafConfigs = this._getDepositLeaf();
     const leaves = leafConfigs.map((config) => {
       const { target, method, packedArguments, sanitizer, id } = config;
-      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((config) => {
       const { target, method, packedArguments, sanitizer, id } = config;
-      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 = import_starknet21.uint256.bnToUint256(params.amount.toWei());
     return [
@@ -28849,7 +28945,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     ];
   }
   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
@@ -28874,7 +28972,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       },
       // Vesu multiply call
       {
-        sanitizer: SIMPLE_SANITIZER_V2,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
         call: {
           contractAddress: vesuMultiply,
           selector: import_starknet21.hash.getSelectorFromName("modify_lever"),
@@ -28904,7 +29002,11 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     ];
   }
   async getMultiplyCallCalldata(params, isDeposit) {
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getMultiplyCallCalldata params: ${JSON.stringify(params)}, isDeposit: ${isDeposit}, collateral: ${this.config.collateral.symbol}, debt: ${this.config.debt.symbol}`);
+    logger.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 import_starknet21.Contract({
@@ -28914,42 +29016,83 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     });
     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";
-    logger.debug(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall existingCollateralInfo: ${JSON.stringify(existingCollateralInfo)}, 
-    existingDebtInfo: ${JSON.stringify(existingDebtInfo)}, collateralisation: ${JSON.stringify(collateralisation)}`);
+    logger.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;
-    logger.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;
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall dexPrice: ${dexPrice}, ltv: ${legLTV}`);
+    logger.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;
+    logger.verbose(
+      `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall dexPrice: ${dexPrice}, ltv: ${legLTV}`
+    );
     const addedCollateral = params.amount.multipliedBy(isDeposit ? 1 : -1);
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
+    logger.verbose(
+      `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`
+    );
     const numeratorPart1 = existingCollateralInfo.amount.plus(addedCollateral).multipliedBy(collateralPrice).multipliedBy(legLTV);
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`);
+    logger.verbose(
+      `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`
+    );
     const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.config.targetHealthFactor);
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`);
+    logger.verbose(
+      `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`
+    );
     const denominatorPart = this.config.targetHealthFactor - legLTV / dexPrice;
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`);
+    logger.verbose(
+      `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall denominatorPart: ${denominatorPart}`
+    );
     const x_debt_usd = numeratorPart1.minus(numeratorPart2).dividedBy(denominatorPart);
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`);
-    logger.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);
+    logger.verbose(
+      `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall x_debt_usd: ${x_debt_usd}`
+    );
+    logger.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);
     }
-    logger.verbose(`${_VesuMultiplyAdapter.name}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
+    logger.verbose(
+      `${_VesuMultiplyAdapter.name}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`
+    );
     if (!debtAmount.isZero()) {
       try {
         const swapQuote = await ekuboQuoter.getQuote(
@@ -28959,32 +29102,49 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           // 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 (error) {
-        throw new Error(`VesuMultiplyAdapter: Failed to get swap quote: ${error}`);
+        throw new Error(
+          `VesuMultiplyAdapter: Failed to get swap quote: ${error}`
+        );
       }
     }
-    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;
   }
@@ -28998,7 +29158,10 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       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
     } : {
@@ -29012,7 +29175,10 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       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
     };
@@ -29028,12 +29194,16 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     });
     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,
@@ -29044,27 +29214,41 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       debtPrice.price,
       debtToken.decimals
     );
-    console.log("debtAmountToRepay", debtAmountToRepay);
     if (!debtAmountToRepay) {
       throw new Error("error calculating debt amount to repay");
     }
-    const ekuboQuoter = new EkuboQuoter(this.config.networkConfig, this.config.pricer);
-    const debtInDebtUnits = new Web3Number(debtAmountToRepay, debtToken.decimals).dividedBy(debtPrice.price).multipliedBy(10 ** debtToken.decimals);
-    const debtInCollateralUnits = new Web3Number(debtAmountToRepay, debtToken.decimals).dividedBy(collateralPrice.price).multipliedBy(10 ** collateralToken.decimals);
+    const 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 {
-      logger.error(`VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`);
+      logger.error(
+        `VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`
+      );
     }
-    const anotherLeverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(collateralToken, debtToken, debtInDebtUnits, MAX_SLIPPAGE);
-    leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(debtToken, collateralToken, debtInCollateralUnits, MAX_SLIPPAGE);
-    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)
     });
@@ -29074,100 +29258,132 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     if (isIncrease) {
       const _params2 = params;
       return {
-        action: new import_starknet21.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 import_starknet21.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(
+                    import_starknet21.num.hexToDecimalString(route.pool_key.extension)
+                  )
+                },
+                sqrt_ratio_limit: import_starknet21.uint256.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(
+                    import_starknet21.num.hexToDecimalString(route.pool_key.extension)
+                  )
+                },
+                sqrt_ratio_limit: import_starknet21.uint256.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 import_starknet21.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(import_starknet21.num.hexToDecimalString(route.pool_key.extension))
+                extension: ContractAddr.from(
+                  route.pool_key.extension
+                ).toBigInt()
               },
-              sqrt_ratio_limit: import_starknet21.uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
-              skip_ahead: BigInt(100)
+              sqrt_ratio_limit: import_starknet21.uint256.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(import_starknet21.num.hexToDecimalString(route.pool_key.extension))
+                extension: ContractAddr.from(
+                  route.pool_key.extension
+                ).toBigInt()
               },
-              sqrt_ratio_limit: import_starknet21.uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
-              skip_ahead: BigInt(0)
+              sqrt_ratio_limit: import_starknet21.uint256.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 import_starknet21.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: import_starknet21.uint256.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: import_starknet21.uint256.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() {
@@ -29176,11 +29392,15 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
   }
   async getNetAPY() {
     const positions = await this.getPositions();
-    logger.verbose(`${this.name}::getNetAPY: positions: ${JSON.stringify(positions)}`);
+    logger.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),
@@ -29323,7 +29543,22 @@ var ExtendedWrapper = class {
             `HTTP ${response.status}: ${errorData.detail || response.statusText}`
           );
         }
-        const data = await response.json();
+        const text = await response.text();
+        const MAX_SAFE_INTEGER_STR = "9007199254740991";
+        const largeIntegerRegex = /"data"\s*:\s*(\d{16,})/g;
+        const modifiedText = text.replace(largeIntegerRegex, (match, largeInt) => {
+          if (largeInt.length > MAX_SAFE_INTEGER_STR.length || largeInt.length === MAX_SAFE_INTEGER_STR.length && largeInt > MAX_SAFE_INTEGER_STR) {
+            return `"data":"${largeInt}"`;
+          }
+          return match;
+        });
+        const data = JSON.parse(modifiedText);
+        if (data && typeof data.data === "string" && /^\d+$/.test(data.data)) {
+          const numValue = Number(data.data);
+          if (Number.isSafeInteger(numValue)) {
+            data.data = numValue;
+          }
+        }
         return data;
       } catch (error) {
         lastError = error;
@@ -29383,6 +29618,7 @@ var ExtendedWrapper = class {
   }
   /**
    * Initiate a withdrawal from Extended Exchange
+   * Returns data as number | string to preserve precision for large integers
    */
   async withdraw(request) {
     return this.makeRequest("/api/v1/withdraw", {
@@ -29521,6 +29757,7 @@ var ExtendedWrapper = class {
   }
   /**
    * Withdraw USDC (convenience method)
+   * Returns data as number | string to preserve precision for large integers
    */
   async withdrawUSDC(amount) {
     return this.withdraw({ amount, asset: "USDC" });
@@ -29552,12 +29789,17 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       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") {
       logger.error("error getting funding rates", fundingRates);
       return { apy: 0, type: "base" /* BASE */ };
@@ -29601,14 +29843,14 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     });
   }
   _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
       },
@@ -29635,17 +29877,62 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       }
     ];
   }
+  getSwapFromLegacyLeaf() {
+    const leafConfigs = this._getSwapFromLegacyLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      const leaf = this.constructSimpleLeafData(
+        {
+          id,
+          target,
+          method,
+          packedArguments
+        },
+        sanitizer
+      );
+      return leaf;
+    });
+    return {
+      leaves,
+      callConstructor: this.getSwapFromLegacyCall.bind(
+        this
+      )
+    };
+  }
+  _getSwapFromLegacyLeaf() {
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
+    return [
+      {
+        target: usdceToken.address,
+        method: "approve",
+        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
+        id: `extendedswaplegacyapprove_${usdceToken.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER
+      },
+      {
+        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+        method: "swap_to_new",
+        packedArguments: [],
+        id: `extended_swap_to_new_${usdceToken.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER
+      }
+    ];
+  }
   _getWithdrawLeaf() {
     return [];
   }
   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 = import_starknet22.uint256.bnToUint256(
+        params.amount.multipliedBy(10).toWei()
       );
-      const amount = import_starknet22.uint256.bnToUint256(params.amount.multipliedBy(10).toWei());
       const quotes = await this.config.avnuAdapter.getQuotesAvnu(
         usdcToken.address.toString(),
         usdceToken.address.toString(),
@@ -29658,7 +29945,9 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         logger.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 [
         {
@@ -29715,6 +30004,76 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       return [];
     }
   }
+  getProofsForFromLegacySwap(tree) {
+    let proofGroups = [];
+    const ids = this.getSwapFromLegacyLeaf().leaves.map((l) => l.readableId);
+    for (const [i, v] of tree.entries()) {
+      if (ids.includes(v.readableId)) {
+        proofGroups.push(tree.getProof(i));
+      }
+    }
+    if (proofGroups.length != ids.length) {
+      throw new Error(`Not all proofs found for IDs: ${ids.join(", ")}`);
+    }
+    return {
+      proofs: proofGroups,
+      callConstructor: this.getSwapFromLegacyCall.bind(this)
+    };
+  }
+  async getSwapFromLegacyCall(params) {
+    try {
+      const usdcToken = this.config.supportedPositions[0].asset;
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
+      );
+      const amount = import_starknet22.uint256.bnToUint256(
+        params.amount.multipliedBy(10).toWei()
+      );
+      const quotes = await this.config.avnuAdapter.getQuotesAvnu(
+        usdceToken.address.toString(),
+        usdcToken.address.toString(),
+        params.amount.toNumber(),
+        this.config.avnuAdapter.config.vaultAllocator.address.toString(),
+        usdcToken.decimals,
+        false
+      );
+      if (!quotes) {
+        logger.error("error getting quotes from avnu");
+        return [];
+      }
+      const getCalldata = await this.config.avnuAdapter.getSwapCallData(
+        quotes
+      );
+      const swapCallData = getCalldata[0];
+      return [
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: usdceToken.address,
+            selector: import_starknet22.hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+              toBigInt(amount.low.toString()),
+              // amount low
+              toBigInt(amount.high.toString())
+              // amount high
+            ]
+          }
+        },
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+            selector: import_starknet22.hash.getSelectorFromName("swap_to_new"),
+            calldata: swapCallData
+          }
+        }
+      ];
+    } catch (error) {
+      logger.error(`Error creating Deposit Call: ${error}`);
+      return [];
+    }
+  }
   //Swap wbtc to usdc
   async getWithdrawCall(params) {
     try {
@@ -29730,13 +30089,60 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
   async withdrawFromExtended(amount) {
     try {
       if (!this.client) {
-        throw new Error("Client not initialized");
+        logger.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)) {
+        logger.error(
+          `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+        );
+        return false;
+      }
+      if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
+        logger.warn(
+          `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
+        );
+        return false;
+      }
+      const holdings = await this.getExtendedDepositAmount();
+      if (!holdings) {
+        logger.error(
+          "Cannot get holdings - unable to validate withdrawal amount"
+        );
+        return false;
+      }
+      const availableForWithdrawal = parseFloat(
+        holdings.availableForWithdrawal
+      );
+      if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+        logger.error(
+          `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
+        );
+        return false;
+      }
+      const withdrawalAmount = amount.toNumber();
+      if (withdrawalAmount > availableForWithdrawal) {
+        logger.error(
+          `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
+        );
+        return false;
+      }
+      logger.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;
       }
+      logger.error(
+        `Withdrawal request failed with status: ${withdrawalRequest.status}`
+      );
       return false;
     } catch (error) {
       logger.error(`Error creating Withdraw Call: ${error}`);
@@ -29747,21 +30153,44 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     return Promise.resolve(1);
   }
   async getExtendedDepositAmount() {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return void 0;
-    }
-    const result = await this.client.getHoldings();
-    if (!result) {
-      logger.error(`error getting holdings: ${result}`);
-      return void 0;
-    }
-    const holdings = result.data;
-    if (!holdings) {
-      logger.error(`error getting holdings: ${holdings}`);
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client - client is null");
+        return void 0;
+      }
+      const result = await this.client.getHoldings();
+      if (!result) {
+        logger.error("error getting holdings - API returned null/undefined");
+        return void 0;
+      }
+      if (result.status && result.status !== "OK") {
+        logger.error(
+          `error getting holdings - API returned status: ${result.status}`
+        );
+        return void 0;
+      }
+      const holdings = result.data;
+      if (!holdings) {
+        logger.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 (error) {
+      logger.error(`error getting holdings - exception: ${error}`);
       return void 0;
     }
-    return holdings;
   }
   async setLeverage(leverage, marketName) {
     if (this.client === null) {
@@ -29803,21 +30232,24 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     return result.data;
   }
   async getOrderStatus(orderId, marketName) {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return null;
-    }
-    const orderhistory = await this.getOrderHistory(marketName);
-    if (!orderhistory || orderhistory.length === 0) {
-      logger.error(`error getting order: ${orderId}`);
+    try {
+      if (this.client === null) {
+        logger.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) {
-      logger.error(`error getting order: ${order}`);
+    } catch (error) {
+      logger.error(`error getting order status: ${error}`);
       return null;
     }
-    return order;
   }
   async fetchOrderBookBTCUSDC() {
     try {
@@ -29868,14 +30300,40 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         logger.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)) {
+        logger.error(
+          `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`
+        );
         return null;
       }
-      const { ask, bid } = await this.fetchOrderBookBTCUSDC();
       const spread = ask.minus(bid);
-      let price = ask.plus(bid).div(2);
-      side === "SELL" /* SELL */ ? price = price.minus(spread.times(0.2 * attempt)) : price = price.plus(spread.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 = spread.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)) {
+        logger.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);
+      }
+      logger.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
       );
@@ -29886,14 +30344,57 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         price.toFixed(0),
         side
       );
-      if (!result) {
+      if (!result || !result.position_id) {
+        logger.error("Failed to create order - no position_id returned");
         return null;
       }
-      await new Promise((resolve) => setTimeout(resolve, 5e3));
-      const openOrder = await this.getOrderStatus(result.position_id, this.config.extendedMarketName);
-      if (!openOrder || openOrder.status !== "FILLED" /* FILLED */) {
+      const positionId = result.position_id;
+      logger.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) {
+        logger.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) {
+            logger.info(
+              `Order ${positionId} found after ${statusRetry} status retry(ies)`
+            );
+            break;
+          }
+          logger.warn(
+            `Order ${positionId} still not found after ${statusRetry}/${maxStatusRetries} status retries`
+          );
+        }
+      }
+      if (openOrder && openOrder.status === "FILLED" /* FILLED */) {
+        logger.info(
+          `Order ${positionId} successfully filled with quantity ${openOrder.qty}`
+        );
+        return {
+          position_id: positionId,
+          btc_exposure: openOrder.qty
+        };
+      } else if (openOrder && openOrder.status !== "FILLED" /* FILLED */) {
+        logger.warn(
+          `Order ${positionId} found but status is ${openOrder.status}, not FILLED. Retrying order creation...`
+        );
         if (attempt >= maxAttempts) {
-          logger.error("Max retries reached \u2014 could not verify open position");
+          logger.error(
+            `Max retries reached \u2014 order ${positionId} status is ${openOrder.status}, not FILLED`
+          );
           return null;
         } else {
           const backoff = 2e3 * attempt;
@@ -29907,16 +30408,21 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
           );
         }
       } else {
+        logger.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: result.position_id,
-          btc_exposure: openOrder.qty
+          position_id: positionId,
+          btc_exposure: amount_in_token
         };
       }
     } catch (err) {
-      logger.error(`createShortOrder failed on attempt ${attempt}: ${err.message}`);
+      logger.error(
+        `createShortOrder failed on attempt ${attempt}: ${err.message}`
+      );
       if (attempt < maxAttempts) {
         const backoff = 1200 * attempt;
-        console.log(`Retrying after ${backoff}ms...`);
+        logger.info(`Retrying after ${backoff}ms...`);
         await new Promise((resolve) => setTimeout(resolve, backoff));
         return this.createOrder(
           leverage,
@@ -29947,34 +30453,106 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
       }
       return null;
     } catch (err) {
-      console.log("Error opening short extended position", err);
+      logger.error(`Error opening short extended position, ${err}`);
       return null;
     }
   }
   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) {
+              logger.info(
+                `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Deposit operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
+        } else {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.id === orderId.toString()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Withdrawal operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.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 (err) {
+        logger.error(
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`
+        );
+        if (attempt < maxAttempts) {
+          logger.info(`Retrying after ${retryDelayMs}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+          continue;
         }
-        return true;
+        logger.error(
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+        );
+        return false;
       }
-    } catch (err) {
-      logger.error(`error getting deposit or withdrawal status: ${err}`);
-      return false;
     }
+    return false;
   }
 };
 
@@ -30060,6 +30638,11 @@ var AUMTypes = /* @__PURE__ */ ((AUMTypes2) => {
   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";
@@ -33240,7 +33823,8 @@ function getLooperSettings(lstSymbol, underlyingSymbol, vaultSettings, pool1) {
     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
@@ -33556,7 +34140,7 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
         packedArguments: [
           fromToken.address.toBigInt(),
           //wbtc
-          fromToken.address.toBigInt(),
+          toToken.address.toBigInt(),
           //usdc
           vaultAllocator.toBigInt()
         ],
@@ -33570,13 +34154,11 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
   }
   async getDepositCall(params) {
     try {
-      console.log("params.amount", params.amount);
       const fromToken = this.config.supportedPositions[0].asset;
       const toToken = this.config.supportedPositions[1].asset;
       const vaultAllocator = ContractAddr.from(
         this.config.vaultAllocator.address
       );
-      console.log("vaultAllocator", vaultAllocator);
       const quote = await this.getQuotesAvnu(
         fromToken.address.toString(),
         toToken.address.toString(),
@@ -33632,7 +34214,6 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
       const vaultAllocator = ContractAddr.from(
         this.config.vaultAllocator.address
       );
-      console.log("params.amount", params.amount);
       const quote = await this.getQuotesAvnu(
         fromToken.address.toString(),
         toToken.address.toString(),
@@ -33651,8 +34232,6 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
       );
       const swapCallData = getCalldata[0];
       const amount = import_starknet24.uint256.bnToUint256(params.amount.toWei());
-      console.log("amount", amount);
-      console.log("swapCallData", swapCallData);
       return [
         {
           sanitizer: SIMPLE_SANITIZER,
@@ -33706,7 +34285,7 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
     }
     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;
@@ -33727,14 +34306,12 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
         return dataObject2;
       }
       const btcPrice = await this.getPriceOfToken(toToken.address.toString());
-      console.log("btcPrice", btcPrice);
       if (!btcPrice) {
         logger.error(`error getting btc price: ${btcPrice}`);
         return null;
       }
       const estimatedUsdcAmount = Math.floor(amount * btcPrice);
       const targetBtcBig = BigInt(returnFormattedAmount(amount, toTokenDecimals));
-      console.log("targetBtcBig", targetBtcBig);
       let low = BigInt(
         Math.floor(
           estimatedUsdcAmount * 10 ** fromToken.decimals * 0.9
@@ -33837,6 +34414,23 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       debtPrice
     };
   }
+  async getUnusedBalanceUSDCE() {
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
+    const balance = await new ERC20(this.config).balanceOf(
+      usdceToken.address,
+      WALLET_ADDRESS,
+      usdceToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdceToken.symbol);
+    const usdValue = Number(balance.toFixed(usdceToken.decimals)) * price.price;
+    return {
+      tokenInfo: usdceToken,
+      amount: balance,
+      usdValue
+    };
+  }
   async getUnusedBalanceWBTC() {
     const collateralToken = this.metadata.additionalInfo.borrowable_assets[0];
     const balance = await new ERC20(this.config).balanceOf(
@@ -33882,22 +34476,30 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     }
     return extendedAdapter.adapter;
   }
-  async moveAssetsToVaultAllocator(amount) {
+  async moveAssetsToVaultAllocator(amount, extendedAdapter) {
     try {
-      const usdcToken = Global.getDefaultTokens().find(
-        (token) => token.symbol === "USDC"
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
       );
       const approveCall = new ERC20(this.config).approve(
-        usdcToken.address,
+        usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
         amount
       );
       const transferCall = new ERC20(this.config).transfer(
-        usdcToken.address,
+        usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
         amount
       );
-      return [approveCall, transferCall];
+      const proofsInfo = extendedAdapter.getProofsForFromLegacySwap(
+        this.getMerkleTree()
+      );
+      const proofGroups = proofsInfo.proofs;
+      const call = this.getManageCall(
+        proofGroups,
+        await proofsInfo.callConstructor({ amount })
+      );
+      return [approveCall, transferCall, call];
     } catch (err) {
       logger.error(`error moving assets to vault allocator: ${err}`);
       return [];
@@ -33905,11 +34507,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
   }
   async shouldInvest() {
     try {
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest starting`);
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
+      if (!vesuAdapter) {
         logger.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,
@@ -33921,10 +34525,87 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           vesuLeverage: 0
         };
       }
+      if (!extendedAdapter) {
+        logger.error(
+          `Extended 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.client) {
+        logger.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
+        };
+      }
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
       const balance = await this.getUnusedBalance();
+      if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
+        logger.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
+        };
+      }
+      logger.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) {
+          logger.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)) {
+        logger.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
+        };
+      }
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
+      if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
         return {
           shouldInvest: false,
           vesuAmount: new Web3Number(0, 0),
@@ -33953,6 +34634,34 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         collateralPrice,
         debtPrice
       } = await this.getAssetPrices();
+      if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+        logger.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) {
+        logger.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,
@@ -33976,6 +34685,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           vesuLeverage: 0
         };
       }
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`);
       return {
         shouldInvest: true,
         vesuAmount: vesu_amount,
@@ -34002,18 +34712,48 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     try {
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      let calls = [];
       if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return calls;
+        return [];
+      }
+      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedHoldings) {
+        logger.error(`error getting extended holdings: ${extendedHoldings}`);
+        return [];
       }
-      console.log("extendedAmount", extendedAmount);
-      console.log("vesuAmount", vesuAmount);
-      if (extendedAmount.lessThan(0)) {
+      const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
+      const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
+        extendedHoldings.availableForWithdrawal
+      );
+      logger.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();
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`);
+      let 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,
@@ -34022,14 +34762,18 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             extendedAdapter,
             vesuAdapter
           );
-          calls.push(...extendedCalls);
+          if (extendedStatus) {
+            calls.push(...extendedCalls);
+          } else {
+            return [];
+          }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
-      if (vesuAmount.lessThan(0)) {
+      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,
@@ -34039,49 +34783,83 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             vesuAdapter
           );
           calls.push(...vesuCalls);
+          if (!vesuStatus) {
+            return [];
+          }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
-      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-      if (!extendedHoldings) {
-        logger.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 (err) {
-          logger.error(`Failed moving assets to extended: ${err}`);
+      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 {
+              logger.error(`Failed to move assets to extended - operation returned false status`);
+              return [];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets to extended: ${err}`);
+            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 {
+              logger.error(`Failed to withdraw from extended - operation returned false status`);
+              return [];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets from extended to vault: ${err}`);
+            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)) {
+          logger.warn(
+            `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
           );
-          calls.push(...vesuCalls);
-        } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
+        } else {
+          try {
+            const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: vesuAmountDifference
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (!vesuStatus) {
+              logger.error(`Failed to move assets to vesu - operation returned false status`);
+              return [];
+            }
+            calls.push(...vesuCalls);
+          } catch (err) {
+            logger.error(`Failed moving assets to vault: ${err}`);
+            return [];
+          }
         }
       }
       return calls;
@@ -34092,12 +34870,47 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
   }
   async moveAssets(params, extendedAdapter, vesuAdapter) {
     try {
+      if (params.amount.lessThanOrEqualTo(0)) {
+        logger.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)) {
+          logger.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)) {
+          logger.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) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return [];
+        return {
+          calls: [],
+          status: false
+        };
       }
-      logger.info("moveAssets params", params);
+      logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
       const {
         collateralPrice
@@ -34114,21 +34927,78 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return calls;
+        return {
+          calls: [call],
+          status: true
+        };
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
+        const extendedLeverage = calculateExtendedLevergae();
+        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+        if (!extendedHoldings) {
+          logger.error(`error getting extended holdings: ${extendedHoldings}`);
+          return {
+            calls: [],
+            status: false
+          };
+        }
+        const extendedHoldingAmount = new Web3Number(
+          extendedHoldings.availableForWithdrawal,
+          USDC_TOKEN_DECIMALS
+        );
+        logger.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`);
+        if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
+          const leftAmountAfterWithdrawalAmountInAccount = params.amount.abs().minus(extendedHoldingAmount);
+          logger.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) {
+            logger.error(`error opening long position: ${openLongPosition}`);
+          }
+          const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
+          if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
+            logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
+            return { calls: [], status: false };
+          }
+        }
         const withdrawalFromExtended = await extendedAdapter.withdrawFromExtended(params.amount);
         if (withdrawalFromExtended) {
-          const calls = await this.moveAssetsToVaultAllocator(params.amount);
+          const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
+          logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.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 {
           logger.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) {
+          logger.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(),
+          params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
           collateralToken.decimals
         );
         const proofsInfo = vesuAdapter.getProofs(false, this.getMerkleTree());
@@ -34146,8 +35016,19 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return calls;
+        return {
+          calls,
+          status: true
+        };
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
+        if (!isPriceDifferenceBetweenAvnuAndExtended) {
+          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+          return {
+            calls: [],
+            status: false
+          };
+        }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
           collateralToken.decimals
@@ -34177,13 +35058,21 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return calls;
+        return {
+          calls,
+          status: true
+        };
       }
-      console.warn("moveAssets received unsupported route:", params);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
   async handleDeposit() {
@@ -34203,7 +35092,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         };
       }
       const extendedLeverage = calculateExtendedLevergae();
-      const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter);
+      const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "open" /* OPEN */);
       if (!isPriceDifferenceBetweenAvnuAndExtended) {
         logger.error("price difference between avnu and extended doesn't fit the range");
         return {
@@ -34220,6 +35109,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         };
       }
       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) {
         logger.error(`error getting extended holdings: ${extendedHoldings}`);
@@ -34238,12 +35128,11 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       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);
+      logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
       let calls = [];
       if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
         const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
@@ -34256,7 +35145,6 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         );
         const { amount: wbtcAmountInVaultAllocator } = await this.getUnusedBalanceWBTC();
         if (wbtcAmountInVaultAllocator.lessThan(vesuAmountInBTC)) {
-          console.log("error wbtc amount in vault allocator is less than vesu amount in btc", wbtcAmountInVaultAllocator, vesuAmountInBTC);
           const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
           const swapProofGroups = swapProofsInfo.proofs;
           const swapCall = this.getManageCall(
@@ -34291,68 +35179,98 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         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) {
       logger.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 */) {
+      logger.info(`price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`);
+      const result = priceDifference.greaterThanOrEqualTo(avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen);
+      logger.info(`result: ${result}`);
+      return result;
+    } else {
+      logger.info(`price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+      const result = priceDifference.lessThanOrEqualTo(avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing);
+      logger.info(`result: ${result}`);
+      return result;
     }
-    logger.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);
       logger.info(`usdcBalanceDifference, ${usdcBalanceDifference.toNumber()}`);
+      let calls = [];
+      let status = true;
       if (usdcBalanceDifference.lessThan(0)) {
-        const withdrawCall = await this.getBringLiquidityCall({
-          amount
+        const withdrawCall2 = await this.getBringLiquidityCall({
+          amount: usdcBalanceVaultAllocator.amount
         });
-        logger.info("withdraw call", withdrawCall);
-        return [withdrawCall];
+        logger.info("withdraw call", withdrawCall2);
+        calls.push(withdrawCall2);
+        return {
+          calls,
+          status: true
+        };
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
       if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        status = false;
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return [];
+        return {
+          calls,
+          status
+        };
       }
       const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
       const {
         collateralPrice
       } = await this.getAssetPrices();
       const extendedPositon = await extendedAdapter.getAllOpenPositions();
+      if (!extendedPositon) {
+        status = false;
+        logger.error("error getting extended position", extendedPositon);
+        return {
+          calls,
+          status
+        };
+      }
       const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
-        amount,
+        usdcBalanceDifference,
         collateralPrice.price,
         collateralTokenAmount,
         extendedPositon
       );
       if (!amountDistributionForWithdrawal) {
+        status = false;
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return [];
+        return {
+          calls,
+          status
+        };
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
-      if (vesu_amount.greaterThan(0)) {
-        const result = await this.moveAssets(
+      if (status && vesu_amount.greaterThan(0)) {
+        const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
@@ -34361,10 +35279,11 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedAdapter,
           vesuAdapter
         );
-        return result;
+        status = vesuStatus;
+        calls.push(...vesuCalls);
       }
-      if (extended_amount.greaterThan(0)) {
-        const result = await this.moveAssets(
+      if (status && extended_amount.greaterThan(0)) {
+        const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
@@ -34373,12 +35292,32 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           extendedAdapter,
           vesuAdapter
         );
-        return result;
+        status = extendedStatus;
+        if (status) {
+          calls.push(...extendedCalls);
+        } else {
+          logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
+          return {
+            calls: [],
+            status
+          };
+        }
       }
-      return [];
+      const withdrawCall = await this.getBringLiquidityCall({
+        amount
+      });
+      logger.info("withdraw call", withdrawCall);
+      calls.push(withdrawCall);
+      return {
+        calls,
+        status
+      };
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
   async getAUM() {
@@ -34426,7 +35365,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     };
   }
 };
-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
@@ -34450,7 +35389,9 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     ...baseAdapterConfig,
     avnuContract: AVNU_MIDDLEWARE,
     slippage: 0.01,
-    baseUrl: AVNU_QUOTE_URL
+    baseUrl: AVNU_QUOTE_URL,
+    minimumExtendedPriceDifferenceForSwapOpen,
+    maximumExtendedPriceDifferenceForSwapClosing
   });
   const extendedAdapter = new ExtendedAdapter({
     ...baseAdapterConfig,
@@ -34466,7 +35407,10 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     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,
@@ -34479,7 +35423,9 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     supportedPositions: [
       { asset: wbtcToken, isDebt: false },
       { asset: usdcToken, isDebt: true }
-    ]
+    ],
+    minimumVesuMovementAmount: minimumVesuMovementAmount ?? 5
+    //5 usdc
   });
   const unusedBalanceAdapter = new UnusedBalanceAdapter({
     ...baseAdapterConfig
@@ -34512,6 +35458,7 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     () => vesuMultiplyAdapter.getWithdrawLeaf()
   );
   vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(
@@ -34574,11 +35521,11 @@ function VaultDescription2(lstSymbol, underlyingSymbol) {
   ] });
 }
 var re7UsdcPrimeDevansh = {
-  vaultAddress: ContractAddr.from("0x520a2e945dd0762e5284fc1b012f62ca04e238e105eb362d5e0ce208928729d"),
-  manager: ContractAddr.from("0x6abe24d31cbc16d7c4acb2421a826f96273e225b4a2d168d91e65123da0bfb9"),
-  vaultAllocator: ContractAddr.from("0x6e4f716e22efb164ee4a831233e513f45396ad3be4cff3c07386be0226febed"),
-  redeemRequestNFT: ContractAddr.from("0x66060e1874e05506b18e6029188ec49bf231a411ad57642311bbdf3cb22e5f"),
-  aumOracle: ContractAddr.from("0x301d883b9b45c76132638e39326b3f464c492599623263d405ec0df991e27ab"),
+  vaultAddress: ContractAddr.from("0x7efaff77601813ca674c1ffe0479fc0361c0f5099f64a67d4793b80382750c2"),
+  manager: ContractAddr.from("0x2579342f53fbf2f775b0c71d24f162aaf1d3e466edea09a6c51e77a95bd986d"),
+  vaultAllocator: ContractAddr.from("0x46ee6073484a669631e8f88b9f357b0b073cee1bc47752fc32453dd6c1efd7b"),
+  redeemRequestNFT: ContractAddr.from("0x1d66120b0a76068454ea36276d9f404b0a980083dcaebbf6d9f4ad154a79dbe"),
+  aumOracle: ContractAddr.from("0x419a5e8b5a1fe5b2586e64409d5cfdb1712791aaa9361264730227563d4e140"),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.4,
@@ -34593,12 +35540,12 @@ var re7UsdcPrimeDevansh = {
   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),
@@ -34606,7 +35553,7 @@ function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses,
     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),
@@ -38883,6 +39830,7 @@ var deployer_default = Deployer;
   PRICE_ROUTER,
   PasswordJsonCryptoUtil,
   PositionSide,
+  PositionTypeAvnuExtended,
   Pragma,
   Pricer,
   PricerBase,