@strkfarm/sdk 1.1.70 → 2.0.0-dev.1

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

@@ -1,30 +1,27 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { IConfig, TokenInfo } from "@/interfaces";
+import { IConfig, Protocols, TokenInfo } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
-import { BaseAdapter, BaseAdapterConfig, SupportedPosition, PositionInfo, PositionAPY, APYType, ManageCall, AdapterLeafType, GenerateCallFn } from "./baseAdapter";
+import { BaseAdapter, BaseAdapterConfig, SupportedPosition, PositionInfo, PositionAPY, APYType, ManageCall, AdapterLeafType, GenerateCallFn, DepositParams, WithdrawParams, PositionAmount } from "./baseAdapter";
 import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
 import { hash, uint256, Contract } from "starknet";
 import { VesuAdapter } from "./vesu-adapter";
 import { logger } from "@/utils";
+import ERC4626Abi from "@/data/erc4626.abi.json";
+import { TokenMarketData } from "@/modules";
 
 export interface VesuSupplyOnlyAdapterConfig extends BaseAdapterConfig {
   vTokenContract: ContractAddr;
 }
 
-export interface DepositParams {
-  amount: Web3Number;
-}
-
-export interface WithdrawParams {
-  amount: Web3Number;
-}
 
-export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
+export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
   readonly config: VesuSupplyOnlyAdapterConfig;
+  readonly tokenMarketData: TokenMarketData;
 
   constructor(config: VesuSupplyOnlyAdapterConfig) {
-    super(config);
+    super(config, VesuSupplyOnlyAdapter.name, Protocols.VESU);
     this.config = config;
+    this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
   }
 
   protected async getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY> {
@@ -71,14 +68,14 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
       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 isSupported = this.tokenMarketData.isAPYSupported(baseToken);
+      const lstAPY = isSupported ? await this.tokenMarketData.getAPY(baseToken) : 0;
 
-      const totalAPY = supplyApy + lstAPY;
+      const rewardAPY = Number(assetStats.defiSpringSupplyApr?.value || "0") / 1e18;
+
+      // only account lstAPY if rewardAPY is positive
+      // bcz, without rewards, no point in simply depositing LST in vesu
+      const totalAPY = rewardAPY > 0 ? rewardAPY + supplyApy + lstAPY : supplyApy;
       
       const result = {
         apy: totalAPY,
@@ -89,16 +86,13 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
       return result;
     } catch (error) {
       logger.error(`VesuSupplyOnlyAdapter: Error getting APY for ${supportedPosition.asset.symbol}:`, error);
-      return {
-        apy: 0,
-        type: APYType.BASE
-      };
+      throw error;
     }
   }
 
-  protected async getPosition(supportedPosition: SupportedPosition): Promise<Web3Number> {
+  protected async getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount> {
     const CACHE_KEY = `position_${this.config.vTokenContract.address}`;
-    const cacheData = this.getCache<Web3Number>(CACHE_KEY);
+    const cacheData = this.getCache<PositionAmount>(CACHE_KEY);
     if (cacheData) {
       return cacheData;
     }
@@ -106,69 +100,78 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
     try {
       // Create contract instance for the vToken
       const vTokenContract = new Contract({
-        abi: [], // We only need basic ERC20 methods
+        abi: ERC4626Abi, // 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);
+      const shares = await vTokenContract.balance_of(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
-      );
+      const result = {
+        amount: Web3Number.fromWei(
+          assets.toString(),
+          supportedPosition.asset.decimals
+        ),
+        remarks: "Vesu Earn"
+      };
 
       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);
+      throw error;
     }
   }
 
-  protected async maxDeposit(amount?: Web3Number): Promise<PositionInfo[]> {
+  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 [{
+      return {
+        tokenInfo: baseToken,
         amount: new Web3Number('999999999999999999999999999', baseToken.decimals),
         usdValue: 999999999999999999999999999,
         remarks: "Max deposit (infinity)",
-        apy: await this.getAPY({ asset: baseToken, isDebt: false })
-      }];
+        apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+        protocol: this.protocol
+      };
     }
 
     // Return position info based on input amount
     const usdValue = await this.getUSDValue(baseToken, amount);
-    return [{
+    return {
+      tokenInfo: baseToken,
       amount,
       usdValue,
       remarks: "Deposit amount",
-      apy: await this.getAPY({ asset: baseToken, isDebt: false })
-    }];
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol
+    };
   }
 
-  protected async maxWithdraw(): Promise<PositionInfo[]> {
+  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,
+    const usdValue = await this.getUSDValue(baseToken, currentPosition.amount);
+    return {
+      tokenInfo: baseToken,
+      amount: currentPosition.amount,
       usdValue,
       remarks: "Max withdraw",
-      apy: await this.getAPY({ asset: baseToken, isDebt: false })
-    }];
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol
+    };
   }
 
   protected _getDepositLeaf(): {
@@ -190,7 +193,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
           vTokenContract.toBigInt(), // spender
         ],
         sanitizer: SIMPLE_SANITIZER,
-        id: `approve_deposit_vtoken_${this.config.vTokenContract.address}`
+        id: `appr_dep_vtkn_${this.config.vTokenContract.shortString()}`
       },
       // Deposit step
       {
@@ -200,7 +203,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
           this.config.vaultAllocator.toBigInt(),
         ],
         sanitizer: SIMPLE_SANITIZER,
-        id: `deposit_vtoken_${this.config.vTokenContract.address}`
+        id: `deposit_vtoken_${this.config.vTokenContract.shortString()}`
       }
     ];
   }
@@ -224,7 +227,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
           this.config.vaultAllocator.toBigInt(),
         ],
         sanitizer: SIMPLE_SANITIZER,
-        id: `withdraw_vtoken_${this.config.vTokenContract.address}`
+        id: `withdraw_vtoken_${this.config.vTokenContract.shortString()}`
       }
     ];
   }
@@ -241,7 +244,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
       }, sanitizer);
       return leaf;
     });
-    return { leaves, callConstructor: this.createDepositCall.bind(this) as unknown as GenerateCallFn<DepositParams> };
+    return { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<DepositParams> };
   }
 
   getWithdrawAdapter(): AdapterLeafType<WithdrawParams> {
@@ -256,10 +259,10 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
       }, sanitizer);
       return leaf;
     });
-    return { leaves, callConstructor: this.createWithdrawCall.bind(this) as unknown as GenerateCallFn<WithdrawParams> };
+    return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<WithdrawParams> };
   }
 
-  private createDepositCall(params: DepositParams): ManageCall[] {
+  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
     const baseToken = this.config.baseToken;
     const vTokenContract = this.config.vTokenContract;
     
@@ -296,7 +299,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
     ];
   }
 
-  private createWithdrawCall(params: WithdrawParams): ManageCall[] {
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
     const vTokenContract = this.config.vTokenContract;
     
     const amount = params.amount;
@@ -319,4 +322,8 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<any, any> {
       }
     ];
   }
+
+  getHealthFactor(): Promise<number> {
+    return Promise.resolve(10);
+  }
 }