@strkfarm/sdk 2.0.0-dev.3 → 2.0.0-dev.31

package/src/strategies/universal-adapters/vesu-multiply-adapter.ts

@@ -1,333 +1,447 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { IConfig, Protocols, TokenInfo } from "@/interfaces";
-import { PricerBase } from "@/modules/pricerBase";
-import { BaseAdapter, BaseAdapterConfig, SupportedPosition, PositionInfo, PositionAPY, APYType, ManageCall, AdapterLeafType, GenerateCallFn, DepositParams, WithdrawParams, PositionAmount } from "./baseAdapter";
-import { SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, toBigInt, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER } from "./adapter-utils";
+import { Protocols, TokenInfo } from "@/interfaces";
+import {
+  BaseAdapter,
+  BaseAdapterConfig,
+  SupportedPosition,
+  PositionInfo,
+  PositionAPY,
+  APYType,
+  ManageCall,
+  AdapterLeafType,
+  GenerateCallFn,
+  PositionAmount,
+  SwapPriceInfo,
+} from "./baseAdapter";
+import {
+  SIMPLE_SANITIZER,
+  SIMPLE_SANITIZER_V2,
+  toBigInt,
+} from "./adapter-utils";
 import { hash, uint256, Contract, CairoCustomEnum, num } from "starknet";
-import { VesuAdapter, VesuMultiplyCallParams, VesuModifyDelegationCallParams, getVesuSingletonAddress, VesuPools, Swap, IncreaseLeverParams, DecreaseLeverParams } from "./vesu-adapter";
-import { logger } from "@/utils";
-import { WALLET_ADDRESS } from "../vesu-extended-strategy/utils/constants";
-import VesuMultiplyAbi from '@/data/vesu-multiple.abi.json';
-import VesuSingletonAbi from '../../data/vesu-singleton.abi.json';
-import VesuPoolV2Abi from '@/data/vesu-pool-v2.abi.json';
-import { EkuboQuoter, TokenMarketData } from "@/modules";
+import {
+  VesuAdapter,
+  getVesuSingletonAddress,
+  Swap,
+  IncreaseLeverParams,
+  DecreaseLeverParams,
+} from "./vesu-adapter";
+import { assert, logger } from "@/utils";
+import VesuMultiplyAbi from "@/data/vesu-multiple.abi.json";
+import { EkuboQuote, EkuboQuoter, TokenMarketData } from "@/modules";
 import { calculateDebtReductionAmountForWithdrawal } from "../vesu-extended-strategy/utils/helper";
 import { HealthFactorMath } from "@/utils/health-factor-math";
 import { MAX_LIQUIDATION_RATIO } from "../vesu-extended-strategy/utils/constants";
+import {
+  VesuPositionCommonContext,
+  getVesuCommonAPY,
+  getVesuCommonMaxBorrowableAPY,
+  getVesuCommonMaxDeposit,
+  getVesuCommonMaxWithdraw,
+  getVesuCommonPosition,
+} from "./vesu-position-common";
+
+const MIN_REMAINING_DEBT_USD = 11;
+const SCALE_128 = BigInt('1000000000000000000'); // 1e18 (matches vesu::units::SCALE_128)
+const MIN_SQRT_RATIO_LIMIT = BigInt('18446748437148339061');
+const MAX_SQRT_RATIO_LIMIT = BigInt('6277100250585753475930931601400621808602321654880405518632');
+
+export interface VesuDepositParams {
+  amount: Web3Number;
+  marginSwap?: {
+    marginToken: TokenInfo;
+  };
+  leverSwap?: {
+    exactOutput?: Web3Number;
+  };
+}
+
+export interface VesuWithdrawParams {
+  amount: Web3Number;
+  withdrawSwap?: {
+    outputToken: TokenInfo;
+  };
+}
 
 export interface VesuMultiplyAdapterConfig extends BaseAdapterConfig {
   poolId: ContractAddr;
   collateral: TokenInfo;
   debt: TokenInfo;
+  marginToken: TokenInfo; // in case of using ekubo to do margin swap, this can be diff token, else collateral itself.
   targetHealthFactor: number;
   minHealthFactor: number;
   quoteAmountToFetchPrice: Web3Number;
+  minimumVesuMovementAmount: number;
+  maxSlippage?: number; // e.g. 0.005 for 0.5%
 }
 
-export class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+export class VesuMultiplyAdapter extends BaseAdapter<
+  VesuDepositParams,
+  VesuWithdrawParams
+> {
   readonly config: VesuMultiplyAdapterConfig;
-  readonly vesuAdapter: VesuAdapter;
+  readonly _vesuAdapter: VesuAdapter;
   readonly tokenMarketData: TokenMarketData;
-
+  readonly minimumVesuMovementAmount: number;
+  lastSwapPriceInfo: SwapPriceInfo | null = null;
+  maxSlippage: number = 0.002; // 0.2%
   constructor(config: VesuMultiplyAdapterConfig) {
     super(config, VesuMultiplyAdapter.name, Protocols.VESU);
     this.config = config;
-    this.vesuAdapter = new VesuAdapter({
+    this._vesuAdapter = new VesuAdapter({
       poolId: config.poolId,
       collateral: config.collateral,
       debt: config.debt,
       vaultAllocator: config.vaultAllocator,
-      id: ''
+      id: "",
     });
-    this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
+    this.minimumVesuMovementAmount = config.minimumVesuMovementAmount ?? 5; //5 usdc
+    this.tokenMarketData = new TokenMarketData(
+      this.config.pricer,
+      this.config.networkConfig
+    );
+    this.config.maxSlippage = config.maxSlippage ?? 0.002; // 0.2%
+    this.maxSlippage = config.maxSlippage ?? 0.002; // 0.2%
   }
 
-  protected async getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY> {
-    const CACHE_KEY = `apy_${this.config.poolId.address}_${supportedPosition.asset.symbol}`;
-    const cacheData = this.getCache<PositionAPY>(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);
-    if (cacheData) {
-      return cacheData;
-    }
-    try {
-      // Get Vesu pools to find APY for the asset
-      const allVesuPools = await VesuAdapter.getVesuPools();
-      const asset = supportedPosition.asset;
-      const pool = allVesuPools.pools.find(p => this.vesuAdapter.config.poolId.eqString(num.getHexString(p.id)));
-      if (!pool) {
-        logger.warn(`VesuMultiplyAdapter: Pool not found for token ${asset.symbol}`);
-        return {
-          apy: 0,
-          type: APYType.BASE
-        };
-      }
-      // Find the asset stats for our token
-      const assetStats = pool.assets.find((a: any) => 
-        a.symbol.toLowerCase() === asset.symbol.toLowerCase()
-      )?.stats;
-
-      if (!assetStats) {
-        logger.warn(`VesuMultiplyAdapter: Asset stats not found for token ${asset.symbol}`);
-        return {
-          apy: 0,
-          type: APYType.BASE
-        };
-      }
-      // Get appropriate APY based on position type
-      let apy = 0;
-      if (supportedPosition.isDebt) {
-        // For debt positions, use borrow APY
-        apy = Number(assetStats.borrowApr?.value || 0) / 1e18;
-
-        // todo 
-        // Account for rewards on debt token
-      } else {
-        // For collateral positions, use supply APY
-        const isAssetBTC = asset.symbol.toLowerCase().includes("btc");
-        const baseAPY = Number(isAssetBTC ? assetStats.btcFiSupplyApr?.value + assetStats.supplyApy?.value : assetStats.supplyApy?.value || 0) / 1e18;
-
-        // account for reward yield (like STRK rewards)
-        const rewardAPY = Number(assetStats.defiSpringSupplyApr?.value || "0") / 1e18;
-
-        // account for base yield of LST
-        const isSupported = this.tokenMarketData.isAPYSupported(asset);
-        apy = baseAPY + rewardAPY;
-        if (isSupported) {
-          const tokenAPY = await this.tokenMarketData.getAPY(asset);
-          apy += tokenAPY;
-        }
-      }
-      const result = {
-        apy,
-        type: supportedPosition.isDebt ? APYType.BASE : APYType.BASE
-      };
+  // ─── Shared Helpers ──────────────────────────────────────────────────────────
 
-      this.setCache(CACHE_KEY, result, 300000); // Cache for 5 minutes
-      return result;
-    } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error getting APY for ${supportedPosition.asset.symbol}:`, error);
-      // return {
-      //   apy: 0,
-      //   type: APYType.BASE
-      // };
-      throw error;
-    }
+  private _getMultiplyContract(): {
+    contract: Contract;
+    vesuMultiply: ContractAddr;
+    vesuSingleton: ContractAddr;
+    isV2: boolean;
+  } {
+    const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(
+      this.config.poolId
+    );
+    const vesuMultiply = isV2
+      ? this._vesuAdapter.VESU_WITHDRAW_SWAP_FIXED_MULTIPLIER
+      : this._vesuAdapter.VESU_MULTIPLY_V1;
+    const contract = new Contract({
+      abi: VesuMultiplyAbi,
+      address: vesuMultiply.address,
+      providerOrAccount: this.config.networkConfig.provider,
+    });
+    return { contract, vesuMultiply, vesuSingleton, isV2 };
   }
 
-  protected async getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount> {
-    const CACHE_KEY = `position_${this.config.poolId.address}_${supportedPosition.asset.symbol}`;
-    const cacheData = this.getCache<PositionAmount>(CACHE_KEY);
-    if (cacheData) {
-      return cacheData;
-    }
+  private _buildDelegationWrappedCalls(
+    preCalls: ManageCall[],
+    modifyLeverCalldata: bigint[],
+    proofReadableIds: {
+      delegationOn: string;
+      modifyLever: string;
+      delegationOff: string;
+    },
+  ): ManageCall[] {
+    const { vesuMultiply, vesuSingleton, isV2 } = this._getMultiplyContract();
 
-    try {
-      // Use VesuAdapter to get positions
-      this.vesuAdapter.networkConfig = this.config.networkConfig;
-      this.vesuAdapter.pricer = this.config.pricer;
-      
-      const positions = await this.vesuAdapter.getPositions(this.config.networkConfig);
-      
-      // Find the position for our asset
-      let position = positions.find(p => 
-        p.token.address.eq(supportedPosition.asset.address)
-      );
+    const delegationOn: ManageCall = {
+      proofReadableId: proofReadableIds.delegationOn,
+      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+      call: {
+        contractAddress: vesuSingleton,
+        selector: hash.getSelectorFromName("modify_delegation"),
+        calldata: isV2
+          ? [vesuMultiply.toBigInt(), BigInt(1)]
+          : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt(), BigInt(1)],
+      },
+    };
 
-      if (!position) {
-        logger.warn(`VesuMultiplyAdapter: Position not found for token ${supportedPosition.asset.symbol}`);
-        return {
-          amount: new Web3Number('0', supportedPosition.asset.decimals),
-          remarks: "Position not found"
-        };
-      }
+    const modifyLever: ManageCall = {
+      proofReadableId: proofReadableIds.modifyLever,
+      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+      call: {
+        contractAddress: vesuMultiply,
+        selector: hash.getSelectorFromName("modify_lever"),
+        calldata: modifyLeverCalldata,
+      },
+    };
 
-      if (supportedPosition.isDebt) {
-        position.amount = position.amount.multipliedBy(-1);
-        position.usdValue = position.usdValue * -1;
-      }
+    const delegationOff: ManageCall = {
+      proofReadableId: proofReadableIds.delegationOff,
+      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+      call: {
+        contractAddress: vesuSingleton,
+        selector: hash.getSelectorFromName("modify_delegation"),
+        calldata: isV2
+          ? [vesuMultiply.toBigInt(), BigInt(0)]
+          : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt(), BigInt(0)],
+      },
+    };
 
-      this.setCache(CACHE_KEY, position, 60000); // Cache for 1 minute
-      return position;
-    } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error getting position for ${supportedPosition.asset.symbol}:`, error);
-      // return new Web3Number('0', supportedPosition.asset.decimals);
-      throw error;
-    }
+    return [...preCalls, delegationOn, modifyLever, delegationOff];
   }
 
-  async maxBorrowableAPY(): Promise<number> {
-    // get collateral APY
-    const collateralAPY = await this.getAPY({ asset: this.config.collateral, isDebt: false });
-    const apy = collateralAPY.apy * 0.8;
-    return apy;
+  private _getDepositProofReadableIds() {
+    const collateral = this.config.collateral;
+    const debt = this.config.debt;
+    return {
+      approve: `amc_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      delegationOn: `sd1_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      modifyLever: `vm_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      delegationOff: `sd2_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+    };
   }
 
-  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+  private _getWithdrawProofReadableIds() {
     const collateral = this.config.collateral;
     const debt = this.config.debt;
+    return {
+      delegationOn: `sdow_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      modifyLever: `vmw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      delegationOff: `sdofw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+    };
+  }
 
-    try {
-      // Get current positions
-      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));
-
-      if (!collateralPosition || !debtPosition) {
-        throw new Error('Could not find current positions');
-      }
-
-      // Calculate max borrowable amount
-      const maxBorrowableAPY = await this.maxBorrowableAPY();
-      const maxBorrowable = await this.vesuAdapter.getMaxBorrowableByInterestRate(
-        this.config.networkConfig,
-        debt,
-        maxBorrowableAPY
-      );
-      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()}`);
-
-      // Calculate max collateral that can be deposited based on LTV
-      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');
-      }
-      const debtPrice = await this.config.pricer.getPrice(debt.symbol);
-      if (debtPrice.price === 0) {
-        throw new Error('Debt price is 0');
-      }
-      const maxCollateralFromDebt = HealthFactorMath.getMinCollateralRequiredOnLooping(
-        actualMaxBorrowable,
-        debtPrice.price,
-        this.config.targetHealthFactor,
-        maxLTV,
-        collateralPrice.price,
-        collateral
-      )
+  private _buildZeroAmountSwapsWithWeights(
+    quote: EkuboQuote,
+    token: TokenInfo,
+    reverseRoutes = false,
+  ): { swaps: Swap[]; weights: Web3Number[] } {
+    const swaps: Swap[] = quote.splits.map((split) => {
+      let sellToken = token.address;
+      const routeNodes = split.route.map((_route: any) => {
+        // switch to other for next route.
+        let isSellToken0 = sellToken.eqString(_route.pool_key.token0);
+        isSellToken0 = reverseRoutes ? !isSellToken0 : isSellToken0;
+        sellToken = isSellToken0 ? ContractAddr.from(_route.pool_key.token1) : ContractAddr.from(_route.pool_key.token0);
 
-      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}`);
-
-      const borrowAmountUSD = actualMaxBorrowable.multipliedBy(debtPrice.price);
-      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}`);
+        return {
+          pool_key: {
+            token0: ContractAddr.from(_route.pool_key.token0),
+            token1: ContractAddr.from(_route.pool_key.token1),
+            fee: _route.pool_key.fee,
+            tick_spacing: _route.pool_key.tick_spacing.toString(),
+            extension: _route.pool_key.extension,
+          },
+          sqrt_ratio_limit: isSellToken0 ? Web3Number.fromWei(MIN_SQRT_RATIO_LIMIT.toString(), 18) : Web3Number.fromWei(MAX_SQRT_RATIO_LIMIT.toString(), 18),
+          skip_ahead: Web3Number.fromWei(_route.skip_ahead, 0),
+        }
+      });
+      // incorrect logic, hence commented. Ekubo already returns routes in correct order.
+      // if (reverseRoutes) {
+      //   routeNodes.reverse();
+      // }
       return {
-        tokenInfo: collateral,
-        amount: maxDepositAmount,
-        usdValue,
-        remarks: "Max deposit based on available debt capacity",
-        apy: {
-          apy: netAPY,
-          type: APYType.BASE
+        route: routeNodes,
+        token_amount: {
+          token: token.address,
+          amount: Web3Number.fromWei(0, token.decimals),
         },
-        protocol: this.protocol
       };
-    } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error calculating max deposit:`, error);
-      throw error;
+    });
+
+    const totalSpecifiedBig = quote.splits.reduce(
+      (sum: bigint, s: any) => sum + BigInt(Math.abs(Number(s.amount_specified))),
+      0n
+    );
+    const weights: Web3Number[] = [];
+    let allocatedWeight = 0n;
+    for (let i = 0; i < quote.splits.length; i++) {
+      const split = quote.splits[i];
+      let weight: bigint;
+      if (i === quote.splits.length - 1) {
+        weight = SCALE_128 - allocatedWeight;
+      } else if (totalSpecifiedBig > 0n) {
+        const splitAbs = BigInt(Math.abs(Number(split.amount_specified)));
+        weight = (splitAbs * SCALE_128) / totalSpecifiedBig;
+      } else {
+        weight = SCALE_128;
+      }
+      allocatedWeight += weight;
+      weights.push(Web3Number.fromWei(weight.toString(), 0));
     }
+
+    return { swaps, weights };
   }
 
-  async maxWithdraw(): Promise<PositionInfo> {
-    const collateral = this.config.collateral;
-    const debt = this.config.debt;
+  private async _fetchPositionAndPrices(): Promise<{
+    existingCollateralInfo: any;
+    existingDebtInfo: any;
+    collateralisation: any;
+    collateralPrice: number;
+    debtPrice: number;
+    ekuboQuoter: EkuboQuoter;
+  }> {
+    this._vesuAdapter.networkConfig = this.config.networkConfig;
+    this._vesuAdapter.pricer = this.config.pricer;
 
-    try {
-      // Calculate how much can be withdrawn without affecting health factor too much
-      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));
-
-      if (!collateralPosition || !debtPosition) {
-        throw new Error('Could not find current positions');
-      }
+    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];
 
-      // Calculate max withdrawable (conservative approach)
-      const collateralPrice = collateralPosition.usdValue / collateralPosition.amount.toNumber();
-      const debtInCollateral = debtPosition.usdValue / collateralPrice;
-      const maxWithdrawable = collateralPosition.amount.minus(debtInCollateral);
-
-      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}`);
-      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}`);
-      return {
-        tokenInfo: collateral,
-        amount: result,
-        usdValue,
-        remarks: "Max withdraw based on health factor",
-        apy: {
-          apy: netAPY,
-          type: APYType.BASE
-        },
-        protocol: this.protocol
-      };
-    } catch (error) {
-      logger.error(`VesuMultiplyAdapter: Error calculating max withdraw:`, error);
-      throw error;
+    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;
+
+    const ekuboQuoter = new EkuboQuoter(
+      this.config.networkConfig,
+      this.config.pricer
+    );
+
+    return {
+      existingCollateralInfo,
+      existingDebtInfo,
+      collateralisation,
+      collateralPrice,
+      debtPrice,
+      ekuboQuoter,
+    };
+  }
+
+  private _computeTargetDebtDelta(
+    addedCollateral: Web3Number,
+    existingCollateral: Web3Number,
+    existingDebt: Web3Number,
+    collateralPrice: number,
+    debtPrice: number,
+    ltv: number,
+    dexPrice: number
+  ): Web3Number {
+    // target hf = (((collateral + addedCollateral) * collateralPrice + X)) * ltv / (debt * debtPrice + X)
+    // => X = (((collateral + addedCollateral) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
+    const numeratorPart1 = existingCollateral
+      .plus(addedCollateral)
+      .multipliedBy(collateralPrice)
+      .multipliedBy(ltv);
+    const numeratorPart2 = existingDebt
+      .multipliedBy(debtPrice)
+      .multipliedBy(this.config.targetHealthFactor);
+    const denominatorPart = this.config.targetHealthFactor - ltv / dexPrice;
+    const x_debt_usd = numeratorPart1
+      .minus(numeratorPart2)
+      .dividedBy(denominatorPart);
+
+    return new Web3Number(
+      x_debt_usd.dividedBy(debtPrice).toFixed(this.config.debt.decimals),
+      this.config.debt.decimals
+    );
+  }
+
+  private _getPositionCommonContext(): VesuPositionCommonContext {
+    return {
+      adapterName: VesuMultiplyAdapter.name,
+      protocol: this.protocol,
+      poolId: this.config.poolId,
+      collateral: this.config.collateral,
+      debt: this.config.debt,
+      networkConfig: this.config.networkConfig,
+      pricer: this.config.pricer,
+      vesuAdapter: this._vesuAdapter,
+      tokenMarketData: this.tokenMarketData,
+      targetHealthFactor: this.config.targetHealthFactor,
+      getCache: this.getCache.bind(this),
+      setCache: this.setCache.bind(this),
+      getUSDValue: this.getUSDValue.bind(this),
+    };
+  }
+
+  // ─── APY / Position / Max Deposit/Withdraw ─────────────────────────────────
+
+  protected async getAPY(
+    supportedPosition: SupportedPosition
+  ): Promise<PositionAPY> {
+    // always add vesu modify position adapter, which shall
+    // return correct apy
+    return {
+      apy: 0,
+      type: APYType.BASE,
+    }
+  }
+
+  protected async getPosition(
+    supportedPosition: SupportedPosition
+  ): Promise<PositionAmount | null> {
+    // always add vesu modify position adapter, which shall
+    // return correct position amount
+    return null;
+  }
+
+  async maxBorrowableAPY(): Promise<number> {
+    // always add vesu modify position adapter, which shall
+    // return correct max borrowable apy
+    return 0;
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    // always add vesu modify position adapter, which shall
+    // return correct max deposit
+    return {
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, this.config.baseToken.decimals),
+      usdValue: 0,
+      remarks: "Max deposit",
+      apy: { apy: 0, type: APYType.BASE },
+      protocol: this.protocol,
     }
   }
 
+  async maxWithdraw(): Promise<PositionInfo> {
+    // always add vesu modify position adapter, which shall
+    // return correct max withdraw
+    return {
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, this.config.baseToken.decimals),
+      usdValue: 0,
+      remarks: "Max withdraw",
+      apy: { apy: 0, type: APYType.BASE },
+      protocol: this.protocol,
+    }
+  }
+
+  // ─── Leaf Configuration ────────────────────────────────────────────────────
+
   protected _getDepositLeaf(): {
-    target: ContractAddr,
-    method: string,
-    packedArguments: bigint[],
-    sanitizer: ContractAddr,
-    id: string
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
   }[] {
     const collateral = this.config.collateral;
     const debt = this.config.debt;
-    const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
-    const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
+    const { vesuMultiply, vesuSingleton, isV2 } = this._getMultiplyContract();
+    const token = debt;
+    const idSuffix = `${collateral.symbol}_${debt.symbol}`;
+    const idApprovePrefix = "amc";
+    const idDelegOnPrefix = "sd1";
+    const idMultiplyPrefix = "vm";
+    const idDelegOffPrefix = "sd2";
 
     return [
-      // Approval step for collateral
       {
-        target: collateral.address,
-        method: 'approve',
-        packedArguments: [
-          vesuMultiply.toBigInt(), // spender
-        ],
+        target: token.address,
+        method: "approve",
+        packedArguments: [vesuMultiply.toBigInt()],
         sanitizer: SIMPLE_SANITIZER,
-        // amc = approve multiply collateral
-        id: `amc_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+        id: `${idApprovePrefix}_${this.config.poolId.shortString()}_${idSuffix}`,
       },
-      // Switch delegation on
       {
         target: vesuSingleton,
-        method: 'modify_delegation',
-        packedArguments: isV2 ? [
-          vesuMultiply.toBigInt(), // delegatee
-        ] : [
-          this.config.poolId.toBigInt(),
-          vesuMultiply.toBigInt(), // delegatee
-        ],
+        method: "modify_delegation",
+        packedArguments: isV2
+          ? [vesuMultiply.toBigInt()]
+          : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
         sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        // sd1 = switch delegation on
-        id: `sd1_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+        id: `${idDelegOnPrefix}_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
-      // Vesu multiply call
       {
         target: vesuMultiply,
-        method: 'modify_lever',
+        method: "modify_lever",
         packedArguments: [
           this.config.poolId.toBigInt(),
           collateral.address.toBigInt(),
@@ -335,57 +449,44 @@ export class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawPara
           this.config.vaultAllocator.toBigInt(),
         ],
         sanitizer: SIMPLE_SANITIZER_V2,
-        // vm = vesu multiply
-        id: `vm_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+        id: `${idMultiplyPrefix}_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
-      // Switch delegation off
       {
         target: vesuSingleton,
-        method: 'modify_delegation',
-        packedArguments: isV2 ? [
-          vesuMultiply.toBigInt(), // delegatee
-        ] : [
-          this.config.poolId.toBigInt(),
-          vesuMultiply.toBigInt(), // delegatee
-        ],
+        method: "modify_delegation",
+        packedArguments: isV2
+          ? [vesuMultiply.toBigInt()]
+          : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
         sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        // sd2 = switch delegation off
-        id: `sd2_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
-      }
+        id: `${idDelegOffPrefix}_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      },
     ];
   }
 
   protected _getWithdrawLeaf(): {
-    target: ContractAddr,
-    method: string,
-    packedArguments: bigint[],
-    sanitizer: ContractAddr,
-    id: string
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
   }[] {
-    const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
-    const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
+    const { vesuMultiply, vesuSingleton, isV2 } = this._getMultiplyContract();
     const collateral = this.config.collateral;
     const debt = this.config.debt;
 
     return [
-      // Switch delegation on
       {
         target: vesuSingleton,
-        method: 'modify_delegation',
-        packedArguments: isV2 ? [
-          vesuMultiply.toBigInt(), // delegatee
-        ] : [
-          this.config.poolId.toBigInt(),
-          vesuMultiply.toBigInt(), // delegatee
-        ],
+        method: "modify_delegation",
+        packedArguments: isV2
+          ? [vesuMultiply.toBigInt()]
+          : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
         sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        // sdow = switch delegation on withdraw
-        id: `sdow_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+        id: `sdow_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
-      // Vesu multiply call
       {
         target: vesuMultiply,
-        method: 'modify_lever',
+        method: "modify_lever",
         packedArguments: [
           this.config.poolId.toBigInt(),
           this.config.collateral.address.toBigInt(),
@@ -393,531 +494,793 @@ export class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawPara
           this.config.vaultAllocator.toBigInt(),
         ],
         sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        // vmw = vesu multiply withdraw
-        id: `vmw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+        id: `vmw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
-      // Switch delegation off
       {
         target: vesuSingleton,
-        method: 'modify_delegation',
-        packedArguments: isV2 ? [
-          vesuMultiply.toBigInt(), // delegatee
-        ] : [
-          this.config.poolId.toBigInt(),
-          vesuMultiply.toBigInt(), // delegatee
-        ],
+        method: "modify_delegation",
+        packedArguments: isV2
+          ? [vesuMultiply.toBigInt()]
+          : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
         sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        // sdofw = switch delegation off withdraw
-        id: `sdofw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
-      }
+        id: `sdofw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      },
     ];
   }
 
-  getDepositAdapter(): AdapterLeafType<DepositParams> {
+  // ─── Leaf Adapters ─────────────────────────────────────────────────────────
+
+  getDepositAdapter(approveToken?: TokenInfo): AdapterLeafType<VesuDepositParams> {
+    throw new Error("getDepositAdapter::Not implemented");
     const leafConfigs = this._getDepositLeaf();
-    const leaves = leafConfigs.map(config => {
+    const leaves = leafConfigs.map((config) => {
       const { target, method, packedArguments, sanitizer, id } = config;
-      const leaf = this.constructSimpleLeafData({
-        id: id,
-        target,
-        method,
-        packedArguments
-      }, sanitizer);
-      return leaf;
+      return this.constructSimpleLeafData(
+        { id, target, method, packedArguments },
+        sanitizer
+      );
     });
-    return { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<DepositParams> };
+    return {
+      leaves,
+      callConstructor: this.getDepositCall.bind(
+        this
+      ) as unknown as GenerateCallFn<VesuDepositParams>,
+    };
   }
 
-  getWithdrawAdapter(): AdapterLeafType<WithdrawParams> {
+  getWithdrawAdapter(): AdapterLeafType<VesuWithdrawParams> {
+    throw new Error("getWithdrawAdapter::Dont think this fn is used anywhere");
     const leafConfigs = this._getWithdrawLeaf();
-    const leaves = leafConfigs.map(config => {
+    const leaves = leafConfigs.map((config) => {
       const { target, method, packedArguments, sanitizer, id } = config;
-      const leaf = this.constructSimpleLeafData({
-        id: id,
-        target,
-        method,
-        packedArguments
-      }, sanitizer);
-      return leaf;
+      return this.constructSimpleLeafData(
+        { id, target, method, packedArguments },
+        sanitizer
+      );
     });
-    return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<WithdrawParams> };
+    return {
+      leaves,
+      callConstructor: this.getWithdrawCall.bind(
+        this
+      ) as unknown as GenerateCallFn<VesuWithdrawParams>,
+    };
   }
 
-  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
-    const collateral = this.config.collateral;
-    const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
-    const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
+  // ─── Public Call Builders ──────────────────────────────────────────────────
 
-    const uint256MarginAmount = uint256.bnToUint256(params.amount.toWei());
+  async getDepositCall(params: VesuDepositParams): Promise<ManageCall[]> {
+    const { calldata, approveToken, approveAmount } = await this._getIncreaseCalldata(params);
+    const { vesuMultiply } = this._getMultiplyContract();
+    const proofReadableIds = this._getDepositProofReadableIds();
 
-    return [
-      // Approval call
-      {
-        sanitizer: SIMPLE_SANITIZER,
-        call: {
-          contractAddress: collateral.address,
-          selector: hash.getSelectorFromName('approve'),
-          calldata: [
-            vesuMultiply.toBigInt(), // spender
-            toBigInt(uint256MarginAmount.low.toString()), // amount low
-            toBigInt(uint256MarginAmount.high.toString()), // amount high
-          ]
-        }
-      },
-      // Switch delegation on
-      {
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        call: {
-          contractAddress: vesuSingleton,
-          selector: hash.getSelectorFromName('modify_delegation'),
-          calldata: isV2 ? [
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(1), // delegation: true
-          ] : [
-            this.config.poolId.toBigInt(),
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(1), // delegation: true
-          ]
-        }
-      },
-      // Vesu multiply call
-      {
-        sanitizer: SIMPLE_SANITIZER_V2,
-        call: {
-          contractAddress: vesuMultiply,
-          selector: hash.getSelectorFromName('modify_lever'),
-          calldata: await this.getMultiplyCallCalldata(params, true)
-        }
-      },
-      // Switch delegation off
-      {
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        call: {
-          contractAddress: vesuSingleton,
-          selector: hash.getSelectorFromName('modify_delegation'),
-          calldata: isV2 ? [
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(0), // delegation: false
-          ] : [
-            this.config.poolId.toBigInt(),
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(0), // delegation: false
-          ]
-        }
-      }
-    ];
-  }
 
-  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
-    const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(this.config.poolId);
-    const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
+    const uint256Amount = uint256.bnToUint256(approveAmount.toWei());
 
-    return [
-      // Switch delegation on
-      {
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        call: {
-          contractAddress: vesuSingleton,
-          selector: hash.getSelectorFromName('modify_delegation'),
-          calldata: isV2 ? [
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(1), // delegation: true
-          ] : [
-            this.config.poolId.toBigInt(),
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(1), // delegation: true
-          ]
-        }
-      },
-      // Vesu multiply call
-      {
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        call: {
-          contractAddress: vesuMultiply,
-          selector: hash.getSelectorFromName('modify_lever'),
-          calldata: await this.getWithdrawalCalldata(params)
-        }
+    const approveCall: ManageCall = {
+      proofReadableId: proofReadableIds.approve,
+      sanitizer: SIMPLE_SANITIZER,
+      call: {
+        contractAddress: approveToken.address,
+        selector: hash.getSelectorFromName("approve"),
+        calldata: [
+          vesuMultiply.toBigInt(),
+          toBigInt(uint256Amount.low.toString()),
+          toBigInt(uint256Amount.high.toString()),
+        ],
       },
-      // Switch delegation off
-      {
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        call: {
-          contractAddress: vesuSingleton,
-          selector: hash.getSelectorFromName('modify_delegation'),
-          calldata: isV2 ? [
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(0), // delegation: false
-          ] : [
-            this.config.poolId.toBigInt(),
-            vesuMultiply.toBigInt(), // delegatee
-            BigInt(0), // delegation: false
-          ]
-        }
-      }
-    ];
+    };
+
+    return this._buildDelegationWrappedCalls([approveCall], calldata, {
+      delegationOn: proofReadableIds.delegationOn,
+      modifyLever: proofReadableIds.modifyLever,
+      delegationOff: proofReadableIds.delegationOff,
+    });
   }
 
-  private async getMultiplyCallCalldata(params: DepositParams | WithdrawParams, isDeposit: boolean): Promise<bigint[]> {
-    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;
-    
-    // Create a temporary contract instance to populate the call
-    const multiplyContract = new Contract({
-      abi: VesuMultiplyAbi, 
-      address: vesuMultiply.address, 
-      providerOrAccount: this.config.networkConfig.provider
+  async getWithdrawCall(params: VesuWithdrawParams): Promise<ManageCall[]> {
+    const calldata = await this._getDecreaseCalldata(params);
+    const proofReadableIds = this._getWithdrawProofReadableIds();
+    return this._buildDelegationWrappedCalls([], calldata, {
+      delegationOn: proofReadableIds.delegationOn,
+      modifyLever: proofReadableIds.modifyLever,
+      delegationOff: proofReadableIds.delegationOff,
     });
+  }
 
-    // Configure swaps based on the operation
-    let leverSwap: Swap[] = [];
-    let leverSwapLimitAmount = Web3Number.fromWei(0, this.config.debt.decimals);
+  // ─── Consolidated Calldata Builders ────────────────────────────────────────
 
-    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)}`);
-
-    // - Prices as seen by Vesu contracts, ideal for HF math
-    // Price 1 is ok as fallback bcz that would relatively price the 
-    // collateral and debt as equal.
-    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}`);
-
-    // compute optimal amount of collateral and debt post addition/removal
-    // target hf = collateral * collateralPrice * ltv / debt * debtPrice
-    // assuming X to be the usd amount of debt borrowed or repaied (negative). 
-    // target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv / (debt * debtPrice + X)
-    // => X * target hf = (((collateral + legDepositAmount) * collateralPrice + X)) * ltv - (debt * debtPrice * target hf)
-    // => X * (target hf - ltv)= ((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)
-    // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
-
-    const addedCollateral = params.amount
-      .multipliedBy(isDeposit ? 1 : -1)
-    logger.verbose(`${VesuMultiplyAdapter.name}::getVesuMultiplyCall addedCollateral: ${addedCollateral}`);
-    const numeratorPart1 = (existingCollateralInfo.amount.plus((addedCollateral))).multipliedBy(collateralPrice).multipliedBy(legLTV);
-    logger.verbose(`${VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart1: ${numeratorPart1}`);
-    const numeratorPart2 = existingDebtInfo.amount.multipliedBy(debtPrice).multipliedBy(this.config.targetHealthFactor);
-    logger.verbose(`${VesuMultiplyAdapter.name}::getVesuMultiplyCall numeratorPart2: ${numeratorPart2}`);
-    const denominatorPart = this.config.targetHealthFactor - (legLTV / dexPrice); // TODO Write reason for this.  this dexPrice is some custom thing. this dexPrice is probably exchange rate (1 xWBTC in WBTC terms)
-    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}`);
-
-    // both in underlying
-    // debtAmount in debt units
-    let debtAmount = new Web3Number(x_debt_usd.dividedBy(debtPrice).toFixed(this.config.debt.decimals), this.config.debt.decimals);
-    const marginAmount = addedCollateral;
+  private async _getIncreaseCalldata(
+    params: VesuDepositParams
+  ): Promise<{ calldata: bigint[]; approveToken: TokenInfo; approveAmount: Web3Number }> {
     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);
-    
-    // increase multiply lever or not
-    const isIncrease = debtAmount.greaterThanOrEqualTo(0);
+    const { contract: multiplyContract } = this._getMultiplyContract();
+    this.lastSwapPriceInfo = null;
+
+    const {
+      existingCollateralInfo,
+      existingDebtInfo,
+      collateralPrice,
+      debtPrice,
+      ekuboQuoter,
+    } = await this._fetchPositionAndPrices();
+
+    logger.verbose(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata params: ${JSON.stringify(
+        params
+      )}, collateral: ${collateralToken.symbol}, debt: ${debtToken.symbol}`
+    );
+    logger.debug(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata existingCollateralInfo: ${JSON.stringify(
+        existingCollateralInfo
+      )}, existingDebtInfo: ${JSON.stringify(existingDebtInfo)}`
+    );
+    logger.debug(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`
+    );
+
+    const legLTV = await this._vesuAdapter.getLTVConfig(
+      this.config.networkConfig
+    );
+    const isDexPriceRequired = debtToken.symbol !== "USDC";
+    const dexPrice = isDexPriceRequired
+      ? await ekuboQuoter.getDexPrice(
+        collateralToken,
+        debtToken,
+        this.config.quoteAmountToFetchPrice
+      )
+      : 1;
+    logger.verbose(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata dexPrice: ${dexPrice}, ltv: ${legLTV}`
+    );
+
+    let marginSwap: Swap[] = [];
+    let marginSwapLimitAmount = Web3Number.fromWei(0, collateralToken.decimals);
+    let addedCollateral: Web3Number = params.amount;
+    let approveAmount: Web3Number = params.amount;
+    let aggregatedFromAmount = 0; // e.g. USDC
+    let aggregatedToAmount = 0; // e.g. BTC
+    let aggregatedFromSymbol: string = debtToken.symbol;
+    const aggregatedToSymbol = collateralToken.symbol;
+    let executedSwapCount = 0;
 
+    if (params.marginSwap) {
+      const marginToken = params.marginSwap.marginToken;
+      const requiredAmount = params.amount;
 
-    // due to directional limitations in multiply contract
-    if (isIncrease && debtAmount.lessThan(0)) {
-      // we are increasing lever but math says reduce debt
-      // - this is ok
-    } else if (!isIncrease && debtAmount.greaterThan(0)) {
-      // we are decreasing level but math says increase debt
-      // - such actions must be done with zero margin amount
-      // - so just set debt 0
+      // bcz, last swap price is configured to be common between margin swap and lever swap,
+      // hence need same tokens in both
+      assert(marginToken.address.eq(debtToken.address), 'Margin token must be the same as debt token');
+
+      const marginSwapQuote = await ekuboQuoter.getQuoteExactOutput(
+        marginToken.address.address,
+        collateralToken.address.address,
+        requiredAmount
+      );
+      if (marginSwapQuote.price_impact > 0.01) {
+        throw new Error(
+          `VesuMultiplyAdapter: Margin swap price impact too high (${marginSwapQuote.price_impact})`
+        );
+      }
+
+      marginSwap = ekuboQuoter.getVesuMultiplyQuote(
+        marginSwapQuote,
+        marginToken,
+        collateralToken
+      );
+      const marginSwapInputAmount = Web3Number
+        .fromWei(marginSwapQuote.total_calculated, marginToken.decimals)
+        .abs()
+        .toNumber();
+      const marginSwapOutputAmount = requiredAmount.abs().toNumber();
+      aggregatedFromAmount += marginSwapInputAmount;
+      aggregatedToAmount += marginSwapOutputAmount;
+      executedSwapCount += 1;
+
+      approveAmount = Web3Number
+        .fromWei(marginSwapQuote.total_calculated, marginToken.decimals)
+        .multipliedBy(1 + this.maxSlippage)
+        .abs();
+    }
+
+    let debtAmount = this._computeTargetDebtDelta(
+      addedCollateral,
+      existingCollateralInfo.amount,
+      existingDebtInfo.amount,
+      collateralPrice,
+      debtPrice,
+      legLTV,
+      dexPrice
+    );
+
+    logger.info(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata debtAmount: ${debtAmount}, addedCollateral: ${addedCollateral}`
+    );
+    let leverSwap: Swap[] = [];
+    let leverSwapLimitAmount = Web3Number.fromWei(0, debtToken.decimals);
+
+    const isIncrease = debtAmount.greaterThanOrEqualTo(0);
+    if (!isIncrease && debtAmount.greaterThan(0)) {
       debtAmount = Web3Number.fromWei(0, this.config.debt.decimals);
     }
-    logger.verbose(`${VesuMultiplyAdapter.name}::getVesuMultiplyCall debtAmount: ${debtAmount}, marginAmount: ${marginAmount}`);
-    if (!debtAmount.isZero()) {
-      // Get swap quote for leverage operation
-      // Determine swap direction based on operation type
-      
-       try {
-        const swapQuote = await ekuboQuoter.getQuote(
-          collateralToken.address.address,
+
+    if (!debtAmount.isZero() && debtAmount.greaterThan(0)) {
+      try {
+        let swapQuote: EkuboQuote;
+        if (params.leverSwap?.exactOutput) {
+          swapQuote = await ekuboQuoter.getQuoteExactOutput(
+            debtToken.address.address,
+            collateralToken.address.address,
+            params.leverSwap?.exactOutput?.abs()!
+          );
+          debtAmount = Web3Number.fromWei(swapQuote.total_calculated, debtToken.decimals).abs();
+        }
+
+        swapQuote = await ekuboQuoter.getQuoteExactInput(
           debtToken.address.address,
-          debtAmountInCollateralUnits.multipliedBy(-1)// negative for exact amount out
+          collateralToken.address.address,
+          debtAmount.abs()
         );
-        
-        // todo add better slip checks
-        // Check price impact
-        if (swapQuote.price_impact < 0.01) { // 1% max price impact
-          // from and toToken param position reversed, to fetch the required quote and keep things generalised
-          leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, debtToken, collateralToken);
-          //console.log("leverSwap", leverSwap[-1].token_amount);
-          //console.log(JSON.stringify(leverSwap));
-          // Calculate limit amount with slippage protection
-          const MAX_SLIPPAGE = 0.002; // 0.2% slippage
-          if (debtAmount.greaterThan(0)) {
-            // For increase: minimum amount of collateral received
-            // from debt token to collateral token
-            //console.log("debtAmountInCollateralUnits", debtAmountInCollateralUnits.toNumber());
-            //leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(debtToken, collateralToken, debtAmount, MAX_SLIPPAGE);
-            leverSwapLimitAmount = debtAmount.multipliedBy(1 + MAX_SLIPPAGE);
-            //console.log("anotherleverSwapLimitAmount", anotherleverSwapLimitAmount, leverSwapLimitAmount);
-          } else if (debtAmount.lessThan(0)) {
-            // For decrease: maximum amount of collateral used
-            // from collateral token to debt token
-            //leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(collateralToken, debtToken, debtAmountInCollateralUnits.multipliedBy(-1), MAX_SLIPPAGE);
-            leverSwapLimitAmount = debtAmount.abs().multipliedBy(1 - MAX_SLIPPAGE);
-            //console.log("anotherleverSwapLimitAmount", anotherleverSwapLimitAmount, leverSwapLimitAmount);
-          } else {
-            leverSwapLimitAmount = Web3Number.fromWei(0, this.config.debt.decimals);
-          }
+        const expectedOutputAmount = debtAmount.multipliedBy(debtPrice).dividedBy(collateralPrice);
+        expectedOutputAmount.decimals = collateralToken.decimals;
+        leverSwapLimitAmount = expectedOutputAmount.multipliedBy(1 - this.maxSlippage);
+
+        if (swapQuote.price_impact < 0.01) {
+          const quoteOutputAmount = Web3Number.fromWei(
+            swapQuote.total_calculated,
+            collateralToken.decimals
+          )
+            .abs()
+            .toNumber();
+
+          const inputAmt = debtAmount.abs().toNumber();
+          const outputAmt = quoteOutputAmount;
+          aggregatedFromAmount += inputAmt;
+          aggregatedToAmount += outputAmt;
+          executedSwapCount += 1;
+
+          leverSwap = ekuboQuoter.getVesuMultiplyQuote(
+            swapQuote,
+            debtToken,
+            collateralToken
+          );
           await new Promise((resolve) => setTimeout(resolve, 10000));
-          //console.log("leverSwapLimitAmount", leverSwapLimitAmount);
         } else {
-          throw new Error(`VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`);
+          throw new Error(
+            `VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap, debtAmount=${debtAmount.toNumber()}, collateralPrice=${collateralPrice}, debtPrice=${debtPrice}`
+          );
         }
       } 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 call = multiplyContract.populate('modify_lever', {
-      modify_lever_params: this.formatMultiplyParams(isIncrease, multiplyParams)
-    });
 
-    return call.calldata as bigint[];
-  }
+    if (executedSwapCount > 0) {
+      this.lastSwapPriceInfo = {
+        source: "ekubo",
+        fromTokenSymbol: aggregatedFromSymbol ?? debtToken.symbol,
+        toTokenSymbol: aggregatedToSymbol,
+        fromAmount: aggregatedFromAmount,
+        toAmount: aggregatedToAmount,
+        effectivePrice: aggregatedToAmount !== 0 ? aggregatedFromAmount / aggregatedToAmount : 0,
+      };
+      logger.verbose(
+        `${VesuMultiplyAdapter.name}::_getIncreaseCalldata stored aggregated price info: ` +
+        `${aggregatedFromAmount} ${this.lastSwapPriceInfo.fromTokenSymbol} → ${aggregatedToAmount} ${aggregatedToSymbol}, ` +
+        `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}, swaps=${executedSwapCount}`
+      );
+    }
 
-  private async getLeverParams(isIncrease: boolean, params: DepositParams | WithdrawParams, leverSwap: Swap[], leverSwapLimitAmount: Web3Number): Promise<IncreaseLeverParams | DecreaseLeverParams> {
-    const multiplyParams: IncreaseLeverParams | DecreaseLeverParams = isIncrease ? {
+    logger.verbose(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata leverSwapLimitAmount: ${leverSwapLimitAmount.toWei()}`
+    );
+    logger.verbose(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata approveAmount: ${approveAmount.toWei()}, marginSwapLimitAmount: ${marginSwapLimitAmount.toWei()}`
+    );
+    logger.verbose(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata marginSwap: ${JSON.stringify(marginSwap)}`
+    );
+    const multiplyParams: IncreaseLeverParams = {
       user: this.config.vaultAllocator,
       pool_id: this.config.poolId,
-      collateral_asset: this.config.collateral.address,
-      debt_asset: this.config.debt.address,
-      recipient: this.config.vaultAllocator,
-      add_margin: params.amount, // multiplied by collateral decimals in format
-      margin_swap: [],
-      margin_swap_limit_amount: Web3Number.fromWei(0, this.config.collateral.decimals),
+      collateral_asset: collateralToken.address,
+      debt_asset: debtToken.address,
+      add_margin: params.marginSwap
+        ? Web3Number.fromWei(0, collateralToken.decimals)
+        : params.amount,
+      margin_swap: marginSwap,
+      margin_swap_limit_amount: params.marginSwap ? approveAmount : marginSwapLimitAmount,
       lever_swap: leverSwap,
-      lever_swap_limit_amount: leverSwapLimitAmount
-    } : {
+      lever_swap_limit_amount: leverSwapLimitAmount,
+    };
+
+    const call = multiplyContract.populate("modify_lever", {
+      modify_lever_params: this.formatMultiplyParams(true, multiplyParams),
+    });
+    logger.debug(
+      `${VesuMultiplyAdapter.name}::_getIncreaseCalldata marginSwapCount=${marginSwap.length}, leverSwapCount=${leverSwap.length}`,
+    );
+
+    return {
+      calldata: call.calldata as bigint[],
+      approveToken: params.marginSwap?.marginToken ?? this.config.collateral,
+      approveAmount: approveAmount,
+    };
+  }
+
+  // private _setLastSwapPriceAsNoSwap(): void {
+  //   this.lastSwapPriceInfo = {
+  //     source: "no-swap",
+  //     fromTokenSymbol: this.config.collateral.symbol,
+  //     toTokenSymbol: this.config.debt.symbol,
+  //     fromAmount: 0,
+  //     toAmount: 0,
+  //     effectivePrice: 0,
+  //   };
+  // }
+
+  private async _buildDecreaseLikeCalldata(params: {
+    subMargin: Web3Number;
+    debtToRepayAbs: Web3Number;
+    existingCollateral: Web3Number;
+    closePosition: boolean;
+    outputToken?: TokenInfo;
+    collateralPrice: number;
+    debtPrice: number;
+  }): Promise<bigint[]> {
+    const collateralToken = this.config.collateral;
+    const debtToken = this.config.debt;
+    const { contract: multiplyContract } = this._getMultiplyContract();
+    this.lastSwapPriceInfo = null;
+    const ekuboQuoter = new EkuboQuoter(
+      this.config.networkConfig,
+      this.config.pricer
+    );
+
+    let leverSwap: Swap[] = [];
+    let leverSwapWeights: Web3Number[] = [];
+    let leverSwapLimitAmount = Web3Number.fromWei(0, collateralToken.decimals);
+    let leverCollateralUsed = Web3Number.fromWei(0, collateralToken.decimals);
+    let aggregatedFromAmount = 0; // collateral sold
+    let aggregatedToAmount = 0; // debt bought
+    let executedSwapCount = 0;
+
+    if (params.closePosition) {
+      const debtQuote = await ekuboQuoter.getQuoteExactOutput(
+        collateralToken.address.address,
+        debtToken.address.address,
+        params.debtToRepayAbs
+      );
+
+      const built = this._buildZeroAmountSwapsWithWeights(
+        debtQuote,
+        debtToken,
+        true
+      );
+      leverSwap = built.swaps;
+      leverSwapWeights = built.weights;
+      leverCollateralUsed = Web3Number.fromWei(
+        debtQuote.total_calculated,
+        collateralToken.decimals
+      ).abs();
+      leverSwapLimitAmount = leverCollateralUsed.multipliedBy(1 + this.maxSlippage);
+      aggregatedFromAmount += leverCollateralUsed.toNumber();
+      aggregatedToAmount += params.debtToRepayAbs.abs().toNumber();
+      executedSwapCount += 1;
+
+    } else {
+      if (params.collateralPrice === undefined || params.debtPrice === undefined) {
+        throw new Error(
+          "VesuMultiplyAdapter: Missing prices for non-close decrease calldata"
+        );
+      }
+      const collateralToSwap = new Web3Number(
+        params.debtToRepayAbs
+          .multipliedBy(params.debtPrice)
+          .dividedBy(params.collateralPrice)
+          .toFixed(collateralToken.decimals),
+        collateralToken.decimals
+      );
+      const leverSwapQuote = await ekuboQuoter.getQuoteExactInput(
+        collateralToken.address.address,
+        debtToken.address.address,
+        collateralToSwap
+      );
+      if (leverSwapQuote.price_impact < 0.0025) {
+        const inputAmt = collateralToSwap.toNumber();
+        const outputAmt = Web3Number.fromWei(
+          leverSwapQuote.total_calculated,
+          debtToken.decimals
+        )
+          .abs()
+          .toNumber();
+        aggregatedFromAmount += inputAmt;
+        aggregatedToAmount += outputAmt;
+        executedSwapCount += 1;
+
+        leverSwap = ekuboQuoter.getVesuMultiplyQuote(
+          leverSwapQuote,
+          collateralToken,
+          debtToken
+        );
+        leverSwapLimitAmount = collateralToSwap
+          .multipliedBy(params.collateralPrice)
+          .dividedBy(params.debtPrice)
+          .multipliedBy(1 - this.maxSlippage);
+        leverSwapLimitAmount.decimals = debtToken.decimals;
+      } else {
+        throw new Error(`VesuMultiplyAdapter: Lever swap price impact too high (${leverSwapQuote.price_impact})`);
+      }
+
+      leverCollateralUsed = Web3Number.fromWei(
+        leverSwapQuote.total_calculated,
+        collateralToken.decimals
+      ).abs();
+    }
+
+    let withdrawSwap: Swap[] = [];
+    let withdrawSwapLimitAmount = Web3Number.fromWei(
+      0,
+      params.outputToken?.decimals ?? collateralToken.decimals
+    );
+    const withdrawSwapWeights: Web3Number[] = [];
+
+    if (params.outputToken && !params.outputToken.address.eq(collateralToken.address)) {
+      // bcz, last swap price is configured to be common between withdraw swap and lever swap,
+      // hence need same tokens in both
+      assert(params.outputToken.address.eq(debtToken.address), 'Withdraw output token must be the same as debt token');
+      const residualCollateral = params.closePosition
+        ? params.existingCollateral.minus(leverCollateralUsed)
+        : params.subMargin;
+      const outputTokenPrice = await this.config.pricer.getPrice(params.outputToken.symbol);
+      if (residualCollateral.greaterThan(0)) {
+        await new Promise((r) => setTimeout(r, 10000));
+        const withdrawQuote = await ekuboQuoter.getQuoteExactInput(
+          collateralToken.address.address,
+          params.outputToken.address.address,
+          residualCollateral
+        );
+        if (withdrawQuote.price_impact < 0.0025) {
+          const built = this._buildZeroAmountSwapsWithWeights(
+            withdrawQuote,
+            collateralToken
+          );
+          withdrawSwap = built.swaps;
+          withdrawSwapWeights.push(...built.weights);
+          const withdrawOutputAmount = Web3Number.fromWei(
+            withdrawQuote.total_calculated,
+            params.outputToken.decimals
+          ).abs().toNumber();
+          aggregatedFromAmount += residualCollateral.toNumber();
+          aggregatedToAmount += withdrawOutputAmount;
+          executedSwapCount += 1;
+          const estimatedOutput = residualCollateral
+            .multipliedBy(params.collateralPrice)
+            .dividedBy(outputTokenPrice.price);
+          estimatedOutput.decimals = params.outputToken.decimals;
+          withdrawSwapLimitAmount = estimatedOutput
+            .multipliedBy(1 - this.maxSlippage);
+        }
+      }
+    }
+
+    if (executedSwapCount > 0) {
+      this.lastSwapPriceInfo = {
+        source: "ekubo",
+        fromTokenSymbol: collateralToken.symbol,
+        toTokenSymbol: debtToken.symbol,
+        fromAmount: aggregatedFromAmount,
+        toAmount: aggregatedToAmount,
+        effectivePrice: aggregatedFromAmount !== 0 ? aggregatedToAmount / aggregatedFromAmount : 0,
+      };
+      logger.verbose(
+        `${VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata stored aggregated price info: ` +
+        `${aggregatedFromAmount} ${collateralToken.symbol} → ${aggregatedToAmount} ${debtToken.symbol}, ` +
+        `effectivePrice=${this.lastSwapPriceInfo.effectivePrice}, swaps=${executedSwapCount}`
+      );
+    } else {
+      this.lastSwapPriceInfo = null;
+    }
+
+    logger.debug(
+      `${VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata leverSwapCount=${leverSwap.length}, withdrawSwapCount=${withdrawSwap.length}, withdrawSwapLimitAmount=${withdrawSwapLimitAmount.toNumber()}, subMargin=${params.subMargin.toNumber()}`,
+    );
+    const multiplyParams: DecreaseLeverParams = {
       user: this.config.vaultAllocator,
       pool_id: this.config.poolId,
-      collateral_asset: this.config.collateral.address,
-      debt_asset: this.config.debt.address,
+      collateral_asset: collateralToken.address,
+      debt_asset: debtToken.address,
       recipient: this.config.vaultAllocator,
-      sub_margin: params.amount,
+      sub_margin: params.closePosition
+        ? Web3Number.fromWei(0, collateralToken.decimals)
+        : params.subMargin,
       lever_swap: leverSwap,
       lever_swap_limit_amount: leverSwapLimitAmount,
-      lever_swap_weights: [],
-      withdraw_swap: [],
-      withdraw_swap_limit_amount: Web3Number.fromWei(0, this.config.collateral.decimals),
-      withdraw_swap_weights: [],
-      close_position: false
+      lever_swap_weights: leverSwapWeights,
+      withdraw_swap: withdrawSwap,
+      withdraw_swap_limit_amount: withdrawSwapLimitAmount,
+      withdraw_swap_weights: withdrawSwapWeights,
+      close_position: params.closePosition,
     };
-    return multiplyParams;
-  }
 
-  private async getWithdrawalCalldata(params: WithdrawParams): Promise<bigint[]> {
-    //params.amount must be in btc here
-    const { isV2 } = getVesuSingletonAddress(this.config.poolId);
-    const vesuMultiply = isV2 ? this.vesuAdapter.VESU_MULTIPLY : this.vesuAdapter.VESU_MULTIPLY_V1;
-    const multiplyContract = new Contract({
-      abi: VesuMultiplyAbi, 
-      address: vesuMultiply.address, 
-      providerOrAccount: this.config.networkConfig.provider
+    const call = multiplyContract.populate("modify_lever", {
+      modify_lever_params: this.formatMultiplyParams(false, multiplyParams),
     });
-    let leverSwap: Swap[] = [];
-    let leverSwapLimitAmount = Web3Number.fromWei(0, this.config.debt.decimals);
-    const existingPositions = await this.vesuAdapter.getPositions(this.config.networkConfig);
-    const existingCollateralInfo = existingPositions[0];
-    const existingDebtInfo = existingPositions[1];
+    return call.calldata as bigint[];
+  }
+
+  private async _getDecreaseCalldata(
+    params: VesuWithdrawParams
+  ): Promise<bigint[]> {
     const collateralToken = this.config.collateral;
     const debtToken = this.config.debt;
-    const collateralPrice = await this.config.pricer.getPrice(collateralToken.symbol);
+
+    this._vesuAdapter.networkConfig = this.config.networkConfig;
+    this._vesuAdapter.pricer = this.config.pricer;
+    const existingPositions = await this._vesuAdapter.getPositions(
+      this.config.networkConfig
+    );
+    const existingCollateralInfo = existingPositions[0];
+    const existingDebtInfo = existingPositions[1];
+    const collateralPrice = await this.config.pricer.getPrice(
+      collateralToken.symbol
+    );
     const debtPrice = await this.config.pricer.getPrice(debtToken.symbol);
-    // the debt amount is negative as we are reducing debt to withdraw
+
     const { deltadebtAmountUnits: debtAmountToRepay } =
-    calculateDebtReductionAmountForWithdrawal(
-      existingDebtInfo.amount,
-      existingCollateralInfo.amount,
-      MAX_LIQUIDATION_RATIO,
-      params.amount,
-      collateralPrice.price,
-      debtPrice.price,
-      debtToken.decimals
-    );
-    //console.log("debtAmountToRepay", debtAmountToRepay);
-    if(!debtAmountToRepay) {
+      calculateDebtReductionAmountForWithdrawal(
+        existingDebtInfo.amount,
+        existingCollateralInfo.amount,
+        MAX_LIQUIDATION_RATIO,
+        params.amount,
+        collateralPrice.price,
+        debtPrice.price,
+        debtToken.decimals
+      );
+    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 swapQuote = await ekuboQuoter.getQuote(
-      debtToken.address.address,
-      collateralToken.address.address,
-      debtInDebtUnits
-    )
-    const MAX_SLIPPAGE = 0.002; // 0.2% slippag
-    if(swapQuote.price_impact < 0.0025) {
-      leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, collateralToken, debtToken);
-    } else {
-      logger.error(`VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`);
+
+    const debtToRepayAbs = new Web3Number(
+      debtAmountToRepay,
+      debtToken.decimals
+    ).abs();
+    const existingDebtAbs = existingDebtInfo.amount.abs();
+
+    const shouldCloseByDebt = debtToRepayAbs.greaterThanOrEqualTo(existingDebtAbs);
+    const remainingDebtUSD = existingDebtAbs
+      .minus(debtToRepayAbs)
+      .multipliedBy(debtPrice.price)
+      .toNumber();
+    const shouldCloseByDust = remainingDebtUSD < MIN_REMAINING_DEBT_USD;
+
+    if (shouldCloseByDebt) {
+      logger.info(
+        `${VesuMultiplyAdapter.name}::_getDecreaseCalldata debt to repay (${debtToRepayAbs.toNumber()}) >= existing debt (${existingDebtAbs.toNumber()}), auto-closing position`
+      );
+    } else if (shouldCloseByDust) {
+      logger.info(
+        `${VesuMultiplyAdapter.name}::_getDecreaseCalldata remaining debt $${remainingDebtUSD.toFixed(2)} < $${MIN_REMAINING_DEBT_USD}, auto-closing position`
+      );
     }
 
-    leverSwapLimitAmount = new Web3Number(debtAmountToRepay, debtToken.decimals).abs().multipliedBy(1 + MAX_SLIPPAGE);
-    //leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(debtToken, collateralToken, debtInCollateralUnits, MAX_SLIPPAGE);
-   const multiplyParams = await this.getLeverParams(false, params, leverSwap, leverSwapLimitAmount);
-    const call = multiplyContract.populate('modify_lever', {
-      modify_lever_params: this.formatMultiplyParams(false, multiplyParams)
+    return this._buildDecreaseLikeCalldata({
+      subMargin: params.amount,
+      debtToRepayAbs: shouldCloseByDebt || shouldCloseByDust ? existingDebtAbs : debtToRepayAbs,
+      existingCollateral: existingCollateralInfo.amount,
+      closePosition: shouldCloseByDebt || shouldCloseByDust,
+      outputToken: params.withdrawSwap?.outputToken,
+      collateralPrice: collateralPrice.price,
+      debtPrice: debtPrice.price,
     });
-    return call.calldata as bigint[];
   }
 
-  formatMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams | DecreaseLeverParams) {
+  // private async _getClosePositionCalldata(
+  //   outputToken?: TokenInfo
+  // ): Promise<bigint[]> {
+  //   this._vesuAdapter.networkConfig = this.config.networkConfig;
+  //   this._vesuAdapter.pricer = this.config.pricer;
+  //   const existingPositions = await this._vesuAdapter.getPositions(
+  //     this.config.networkConfig
+  //   );
+  //   const existingCollateralInfo = existingPositions[0];
+  //   const existingDebtInfo = existingPositions[1];
+
+  //   if (existingDebtInfo.amount.isZero()) {
+  //     throw new Error("VesuMultiplyAdapter: No debt to close");
+  //   }
+
+  //   return this._buildDecreaseLikeCalldata({
+  //     subMargin: Web3Number.fromWei(0, this.config.collateral.decimals),
+  //     debtToRepayAbs: existingDebtInfo.amount.abs(),
+  //     existingCollateral: existingCollateralInfo.amount,
+  //     closePosition: true,
+  //     outputToken,
+  //   });
+  // }
+
+  // ─── Param Formatting ─────────────────────────────────────────────────────
+
+  formatMultiplyParams(
+    isIncrease: boolean,
+    params: IncreaseLeverParams | DecreaseLeverParams
+  ) {
     if (isIncrease) {
       const _params = params as IncreaseLeverParams;
       return {
-        action: new CairoCustomEnum({ IncreaseLever: {
+        action: new CairoCustomEnum({
+          IncreaseLever: {
+            pool_id: _params.pool_id.toBigInt(),
+            collateral_asset: _params.collateral_asset.toBigInt(),
+            debt_asset: _params.debt_asset.toBigInt(),
+            user: _params.user.toBigInt(),
+            add_margin: BigInt(_params.add_margin.toWei()),
+            margin_swap: _params.margin_swap.map((swap) => ({
+              route: swap.route.map((route) => ({
+                pool_key: {
+                  token0: route.pool_key.token0.toBigInt(),
+                  token1: route.pool_key.token1.toBigInt(),
+                  fee: route.pool_key.fee,
+                  tick_spacing: route.pool_key.tick_spacing,
+                  extension: BigInt(
+                    num.hexToDecimalString(route.pool_key.extension)
+                  ),
+                },
+                sqrt_ratio_limit: 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(
+              _params.margin_swap_limit_amount.toWei()
+            ),
+            lever_swap: _params.lever_swap.map((swap) => ({
+              route: swap.route.map((route) => ({
+                pool_key: {
+                  token0: route.pool_key.token0.toBigInt(),
+                  token1: route.pool_key.token1.toBigInt(),
+                  fee: route.pool_key.fee,
+                  tick_spacing: route.pool_key.tick_spacing,
+                  extension: BigInt(
+                    num.hexToDecimalString(route.pool_key.extension)
+                  ),
+                },
+                sqrt_ratio_limit: 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(
+              _params.lever_swap_limit_amount.toWei()
+            ),
+          },
+        }),
+      };
+    }
+
+    const _params = params as DecreaseLeverParams;
+    return {
+      action: new CairoCustomEnum({
+        DecreaseLever: {
           pool_id: _params.pool_id.toBigInt(),
           collateral_asset: _params.collateral_asset.toBigInt(),
           debt_asset: _params.debt_asset.toBigInt(),
           user: _params.user.toBigInt(),
-          add_margin: BigInt(_params.add_margin.toWei()),
-          margin_swap: _params.margin_swap.map(swap => ({
-            route: swap.route.map(route => ({
+          sub_margin: BigInt(_params.sub_margin.toWei()),
+          recipient: _params.recipient.toBigInt(),
+          lever_swap: _params.lever_swap.map((swap) => ({
+            route: swap.route.map((route) => ({
               pool_key: {
                 token0: route.pool_key.token0.toBigInt(),
                 token1: route.pool_key.token1.toBigInt(),
                 fee: route.pool_key.fee,
                 tick_spacing: route.pool_key.tick_spacing,
-                extension: BigInt(num.hexToDecimalString(route.pool_key.extension)),
+                extension: ContractAddr.from(
+                  route.pool_key.extension
+                ).toBigInt(),
               },
-              sqrt_ratio_limit: uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
-              skip_ahead: BigInt(100)
+              sqrt_ratio_limit: 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()
-            }
+              amount: swap.token_amount.amount.toI129(),
+            },
           })),
-          margin_swap_limit_amount: BigInt(_params.margin_swap_limit_amount.toWei()),
-          lever_swap: _params.lever_swap.map(swap => ({
-            route: swap.route.map(route => ({
+          lever_swap_limit_amount: BigInt(
+            _params.lever_swap_limit_amount.toWei()
+          ),
+          lever_swap_weights: _params.lever_swap_weights.map((weight) =>
+            BigInt(weight.toWei())
+          ),
+          withdraw_swap: _params.withdraw_swap.map((swap) => ({
+            route: swap.route.map((route) => ({
               pool_key: {
                 token0: route.pool_key.token0.toBigInt(),
                 token1: route.pool_key.token1.toBigInt(),
                 fee: route.pool_key.fee,
                 tick_spacing: route.pool_key.tick_spacing,
-                extension: BigInt(num.hexToDecimalString(route.pool_key.extension)),
+                extension: ContractAddr.from(
+                  route.pool_key.extension
+                ).toBigInt(),
               },
-              sqrt_ratio_limit: uint256.bnToUint256(route.sqrt_ratio_limit.toWei()),
-              skip_ahead: BigInt(0)
+              sqrt_ratio_limit: 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()),
-        } }),
-      }
-    }
-  
-    const _params = params as DecreaseLeverParams;  
-    return {
-      action: new CairoCustomEnum({ DecreaseLever: {
-        pool_id: _params.pool_id.toBigInt(),
-        collateral_asset: _params.collateral_asset.toBigInt(),
-        debt_asset: _params.debt_asset.toBigInt(),
-        user: _params.user.toBigInt(),
-        sub_margin: BigInt(_params.sub_margin.toWei()),
-        recipient: _params.recipient.toBigInt(),
-        lever_swap: _params.lever_swap.map(swap => ({
-          route: swap.route.map(route => ({
-            pool_key: {
-              token0: route.pool_key.token0.toBigInt(),
-              token1: route.pool_key.token1.toBigInt(),
-              fee: route.pool_key.fee,
-              tick_spacing: route.pool_key.tick_spacing,
-              extension: ContractAddr.from(route.pool_key.extension).toBigInt(),
+              amount: swap.token_amount.amount.toI129(),
             },
-            sqrt_ratio_limit: 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: 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,
+        },
+      }),
+    };
   }
 
+  // ─── Health Factor / Net APY ───────────────────────────────────────────────
+
   async getHealthFactor(): Promise<number> {
-    const healthFactor = await this.vesuAdapter.getHealthFactor();
+    const healthFactor = await this._vesuAdapter.getHealthFactor();
     return healthFactor;
   }
 
   async getNetAPY(): Promise<number> {
     const positions = await this.getPositions();
-    logger.verbose(`${this.name}::getNetAPY: positions: ${JSON.stringify(positions)}`);
-    const allZero = positions.every(p => p.usdValue === 0);
+    logger.verbose(
+      `${this.name}::getNetAPY: positions: ${JSON.stringify(positions)}`
+    );
+    const allZero = positions.every((p) => p.usdValue === 0);
 
-    // in case of zero positions, apy will come zero/NaN
-    // bcz of net 0 zero weights
     if (allZero) {
-      // use approx dummy usd values to compute netAPY
       const collateralUSD = 1000;
-      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),
-        1, // assume price 1 for simplicity
+        1,
         maxLTV,
         targetHF,
-        1, // assume price 1 for simplicity
+        1,
         this.config.debt
-      )
+      );
 
-      // debt is also added to collateral bcz, we assume debt is swapped to collateral
-      const debtUSD = maxDebt.multipliedBy(1); // assume price 1 for simplicity
-      const netAPY = (positions[0].apy.apy * (collateralUSD + debtUSD.toNumber()) + positions[1].apy.apy * debtUSD.toNumber()) / (collateralUSD);
+      const debtUSD = maxDebt.multipliedBy(1);
+      const netAPY =
+        (positions[0].apy.apy * (collateralUSD + debtUSD.toNumber()) +
+          positions[1].apy.apy * debtUSD.toNumber()) /
+        collateralUSD;
       return netAPY;
     }
 
-    // Return true APY
     const netAmount = positions.reduce((acc, curr) => acc + curr.usdValue, 0);
-    const netAPY = positions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) / netAmount;
+    const netAPY =
+      positions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) /
+      netAmount;
     logger.verbose(`${this.name}::getNetAPY: netAPY: ${netAPY}`);
     return netAPY;
   }