@strkfarm/sdk 1.1.70 → 2.0.0-dev.1

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

@@ -0,0 +1,924 @@
+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 { 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 { calculateDebtReductionAmountForWithdrawal } from "../vesu-extended-strategy/utils/helper";
+import { HealthFactorMath } from "@/utils/health-factor-math";
+import { MAX_LIQUIDATION_RATIO } from "../vesu-extended-strategy/utils/constants";
+
+export interface VesuMultiplyAdapterConfig extends BaseAdapterConfig {
+  poolId: ContractAddr;
+  collateral: TokenInfo;
+  debt: TokenInfo;
+  targetHealthFactor: number;
+  minHealthFactor: number;
+  quoteAmountToFetchPrice: Web3Number;
+}
+
+export class VesuMultiplyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+  readonly config: VesuMultiplyAdapterConfig;
+  readonly vesuAdapter: VesuAdapter;
+  readonly tokenMarketData: TokenMarketData;
+
+  constructor(config: VesuMultiplyAdapterConfig) {
+    super(config, VesuMultiplyAdapter.name, Protocols.VESU);
+    this.config = config;
+    this.vesuAdapter = new VesuAdapter({
+      poolId: config.poolId,
+      collateral: config.collateral,
+      debt: config.debt,
+      vaultAllocator: config.vaultAllocator,
+      id: ''
+    });
+    this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
+  }
+
+  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
+      };
+
+      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;
+    }
+  }
+
+  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;
+    }
+
+    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)
+      );
+
+      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"
+        };
+      }
+
+      if (supportedPosition.isDebt) {
+        position.amount = position.amount.multipliedBy(-1);
+        position.usdValue = position.usdValue * -1;
+      }
+
+      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;
+    }
+  }
+
+  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;
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    const collateral = this.config.collateral;
+    const debt = this.config.debt;
+
+    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
+      )
+
+      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 {
+        tokenInfo: collateral,
+        amount: maxDepositAmount,
+        usdValue,
+        remarks: "Max deposit based on available debt capacity",
+        apy: {
+          apy: netAPY,
+          type: APYType.BASE
+        },
+        protocol: this.protocol
+      };
+    } catch (error) {
+      logger.error(`VesuMultiplyAdapter: Error calculating max deposit:`, error);
+      throw error;
+    }
+  }
+
+  async maxWithdraw(): Promise<PositionInfo> {
+    const collateral = this.config.collateral;
+    const debt = this.config.debt;
+
+    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');
+      }
+
+      // 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;
+    }
+  }
+
+  protected _getDepositLeaf(): {
+    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;
+
+    return [
+      // Approval step for collateral
+      {
+        target: collateral.address,
+        method: 'approve',
+        packedArguments: [
+          vesuMultiply.toBigInt(), // spender
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        // amc = approve multiply collateral
+        id: `amc_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+      },
+      // Switch delegation on
+      {
+        target: vesuSingleton,
+        method: 'modify_delegation',
+        packedArguments: isV2 ? [
+          vesuMultiply.toBigInt(), // delegatee
+        ] : [
+          this.config.poolId.toBigInt(),
+          vesuMultiply.toBigInt(), // delegatee
+        ],
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        // sd1 = switch delegation on
+        id: `sd1_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+      },
+      // Vesu multiply call
+      {
+        target: vesuMultiply,
+        method: 'modify_lever',
+        packedArguments: [
+          this.config.poolId.toBigInt(),
+          collateral.address.toBigInt(),
+          this.config.debt.address.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: SIMPLE_SANITIZER_V2,
+        // vm = vesu multiply
+        id: `vm_${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
+        ],
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        // sd2 = switch delegation off
+        id: `sd2_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+      }
+    ];
+  }
+
+  protected _getWithdrawLeaf(): {
+    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 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
+        ],
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        // sdow = switch delegation on withdraw
+        id: `sdow_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+      },
+      // Vesu multiply call
+      {
+        target: vesuMultiply,
+        method: 'modify_lever',
+        packedArguments: [
+          this.config.poolId.toBigInt(),
+          this.config.collateral.address.toBigInt(),
+          this.config.debt.address.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: SIMPLE_SANITIZER_V2,
+        // vmw = vesu multiply withdraw
+        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
+        ],
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        // sdofw = switch delegation off withdraw
+        id: `sdofw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`
+      }
+    ];
+  }
+
+  getDepositAdapter(): AdapterLeafType<DepositParams> {
+    const leafConfigs = this._getDepositLeaf();
+    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 { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<DepositParams> };
+  }
+
+  getWithdrawAdapter(): AdapterLeafType<WithdrawParams> {
+    const leafConfigs = this._getWithdrawLeaf();
+    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 { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<WithdrawParams> };
+  }
+
+  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;
+
+    const uint256MarginAmount = uint256.bnToUint256(params.amount.toWei());
+
+    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;
+
+    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: SIMPLE_SANITIZER_V2,
+        call: {
+          contractAddress: vesuMultiply,
+          selector: hash.getSelectorFromName('modify_lever'),
+          calldata: await this.getWithdrawalCalldata(params)
+        }
+      },
+      // 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
+          ]
+        }
+      }
+    ];
+  }
+
+  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
+    });
+
+    // Configure swaps based on the operation
+    let leverSwap: Swap[] = [];
+    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 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;
+    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);
+
+
+    // 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
+      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,
+          debtToken.address.address,
+          debtAmountInCollateralUnits.multipliedBy(-1)// negative for exact amount out
+        );
+        
+        // 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);
+            const anotherleverSwapLimitAmount = 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);
+            const anotherleverSwapLimitAmount = debtAmount.abs().multipliedBy(1 - MAX_SLIPPAGE);
+            console.log("anotherleverSwapLimitAmount", anotherleverSwapLimitAmount, leverSwapLimitAmount);
+          } else {
+            leverSwapLimitAmount = Web3Number.fromWei(0, this.config.debt.decimals);
+          }
+          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`);
+        }
+      } catch (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[];
+  }
+
+  private async getLeverParams(isIncrease: boolean, params: DepositParams | WithdrawParams, leverSwap: Swap[], leverSwapLimitAmount: Web3Number): Promise<IncreaseLeverParams | DecreaseLeverParams> {
+    const multiplyParams: IncreaseLeverParams | DecreaseLeverParams = isIncrease ? {
+      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),
+      lever_swap: leverSwap,
+      lever_swap_limit_amount: leverSwapLimitAmount
+    } : {
+      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,
+      sub_margin: params.amount,
+      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
+    };
+    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
+    });
+    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];
+    const collateralToken = this.config.collateral;
+    const debtToken = this.config.debt;
+    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) {
+      throw new Error("error calculating debt amount to repay");
+    }
+    const ekuboQuoter = new EkuboQuoter(this.config.networkConfig, this.config.pricer);
+    const debtInDebtUnits = new Web3Number(debtAmountToRepay, debtToken.decimals).dividedBy(debtPrice.price).multipliedBy(10 ** debtToken.decimals);
+    const debtInCollateralUnits = new Web3Number(debtAmountToRepay, debtToken.decimals).dividedBy(collateralPrice.price).multipliedBy(10 ** collateralToken.decimals);
+    const swapQuote = await ekuboQuoter.getQuote(
+      debtToken.address.address,
+      collateralToken.address.address,
+      debtInDebtUnits
+    )
+    const MAX_SLIPPAGE = 0.002; // 0.2% slippag
+    if(swapQuote.price_impact < 0.025) {
+      leverSwap = ekuboQuoter.getVesuMultiplyQuote(swapQuote, debtToken, collateralToken);
+    } else {
+      logger.error(`VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`);
+    }
+    const anotherLeverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(collateralToken, debtToken, debtInDebtUnits, MAX_SLIPPAGE);
+    leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(debtToken, collateralToken, debtInCollateralUnits, MAX_SLIPPAGE);
+   const multiplyParams = await this.getLeverParams(false, params, leverSwap, leverSwapLimitAmount);
+    const call = multiplyContract.populate('modify_lever', {
+      modify_lever_params: this.formatMultiplyParams(false, multiplyParams)
+    });
+    return call.calldata as bigint[];
+  }
+
+  formatMultiplyParams(isIncrease: boolean, params: IncreaseLeverParams | DecreaseLeverParams) {
+    if (isIncrease) {
+      const _params = params as IncreaseLeverParams;
+      return {
+        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(),
+        sub_margin: BigInt(_params.sub_margin.toWei()),
+        recipient: _params.recipient.toBigInt(),
+        lever_swap: _params.lever_swap.map(swap => ({
+          route: swap.route.map(route => ({
+            pool_key: {
+              token0: route.pool_key.token0.toBigInt(),
+              token1: route.pool_key.token1.toBigInt(),
+              fee: route.pool_key.fee,
+              tick_spacing: route.pool_key.tick_spacing,
+              extension: ContractAddr.from(route.pool_key.extension).toBigInt(),
+            },
+            sqrt_ratio_limit: uint256.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,
+      }}),
+    }
+  }
+
+  async getHealthFactor(): Promise<number> {
+    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);
+
+    // 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 targetHF = this.config.targetHealthFactor;
+      const maxDebt = HealthFactorMath.getMaxDebtAmountOnLooping(
+        new Web3Number(collateralUSD, this.config.collateral.decimals),
+        1, // assume price 1 for simplicity
+        maxLTV,
+        targetHF,
+        1, // assume price 1 for simplicity
+        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);
+      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;
+    logger.verbose(`${this.name}::getNetAPY: netAPY: ${netAPY}`);
+    return netAPY;
+  }
+}