@strkfarm/sdk 1.1.39 → 1.1.41

package/src/strategies/universal-adapters/baseAdapter.ts

@@ -1,6 +1,8 @@
 import { Call, hash, num, shortString } from "starknet";
 import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
-import { ContractAddr } from "@/dataTypes";
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PricerBase } from "@/modules/pricerBase";
 import { LeafData } from "@/utils";
 import { CacheClass } from "@/utils/cacheClass";
 
@@ -15,10 +17,96 @@ export interface ManageCall {
 
 export type GenerateCallFn<T> = (params: T) => ManageCall;
 export type AdapterLeafType<T> = {leaf: LeafData, callConstructor: GenerateCallFn<T>}
+// export type GenerateCallFn<T> = (params: T) => ManageCall[];
+// export type AdapterLeafType<T> = {leaves: LeafData[], callConstructor: GenerateCallFn<T>}
 export type LeafAdapterFn<T> = () => AdapterLeafType<T>;
 
-export class BaseAdapter extends CacheClass {
+export enum APYType {
+  BASE = "base",
+  REWARD = "reward",
+  LST = "lst"
+}
+
+export interface SupportedPosition {
+  asset: TokenInfo,
+  isDebt: boolean
+}
+
+export interface BaseAdapterConfig {
+  baseToken: TokenInfo,
+  supportedPositions: SupportedPosition[],
+  networkConfig: IConfig,
+  pricer: PricerBase,
+  vaultAllocator: ContractAddr
+  vaultAddress: ContractAddr
+}
+
+export type PositionAPY = { apy: number, type: APYType };
+export type PositionInfo = {
+  amount: Web3Number,
+  usdValue: number,
+  remarks?: string,
+  apy: PositionAPY
+};
+
+// export abstract class BaseAdapter<T1, T2> extends CacheClass {
+  export abstract class BaseAdapter extends CacheClass {
+
+  // readonly config: BaseAdapterConfig;
+
+  // constructor(config: BaseAdapterConfig) {
+  //   super();
+  //   this.config = config;
+  // }
+
+  constructor() {
+    super();
+  }
+
+  // /**
+  //  * Loop through all supported positions and return amount, usd value, remarks and apy for each
+  //  */
+  // async getPositions(): Promise<PositionInfo[]> {
+  //   const results: PositionInfo[] = [];
+  //   for (const supported of this.config.supportedPositions) {
+  //     const amount = await this.getPosition(supported);
+  //     const usdValue = await this.getUSDValue(supported.asset, amount);
+  //     const apy = await this.getAPY(supported);
+  //     results.push({ amount, usdValue, apy });
+  //   }
+  //   return results;
+  // }
 
+  // /**
+  //  * Implemented by child adapters to compute APY for a given supported position
+  //  */
+  // protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+
+  // /**
+  //  * Implemented by child adapters to fetch amount for a given supported position
+  //  */
+  // protected abstract getPosition(supportedPosition: SupportedPosition): Promise<Web3Number>;
+
+  // /**
+  //  * Implemented by child adapters to calculate maximum deposit positions
+  //  * @param amount Optional amount in baseToken to deposit
+  //  */
+  // protected abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo[]>;
+
+  // /**
+  //  * Implemented by child adapters to calculate maximum withdraw positions
+  //  */
+  // protected abstract maxWithdraw(): Promise<PositionInfo[]>;
+
+  // /**
+  //  * Uses pricer to convert an amount of an asset to USD value
+  //  */
+  // protected async getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number> {
+  //   const priceInfo = await this.config.pricer.getPrice(asset.symbol);
+  //   return amount.toNumber() * priceInfo.price;
+  // }
+
+  
   protected constructSimpleLeafData(params: {
     id: string,
     target: ContractAddr,
@@ -38,4 +126,98 @@ export class BaseAdapter extends CacheClass {
       ]
     };
   }
+
+  // /**
+  //  * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+  //  */
+  // protected abstract _getDepositLeaf(): {
+  //   target: ContractAddr,
+  //   method: string,
+  //   packedArguments: bigint[],
+  //   sanitizer: ContractAddr,
+  //   id: string
+  // }[];
+
+  // /**
+  //  * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
+  //  */
+  // protected abstract _getWithdrawLeaf(): {
+  //   target: ContractAddr,
+  //   method: string,
+  //   packedArguments: bigint[],
+  //   sanitizer: ContractAddr,
+  //   id: string
+  // }[];
+
+  // /**
+  //  * Returns deposit leaf adapter using configured proof id
+  //  */
+  // getDepositLeaf(): AdapterLeafType<T1> {
+  //   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<T1> };
+  // }
+
+  // /**
+  //  * Returns withdraw leaf adapter using configured proof id
+  //  */
+  // getWithdrawLeaf(): AdapterLeafType<T2> {
+  //   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 ?? SIMPLE_SANITIZER);
+  //     return leaf;
+  //   });
+  //   return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<T2> };
+  // }
+
+  // /**
+  //  * Default deposit callConstructor: expects params as calldata (bigint[])
+  //  */
+  // protected getDepositCall<T1 = bigint[]>(params: T1): ManageCall[] {
+  //   const leafConfigs = this._getDepositLeaf();
+  //   return leafConfigs.map(config => {
+  //     const { target, method, sanitizer } = config;
+  //     return {
+  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
+  //       call: {
+  //         contractAddress: target,
+  //         selector: hash.getSelectorFromName(method),
+  //         calldata: params as unknown as bigint[]
+  //       }
+  //     };
+  //   });
+  // }
+
+  // /**
+  //  * Default withdraw callConstructor: expects params as calldata (bigint[])
+  //  */
+  // protected getWithdrawCall<T2 = bigint[]>(params: T2): ManageCall[] {
+  //   const leafConfigs = this._getWithdrawLeaf();
+  //   return leafConfigs.map(config => {
+  //     const { target, method, sanitizer } = config;
+  //     return {
+  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
+  //       call: {
+  //         contractAddress: target,
+  //         selector: hash.getSelectorFromName(method),
+  //         calldata: params as unknown as bigint[]
+  //       }
+  //     };
+  //   });
+  // }
 }

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

@@ -1,5 +1,5 @@
 import { LeafData, logger  } from "@/utils"
-import { CairoCustomEnum, Contract, hash, num, RpcProvider, shortString, uint256, Uint256 } from "starknet";
+import { BlockIdentifier, CairoCustomEnum, Contract, hash, num, RpcProvider, shortString, uint256, Uint256 } from "starknet";
 import { SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, toBigInt, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER } from "./adapter-utils";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { AdapterLeafType, BaseAdapter, GenerateCallFn, LeafAdapterFn, ManageCall } from "./baseAdapter";
@@ -536,7 +536,22 @@ export class VesuAdapter extends BaseAdapter {
     }
     const output: any = await contract.call('pair_config', [this.config.collateral.address.address, this.config.debt.address.address]);
     logger.verbose(`${this.config.debt.symbol}::VesuAdapter::getDebtCap debt_cap: ${output.debt_cap.toString()}`);
-    return Web3Number.fromWei(output.debt_cap.toString(), this.config.debt.decimals);
+    
+    if (!isV2) {
+      throw new Error('getDebtCap is not supported for v1');
+    }
+    const currentDebt = await this.getCurrentDebtUtilisationAmount(config);
+    logger.verbose(`${this.config.debt.symbol}::VesuAdapter::getDebtCap currentDebt: ${currentDebt.toString()}`);
+    return Web3Number.fromWei(output.debt_cap.toString(), this.config.debt.decimals).minus(currentDebt);
+  }
+
+  async getCurrentDebtUtilisationAmount(config: IConfig) {
+    const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
+    if (!isV2) {
+      throw new Error('getCurrentDebtUtilisationAmount is not supported for v1');
+    }
+    const output: any = await contract.call('pairs', [this.config.collateral.address.address, this.config.debt.address.address]);
+    return new Web3Number((Number(output.total_nominal_debt) / 1e18).toFixed(9), this.config.debt.decimals);
   }
 
   async getMaxBorrowableByInterestRate(config: IConfig, asset: TokenInfo, maxBorrowAPY: number) {
@@ -572,19 +587,20 @@ export class VesuAdapter extends BaseAdapter {
     const assetConfig = isV2 ? _assetConfig : _assetConfig['0'];
     const timeDelta = assetConfig.last_updated;
     const lastFullUtilizationRate = assetConfig.last_full_utilization_rate;
-    const totalSupply = (new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals)).plus(Web3Number.fromWei(assetConfig.reserve, asset.decimals));
+    const currentDebt = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals);
+    const totalSupply = currentDebt.plus(Web3Number.fromWei(assetConfig.reserve, asset.decimals));
 
     const ratePerSecond = BigInt(Math.round(maxBorrowAPY / 365 / 24 / 60 / 60 * Number(SCALE)));
     const maxUtilisation = this.getMaxUtilizationGivenRatePerSecond(interestRateConfig, ratePerSecond, timeDelta, lastFullUtilizationRate);
     logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate maxUtilisation: ${Number(maxUtilisation) / 1e18}, totalSupply: ${totalSupply.toString()}`);
    
     const maxDebtToHave = totalSupply.multipliedBy(Number(maxUtilisation) / 1e18);
-    const currentDebt = new Web3Number((Number(assetConfig.total_nominal_debt) / 1e18).toFixed(9), asset.decimals);
+    logger.verbose(`${asset.symbol}::VesuAdapter::getMaxBorrowableByInterestRate currentDebt: ${currentDebt.toString()}, maxDebtToHave: ${maxDebtToHave.toString()}`);
     return maxDebtToHave.minus(currentDebt);
   }
 
-  async getLTVConfig(config: IConfig) {
-    const CACHE_KEY = 'ltv_config';
+  async getLTVConfig(config: IConfig, blockNumber: BlockIdentifier = 'latest') {
+    const CACHE_KEY = `ltv_config_${blockNumber}`;
     const cacheData = this.getCache<number>(CACHE_KEY);
     if (cacheData) {
       return cacheData as number;
@@ -592,10 +608,10 @@ export class VesuAdapter extends BaseAdapter {
     const { contract, isV2 } = await this.getVesuSingletonContract(config, this.config.poolId);
     let ltv = 0;
     if (isV2) {
-      const output: any = await contract.call('pair_config', [this.config.collateral.address.address, this.config.debt.address.address]);
+      const output: any = await contract.call('pair_config', [this.config.collateral.address.address, this.config.debt.address.address], { blockIdentifier: blockNumber });
       ltv = Number(output.max_ltv) / 1e18;
     } else {
-      const output: any = await contract.call('ltv_config', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address]);
+      const output: any = await contract.call('ltv_config', [this.config.poolId.address, this.config.collateral.address.address, this.config.debt.address.address], { blockIdentifier: blockNumber });
       ltv = Number(output.max_ltv) / 1e18;
     }
     if (ltv == 0) {
@@ -605,12 +621,12 @@ export class VesuAdapter extends BaseAdapter {
     return this.getCache<number>(CACHE_KEY) as number;
   }
 
-  async getPositions(config: IConfig): Promise<VaultPosition[]> {
+  async getPositions(config: IConfig, blockNumber: BlockIdentifier = 'latest'): Promise<VaultPosition[]> {
     if (!this.pricer) {
       throw new Error('Pricer is not initialized');
     }
     //  { '0': { collateral_shares: 0n, nominal_debt: 0n }, '1': 0n, '2': 0n }
-    const CACHE_KEY = 'positions';
+    const CACHE_KEY = `positions_${blockNumber}`;
     const cacheData = this.getCache<VaultPosition[]>(CACHE_KEY);
     if (cacheData) {
       return cacheData;
@@ -623,8 +639,9 @@ export class VesuAdapter extends BaseAdapter {
         this.config.collateral.address.address,
         this.config.debt.address.address,
         this.config.vaultAllocator.address
-      ]);
+      ], { blockIdentifier: blockNumber });
 
+      console.log(output)
     const token1Price = await this.pricer.getPrice(this.config.collateral.symbol);
     const token2Price = await this.pricer.getPrice(this.config.debt.symbol);
     logger.verbose(`VesuAdapter::getPositions token1Price: ${token1Price.price}, token2Price: ${token2Price.price}`);
@@ -646,12 +663,12 @@ export class VesuAdapter extends BaseAdapter {
     return value;
   }
 
-  async getCollateralization(config: IConfig): Promise<Omit<VaultPosition, 'amount'>[]> {
+  async getCollateralization(config: IConfig, blockNumber: BlockIdentifier = 'latest'): Promise<Omit<VaultPosition, 'amount'>[]> {
     if (!this.pricer) {
       throw new Error('Pricer is not initialized');
     }
     //  { '0': bool, '1': 0n, '2': 0n }
-    const CACHE_KEY = 'collateralization';
+    const CACHE_KEY = `collateralization_${blockNumber}`;
     const cacheData = this.getCache<Omit<VaultPosition, 'amount'>[]>(CACHE_KEY);
     if (cacheData) {
       return cacheData;
@@ -664,7 +681,7 @@ export class VesuAdapter extends BaseAdapter {
         this.config.collateral.address.address,
         this.config.debt.address.address,
         this.config.vaultAllocator.address
-      ]);
+      ], { blockIdentifier: blockNumber });
 
     // usd values
     const collateralAmount = Web3Number.fromWei(output['1'].toString(), 18);
@@ -709,9 +726,9 @@ export class VesuAdapter extends BaseAdapter {
     }
   }
 
-  async getHealthFactor() {
-    const ltv = await this.getLTVConfig(this.networkConfig!);
-    const collateralisation = await this.getCollateralization(this.networkConfig!);
+  async getHealthFactor(blockNumber: BlockIdentifier = 'latest') {
+    const ltv = await this.getLTVConfig(this.networkConfig!, blockNumber);
+    const collateralisation = await this.getCollateralization(this.networkConfig!, blockNumber);
     return collateralisation[0].usdValue * ltv / collateralisation[1].usdValue;
   }
 

package/src/strategies/universal-adapters/vesu-supply-only-adapter.ts

@@ -0,0 +1,322 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { PricerBase } from "@/modules/pricerBase";
+import { BaseAdapter, BaseAdapterConfig, SupportedPosition, PositionInfo, PositionAPY, APYType, ManageCall, AdapterLeafType, GenerateCallFn } from "./baseAdapter";
+import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import { hash, uint256, Contract } from "starknet";
+import { VesuAdapter } from "./vesu-adapter";
+import { logger } from "@/utils";
+
+export interface VesuSupplyOnlyAdapterConfig extends BaseAdapterConfig {
+  vTokenContract: ContractAddr;
+}
+
+export interface DepositParams {
+  amount: Web3Number;
+}
+
+export interface WithdrawParams {
+  amount: Web3Number;
+}
+
+export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
+  readonly config: VesuSupplyOnlyAdapterConfig;
+
+  constructor(config: VesuSupplyOnlyAdapterConfig) {
+    super(config);
+    this.config = config;
+  }
+
+  protected async getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY> {
+    const CACHE_KEY = `apy_${this.config.vTokenContract.address}`;
+    const cacheData = this.getCache<PositionAPY>(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
+    }
+
+    try {
+      // Get Vesu pools to find APY for the underlying asset
+      const allVesuPools = await VesuAdapter.getVesuPools();
+      const baseToken = this.config.baseToken;
+      
+      // Find the pool that contains our base token
+      const pool = allVesuPools.pools.find(p => {
+        return p.assets.some((asset: any) => 
+          asset.symbol.toLowerCase() === baseToken.symbol.toLowerCase()
+        );
+      });
+
+      if (!pool) {
+        logger.warn(`VesuSupplyOnlyAdapter: Pool not found for token ${baseToken.symbol}`);
+        return {
+          apy: 0,
+          type: APYType.BASE
+        };
+      }
+
+      // Find the asset stats for our token
+      const assetStats = pool.assets.find((a: any) => 
+        a.symbol.toLowerCase() === baseToken.symbol.toLowerCase()
+      )?.stats;
+
+      if (!assetStats) {
+        logger.warn(`VesuSupplyOnlyAdapter: Asset stats not found for token ${baseToken.symbol}`);
+        return {
+          apy: 0,
+          type: APYType.BASE
+        };
+      }
+
+      // Get supply APY (divide by 1e18 as it's in wei)
+      const supplyApy = Number(assetStats.supplyApy?.value || 0) / 1e18;
+      
+      // Get LST APR if applicable (for LST tokens)
+      let lstAPY = 0;
+      if (baseToken.symbol === 'STRK' || baseToken.symbol === 'ETH') {
+        // This would need to be implemented based on your LST APR service
+        // For now, using a placeholder
+        lstAPY = 0;
+      }
+
+      const totalAPY = supplyApy + lstAPY;
+      
+      const result = {
+        apy: totalAPY,
+        type: APYType.BASE
+      };
+
+      this.setCache(CACHE_KEY, result, 300000); // Cache for 5 minutes
+      return result;
+    } catch (error) {
+      logger.error(`VesuSupplyOnlyAdapter: Error getting APY for ${supportedPosition.asset.symbol}:`, error);
+      return {
+        apy: 0,
+        type: APYType.BASE
+      };
+    }
+  }
+
+  protected async getPosition(supportedPosition: SupportedPosition): Promise<Web3Number> {
+    const CACHE_KEY = `position_${this.config.vTokenContract.address}`;
+    const cacheData = this.getCache<Web3Number>(CACHE_KEY);
+    if (cacheData) {
+      return cacheData;
+    }
+
+    try {
+      // Create contract instance for the vToken
+      const vTokenContract = new Contract({
+        abi: [], // We only need basic ERC20 methods
+        address: this.config.vTokenContract.address,
+        providerOrAccount: this.config.networkConfig.provider
+      });
+
+      // Get the vault allocator's balance (shares) in the vToken contract
+      const shares = await vTokenContract.balanceOf(this.config.vaultAllocator.address);
+      
+      // Convert shares to assets using convert_to_assets
+      const assets = await vTokenContract.convert_to_assets(
+        uint256.bnToUint256(shares)
+      );
+      
+      const result = Web3Number.fromWei(
+        assets.toString(),
+        supportedPosition.asset.decimals
+      );
+
+      this.setCache(CACHE_KEY, result, 60000); // Cache for 1 minute
+      return result;
+    } catch (error) {
+      logger.error(`VesuSupplyOnlyAdapter: Error getting position for ${supportedPosition.asset.symbol}:`, error);
+      return new Web3Number('0', supportedPosition.asset.decimals);
+    }
+  }
+
+  protected async maxDeposit(amount?: Web3Number): Promise<PositionInfo[]> {
+    const baseToken = this.config.baseToken;
+    // todo for assets with some borrowing on Vesu, the yield wont 
+    // remain same as supply increases. So need to account for that. 
+
+    if (!amount) {
+      // Return infinity for max deposit when no amount specified
+      return [{
+        amount: new Web3Number('999999999999999999999999999', baseToken.decimals),
+        usdValue: 999999999999999999999999999,
+        remarks: "Max deposit (infinity)",
+        apy: await this.getAPY({ asset: baseToken, isDebt: false })
+      }];
+    }
+
+    // Return position info based on input amount
+    const usdValue = await this.getUSDValue(baseToken, amount);
+    return [{
+      amount,
+      usdValue,
+      remarks: "Deposit amount",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false })
+    }];
+  }
+
+  protected async maxWithdraw(): Promise<PositionInfo[]> {
+    const baseToken = this.config.baseToken;
+    const currentPosition = await this.getPosition({ asset: baseToken, isDebt: false });
+    
+    // Return the current position as max withdraw
+    const usdValue = await this.getUSDValue(baseToken, currentPosition);
+    return [{
+      amount: currentPosition,
+      usdValue,
+      remarks: "Max withdraw",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false })
+    }];
+  }
+
+  protected _getDepositLeaf(): {
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[],
+    sanitizer: ContractAddr,
+    id: string
+  }[] {
+    const baseToken = this.config.baseToken;
+    const vTokenContract = this.config.vTokenContract;
+
+    return [
+      // Approval step
+      {
+        target: baseToken.address,
+        method: 'approve',
+        packedArguments: [
+          vTokenContract.toBigInt(), // spender
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_deposit_vtoken_${this.config.vTokenContract.address}`
+      },
+      // Deposit step
+      {
+        target: vTokenContract,
+        method: 'deposit',
+        packedArguments: [
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `deposit_vtoken_${this.config.vTokenContract.address}`
+      }
+    ];
+  }
+
+  protected _getWithdrawLeaf(): {
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[],
+    sanitizer: ContractAddr,
+    id: string
+  }[] {
+    const vTokenContract = this.config.vTokenContract;
+
+    return [
+      // Withdraw step
+      {
+        target: vTokenContract,
+        method: 'withdraw',
+        packedArguments: [
+          this.config.vaultAllocator.toBigInt(),
+          this.config.vaultAllocator.toBigInt(),
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `withdraw_vtoken_${this.config.vTokenContract.address}`
+      }
+    ];
+  }
+
+  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.createDepositCall.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.createWithdrawCall.bind(this) as unknown as GenerateCallFn<WithdrawParams> };
+  }
+
+  private createDepositCall(params: DepositParams): ManageCall[] {
+    const baseToken = this.config.baseToken;
+    const vTokenContract = this.config.vTokenContract;
+    
+    const amount = params.amount;
+    const uint256Amount = uint256.bnToUint256(amount.toWei());
+
+    return [
+      // Approval call
+      {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: baseToken.address,
+          selector: hash.getSelectorFromName('approve'),
+          calldata: [
+            vTokenContract.toBigInt(), // spender
+            toBigInt(uint256Amount.low.toString()), // amount low
+            toBigInt(uint256Amount.high.toString()), // amount high
+          ]
+        }
+      },
+      // Deposit call
+      {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: vTokenContract,
+          selector: hash.getSelectorFromName('deposit'),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()), // amount low
+            toBigInt(uint256Amount.high.toString()), // amount high
+            this.config.vaultAllocator.toBigInt(),
+          ]
+        }
+      }
+    ];
+  }
+
+  private createWithdrawCall(params: WithdrawParams): ManageCall[] {
+    const vTokenContract = this.config.vTokenContract;
+    
+    const amount = params.amount;
+    const uint256Amount = uint256.bnToUint256(amount.toWei());
+
+    return [
+      // Withdraw call
+      {
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: vTokenContract,
+          selector: hash.getSelectorFromName('withdraw'),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()), // amount low
+            toBigInt(uint256Amount.high.toString()), // amount high
+            this.config.vaultAllocator.toBigInt(),
+            this.config.vaultAllocator.toBigInt(),
+          ]
+        }
+      }
+    ];
+  }
+}