@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

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

@@ -1,1306 +0,0 @@
-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;
-  minimumVesuMovementAmount: number;
-}
-
-export class VesuMultiplyAdapter extends BaseAdapter<
-  DepositParams,
-  WithdrawParams
-> {
-  readonly config: VesuMultiplyAdapterConfig;
-  readonly vesuAdapter: VesuAdapter;
-  readonly tokenMarketData: TokenMarketData;
-  readonly minimumVesuMovementAmount: number;
-  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.minimumVesuMovementAmount = config.minimumVesuMovementAmount ?? 5; //5 usdc
-    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: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        // 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: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
-        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 = debtAmount.isNegative()
-            ? ekuboQuoter.getVesuMultiplyQuote(
-                swapQuote,
-                collateralToken,
-                debtToken
-              )
-            : 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
-            );
-          }
-          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 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`
-      );
-    }
-
-    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 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;
-  }
-}