@strkfarm/sdk 1.2.0 → 2.0.0-dev-strategy2.1

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

@@ -0,0 +1,1247 @@
+import {
+  BaseAdapterConfig,
+  BaseAdapter,
+  DepositParams,
+  WithdrawParams,
+  PositionInfo,
+  ManageCall,
+  AdapterLeafType,
+  GenerateCallFn,
+} from "./baseAdapter";
+import { num } from "starknet";
+import { StandardMerkleTree } from "@/utils";
+import VesuMultiplyAbi from "@/data/vesu-multiple.abi.json";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { TokenInfo, VaultPosition } from "@/interfaces";
+import {
+  DecreaseLeverParams,
+  IncreaseLeverParams,
+  Swap,
+  VesuAdapter,
+} from "./vesu-adapter";
+import { EkuboQuoter, TokenMarketData } from "@/modules";
+import { Protocols } from "@/interfaces";
+import { SupportedPosition, PositionAPY, APYType } from "./baseAdapter";
+import {
+  SIMPLE_SANITIZER,
+  SIMPLE_SANITIZER_V2,
+  VESU_V2_MODIFY_POSITION_SANITIZER,
+} from "./adapter-utils";
+import { getVesuSingletonAddress } from "./vesu-adapter";
+import { hash, Contract, CairoCustomEnum, Uint256 } from "starknet";
+import VesuPoolV2Abi from "@/data/vesu-pool-v2.abi.json";
+import { toBigInt } from "./adapter-utils";
+import { logger } from "@/utils";
+import { uint256 } from "starknet";
+import { ExtendedAdapter, VesuMultiplyAdapter } from "../universal-adapters";
+import { AvnuAdapter } from "./avnu-adapter";
+import { DepositParamsForLendingBorrowing } from "../btc-vesu-extended-strategy/utils/types";
+import { WBTC_TOKEN_DECIMALS } from "../vesu-extended-strategy/utils/constants";
+
+export interface VesuBorrowSupplyAdapterConfig extends BaseAdapterConfig {
+  poolId: ContractAddr;
+  borrowToken: TokenInfo;
+  supplyToken: TokenInfo;
+  targetHealthFactor: number;
+  minHealthFactor: number;
+  quoteAmountToFetchPrice: Web3Number;
+  vaultIdExtended: number;
+  extendedContract: ContractAddr;
+  extendedBackendUrl: string;
+  extendedApiKey: string;
+  extendedTimeout: number;
+  extendedRetries: number;
+  extendedBaseUrl: string;
+  extendedMarketName: string;
+  extendedPrecision: number;
+  extendedAdapter: ExtendedAdapter;
+  avnuAdapter: AvnuAdapter;
+  retryDelayForOrderStatus: number;
+  minimumExtendedMovementAmount: number;
+}
+
+export class VesuBorrowSupplyAdapter extends BaseAdapter<
+  DepositParams,
+  WithdrawParams
+> {
+  readonly config: VesuBorrowSupplyAdapterConfig;
+  readonly vesuAdapter: VesuAdapter;
+  readonly tokenMarketData: TokenMarketData;
+  protected extendedAdapter: ExtendedAdapter;
+
+  constructor(config: VesuBorrowSupplyAdapterConfig) {
+    super(config, VesuBorrowSupplyAdapter.name, Protocols.VESU);
+    this.config = config;
+    this.vesuAdapter = new VesuAdapter({
+      poolId: config.poolId,
+      collateral: config.supplyToken, //wbtc
+      debt: config.borrowToken, //usdc
+      vaultAllocator: config.vaultAllocator,
+      id: "",
+    });
+    this.tokenMarketData = new TokenMarketData(
+      this.config.pricer,
+      this.config.networkConfig
+    );
+    this.extendedAdapter = new ExtendedAdapter({
+      baseToken: this.config.baseToken,
+      supportedPositions: this.config.supportedPositions,
+      networkConfig: this.config.networkConfig,
+      pricer: this.config.pricer,
+      vaultAddress: this.config.vaultAddress,
+      vaultAllocator: this.config.vaultAllocator,
+      vaultIdExtended: this.config.vaultIdExtended,
+      extendedContract: this.config.extendedContract,
+      extendedBackendUrl: this.config.extendedBackendUrl,
+      extendedApiKey: this.config.extendedApiKey,
+      extendedTimeout: this.config.extendedTimeout,
+      extendedRetries: this.config.extendedRetries,
+      extendedBaseUrl: this.config.extendedBaseUrl,
+      extendedMarketName: this.config.extendedMarketName,
+      extendedPrecision: this.config.extendedPrecision,
+      avnuAdapter: this.config.avnuAdapter,
+      retryDelayForOrderStatus: this.config.retryDelayForOrderStatus,
+      minimumExtendedMovementAmount: this.config.minimumExtendedMovementAmount,
+    });
+  }
+
+  protected async getAPY(
+    supportedPosition: SupportedPosition
+  ): Promise<PositionAPY> {
+    return {
+      apy: 0,
+      type: APYType.BASE,
+    };
+  }
+
+  protected async getPosition(
+    supportedPosition: SupportedPosition
+  ): Promise<VaultPosition> {
+    return {} as VaultPosition;
+  }
+
+  async maxBorrowableAPY(): Promise<number> {
+    // get collateral APY
+    const collateralAPY = await this.getAPY({
+      asset: this.config.supplyToken,
+      isDebt: false,
+    });
+    const apy = collateralAPY.apy * 0.8;
+    return apy;
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    return {
+      tokenInfo: this.config.supplyToken,
+      amount: new Web3Number(
+        "999999999999999999999999999",
+        this.config.supplyToken.decimals
+      ),
+      usdValue: 999999999999999999999999999,
+      remarks: "Max deposit (infinity)",
+      apy: await this.getAPY({ asset: this.config.supplyToken, isDebt: false }),
+      protocol: this.protocol,
+    };
+  }
+
+  async maxWithdraw(): Promise<PositionInfo> {
+    return {
+      tokenInfo: this.config.borrowToken,
+      amount: new Web3Number(
+        "999999999999999999999999999",
+        this.config.borrowToken.decimals
+      ),
+      usdValue: 999999999999999999999999999,
+      remarks: "Max withdraw (infinity)",
+      apy: await this.getAPY({ asset: this.config.borrowToken, isDebt: false }),
+      protocol: this.protocol,
+    };
+  }
+
+  protected _getDepositLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const supplyToken = this.config.supplyToken; //wbtc
+    const borrowToken = this.config.borrowToken; //usdc
+    const { addr: vesuSingleton } = getVesuSingletonAddress(this.config.poolId);
+    return [
+      {
+        target: supplyToken.address,
+        method: "approve",
+        packedArguments: [
+          vesuSingleton.toBigInt(), // spender
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_supply_${supplyToken.symbol}`,
+      },
+      {
+        target: vesuSingleton,
+        method: "modify_position",
+        packedArguments: [
+          supplyToken.address.toBigInt(),
+          borrowToken.address.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: VESU_V2_MODIFY_POSITION_SANITIZER,
+        id: `modify_position_supply_${supplyToken.symbol}`,
+      },
+    ];
+  }
+
+  protected _getPayDebtLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const supplyToken = this.config.supplyToken; //wbtc
+    const borrowToken = this.config.borrowToken; //usdc
+    const { addr: vesuSingleton } = getVesuSingletonAddress(this.config.poolId);
+    return [
+      {
+        target: borrowToken.address,
+        method: "approve",
+        packedArguments: [
+          vesuSingleton.toBigInt(), // spender
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_borrow_${borrowToken.symbol}`,
+      },
+      {
+        target: vesuSingleton,
+        method: "modify_position",
+        packedArguments: [
+          supplyToken.address.toBigInt(),
+          borrowToken.address.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: VESU_V2_MODIFY_POSITION_SANITIZER,
+        id: `modify_position_borrow_${borrowToken.symbol}`,
+      },
+    ];
+  }
+
+  protected _getBorrowLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const supplyToken = this.config.supplyToken; //wbtc
+    const borrowToken = this.config.borrowToken; //usdc
+    const { addr: vesuSingleton } = getVesuSingletonAddress(this.config.poolId);
+    return [
+      {
+        target: supplyToken.address,
+        method: "approve",
+        packedArguments: [
+          vesuSingleton.toBigInt(), // spender
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approval_supply_${supplyToken.symbol}`,
+      },
+      {
+        target: vesuSingleton,
+        method: "modify_position",
+        packedArguments: [
+          supplyToken.address.toBigInt(),
+          borrowToken.address.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: VESU_V2_MODIFY_POSITION_SANITIZER,
+        id: `modification_posn_sup_${supplyToken.symbol}`,
+      },
+    ];
+  }
+
+  protected _getMultiplyLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const collateral = this.config.supplyToken;
+    const debt = this.config.borrowToken;
+    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}_supplyLend`,
+      },
+      // 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}_supplyLend`,
+      },
+      // Vesu multiply call
+      {
+        target: vesuMultiply,
+        method: "modify_lever",
+        packedArguments: [
+          this.config.poolId.toBigInt(),
+          collateral.address.toBigInt(),
+          debt.address.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: SIMPLE_SANITIZER_V2,
+        // vm = vesu multiply
+        id: `vm_${this.config.poolId.shortString()}_${collateral.symbol}_supplyLend`,
+      },
+      // 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}_supplyLend`,
+      },
+    ];
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    // Withdraw supply token
+    const borrowToken = this.config.borrowToken;
+    const supplyToken = this.config.supplyToken;
+    const { addr: vesuSingleton } = getVesuSingletonAddress(this.config.poolId);
+    return [
+      {
+        target: supplyToken.address,
+        method: "approve",
+        packedArguments: [
+          vesuSingleton.toBigInt(), // spender
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_supply_USDC`,
+      },
+      {
+        target: vesuSingleton,
+        method: "modify_position",
+        packedArguments: [
+          this.config.poolId.toBigInt(),
+          supplyToken.address.toBigInt(),
+          borrowToken.address.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `modify_position_supply_USDC`,
+      },
+    ];
+  }
+
+  async getHealthFactor(): Promise<number> {
+    const healthFactor = await this.vesuAdapter.getHealthFactor();
+    return healthFactor;
+  }
+
+  getPayDebtLeaf(): AdapterLeafType<DepositParams> {
+    const leafConfigs = this._getPayDebtLeaf();
+    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.getPayDebtCall.bind(
+        this
+      ) as unknown as GenerateCallFn<DepositParams>,
+    };
+  }
+
+  getMultiplyLeaf(): AdapterLeafType<DepositParams> {
+    const leafConfigs = this._getMultiplyLeaf();
+    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.getMultiplyCall.bind(
+        this
+      ) as unknown as GenerateCallFn<DepositParams>,
+    };
+  }
+
+  getBorrowLeaf(): AdapterLeafType<DepositParams> {
+    const leafConfigs = this._getBorrowLeaf();
+    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.getBorrowCall.bind(this) as unknown as GenerateCallFn<DepositParams>,
+    };
+  }
+
+  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+    return [
+    ];
+  }
+
+
+
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+    return [
+    ];
+  }
+
+  /**
+   * Pay the debt amount against the collateral amount
+   * @param params { supplyAmount: Web3Number; debtAmount: Web3Number; }
+   * @returns { ManageCall[] }
+   */
+  async getPayDebtCall(params: {
+    supplyAmount: Web3Number;
+    debtAmount: Web3Number;
+  }): Promise<ManageCall[]> {
+    const borrowToken = this.config.borrowToken;
+    const { addr: vesuSingleton } = getVesuSingletonAddress(this.config.poolId);
+    const uint256MarginAmount = uint256.bnToUint256(params.debtAmount.toWei());
+    console.log(
+      "uint256MarginAmount",
+      uint256MarginAmount,
+      params.debtAmount.toWei()
+    );
+    return [
+      {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: borrowToken.address,
+          selector: hash.getSelectorFromName("approve"),
+          calldata: [
+            vesuSingleton.toBigInt(), // spender,
+            toBigInt(uint256MarginAmount.low.toString()), // amount low
+            toBigInt(uint256MarginAmount.high.toString()), // amount high
+          ],
+        },
+      },
+      {
+        sanitizer: VESU_V2_MODIFY_POSITION_SANITIZER,
+        call: {
+          contractAddress: vesuSingleton,
+          selector: hash.getSelectorFromName("modify_position"),
+          /**
+           * In case of debt payment, just call this, the calldata is dynamic for both operations
+           */
+          calldata: (await this.getDepositCalldata(
+            params.supplyAmount,
+            params.debtAmount,
+
+          )) as bigint[],
+        },
+      },
+    ];
+  }
+
+  /**
+   * Increase the debt amount against the collateral amount
+   * @param params { supplyAmount: Web3Number; debtAmount: Web3Number; }
+   * @returns { ManageCall[] }
+   */
+  async getBorrowCall(params: {
+    supplyAmount: Web3Number;
+    debtAmount: Web3Number;
+  }): Promise<ManageCall[]> {
+    const supplyToken = this.config.supplyToken;
+    const { addr: vesuSingleton } = getVesuSingletonAddress(this.config.poolId);
+    const uint256MarginAmount = uint256.bnToUint256(params.supplyAmount.toWei());
+    console.log(
+      "Supply token uint256MarginAmount",
+      uint256MarginAmount,
+      params.supplyAmount.toWei()
+    );
+    const uint256DebtAmount = uint256.bnToUint256(params.debtAmount.toWei());
+    console.log(
+      "Debt token uint256MarginAmount",
+      uint256DebtAmount,
+      params.debtAmount.toWei()
+    );
+    return [
+      {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: supplyToken.address,
+          selector: hash.getSelectorFromName("approve"),
+          calldata: [
+            vesuSingleton.toBigInt(), // spender,
+            toBigInt(uint256MarginAmount.low.toString()), // amount low
+            toBigInt(uint256MarginAmount.high.toString()), // amount high
+          ],
+        },
+      },
+      {
+        sanitizer: VESU_V2_MODIFY_POSITION_SANITIZER,
+        call: {
+          contractAddress: vesuSingleton,
+          selector: hash.getSelectorFromName("modify_position"),
+          /**
+           * In case of debt payment, just call this, the calldata is dynamic for both operations
+           */
+          calldata: (await this.getDepositCalldata(
+            params.debtAmount,
+            params.supplyAmount,
+          )) as bigint[],
+        },
+      },
+    ];
+  }
+
+  private async getMultiplyCall({
+    amount,
+    debtAmount,
+    isWithdraw,
+    closePosition
+  }: {
+    amount: Web3Number;
+    debtAmount: Web3Number;
+    isWithdraw: boolean;
+    closePosition: boolean;
+  }): Promise<ManageCall[]> {
+    const collateralToken = this.config.supplyToken;
+    const { addr: vesuSingleton, isV2 } = getVesuSingletonAddress(
+      this.config.poolId
+    );
+    const vesuMultiply = isV2
+      ? this.vesuAdapter.VESU_MULTIPLY
+      : this.vesuAdapter.VESU_MULTIPLY_V1;
+
+    logger.info(`amount: ${amount} isWithdraw: ${isWithdraw}`);
+    const uint256MarginAmount = uint256.bnToUint256(amount.abs().toWei());
+    logger.info(`uint256MarginAmount: ${uint256MarginAmount} amount: ${amount.abs().toWei()}`);
+    return [
+      {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: collateralToken.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
+            ],
+        },
+      },
+      {
+        sanitizer: SIMPLE_SANITIZER_V2,
+        call: {
+          contractAddress: vesuMultiply,
+          selector: hash.getSelectorFromName("modify_lever"),
+          calldata: !isWithdraw ? await this.getMultiplyCallCalldata(
+            amount,
+            debtAmount,
+          ) : closePosition ? await this.getClosePositionCalldata(amount, debtAmount) : await this.getWithdrawalMultiplyCalldata(amount, debtAmount),
+        },
+      },
+      {
+        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: Web3Number,
+    debtAmount: Web3Number,
+  ): Promise<bigint[]> {
+    const collateralToken = this.config.supplyToken;
+    const debtToken = this.config.borrowToken;
+    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.borrowToken.decimals
+    );
+    const collateralPrice = (
+      await this.config.pricer.getPrice(collateralToken.symbol)
+    ).price;
+    const debtPrice = (await this.config.pricer.getPrice(debtToken.symbol))
+      .price;
+    const ekuboQuoter = new EkuboQuoter(
+      this.config.networkConfig,
+      this.config.pricer
+    );
+    const debtAmountInCollateralUnits = new Web3Number(
+      debtAmount
+        .multipliedBy(debtPrice)
+        .dividedBy(collateralPrice)
+        .multipliedBy(10 ** collateralToken.decimals)
+        .toFixed(0),
+      collateralToken.decimals
+    );
+    logger.info(`debtAmount: ${debtAmount}`);
+    logger.info(`debtPrice: ${debtPrice}`);
+    logger.info(`collateralPrice: ${collateralPrice}`);
+    logger.info(`debtAmountInCollateralUnits: ${debtAmountInCollateralUnits}`);
+    // 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, debtToken.decimals);
+    }
+    logger.verbose(
+      `${VesuMultiplyAdapter.name}::getVesuMultiplyCall debtAmount: ${debtAmount}`
+    );
+    if (!debtAmount.isZero()) {
+      // Get swap quote for leverage operation
+      // Determine swap direction based on operation type
+
+      try {
+        console.log("debtAmountInCollateralUnits", debtAmountInCollateralUnits);
+        console.log("debtToken.address.address", debtToken.address.address);
+        console.log("collateralToken.address.address", collateralToken.address.address);
+        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(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, debtToken.decimals);
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+          //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}`
+        );
+      }
+    }
+
+    logger.info(`leverSwapLimitAmount: ${leverSwapLimitAmount} debtAmount: ${debtAmount} isIncrease: ${isIncrease}`);
+    const multiplyParams = await this.getLeverParams(
+      isIncrease,
+      params,
+      leverSwap,
+      leverSwapLimitAmount
+    );
+
+    const call = multiplyContract.populate("modify_lever", {
+      modify_lever_params: this.formatMultiplyParams(
+        isIncrease,
+        multiplyParams
+      ),
+    });
+    const calldata = call.calldata as bigint[];
+    if (calldata) {
+      console.log("calldata", calldata);
+    }
+    return calldata;
+  }
+
+  private async getWithdrawalMultiplyCalldata(
+    params: Web3Number,
+    debtAmount: Web3Number,
+  ): 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.borrowToken.decimals);
+    const collateralToken = this.config.supplyToken;
+    const debtToken = this.config.borrowToken;
+    const debtPrice = await this.config.pricer.getPrice(debtToken.symbol);
+    // the debt amount is negative as we are reducing debt to withdraw
+    //console.log("debtAmountToRepay", debtAmountToRepay);
+    const ekuboQuoter = new EkuboQuoter(
+      this.config.networkConfig,
+      this.config.pricer
+    );
+    const debtInDebtUnits = debtAmount
+      .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
+    // const debtInCollateralUnits = new Web3Number(existingDebtInfo.amount.dividedBy(collateralPrice.price).multipliedBy(debtPrice.price).toFixed(WBTC_TOKEN_DECIMALS), collateralToken.decimals);
+    // console.log("debtInCollateralUnits", debtInCollateralUnits, existingDebtInfo.amount, collateralPrice.price, debtPrice.price, WBTC_TOKEN_DECIMALS);
+    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 = debtAmount
+      .abs()
+      .multipliedBy(1 + MAX_SLIPPAGE);
+
+    // leverSwapLimitAmount = debtInCollateralUnits; this is used when closing position
+    console.log("leverSwapLimitAmount", leverSwapLimitAmount);
+    //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),
+    });
+    console.log("call", call.calldata);
+    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: 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()
+            ),
+          },
+        }),
+      };
+    }
+
+    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,
+        },
+      }),
+    };
+  }
+
+  private async getLeverParams(
+    isIncrease: boolean,
+    params: Web3Number,
+    leverSwap: Swap[],
+    leverSwapLimitAmount: Web3Number,
+    closePosition?: boolean
+  ): Promise<IncreaseLeverParams | DecreaseLeverParams> {
+    logger.info(`isIncrease: ${isIncrease} params: ${JSON.stringify(params)} leverSwap: ${JSON.stringify(leverSwap)} leverSwapLimitAmount: ${leverSwapLimitAmount} closePosition: ${closePosition}`);
+    const multiplyParams: IncreaseLeverParams | DecreaseLeverParams = isIncrease
+      ? {
+        user: this.config.vaultAllocator,
+        pool_id: this.config.poolId,
+        collateral_asset: this.config.supplyToken.address,
+        debt_asset: this.config.borrowToken.address,
+        recipient: this.config.vaultAllocator,
+        add_margin: params, // multiplied by collateral decimals in format
+        margin_swap: [],
+        margin_swap_limit_amount: Web3Number.fromWei(
+          0,
+          this.config.supplyToken.decimals
+        ),
+        lever_swap: leverSwap,
+        lever_swap_limit_amount: leverSwapLimitAmount,
+      }
+      : {
+        user: this.config.vaultAllocator,
+        pool_id: this.config.poolId,
+        collateral_asset: this.config.supplyToken.address,
+        debt_asset: this.config.borrowToken.address,
+        recipient: this.config.vaultAllocator,
+        sub_margin: params,
+        lever_swap: leverSwap,
+        lever_swap_limit_amount: leverSwapLimitAmount,
+        lever_swap_weights: [],
+        withdraw_swap: [],
+        withdraw_swap_limit_amount: Web3Number.fromWei(
+          0,
+          this.config.supplyToken.decimals
+        ),
+        withdraw_swap_weights: [],
+        close_position: closePosition ?? false,
+      };
+    return multiplyParams;
+  }
+
+  //params amount must be in usdc
+  /**
+   * The amount for debt payment or taken is already calculated and sent here, in
+   * In case of debt payment, amount is the debtToBe Repaid
+   * In case of debt taken, amount is the added collateral
+   * @returns
+   */
+  private async getDepositCalldata(
+    debtAmount: Web3Number,
+    supplyAmount: Web3Number,
+  ): Promise<bigint[]> {
+    try {
+      const supplyToken = this.config.supplyToken;
+      const borrowToken = this.config.borrowToken;
+      let supplyAmountInI257: { mag: Uint256; sign: 0 | 1 };
+      let debtAmountInI257: { mag: Uint256; sign: 0 | 1 };
+      const { addr: vesuSingleton } = getVesuSingletonAddress(
+        this.config.poolId
+      );
+      const multiplyContract = new Contract({
+        abi: VesuPoolV2Abi,
+        address: vesuSingleton.address,
+        providerOrAccount: this.config.networkConfig.provider,
+      });
+
+      /**
+       * The amount that is borrowed is slightly more than 60%, in order to trasnfer proper funds to extended and vesu
+       */
+      supplyAmountInI257 = supplyAmount.toI257();
+      debtAmountInI257 = debtAmount.toI257();
+      logger.info(`debtAmountInI257: ${debtAmountInI257}`);
+
+
+      const depositParams = multiplyContract.populate("modify_position", {
+        params: {
+          collateral_asset: supplyToken.address.toBigInt(),
+          debt_asset: borrowToken.address.toBigInt(),
+          user: this.config.vaultAllocator.toBigInt(),
+          collateral: {
+            denomination: new CairoCustomEnum({ Assets: {} }),
+            value: {
+              abs: supplyAmountInI257.mag,
+              is_negative: supplyAmountInI257.sign === 1,
+            },
+          },
+          debt: {
+            denomination: new CairoCustomEnum({ Assets: {} }),
+            value: {
+              abs: debtAmountInI257.mag,
+              is_negative: debtAmountInI257.sign === 1,
+            },
+          },
+        },
+      });
+      console.log("depositParams.calldata", depositParams.calldata);
+      return depositParams.calldata as bigint[];
+    } catch (err) {
+      console.log("error getting deposit calldata", err);
+      return [];
+    }
+  }
+
+  private async getClosePositionCalldata(
+    debtAmount: Web3Number,
+    supplyAmount: Web3Number,
+  ): Promise<bigint[]> {
+    try {
+      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.borrowToken.decimals);
+      const collateralToken = this.config.supplyToken;
+      const debtToken = this.config.borrowToken;
+      const debtPrice = await this.config.pricer.getPrice(debtToken.symbol);
+      const collateralPrice = await this.config.pricer.getPrice(collateralToken.symbol);
+      // the debt amount is negative as we are reducing debt to withdraw
+      //console.log("debtAmountToRepay", debtAmountToRepay);
+      const ekuboQuoter = new EkuboQuoter(
+        this.config.networkConfig,
+        this.config.pricer
+      );
+      const debtInCollateralUnits = new Web3Number(debtAmount.dividedBy(collateralPrice.price).multipliedBy(debtPrice.price).toFixed(WBTC_TOKEN_DECIMALS), collateralToken.decimals);
+      console.log("debtInCollateralUnits", debtInCollateralUnits, collateralPrice.price, debtPrice.price, WBTC_TOKEN_DECIMALS);
+      const swapQuote = await ekuboQuoter.getQuote(
+        collateralToken.address.address,
+        debtToken.address.address,
+        debtInCollateralUnits.multipliedBy(10 ** 8)
+      );
+      console.log("swapQuote", swapQuote);
+      const MAX_SLIPPAGE = 0.002; // 0.2% slippag
+
+      // if (swapQuote.price_impact < 0.0025) {
+      leverSwap = ekuboQuoter.getVesuMultiplyQuote(
+        swapQuote,
+        debtToken,
+        collateralToken
+      );
+      leverSwapLimitAmount = debtInCollateralUnits.multipliedBy(1 + MAX_SLIPPAGE); //this is used when closing position
+      console.log("leverSwapLimitAmount", leverSwapLimitAmount);
+      //leverSwapLimitAmount = await ekuboQuoter.getSwapLimitAmount(debtToken, collateralToken, debtInCollateralUnits, MAX_SLIPPAGE);
+      const multiplyParams = await this.getLeverParams(
+        false,
+        supplyAmount,
+        leverSwap,
+        leverSwapLimitAmount,
+        true
+      );
+      const call = multiplyContract.populate("modify_lever", {
+        modify_lever_params: this.formatMultiplyParams(false, multiplyParams),
+      });
+      console.log("call", call.calldata);
+      return call.calldata as bigint[];
+    } catch (err) {
+      console.log("error getting close position calldata", err);
+      return [];
+    }
+  }
+
+  getProofsForDebtPayment<T>(tree: StandardMerkleTree): {
+    proofs: string[][];
+    callConstructor:
+    GenerateCallFn<DepositParamsForLendingBorrowing>
+  } {
+    let proofGroups: string[][] = [];
+
+    const ids = this.getPayDebtLeaf().leaves.map((l) => l.readableId);
+    // console.log(`${this.name}::getProofs ids: ${ids}`);
+    for (const [i, v] of tree.entries()) {
+      //   console.log(`${this.name}::getProofs v: ${v.readableId}`);
+      if (ids.includes(v.readableId)) {
+        //console.log(`${this.name}::getProofs found id: ${v.readableId}`);
+        proofGroups.push(tree.getProof(i));
+      }
+    }
+    if (proofGroups.length != ids.length) {
+      throw new Error(`Not all proofs found for IDs: ${ids.join(", ")}`);
+    }
+
+    // find leaf adapter
+    return {
+      proofs: proofGroups,
+      callConstructor: this.getPayDebtCall.bind(this),
+    };
+  }
+
+  getProofsForBorrowing<T>(tree: StandardMerkleTree): {
+    proofs: string[][];
+    callConstructor:
+    GenerateCallFn<DepositParamsForLendingBorrowing>;
+  } {
+    let proofGroups: string[][] = [];
+
+    const ids = this.getBorrowLeaf().leaves.map((l) => l.readableId);
+    // console.log(`${this.name}::getProofs ids: ${ids}`);
+    for (const [i, v] of tree.entries()) {
+      //   console.log(`${this.name}::getProofs v: ${v.readableId}`);
+      if (ids.includes(v.readableId)) {
+        console.log(`${this.name}::getProofs found id: ${v.readableId}`);
+        proofGroups.push(tree.getProof(i));
+      }
+    }
+    if (proofGroups.length != ids.length) {
+      throw new Error(`Not all proofs found for IDs: ${ids.join(", ")}`);
+    }
+
+    // find leaf adapter
+    return {
+      proofs: proofGroups,
+      callConstructor: this.getBorrowCall.bind(this),
+    };
+  }
+
+  getProofsForMultiply(tree: StandardMerkleTree): {
+    proofs: string[][];
+    callConstructor:
+    GenerateCallFn<({
+      amount: Web3Number;
+      debtAmount: Web3Number;
+      isWithdraw: boolean;
+      closePosition: boolean;
+    })>;
+  } {
+    let proofGroups: string[][] = [];
+
+    const ids = this.getMultiplyLeaf().leaves.map((l) => l.readableId);
+    logger.verbose(`${this.name}::getProofsForMultiply searching for IDs: ${ids.join(", ")}`);
+    const treeIds: string[] = [];
+    for (const [i, v] of tree.entries()) {
+      //   console.log(`${this.name}::getProofs v: ${v.readableId}`);
+      if (ids.includes(v.readableId)) {
+        logger.verbose(`${this.name}::getProofsForMultiply found id: ${v.readableId}`);
+        proofGroups.push(tree.getProof(i));
+      }
+    }
+    if (proofGroups.length != ids.length) {
+      throw new Error(`Not all proofs found for IDs: ${ids.join(", ")}`);
+    }
+
+    // find leaf adapter
+    return {
+      proofs: proofGroups,
+      callConstructor: this.getMultiplyCall.bind(this),
+    };
+  }
+
+}