@strkfarm/sdk 1.1.39 → 1.1.40

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(),
+          ]
+        }
+      }
+    ];
+  }
+}