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

package/dist/index.js

@@ -43,11 +43,13 @@ __export(index_exports, {
   AssetOperationStatus: () => AssetOperationStatus,
   AssetOperationType: () => AssetOperationType,
   AutoCompounderSTRK: () => AutoCompounderSTRK,
+  AvnuAdapter: () => AvnuAdapter,
   AvnuWrapper: () => AvnuWrapper,
   BaseAdapter: () => BaseAdapter,
   BaseStrategy: () => BaseStrategy,
   CommonAdapter: () => CommonAdapter,
   ContractAddr: () => ContractAddr,
+  CycleType: () => CycleType,
   Deployer: () => deployer_default,
   ERC20: () => ERC20,
   EXTENDED_CONTRACT: () => EXTENDED_CONTRACT,
@@ -76,6 +78,7 @@ __export(index_exports, {
   PRICE_ROUTER: () => PRICE_ROUTER,
   PasswordJsonCryptoUtil: () => PasswordJsonCryptoUtil,
   PositionSide: () => PositionSide,
+  PositionTypeAvnuExtended: () => PositionTypeAvnuExtended,
   Pragma: () => Pragma,
   Pricer: () => Pricer,
   PricerBase: () => PricerBase,
@@ -125,6 +128,7 @@ __export(index_exports, {
   calculateExtendedLevergae: () => calculateExtendedLevergae,
   calculateVesUPositionSizeGivenExtended: () => calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage: () => calculateVesuLeverage,
+  calculateWBTCAmountToMaintainLTV: () => calculateWBTCAmountToMaintainLTV,
   extensionMap: () => extensionMap,
   getAPIUsingHeadlessBrowser: () => getAPIUsingHeadlessBrowser,
   getContractDetails: () => getContractDetails,
@@ -4474,20 +4478,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 +4503,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) {
@@ -4546,7 +4539,6 @@ var EkuboQuoter = class _EkuboQuoter {
     return quote.splits.map((split) => {
       const isNegativeAmount = BigInt(split.amount_specified) <= 0n;
       const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
-      console.log("token for withdrawal", token, isNegativeAmount);
       return {
         route: split.route.map((_route) => ({
           pool_key: {
@@ -27219,11 +27211,6 @@ var VesuAdapter = class _VesuAdapter extends CacheClass {
     if (!this.pricer) {
       throw new Error("Pricer is not initialized");
     }
-    const CACHE_KEY = `positions_${blockNumber}_${this.config.poolId.shortString()}_${this.config.collateral.symbol}_${this.config.debt.symbol}`;
-    const cacheData = this.getCache(CACHE_KEY);
-    if (cacheData) {
-      return cacheData;
-    }
     const { contract, isV2 } = this.getVesuSingletonContract(config, this.config.poolId);
     const output = await contract.call(isV2 ? "position" : "position_unsafe", [
       ...isV2 ? [] : [this.config.poolId.address],
@@ -27249,7 +27236,6 @@ var VesuAdapter = class _VesuAdapter extends CacheClass {
       usdValue: debtAmount.multipliedBy(token2Price.price).toNumber(),
       remarks: "Debt"
     }];
-    this.setCache(CACHE_KEY, value, 6e4);
     return value.map((v) => ({ ...v, protocol: Protocols.VESU }));
   }
   async getCollateralization(config, blockNumber = "latest") {
@@ -28172,15 +28158,14 @@ var MAX_PRICE_DROP_PERCENTAGE = Number(process.env.MAX_PRICE_DROP_PERCENTAGE ??
 var MAX_LTV_BTC_USDC = 0.8428;
 var MAX_LIQUIDATION_RATIO = 0.86;
 var VAULT_ID_EXTENDED = process.env.VAULT_ID_EXTENDED ?? 220774;
-var WALLET_ADDRESS = process.env.WALLET_ADDRESS ?? "0x07b84bb6E87588BdAde0bfe6173A615b3C220F9C3803456aE183C50EA1d15Ba1";
-var TESTNET_WALLET_ADDRESS = process.env.TESTNET_WALLET_ADDRESS ?? "0x07b84bb6E87588BdAde0bfe6173A615b3C220F9C3803456aE183C50EA1d15Ba1";
-var TEST_WALLET_2 = process.env.TEST_WALLET_2 ?? "0x004C1bdC61DAc7947F3C93d0163d660012E2aB0521567f7155fcf502848791A7";
+var WALLET_ADDRESS = process.env.WALLET_ADDRESS ?? "0x007E24592287427aaE9d291770B17d582E8A45f3aE54228F998793Ec769B7D13";
 var STRK_API_TEST_RPC = process.env.STRK_API_TEST_RPC ?? "https://sepolia.starknet.a5a.ch";
 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);
@@ -28198,8 +28183,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) => {
@@ -28219,8 +28202,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();
@@ -28257,7 +28239,6 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       return null;
     }
     const extendedExposureUSD = extendedPosition.length > 0 ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS) : new Web3Number(0, USDC_TOKEN_DECIMALS);
-    console.log("THe collateral is", collateralPrice, collateralUnits);
     const vesuExposureUSD = collateralUnits.multipliedBy(collateralPrice);
     if (vesuExposureUSD.lessThan(0)) {
       return {
@@ -28314,10 +28295,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);
@@ -28352,19 +28333,34 @@ 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;
   }
 };
+var calculateWBTCAmountToMaintainLTV = (collateralAmount, debtAmount, debtPrice, maxLtv = MAX_LIQUIDATION_RATIO, collateralPrice, targetHF = TARGET_HF) => {
+  try {
+    const numerator1 = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLtv);
+    const numerator2 = debtAmount.multipliedBy(debtPrice).multipliedBy(targetHF);
+    const denominator = maxLtv;
+    const collateralAmountToMaintainLTV = numerator2.minus(numerator1).dividedBy(denominator);
+    let deltaCollateralAmountUnits = new Web3Number(
+      collateralAmountToMaintainLTV.dividedBy(collateralPrice).toFixed(WBTC_TOKEN_DECIMALS),
+      WBTC_TOKEN_DECIMALS
+    );
+    return { deltaCollateralAmountUnits };
+  } catch (err) {
+    return { deltaCollateralAmountUnits: null };
+  }
+};
 var calculateExposureDelta = (exposure_extended, exposure_vesu) => {
   const exposure_delta = new Web3Number(exposure_extended - exposure_vesu, 2);
   return exposure_delta.absoluteValue().toNumber();
@@ -28439,21 +28435,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 */
@@ -28463,7 +28474,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 */
@@ -28474,7 +28487,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;
@@ -28490,7 +28505,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;
     }
   }
@@ -28503,12 +28521,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"
@@ -28521,12 +28543,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;
   }
@@ -28536,9 +28564,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");
       }
@@ -28548,13 +28582,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");
       }
@@ -28572,14 +28616,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,
@@ -28592,7 +28647,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;
     }
   }
@@ -28602,9 +28660,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");
       }
@@ -28614,11 +28678,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,
@@ -28631,14 +28704,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
@@ -28702,7 +28780,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;
@@ -28759,33 +28839,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 [
@@ -28857,7 +28955,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
@@ -28912,7 +29012,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({
@@ -28922,42 +29026,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(
@@ -28967,26 +29112,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)) {
             leverSwapLimitAmount = debtAmount.multipliedBy(1 + MAX_SLIPPAGE);
           } else if (debtAmount.lessThan(0)) {
             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));
         } 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;
   }
@@ -29000,7 +29168,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
     } : {
@@ -29014,7 +29185,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
     };
@@ -29030,12 +29204,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,
@@ -29049,8 +29227,14 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     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 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,
@@ -29058,12 +29242,23 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     );
     const MAX_SLIPPAGE = 2e-3;
     if (swapQuote.price_impact < 25e-4) {
-      leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, collateralToken, debtToken);
+      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`
+      );
     }
     leverSwapLimitAmount = new Web3Number(debtAmountToRepay, debtToken.decimals).abs().multipliedBy(1 + MAX_SLIPPAGE);
-    const multiplyParams = await this.getLeverParams(false, params, leverSwap, leverSwapLimitAmount);
+    const multiplyParams = await this.getLeverParams(
+      false,
+      params,
+      leverSwap,
+      leverSwapLimitAmount
+    );
     const call = multiplyContract.populate("modify_lever", {
       modify_lever_params: this.formatMultiplyParams(false, multiplyParams)
     });
@@ -29073,100 +29268,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() {
@@ -29175,11 +29402,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),
@@ -29322,7 +29553,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;
@@ -29382,6 +29628,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", {
@@ -29520,6 +29767,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" });
@@ -29529,11 +29777,13 @@ var ExtendedWrapper = class {
    * @param marketName - The name of the market to get funding rates for
    * @returns The funding rates for the specified market
    */
-  async getFundingRates(marketName, side) {
+  async getFundingRates(marketName, side, startTime, endTime) {
+    const endTimeParam = endTime !== void 0 ? `&end_time=${endTime}` : "";
+    const startTimeParam = startTime !== void 0 ? `&start_time=${startTime}` : "";
     return this.makeRequest(
       `/api/v1/markets/funding-rates?market_name=${encodeURIComponent(
         marketName
-      )}&side=${encodeURIComponent(side)}`
+      )}&side=${encodeURIComponent(side)}${startTimeParam}${endTimeParam}`
     );
   }
 };
@@ -29546,18 +29796,20 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     super(config, _ExtendedAdapter.name, Protocols.EXTENDED);
     this.config = config;
     const client = new wrapper_default({
-      baseUrl: this.config.extendedBackendUrl,
-      apiKey: this.config.extendedApiKey,
+      baseUrl: this.config.extendedBackendWriteUrl,
+      apiKey: "",
       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);
-    if (fundingRates.status !== "OK") {
+    const fundingRates = await this.getFundingRates(side);
+    if (!fundingRates.success) {
       logger.error("error getting funding rates", fundingRates);
       return { apy: 0, type: "base" /* BASE */ };
     }
@@ -29565,10 +29817,26 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     const apy = Number(fundingRate.f) * 365 * 24;
     return { apy, type: "base" /* BASE */ };
   }
-  async getPosition(supportedPosition) {
-    if (!this.client) {
-      throw new Error("Client not initialized");
+  async getFundingRates(side, startTime, endTime) {
+    try {
+      const response = await import_axios8.default.get(`${this.config.extendedBackendReadUrl}/fundingRates/${this.config.extendedMarketName}/${side}`, {
+        params: {
+          startTime: startTime ? startTime.toString() : void 0,
+          endTime: endTime ? endTime.toString() : void 0
+        }
+      });
+      if (!response.data.success) {
+        logger.error("error getting funding rates", response.data);
+        return { success: false, data: [] };
+      }
+      logger.info("success getting funding rates", response.data.data);
+      return { success: true, data: response.data.data };
+    } catch (err) {
+      logger.error("error getting funding rates", err);
+      return { success: false, data: [] };
     }
+  }
+  async getPosition(supportedPosition) {
     const holdings = await this.getExtendedDepositAmount();
     if (!holdings) {
       throw new Error("No position found");
@@ -29576,7 +29844,7 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     const amount = holdings.equity;
     return Promise.resolve({
       amount: new Web3Number(amount, 0),
-      remarks: `${holdings.availableForWithdrawal} ${holdings.equity}`
+      remarks: `Extended Equity`
     });
   }
   async maxDeposit(amount) {
@@ -29600,14 +29868,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
       },
@@ -29638,25 +29906,33 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     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);
+      const leaf = this.constructSimpleLeafData(
+        {
+          id,
+          target,
+          method,
+          packedArguments
+        },
+        sanitizer
+      );
       return leaf;
     });
-    return { leaves, callConstructor: this.getSwapFromLegacyCall.bind(this) };
+    return {
+      leaves,
+      callConstructor: this.getSwapFromLegacyCall.bind(
+        this
+      )
+    };
   }
   _getSwapFromLegacyLeaf() {
-    const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
     return [
       {
         target: usdceToken.address,
         method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()
-        ],
+        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
         id: `extendedswaplegacyapprove_${usdceToken.symbol}`,
         sanitizer: AVNU_LEGACY_SANITIZER
       },
@@ -29675,11 +29951,13 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
   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(),
@@ -29692,7 +29970,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 [
         {
@@ -29768,8 +30048,12 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
   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 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(),
@@ -29782,7 +30066,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 [
         {
@@ -29828,38 +30114,131 @@ 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 {
+          status: false,
+          receivedTxnHash: false
+        };
+      }
+      if (amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+        );
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
+      }
+      if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
+        logger.warn(
+          `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
+        );
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
+      }
+      const holdings = await this.getExtendedDepositAmount();
+      if (!holdings) {
+        logger.error(
+          "Cannot get holdings - unable to validate withdrawal amount"
+        );
+        return {
+          status: false,
+          receivedTxnHash: 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 {
+          status: false,
+          receivedTxnHash: false
+        };
+      }
+      const withdrawalAmount = amount.toNumber();
+      if (withdrawalAmount > availableForWithdrawal) {
+        logger.error(
+          `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
+        );
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
-      const withdrawalRequest = await this.client.withdrawUSDC(amount.toFixed(2));
+      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;
+        const withdrawalStatus = await this.getDepositOrWithdrawalStatus(
+          withdrawalRequest.data,
+          "WITHDRAWAL" /* WITHDRAWAL */
+        );
+        return {
+          status: true,
+          receivedTxnHash: withdrawalStatus
+        };
       }
-      return false;
+      logger.error(
+        `Withdrawal request failed with status: ${withdrawalRequest.status}`
+      );
+      return {
+        status: false,
+        receivedTxnHash: false
+      };
     } catch (error) {
       logger.error(`Error creating Withdraw Call: ${error}`);
-      return false;
+      return {
+        status: false,
+        receivedTxnHash: false
+      };
     }
   }
   async getHealthFactor() {
     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 {
+      const result = await import_axios8.default.get(`${this.config.extendedBackendReadUrl}/holdings`);
+      if (!result.data) {
+        logger.error("error getting holdings - API returned null/undefined");
+        return void 0;
+      }
+      if (!result.data.success) {
+        logger.error(
+          `error getting holdings - API returned status: ${result.status}`
+        );
+        return void 0;
+      }
+      const holdings = result.data.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) {
@@ -29876,46 +30255,52 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     return false;
   }
   async getAllOpenPositions() {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return null;
-    }
-    const response = await this.client.getPositionsForMarket(
-      this.config.extendedMarketName
-    );
-    if (response.status === "OK") {
-      if (response.data.length === 0) {
-        return [];
-      } else {
-        return response.data;
+    try {
+      const response = await import_axios8.default.get(`${this.config.extendedBackendReadUrl}/positions`);
+      if (response.data.success) {
+        if (response.data.data.length === 0) {
+          return [];
+        } else {
+          return response.data.data;
+        }
       }
+      return null;
+    } catch (err) {
+      logger.error("error getting all open positions", err);
+      return null;
     }
-    return null;
   }
   async getOrderHistory(marketName) {
-    if (this.client === null) {
-      logger.error("error initializing client");
+    try {
+      const result = await import_axios8.default.get(`${this.config.extendedBackendReadUrl}/marketOrders/${marketName}`);
+      if (!result.data.success) {
+        return null;
+      }
+      return result.data.data;
+    } catch (err) {
+      logger.error("error getting order history", err);
       return null;
     }
-    const result = await this.client.getOrderHistory(marketName);
-    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 {
@@ -29966,14 +30351,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
       );
@@ -29984,14 +30395,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;
@@ -30005,13 +30459,18 @@ 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;
         logger.info(`Retrying after ${backoff}ms...`);
@@ -30050,28 +30509,101 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     }
   }
   async getDepositOrWithdrawalStatus(orderId, operationsType) {
-    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) {
-          return true;
+    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?.toLowerCase() === orderId.toString().toLowerCase()
+          );
+          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.toString() === orderId.toString());
-        if (!myTransferStatus) {
-          return true;
+      } 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;
   }
 };
 
@@ -30151,12 +30683,349 @@ var UnusedBalanceAdapter = class _UnusedBalanceAdapter extends BaseAdapter {
   }
 };
 
+// src/strategies/universal-adapters/avnu-adapter.ts
+var import_starknet23 = require("starknet");
+var import_axios9 = __toESM(require("axios"));
+var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
+  constructor(config) {
+    super(config, _AvnuAdapter.name, Protocols.AVNU);
+    this.config = config;
+    this.avnuWrapper = new AvnuWrapper();
+  }
+  //abstract means the method has no implementation in this class; instead, child classes must implement it.
+  async getAPY(supportedPosition) {
+    return Promise.resolve({ apy: 0, type: "base" /* BASE */ });
+  }
+  async getPosition(supportedPosition) {
+    return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "Avnu Positions" });
+  }
+  async maxDeposit(amount) {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: "base" /* BASE */ },
+      protocol: Protocols.AVNU,
+      remarks: ""
+    });
+  }
+  async maxWithdraw() {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: "base" /* BASE */ },
+      protocol: Protocols.AVNU,
+      remarks: ""
+    });
+  }
+  _getDepositLeaf() {
+    const vaultAllocator = ContractAddr.from(
+      this.config.vaultAllocator.address
+    );
+    return [
+      {
+        target: this.config.supportedPositions[0].asset.address,
+        method: "approve",
+        packedArguments: [
+          AVNU_EXCHANGE.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_${this.config.supportedPositions[0].asset.symbol}`
+      },
+      {
+        target: AVNU_EXCHANGE,
+        method: "multi_route_swap",
+        packedArguments: [
+          this.config.supportedPositions[0].asset.address.toBigInt(),
+          //usdc
+          this.config.supportedPositions[1].asset.address.toBigInt(),
+          //wbtc
+          vaultAllocator.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `asutb_${this.config.supportedPositions[0].asset.symbol}_${this.config.supportedPositions[1].asset.symbol}`
+      }
+    ];
+  }
+  _getWithdrawLeaf() {
+    const vaultAllocator = ContractAddr.from(
+      this.config.vaultAllocator.address
+    );
+    const toToken = this.config.supportedPositions[0].asset;
+    const fromToken = this.config.supportedPositions[1].asset;
+    return [
+      {
+        target: fromToken.address,
+        method: "approve",
+        packedArguments: [
+          AVNU_EXCHANGE.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_${fromToken.symbol}`
+      },
+      {
+        target: AVNU_EXCHANGE,
+        method: "multi_route_swap",
+        packedArguments: [
+          fromToken.address.toBigInt(),
+          //wbtc
+          toToken.address.toBigInt(),
+          //usdc
+          vaultAllocator.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `asbtu_${fromToken.symbol}_${fromToken.symbol}`
+      }
+    ];
+  }
+  _getLegacySwapLeaf() {
+    return [];
+  }
+  async getDepositCall(params) {
+    try {
+      const fromToken = this.config.supportedPositions[0].asset;
+      const toToken = this.config.supportedPositions[1].asset;
+      const vaultAllocator = ContractAddr.from(
+        this.config.vaultAllocator.address
+      );
+      const quote = await this.getQuotesAvnu(
+        fromToken.address.toString(),
+        toToken.address.toString(),
+        params.amount.toNumber(),
+        vaultAllocator.address.toString(),
+        toToken.decimals,
+        true
+      );
+      if (!quote) {
+        logger.error("error getting quote from avnu");
+        return [];
+      }
+      const getCalldata = await this.avnuWrapper.getSwapCallData(
+        quote,
+        vaultAllocator.address
+      );
+      const swapCallData = getCalldata[0];
+      const amount = import_starknet23.uint256.bnToUint256(quote.sellAmountInUsd * 10 ** 7);
+      return [
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: fromToken.address,
+            selector: import_starknet23.hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE.toBigInt(),
+              toBigInt(amount.low.toString()),
+              // amount low
+              toBigInt(amount.high.toString())
+              // amount high
+            ]
+          }
+        },
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE,
+            selector: import_starknet23.hash.getSelectorFromName("multi_route_swap"),
+            calldata: swapCallData
+          }
+        }
+      ];
+    } catch (error) {
+      logger.error(`Error getting Avnu quote: ${error}`);
+      return [];
+    }
+  }
+  //Swap wbtc to usdc
+  async getWithdrawCall(params) {
+    try {
+      const toToken = this.config.supportedPositions[0].asset;
+      const fromToken = this.config.supportedPositions[1].asset;
+      const vaultAllocator = ContractAddr.from(
+        this.config.vaultAllocator.address
+      );
+      const quote = await this.getQuotesAvnu(
+        fromToken.address.toString(),
+        toToken.address.toString(),
+        params.amount.toNumber(),
+        vaultAllocator.address.toString(),
+        fromToken.decimals,
+        false
+      );
+      if (!quote) {
+        logger.error("No quotes available for this swap, error in quotes avnu");
+        return [];
+      }
+      const getCalldata = await this.avnuWrapper.getSwapCallData(
+        quote,
+        vaultAllocator.address
+      );
+      const swapCallData = getCalldata[0];
+      const amount = import_starknet23.uint256.bnToUint256(params.amount.toWei());
+      return [
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: fromToken.address,
+            selector: import_starknet23.hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE.toBigInt(),
+              toBigInt(amount.low.toString()),
+              // amount low
+              toBigInt(amount.high.toString())
+              // amount high
+            ]
+          }
+        },
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE,
+            selector: import_starknet23.hash.getSelectorFromName("multi_route_swap"),
+            calldata: swapCallData
+          }
+        }
+      ];
+    } catch (error) {
+      logger.error(`Error getting Avnu quote: ${error}`);
+      return [];
+    }
+  }
+  async getSwapCallData(quote) {
+    return await this.avnuWrapper.getSwapCallData(quote, this.config.vaultAllocator.address);
+  }
+  async getHealthFactor() {
+    return Promise.resolve(1);
+  }
+  async fetchQuoteWithRetry(params, retries = 5) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const response = await import_axios9.default.get(this.config.baseUrl, { params });
+        if (response.data && response.data.length > 0) {
+          return response;
+        }
+        throw new Error("Empty response data");
+      } catch (err) {
+        logger.error(`Error fetching quote with retry: ${err}`);
+        if (attempt === retries - 1) {
+          throw err;
+        }
+        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+      }
+    }
+    throw new Error("Failed to fetch quote after retries");
+  }
+  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;
+      if (!usdcToBtc) {
+        const sellAmount2 = returnFormattedAmount(amount, toTokenDecimals);
+        const params2 = {
+          sellTokenAddress: from_token_address,
+          buyTokenAddress: to_token_address,
+          takerAddress,
+          sellAmount: sellAmount2
+        };
+        const finalQuote2 = await this.fetchQuoteWithRetry(params2);
+        if (!finalQuote2.data.length) {
+          logger.error("No quotes available for this swap, error in quotes avnu");
+          return null;
+        }
+        const dataObject2 = finalQuote2.data[0];
+        return dataObject2;
+      }
+      const btcPrice = await this.getPriceOfToken(toToken.address.toString());
+      if (!btcPrice) {
+        logger.error(`error getting btc price: ${btcPrice}`);
+        return null;
+      }
+      const estimatedUsdcAmount = Math.floor(amount * btcPrice);
+      logger.info(`${_AvnuAdapter.name}::getQuotesAvnu estimatedUsdcAmount: ${estimatedUsdcAmount}`);
+      const targetBtcBig = BigInt(returnFormattedAmount(amount, toTokenDecimals));
+      logger.info(`${_AvnuAdapter.name}::getQuotesAvnu targetBtcBig: ${targetBtcBig}`);
+      let low = BigInt(
+        Math.floor(
+          estimatedUsdcAmount * 10 ** fromToken.decimals * 0.9
+        )
+      );
+      let high = BigInt(
+        Math.floor(
+          estimatedUsdcAmount * 10 ** fromToken.decimals * 1.1
+        )
+      );
+      let mid = 0n;
+      for (let i = 0; i < maxIterations; i++) {
+        mid = (low + high) / 2n;
+        const sellAmount2 = returnFormattedAmount(Number(mid), 0);
+        const quote = await this.fetchQuoteWithRetry({
+          sellTokenAddress: from_token_address,
+          buyTokenAddress: to_token_address,
+          takerAddress,
+          sellAmount: sellAmount2
+        });
+        const gotBtc = BigInt(quote.data[0].buyAmount);
+        if (gotBtc === targetBtcBig) return quote.data[0];
+        if (gotBtc > targetBtcBig) {
+          high = mid;
+        } else {
+          low = mid;
+        }
+        if (gotBtc >= targetBtcBig && gotBtc <= targetBtcBig + BigInt(tolerance)) {
+          return quote.data[0];
+        }
+      }
+      let sellAmount = returnFormattedAmount(
+        Number(mid),
+        0
+      );
+      const params = {
+        sellTokenAddress: from_token_address,
+        buyTokenAddress: to_token_address,
+        takerAddress,
+        sellAmount
+      };
+      const finalQuote = await this.fetchQuoteWithRetry(params);
+      if (!finalQuote.data.length) {
+        logger.error("No quotes available for this swap, error in quotes avnu");
+        return null;
+      }
+      const dataObject = finalQuote.data[0];
+      return dataObject;
+    } catch (err) {
+      logger.error(`No quotes available for this swap: ${err}`);
+      return null;
+    }
+  }
+  async getPriceOfToken(tokenAddress, retries = MAX_RETRIES) {
+    try {
+      const url = `https://starknet.impulse.avnu.fi/v1/tokens/${tokenAddress}/prices/line`;
+      const response = await import_axios9.default.get(url);
+      const length = response.data.length;
+      return response.data[length - 1].value;
+    } catch (err) {
+      if (retries > 0) {
+        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+        return this.getPriceOfToken(tokenAddress, retries - 1);
+      } else {
+        logger.error(`Failed to fetch price for ${tokenAddress} after ${MAX_RETRIES} attempts`);
+        return null;
+      }
+    }
+  }
+};
+
 // src/strategies/universal-strategy.tsx
 var AUMTypes = /* @__PURE__ */ ((AUMTypes2) => {
   AUMTypes2["FINALISED"] = "finalised";
   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";
@@ -30184,7 +31053,7 @@ function getContractDetails(settings) {
 }
 
 // src/strategies/svk-strategy.ts
-var import_starknet23 = require("starknet");
+var import_starknet24 = require("starknet");
 
 // src/data/universal-vault.abi.json
 var universal_vault_abi_default = [
@@ -32511,12 +33380,12 @@ var SVKStrategy = class extends BaseStrategy {
     this.pricer = pricer;
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new import_starknet23.Contract({
+    this.contract = new import_starknet24.Contract({
       abi: universal_vault_abi_default,
       address: this.address.address,
       providerOrAccount: this.config.provider
     });
-    this.managerContract = new import_starknet23.Contract({
+    this.managerContract = new import_starknet24.Contract({
       abi: vault_manager_abi_default,
       address: this.metadata.additionalInfo.manager.address,
       providerOrAccount: this.config.provider
@@ -32629,7 +33498,7 @@ var SVKStrategy = class extends BaseStrategy {
   getSetManagerCall(strategist, root = this.getMerkleRoot()) {
     return this.managerContract.populate("set_manage_root", [
       strategist.address,
-      import_starknet23.num.getHexString(root)
+      import_starknet24.num.getHexString(root)
     ]);
   }
   /**
@@ -33337,7 +34206,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
@@ -33566,335 +34436,15 @@ var HyperLSTStrategies = [
   getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
 ];
 
-// src/strategies/universal-adapters/avnu-adapter.ts
-var import_starknet24 = require("starknet");
-var import_axios9 = __toESM(require("axios"));
-var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
-  constructor(config) {
-    super(config, _AvnuAdapter.name, Protocols.AVNU);
-    this.config = config;
-    this.avnuWrapper = new AvnuWrapper();
-  }
-  //abstract means the method has no implementation in this class; instead, child classes must implement it.
-  async getAPY(supportedPosition) {
-    return Promise.resolve({ apy: 0, type: "base" /* BASE */ });
-  }
-  async getPosition(supportedPosition) {
-    return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "" });
-  }
-  async maxDeposit(amount) {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: "base" /* BASE */ },
-      protocol: Protocols.AVNU,
-      remarks: ""
-    });
-  }
-  async maxWithdraw() {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: "base" /* BASE */ },
-      protocol: Protocols.AVNU,
-      remarks: ""
-    });
-  }
-  _getDepositLeaf() {
-    const vaultAllocator = ContractAddr.from(
-      this.config.vaultAllocator.address
-    );
-    return [
-      {
-        target: this.config.supportedPositions[0].asset.address,
-        method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `approve_${this.config.supportedPositions[0].asset.symbol}`
-      },
-      {
-        target: AVNU_EXCHANGE,
-        method: "multi_route_swap",
-        packedArguments: [
-          this.config.supportedPositions[0].asset.address.toBigInt(),
-          //usdc
-          this.config.supportedPositions[1].asset.address.toBigInt(),
-          //wbtc
-          vaultAllocator.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `asutb_${this.config.supportedPositions[0].asset.symbol}_${this.config.supportedPositions[1].asset.symbol}`
-      }
-    ];
-  }
-  _getWithdrawLeaf() {
-    const vaultAllocator = ContractAddr.from(
-      this.config.vaultAllocator.address
-    );
-    const toToken = this.config.supportedPositions[0].asset;
-    const fromToken = this.config.supportedPositions[1].asset;
-    return [
-      {
-        target: fromToken.address,
-        method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `approve_${fromToken.symbol}`
-      },
-      {
-        target: AVNU_EXCHANGE,
-        method: "multi_route_swap",
-        packedArguments: [
-          fromToken.address.toBigInt(),
-          //wbtc
-          toToken.address.toBigInt(),
-          //usdc
-          vaultAllocator.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `asbtu_${fromToken.symbol}_${fromToken.symbol}`
-      }
-    ];
-  }
-  _getLegacySwapLeaf() {
-    return [];
-  }
-  async getDepositCall(params) {
-    try {
-      const fromToken = this.config.supportedPositions[0].asset;
-      const toToken = this.config.supportedPositions[1].asset;
-      const vaultAllocator = ContractAddr.from(
-        this.config.vaultAllocator.address
-      );
-      const quote = await this.getQuotesAvnu(
-        fromToken.address.toString(),
-        toToken.address.toString(),
-        params.amount.toNumber(),
-        vaultAllocator.address.toString(),
-        toToken.decimals,
-        true
-      );
-      if (!quote) {
-        logger.error("error getting quote from avnu");
-        return [];
-      }
-      const getCalldata = await this.avnuWrapper.getSwapCallData(
-        quote,
-        vaultAllocator.address
-      );
-      const swapCallData = getCalldata[0];
-      const amount = import_starknet24.uint256.bnToUint256(quote.sellAmountInUsd * 10 ** 7);
-      return [
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: fromToken.address,
-            selector: import_starknet24.hash.getSelectorFromName("approve"),
-            calldata: [
-              AVNU_EXCHANGE.toBigInt(),
-              toBigInt(amount.low.toString()),
-              // amount low
-              toBigInt(amount.high.toString())
-              // amount high
-            ]
-          }
-        },
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: AVNU_EXCHANGE,
-            selector: import_starknet24.hash.getSelectorFromName("multi_route_swap"),
-            calldata: swapCallData
-          }
-        }
-      ];
-    } catch (error) {
-      logger.error(`Error getting Avnu quote: ${error}`);
-      return [];
-    }
-  }
-  //Swap wbtc to usdc
-  async getWithdrawCall(params) {
-    try {
-      const toToken = this.config.supportedPositions[0].asset;
-      const fromToken = this.config.supportedPositions[1].asset;
-      const vaultAllocator = ContractAddr.from(
-        this.config.vaultAllocator.address
-      );
-      const quote = await this.getQuotesAvnu(
-        fromToken.address.toString(),
-        toToken.address.toString(),
-        params.amount.toNumber(),
-        vaultAllocator.address.toString(),
-        fromToken.decimals,
-        false
-      );
-      if (!quote) {
-        logger.error("No quotes available for this swap, error in quotes avnu");
-        return [];
-      }
-      const getCalldata = await this.avnuWrapper.getSwapCallData(
-        quote,
-        vaultAllocator.address
-      );
-      const swapCallData = getCalldata[0];
-      const amount = import_starknet24.uint256.bnToUint256(params.amount.toWei());
-      return [
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: fromToken.address,
-            selector: import_starknet24.hash.getSelectorFromName("approve"),
-            calldata: [
-              AVNU_EXCHANGE.toBigInt(),
-              toBigInt(amount.low.toString()),
-              // amount low
-              toBigInt(amount.high.toString())
-              // amount high
-            ]
-          }
-        },
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: AVNU_EXCHANGE,
-            selector: import_starknet24.hash.getSelectorFromName("multi_route_swap"),
-            calldata: swapCallData
-          }
-        }
-      ];
-    } catch (error) {
-      logger.error(`Error getting Avnu quote: ${error}`);
-      return [];
-    }
-  }
-  async getSwapCallData(quote) {
-    return await this.avnuWrapper.getSwapCallData(quote, this.config.vaultAllocator.address);
-  }
-  async getHealthFactor() {
-    return Promise.resolve(1);
-  }
-  async fetchQuoteWithRetry(params, retries = 5) {
-    for (let attempt = 0; attempt < retries; attempt++) {
-      try {
-        const response = await import_axios9.default.get(this.config.baseUrl, { params });
-        if (response.data && response.data.length > 0) {
-          return response;
-        }
-        throw new Error("Empty response data");
-      } catch (err) {
-        logger.error(`Error fetching quote with retry: ${err}`);
-        if (attempt === retries - 1) {
-          throw err;
-        }
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
-      }
-    }
-    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) {
-    try {
-      const fromToken = this.config.supportedPositions[0].asset;
-      const toToken = this.config.supportedPositions[1].asset;
-      if (!usdcToBtc) {
-        const sellAmount2 = returnFormattedAmount(amount, toTokenDecimals);
-        const params2 = {
-          sellTokenAddress: from_token_address,
-          buyTokenAddress: to_token_address,
-          takerAddress,
-          sellAmount: sellAmount2
-        };
-        const finalQuote2 = await this.fetchQuoteWithRetry(params2);
-        if (!finalQuote2.data.length) {
-          logger.error("No quotes available for this swap, error in quotes avnu");
-          return null;
-        }
-        const dataObject2 = finalQuote2.data[0];
-        return dataObject2;
-      }
-      const btcPrice = await this.getPriceOfToken(toToken.address.toString());
-      if (!btcPrice) {
-        logger.error(`error getting btc price: ${btcPrice}`);
-        return null;
-      }
-      const estimatedUsdcAmount = Math.floor(amount * btcPrice);
-      const targetBtcBig = BigInt(returnFormattedAmount(amount, toTokenDecimals));
-      let low = BigInt(
-        Math.floor(
-          estimatedUsdcAmount * 10 ** fromToken.decimals * 0.9
-        )
-      );
-      let high = BigInt(
-        Math.floor(
-          estimatedUsdcAmount * 10 ** fromToken.decimals * 1.1
-        )
-      );
-      let mid = 0n;
-      for (let i = 0; i < maxIterations; i++) {
-        mid = (low + high) / 2n;
-        const sellAmount2 = returnFormattedAmount(Number(mid), 0);
-        const quote = await this.fetchQuoteWithRetry({
-          sellTokenAddress: from_token_address,
-          buyTokenAddress: to_token_address,
-          takerAddress,
-          sellAmount: sellAmount2
-        });
-        const gotBtc = BigInt(quote.data[0].buyAmount);
-        if (gotBtc === targetBtcBig) return quote.data[0];
-        if (gotBtc > targetBtcBig) {
-          high = mid;
-        } else {
-          low = mid;
-        }
-        if (gotBtc >= targetBtcBig && gotBtc <= targetBtcBig + BigInt(tolerance)) {
-          return quote.data[0];
-        }
-      }
-      let sellAmount = returnFormattedAmount(
-        Number(mid),
-        0
-      );
-      const params = {
-        sellTokenAddress: from_token_address,
-        buyTokenAddress: to_token_address,
-        takerAddress,
-        sellAmount
-      };
-      const finalQuote = await this.fetchQuoteWithRetry(params);
-      if (!finalQuote.data.length) {
-        logger.error("No quotes available for this swap, error in quotes avnu");
-        return null;
-      }
-      const dataObject = finalQuote.data[0];
-      return dataObject;
-    } catch (err) {
-      logger.error(`No quotes available for this swap: ${err}`);
-      return null;
-    }
-  }
-  async getPriceOfToken(tokenAddress, retries = MAX_RETRIES) {
-    try {
-      const url = `https://starknet.impulse.avnu.fi/v1/tokens/${tokenAddress}/prices/line`;
-      const response = await import_axios9.default.get(url);
-      const length = response.data.length;
-      return response.data[length - 1].value;
-    } catch (err) {
-      if (retries > 0) {
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
-        return this.getPriceOfToken(tokenAddress, retries - 1);
-      } else {
-        logger.error(`Failed to fetch price for ${tokenAddress} after ${MAX_RETRIES} attempts`);
-        return null;
-      }
-    }
-  }
-};
+// src/strategies/vesu-extended-strategy/types/transaction-metadata.ts
+var CycleType = /* @__PURE__ */ ((CycleType2) => {
+  CycleType2["INVESTMENT"] = "INVESTMENT";
+  CycleType2["REBALANCE_PRICE_DROP"] = "REBALANCE_PRICE_DROP";
+  CycleType2["REBALANCE_PRICE_RISE"] = "REBALANCE_PRICE_RISE";
+  CycleType2["WITHDRAWAL"] = "WITHDRAWAL";
+  CycleType2["DELTA_NEUTRAL_ADJUSTMENT"] = "DELTA_NEUTRAL_ADJUSTMENT";
+  return CycleType2;
+})(CycleType || {});
 
 // src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx
 var import_jsx_runtime5 = require("react/jsx-runtime");
@@ -33994,15 +34544,30 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       const usdceToken = Global.getDefaultTokens().find(
         (token) => token.symbol === "USDCe"
       );
+      const walletBalance = await new ERC20(this.config).balanceOf(
+        usdceToken.address,
+        WALLET_ADDRESS,
+        usdceToken.decimals
+      );
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator walletBalance: ${walletBalance}`);
+      const amountToBeTransferred = amount.minimum(walletBalance);
+      logger.info(`${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred: ${amountToBeTransferred.toNumber()}`);
+      if (amountToBeTransferred.lessThan(0)) {
+        logger.error(`${_VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred is less than 0: ${amountToBeTransferred.toNumber()}`);
+        return {
+          calls: [],
+          status: false
+        };
+      }
       const approveCall = new ERC20(this.config).approve(
         usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
-        amount
+        amountToBeTransferred
       );
       const transferCall = new ERC20(this.config).transfer(
         usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
-        amount
+        amountToBeTransferred
       );
       const proofsInfo = extendedAdapter.getProofsForFromLegacySwap(
         this.getMerkleTree()
@@ -34010,21 +34575,29 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       const proofGroups = proofsInfo.proofs;
       const call = this.getManageCall(
         proofGroups,
-        await proofsInfo.callConstructor({ amount })
+        await proofsInfo.callConstructor({ amount: amountToBeTransferred })
       );
-      return [approveCall, transferCall, call];
+      return {
+        calls: [approveCall, transferCall, call],
+        status: true
+      };
     } catch (err) {
       logger.error(`error moving assets to vault allocator: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
   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,
@@ -34036,10 +34609,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),
@@ -34068,6 +34718,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,
@@ -34091,6 +34769,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,
@@ -34117,111 +34796,251 @@ 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 [];
       }
-      if (extendedAmount.lessThan(0)) {
+      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedHoldings) {
+        logger.error(`error getting extended holdings: ${extendedHoldings}`);
+        return [];
+      }
+      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 = [];
+      let transactionResults = [];
+      if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         try {
-          const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+          const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
             {
               to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
-              amount: extendedAmount.abs()
+              amount: extendedAmount.abs(),
+              cycleType: "INVESTMENT" /* INVESTMENT */
             },
             extendedAdapter,
             vesuAdapter
           );
           if (extendedStatus) {
-            calls.push(...extendedCalls);
+            transactionResults.push({
+              status: extendedStatus,
+              calls: extendedCalls,
+              transactionMetadata: {
+                ...extendedTransactionMetadata,
+                transactionType: "DEPOSIT"
+              }
+            });
           } else {
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
           }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
+          return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
         }
       }
-      if (vesuAmount.lessThan(0)) {
+      if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
         try {
-          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+          const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VESU.name,
-              amount: vesuAmount.abs()
+              amount: vesuAmount.abs(),
+              cycleType: "INVESTMENT" /* INVESTMENT */
             },
             extendedAdapter,
             vesuAdapter
           );
-          calls.push(...vesuCalls);
           if (!vesuStatus) {
-            return [];
-          }
+            return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+          }
+          transactionResults.push({
+            status: vesuStatus,
+            calls: vesuCalls,
+            transactionMetadata: {
+              ...vesuTransactionMetadata,
+              transactionType: "DEPOSIT"
+            }
+          });
         } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
+          logger.error(`Failed moving assets to extended via vault allocator: ${err}`);
+          return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", "INVESTMENT" /* INVESTMENT */)];
         }
       }
-      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 { calls: 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, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+              {
+                to: Protocols.EXTENDED.name,
+                from: Protocols.VAULT.name,
+                amount: extendedAmountDifference,
+                cycleType: "INVESTMENT" /* INVESTMENT */
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: extendedTransactionMetadata
+              });
+            } else {
+              logger.error(`Failed to move assets to extended - operation returned false status`);
+              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets to extended: ${err}`);
+            return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+          }
+        } else if (extendedAmountDifference.lessThan(0)) {
+          try {
+            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: extendedAmountDifferenceAbs,
+                cycleType: "INVESTMENT" /* INVESTMENT */
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: {
+                  ...extendedTransactionMetadata,
+                  transactionType: "DEPOSIT"
+                }
+              });
+            } else {
+              logger.error(`Failed to withdraw from extended - operation returned false status`);
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets from extended to vault: ${err}`);
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+          }
         }
       }
-      if (vesuAmount.minus(usdcAmountInWallet).greaterThan(0)) {
-        try {
-          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
-            {
-              to: Protocols.VAULT.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.`
           );
-          if (!vesuStatus) {
-            return [];
+        } else {
+          try {
+            const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: vesuAmountDifference,
+                cycleType: "INVESTMENT" /* INVESTMENT */
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (!vesuStatus) {
+              logger.error(`Failed to move assets to vesu - operation returned false status`);
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+            }
+            transactionResults.push({
+              status: vesuStatus,
+              calls: vesuCalls,
+              transactionMetadata: {
+                ...vesuTransactionMetadata,
+                transactionType: "DEPOSIT"
+              }
+            });
+          } catch (err) {
+            logger.error(`Failed moving assets to vault: ${err}`);
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", "INVESTMENT" /* INVESTMENT */)];
           }
-          calls.push(...vesuCalls);
-        } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
-      return calls;
+      return transactionResults;
     } catch (err) {
       logger.error(`Failed moving assets to vesu: ${err}`);
-      return [];
+      return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: new Web3Number(0, USDC_TOKEN_DECIMALS) }, "NONE", "INVESTMENT" /* INVESTMENT */)];
+    }
+  }
+  /**
+   * Helper method to create transaction result with metadata
+   */
+  createTransactionResult(calls, status, params, transactionType, cycleType) {
+    if (status) {
+      return {
+        calls,
+        status,
+        transactionMetadata: {
+          protocolFrom: params.from,
+          protocolTo: params.to,
+          transactionType,
+          usdAmount: params.amount.abs().toFixed(),
+          status: "PENDING",
+          cycleType
+        }
+      };
     }
+    return { calls: [], status: false, transactionMetadata: { protocolFrom: "", protocolTo: "", transactionType: "DEPOSIT", usdAmount: "0", status: "FAILED", cycleType } };
   }
   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 this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      }
+      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 this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
+      }
+      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 this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
+      }
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return {
-          calls: [],
-          status: false
-        };
+        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
       }
       logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
@@ -34240,61 +35059,72 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return {
-          calls: [call],
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
         const extendedLeverage = calculateExtendedLevergae();
         const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
         if (!extendedHoldings) {
           logger.error(`error getting extended holdings: ${extendedHoldings}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
         }
         const extendedHoldingAmount = new Web3Number(
           extendedHoldings.availableForWithdrawal,
           USDC_TOKEN_DECIMALS
         );
-        const leftAmountAfterWithdrawalAmountInAccount = params.amount.minus(extendedHoldingAmount);
-        const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
-        const openLongPosition = await extendedAdapter.createOrder(
-          extendedLeverage.toString(),
-          btcAmount.toNumber(),
-          "BUY" /* BUY */
-        );
-        if (!openLongPosition) {
-          logger.error(`error opening long position: ${openLongPosition}`);
-          return {
-            calls: [],
-            status: false
-          };
+        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(),
+            34e-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 this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          }
         }
-        await new Promise((resolve) => setTimeout(resolve, 5e3));
-        const withdrawalFromExtended = await extendedAdapter.withdrawFromExtended(params.amount);
-        if (withdrawalFromExtended) {
+        const {
+          status: withdrawalFromExtendedStatus,
+          receivedTxnHash: withdrawalFromExtendedTxnHash
+        } = await extendedAdapter.withdrawFromExtended(params.amount);
+        logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+        if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
-          logger.info(`extendedHoldings after withdrawal ${extendedHoldings2}`);
-          await new Promise((resolve) => setTimeout(resolve, 1e4));
-          const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
-          if (calls.length > 0) {
-            return {
-              calls,
-              status: true
-            };
+          logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
+          await new Promise((resolve) => setTimeout(resolve, 5e3));
+          const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+          if (calls.length > 0 && status) {
+            return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
+          } else {
+            return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
           }
+        } else if (withdrawalFromExtendedStatus && !withdrawalFromExtendedTxnHash) {
+          logger.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
+          return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
         } else {
           logger.error("withdrawal from extended failed");
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
         }
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
+        if (!isPriceDifferenceBetweenAvnuAndExtended) {
+          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
         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());
@@ -34312,11 +35142,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return {
-          calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
+        if (!isPriceDifferenceBetweenAvnuAndExtended) {
+          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
           collateralToken.decimals
@@ -34346,131 +35178,32 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return {
-          calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
       }
-      return {
-        calls: [],
-        status: false
-      };
+      logger.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
+      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return {
-        calls: [],
-        status: false
-      };
+      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
     }
   }
   async handleDeposit() {
     try {
-      const vesuAdapter = await this.getVesuAdapter();
-      const extendedAdapter = await this.getExtendedAdapter();
-      const avnuAdapter = await this.getAvnuAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client || !avnuAdapter) {
-        logger.error(
-          "vesu or extended adapter not found",
-          vesuAdapter,
-          extendedAdapter
-        );
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedLeverage = calculateExtendedLevergae();
-      const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter);
-      if (!isPriceDifferenceBetweenAvnuAndExtended) {
-        logger.error("price difference between avnu and extended doesn't fit the range");
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const position = await extendedAdapter.getAllOpenPositions();
-      if (!position) {
-        logger.error("error getting extended position", position);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedPositionValue = position.length > 0 ? parseFloat(position[0].value) : 0;
-      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-      if (!extendedHoldings) {
-        logger.error(`error getting extended holdings: ${extendedHoldings}`);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedHoldingAmount = new Web3Number(
-        extendedHoldings.availableForWithdrawal,
-        USDC_TOKEN_DECIMALS
-      );
-      const {
-        collateralTokenAmount
-      } = await vesuAdapter.vesuAdapter.getAssetPrices();
-      const { collateralPrice } = await this.getAssetPrices();
-      const { vesuAmountInBTC, extendedAmountInBTC } = calculateVesUPositionSizeGivenExtended(
-        extendedPositionValue,
-        extendedHoldingAmount,
-        collateralTokenAmount,
-        collateralPrice.price
-      );
-      logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
-      let calls = [];
-      if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
-        const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
-        const proofGroups = proofsInfo.proofs;
-        const call = this.getManageCall(
-          proofGroups,
-          await proofsInfo.callConstructor({
-            amount: vesuAmountInBTC
-          })
-        );
-        const { amount: wbtcAmountInVaultAllocator } = await this.getUnusedBalanceWBTC();
-        if (wbtcAmountInVaultAllocator.lessThan(vesuAmountInBTC)) {
-          logger.info(`WBTC amount in vault allocator is less than vesu amount required in WBTC thus swapping, wbtcAmountInVaultAllocator: ${wbtcAmountInVaultAllocator}, vesuAmountInBTC: ${vesuAmountInBTC}`);
-          const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
-          const swapProofGroups = swapProofsInfo.proofs;
-          const swapCall = this.getManageCall(
-            swapProofGroups,
-            await swapProofsInfo.callConstructor({
-              amount: vesuAmountInBTC
-            })
-          );
-          calls.push(swapCall);
-        }
-        calls.push(call);
-      }
-      const shortPosition = extendedAmountInBTC.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
-        extendedLeverage.toString(),
-        extendedAmountInBTC.toNumber(),
-        "SELL" /* SELL */
-      ) : null;
-      if (!shortPosition && extendedAmountInBTC.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
-        logger.error(`error creating short position thus no position to be opened on vesu: ${shortPosition}`);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      return {
-        extendedAmountInBTC,
-        calls
-      };
+      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", "INVESTMENT" /* INVESTMENT */);
     } catch (err) {
       logger.error(`error handling deposit: ${err}`);
-      return {
-        extendedAmountInBTC: new Web3Number(0, 0),
-        calls: []
-      };
-      ;
+      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", "INVESTMENT" /* INVESTMENT */);
     }
   }
-  async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter) {
+  /**
+   * Check if the price difference between avnu and extended is within the acceptable range to enhance the position size or close the position
+   * @param extendedAdapter - the extended adapter
+   * @param vesuAdapter - the vesu adapter
+   * @param avnuAdapter - the avnu adapter
+   * @param positionType - the position type (open or close)
+   * @returns true if the price difference is within the acceptable range, false otherwise
+   */
+  async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, positionType) {
     const {
       ask,
       bid
@@ -34482,13 +35215,30 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       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;
+    logger.info(`price: ${price}`);
+    logger.info(`btcPriceAvnu: ${btcPriceAvnu}`);
+    const priceDifference = new Web3Number(price.minus(btcPriceAvnu).toFixed(2), 0);
+    logger.info(`priceDifference: ${priceDifference}`);
+    if (priceDifference.isNegative()) {
+      return false;
+    }
+    if (positionType === "open" /* OPEN */) {
+      logger.info(`price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`);
+      const result = priceDifference.greaterThanOrEqualTo(avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen);
+      logger.info(`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;
   }
+  /**
+   * Handle the withdrawal of assets from the vault
+   * @param amount - the amount to withdraw in USDC
+   * @returns the calls to be executed and the status of the calls generated along with the metadata for the calls
+   */
   async handleWithdraw(amount) {
     try {
       const usdcBalanceVaultAllocator = await this.getUnusedBalance();
@@ -34500,12 +35250,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         const withdrawCall2 = await this.getBringLiquidityCall({
           amount: usdcBalanceVaultAllocator.amount
         });
-        logger.info("withdraw call", withdrawCall2);
         calls.push(withdrawCall2);
-        return {
-          calls,
-          status: true
-        };
+        return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "WITHDRAWAL", "WITHDRAWAL" /* WITHDRAWAL */)];
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -34514,11 +35260,9 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
       }
+      let transactionResults = [];
       const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
       const {
         collateralPrice
@@ -34527,10 +35271,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       if (!extendedPositon) {
         status = false;
         logger.error("error getting extended position", extendedPositon);
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
       }
       const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
         usdcBalanceDifference,
@@ -34543,61 +35284,70 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
       if (status && vesu_amount.greaterThan(0)) {
-        const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+        const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
-            to: Protocols.VAULT.name
+            to: Protocols.VAULT.name,
+            cycleType: "WITHDRAWAL" /* WITHDRAWAL */
           },
           extendedAdapter,
           vesuAdapter
         );
         status = vesuStatus;
-        calls.push(...vesuCalls);
+        transactionResults.push({
+          status: vesuStatus,
+          calls: vesuCalls,
+          transactionMetadata: vesuTransactionMetadata
+        });
       }
       if (status && extended_amount.greaterThan(0)) {
-        const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+        const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
-            to: Protocols.VAULT.name
+            to: Protocols.VAULT.name,
+            cycleType: "WITHDRAWAL" /* WITHDRAWAL */
           },
           extendedAdapter,
           vesuAdapter
         );
         status = extendedStatus;
         if (status) {
-          calls.push(...extendedCalls);
+          transactionResults.push({
+            status: extendedStatus,
+            calls: extendedCalls,
+            transactionMetadata: extendedTransactionMetadata
+          });
         } else {
           logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
-          return {
-            calls: [],
-            status
-          };
+          return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
         }
       }
       const withdrawCall = await this.getBringLiquidityCall({
         amount
       });
       logger.info("withdraw call", withdrawCall);
-      calls.push(withdrawCall);
-      return {
-        calls,
-        status
-      };
+      transactionResults.push({
+        status,
+        calls: [withdrawCall],
+        transactionMetadata: {
+          protocolFrom: Protocols.VAULT.name,
+          protocolTo: Protocols.NONE.name,
+          transactionType: "WITHDRAWAL",
+          usdAmount: amount.toFixed(),
+          status: "PENDING",
+          cycleType: "WITHDRAWAL" /* WITHDRAWAL */
+        }
+      });
+      return transactionResults;
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return {
-        calls: [],
-        status: false
-      };
+      return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE", "WITHDRAWAL" /* WITHDRAWAL */)];
     }
   }
   async getAUM() {
@@ -34644,8 +35394,182 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       splits: [realAUM, estimatedAUMDelta]
     };
   }
+  async processTransactionDataFromSDK(txnData) {
+    try {
+      const txnsToBeExecuted = txnData.filter((txn) => {
+        return txn.transactionMetadata.transactionType !== "NONE" && txn.transactionMetadata.protocolFrom !== "" && txn.transactionMetadata.protocolTo !== "";
+      });
+      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap((txn) => txn.calls);
+      const txnMetadata = txnsToBeExecuted.map((txn) => txn.transactionMetadata);
+      return { callsToBeExecutedFinal, txnMetadata };
+    } catch (err) {
+      logger.error(`error processing transaction data from SDK: ${err}`);
+      return null;
+    }
+  }
+  async processTransactionMetadata(txnMetadata, extendedIntentFulfilled) {
+    try {
+      const txnMetadataNew = txnMetadata.map((txn) => {
+        const isExtendedProtocol = txn.protocolFrom === Protocols.EXTENDED.name || txn.protocolTo === Protocols.EXTENDED.name;
+        if (isExtendedProtocol) {
+          txn.status = extendedIntentFulfilled ? "COMPLETED" : "PENDING";
+        } else {
+          txn.status = "COMPLETED";
+        }
+        return txn;
+      });
+      return txnMetadataNew;
+    } catch (err) {
+      logger.error(`error processing transaction data from SDK: ${err}`);
+      return null;
+    }
+  }
+  async getMaxBorrowableAmount() {
+    const vesuAdapter = await this.getVesuAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!vesuAdapter || !extendedAdapter) {
+      return new Web3Number(0, 0);
+    }
+    const extendedFundingRate = new Web3Number((await extendedAdapter.getNetAPY()).toFixed(4), 0);
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    if (!extendedPositions || extendedPositions.length === 0) {
+      logger.info(`no extended positions found`);
+      return new Web3Number(0, 0);
+    }
+    const extendePositionSizeUSD = new Web3Number(extendedPositions[0].value || 0, 0);
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuSupplyApy = vesuPositions[0].apy.apy;
+    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
+    const num22 = vesuCollateralSizeUSD.multipliedBy(vesuSupplyApy);
+    const num32 = vesuDebtSizeUSD.abs();
+    const maxBorrowApy = num1.plus(num22).minus(0.1).dividedBy(num32);
+    const vesuMaxBorrowableAmount = await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxBorrowApy.toNumber());
+    return new Web3Number(vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+  }
+  async getVesuHealthFactors() {
+    const vesuAdapter = await this.getVesuAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!vesuAdapter || !extendedAdapter) {
+      return [0, 0];
+    }
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
+    logger.info(`actualLtv: ${actualLtv.toNumber()}`);
+    const maxLtv = new Web3Number(await vesuAdapter.vesuAdapter.getLTVConfig(this.config), 4);
+    const healthFactor = new Web3Number(maxLtv.dividedBy(actualLtv).toFixed(4), 4);
+    logger.info(`healthFactor: ${healthFactor.toNumber()}`);
+    const extendedBalance = await extendedAdapter.getExtendedDepositAmount();
+    if (!extendedBalance) {
+      return [0, 0];
+    }
+    const extendedLeverage = new Web3Number((Number(extendedBalance.marginRatio) * 100).toFixed(4), 4);
+    logger.info(`extendedLeverage: ${extendedLeverage.toNumber()}`);
+    return [healthFactor.toNumber(), extendedLeverage.toNumber()];
+  }
+  async netAPY() {
+    const allPositions = [];
+    for (let adapter of this.metadata.additionalInfo.adapters) {
+      if (adapter.adapter.name !== ExtendedAdapter.name) {
+        let positions = await adapter.adapter.getPositions();
+        if (positions.length > 0) {
+          allPositions.push(...positions);
+        }
+      }
+    }
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!extendedAdapter) {
+      return {
+        net: 0,
+        splits: []
+      };
+    }
+    let vesuPositions = allPositions.filter((item) => item.protocol === Protocols.VESU);
+    vesuPositions.map((item) => {
+      item.apy.apy = item.apy.apy * 0.1;
+    });
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    const usdcToken = Global.getDefaultTokens().find((token) => token.symbol === "USDC");
+    if (!extendedPositions || !usdcToken) {
+      return {
+        net: 0,
+        splits: []
+      };
+    }
+    const extendedPosition = extendedPositions[0] || 0;
+    const extendedEquity = (await extendedAdapter.getExtendedDepositAmount())?.equity || 0;
+    const extendedApy = await extendedAdapter.getNetAPY();
+    const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) + Number(extendedEquity);
+    console.log(totalHoldingsUSDValue);
+    const extendedPositionSizeMultipliedByApy = Number(extendedPosition.value) * extendedApy;
+    let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) + extendedPositionSizeMultipliedByApy;
+    console.log(weightedAPYs);
+    const netAPY = weightedAPYs / totalHoldingsUSDValue;
+    console.log(netAPY);
+    allPositions.push({
+      tokenInfo: usdcToken,
+      amount: new Web3Number(extendedPosition.size, 0),
+      usdValue: Number(extendedEquity),
+      apy: { apy: extendedApy, type: "base" /* BASE */ },
+      remarks: "finalised" /* FINALISED */,
+      protocol: Protocols.EXTENDED
+    });
+    return {
+      net: netAPY,
+      splits: allPositions.map((p) => ({ apy: p.apy.apy, id: p.remarks ?? "" }))
+    };
+  }
+  async getWalletHoldings() {
+    const usdceToken = Global.getDefaultTokens().find((token) => token.symbol === "USDCe");
+    const wbtcToken = Global.getDefaultTokens().find((token) => token.symbol === "WBTC");
+    const usdcToken = Global.getDefaultTokens().find((token) => token.symbol === "USDC");
+    if (!usdceToken || !wbtcToken || !usdcToken) {
+      return [];
+    }
+    const walletAddress = this.metadata.additionalInfo.walletAddress;
+    const usdceWalletBalance = await new ERC20(this.config).balanceOf(
+      usdceToken.address,
+      walletAddress,
+      usdceToken.decimals
+    );
+    const usdcWalletBalance = await new ERC20(this.config).balanceOf(
+      usdcToken.address,
+      walletAddress,
+      usdcToken.decimals
+    );
+    const wbtcWalletBalance = await new ERC20(this.config).balanceOf(
+      wbtcToken.address,
+      walletAddress,
+      wbtcToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdceToken.symbol);
+    const wbtcPrice = await this.pricer.getPrice(wbtcToken.symbol);
+    const usdceUsdValue = Number(usdceWalletBalance.toFixed(usdceToken.decimals)) * price.price;
+    const usdcUsdValue = Number(usdcWalletBalance.toFixed(usdcToken.decimals)) * price.price;
+    const wbtcUsdValue = Number(wbtcWalletBalance.toFixed(wbtcToken.decimals)) * wbtcPrice.price;
+    return [
+      {
+        tokenInfo: usdceToken,
+        amount: usdceWalletBalance,
+        usdValue: usdceUsdValue
+      },
+      {
+        tokenInfo: usdcToken,
+        amount: usdcWalletBalance,
+        usdValue: usdcUsdValue
+      },
+      {
+        tokenInfo: wbtcToken,
+        amount: wbtcWalletBalance,
+        usdValue: wbtcUsdValue
+      }
+    ];
+  }
 };
-function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended) {
+function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
   vaultSettings.leafAdapters = [];
   const wbtcToken = Global.getDefaultTokens().find(
     (token) => token.symbol === lstSymbol
@@ -34669,7 +35593,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,
@@ -34678,14 +35604,17 @@ function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     ],
     vaultIdExtended,
     extendedContract: EXTENDED_CONTRACT,
-    extendedBackendUrl,
-    extendedApiKey,
+    extendedBackendWriteUrl,
+    extendedBackendReadUrl,
     extendedTimeout: 3e4,
     extendedRetries: 3,
     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,
@@ -34698,7 +35627,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
@@ -34794,11 +35725,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("0x058905be22d6a81792df79425dc9641cf3e1b77f36748631b7d7e5d713a32b55"),
+  manager: ContractAddr.from("0x02648d703783feb2d967cf0520314cb5aa800d69a9426f3e3b317395af44de16"),
+  vaultAllocator: ContractAddr.from("0x07d533c838eab6a4d854dd3aea96a55993fccd35821921970d00bde946b63b6f"),
+  redeemRequestNFT: ContractAddr.from("0x01ef91f08fb99729c00f82fc6e0ece37917bcc43952596c19996259dc8adbbba"),
+  aumOracle: ContractAddr.from("0x030b6acfec162f5d6e72b8a4d2798aedce78fb39de78a8f549f7cd277ae8bc8d"),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.4,
@@ -34811,14 +35742,15 @@ var re7UsdcPrimeDevansh = {
     Global.getDefaultTokens().find((token) => token.symbol === "WBTC").decimals
   ),
   borrowable_assets: [Global.getDefaultTokens().find((token) => token.symbol === "WBTC")],
-  minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP
+  minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+  walletAddress: WALLET_ADDRESS
 };
-var VesuExtendedTestStrategies = (extendedBackendUrl, extendedApiKey, vaultIdExtended) => {
+var VesuExtendedTestStrategies = (extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) => {
   return [
-    getStrategySettingsVesuExtended("WBTC", "USDC", re7UsdcPrimeDevansh, false, false, extendedBackendUrl, extendedApiKey, vaultIdExtended)
+    getStrategySettingsVesuExtended("WBTC", "USDC", re7UsdcPrimeDevansh, false, false, extendedBackendReadUrl, extendedBackendWriteUrl, 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, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
   return {
     name: `Extended Test ${underlyingSymbol}`,
     description: getDescription2(lstSymbol, underlyingSymbol),
@@ -34826,7 +35758,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, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
     risk: {
       riskFactor: _riskFactor3,
       netRisk: _riskFactor3.reduce((acc, curr) => acc + curr.value * curr.weight, 0) / _riskFactor3.reduce((acc, curr) => acc + curr.weight, 0),
@@ -39070,11 +40002,13 @@ var deployer_default = Deployer;
   AssetOperationStatus,
   AssetOperationType,
   AutoCompounderSTRK,
+  AvnuAdapter,
   AvnuWrapper,
   BaseAdapter,
   BaseStrategy,
   CommonAdapter,
   ContractAddr,
+  CycleType,
   Deployer,
   ERC20,
   EXTENDED_CONTRACT,
@@ -39103,6 +40037,7 @@ var deployer_default = Deployer;
   PRICE_ROUTER,
   PasswordJsonCryptoUtil,
   PositionSide,
+  PositionTypeAvnuExtended,
   Pragma,
   Pricer,
   PricerBase,
@@ -39152,6 +40087,7 @@ var deployer_default = Deployer;
   calculateExtendedLevergae,
   calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage,
+  calculateWBTCAmountToMaintainLTV,
   extensionMap,
   getAPIUsingHeadlessBrowser,
   getContractDetails,