@strkfarm/sdk 2.0.0-dev.27 → 2.0.0-dev.28

package/src/strategies/universal-adapters/vesu-position-common.ts

@@ -0,0 +1,251 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig, IProtocol, TokenInfo } from "@/interfaces";
+import { TokenMarketData } from "@/modules";
+import { logger } from "@/utils";
+import { HealthFactorMath } from "@/utils/health-factor-math";
+import { num } from "starknet";
+import {
+  APYType,
+  PositionAPY,
+  PositionAmount,
+  PositionInfo,
+  SupportedPosition,
+} from "./baseAdapter";
+import { VesuAdapter } from "./vesu-adapter";
+
+export type VesuPositionCommonContext = {
+  adapterName: string;
+  protocol: IProtocol;
+  poolId: ContractAddr;
+  collateral: TokenInfo;
+  debt: TokenInfo;
+  networkConfig: IConfig;
+  pricer: {
+    getPrice: (symbol: string) => Promise<{ price: number }>;
+  };
+  vesuAdapter: VesuAdapter;
+  tokenMarketData: TokenMarketData;
+  targetHealthFactor: number;
+  getCache: <T>(key: string) => T | null | undefined;
+  setCache: <T>(key: string, value: T, ttlMs: number) => void;
+  getUSDValue: (asset: TokenInfo, amount: Web3Number) => Promise<number>;
+};
+
+export async function getVesuCommonAPY(
+  ctx: VesuPositionCommonContext,
+  supportedPosition: SupportedPosition,
+): Promise<PositionAPY> {
+  const cacheKey = `apy_${ctx.poolId.address}_${supportedPosition.asset.symbol}`;
+  const cacheData = ctx.getCache<PositionAPY>(cacheKey);
+  if (cacheData) {
+    return cacheData;
+  }
+
+  try {
+    const allVesuPools = await VesuAdapter.getVesuPools();
+    const asset = supportedPosition.asset;
+    const pool = allVesuPools.pools.find((p) =>
+      ctx.poolId.eqString(num.getHexString(p.id)),
+    );
+    if (!pool) {
+      logger.warn(`${ctx.adapterName}: Pool not found for token ${asset.symbol}`);
+      return { apy: 0, type: APYType.BASE };
+    }
+
+    const assetStats = pool.assets.find(
+      (a: any) => a.symbol.toLowerCase() === asset.symbol.toLowerCase(),
+    )?.stats;
+    if (!assetStats) {
+      logger.warn(`${ctx.adapterName}: Asset stats not found for token ${asset.symbol}`);
+      return { apy: 0, type: APYType.BASE };
+    }
+
+    let apy = 0;
+    if (supportedPosition.isDebt) {
+      apy = Number(assetStats.borrowApr?.value || 0) / 1e18;
+    } else {
+      const isAssetBTC = asset.symbol.toLowerCase().includes("btc");
+      const baseAPY =
+        Number(
+          isAssetBTC
+            ? assetStats.btcFiSupplyApr?.value + assetStats.supplyApy?.value
+            : assetStats.supplyApy?.value || 0,
+        ) / 1e18;
+      const rewardAPY = Number(assetStats.defiSpringSupplyApr?.value || "0") / 1e18;
+      apy = baseAPY + rewardAPY;
+      if (ctx.tokenMarketData.isAPYSupported(asset)) {
+        apy += await ctx.tokenMarketData.getAPY(asset);
+      }
+    }
+
+    const result = { apy, type: APYType.BASE };
+    ctx.setCache(cacheKey, result, 300000);
+    return result;
+  } catch (error) {
+    logger.error(`${ctx.adapterName}: Error getting APY for ${supportedPosition.asset.symbol}:`, error);
+    throw error;
+  }
+}
+
+export async function getVesuCommonPosition(
+  ctx: VesuPositionCommonContext,
+  supportedPosition: SupportedPosition,
+): Promise<PositionAmount> {
+  const cacheKey = `position_${ctx.poolId.address}_${supportedPosition.asset.symbol}`;
+  const cacheData = ctx.getCache<PositionAmount>(cacheKey);
+  if (cacheData) {
+    return cacheData;
+  }
+
+  try {
+    ctx.vesuAdapter.networkConfig = ctx.networkConfig;
+    ctx.vesuAdapter.pricer = ctx.pricer as any;
+    const positions = await ctx.vesuAdapter.getPositions(ctx.networkConfig);
+    let position = positions.find((p) => p.token.address.eq(supportedPosition.asset.address));
+    if (!position) {
+      logger.warn(`${ctx.adapterName}: Position not found for token ${supportedPosition.asset.symbol}`);
+      return {
+        amount: new Web3Number("0", supportedPosition.asset.decimals),
+        remarks: "Position not found",
+      };
+    }
+    if (supportedPosition.isDebt) {
+      position.amount = position.amount.multipliedBy(-1);
+      position.usdValue = position.usdValue * -1;
+    }
+    const result = { amount: position.amount, remarks: supportedPosition.isDebt ? "Vesu debt" : "Vesu collateral" };
+    ctx.setCache(cacheKey, result, 60000);
+    return result;
+  } catch (error) {
+    logger.error(`${ctx.adapterName}: Error getting position for ${supportedPosition.asset.symbol}:`, error);
+    throw error;
+  }
+}
+
+export async function getVesuCommonMaxBorrowableAPY(
+  ctx: VesuPositionCommonContext,
+): Promise<number> {
+  const collateralAPY = await getVesuCommonAPY(ctx, {
+    asset: ctx.collateral,
+    isDebt: false,
+  });
+  return collateralAPY.apy * 0.8;
+}
+
+export async function getVesuCommonMaxDeposit(
+  ctx: VesuPositionCommonContext,
+  amount?: Web3Number,
+): Promise<PositionInfo> {
+  const collateral = ctx.collateral;
+  const debt = ctx.debt;
+  try {
+    ctx.vesuAdapter.networkConfig = ctx.networkConfig;
+    ctx.vesuAdapter.pricer = ctx.pricer as any;
+
+    const positions = await ctx.vesuAdapter.getPositions(ctx.networkConfig);
+    const collateralPosition = positions.find((p) => p.token.address.eq(collateral.address));
+    const debtPosition = positions.find((p) => p.token.address.eq(debt.address));
+    if (!collateralPosition || !debtPosition) {
+      throw new Error("Could not find current positions");
+    }
+
+    const maxBorrowableAPY = await getVesuCommonMaxBorrowableAPY(ctx);
+    const maxBorrowableResult = await ctx.vesuAdapter.getMaxBorrowableByInterestRate(
+      ctx.networkConfig,
+      debt,
+      maxBorrowableAPY,
+    );
+    const maxBorrowable = maxBorrowableResult.maxDebtToHave;
+    const debtCap = await ctx.vesuAdapter.getDebtCap(ctx.networkConfig);
+    const actualMaxBorrowable = maxBorrowable.minimum(debtCap);
+    const maxLTV = await ctx.vesuAdapter.getLTVConfig(ctx.networkConfig);
+
+    const collateralPrice = await ctx.pricer.getPrice(collateral.symbol);
+    if (collateralPrice.price === 0) {
+      throw new Error("Collateral price is 0");
+    }
+    const debtPrice = await ctx.pricer.getPrice(debt.symbol);
+    if (debtPrice.price === 0) {
+      throw new Error("Debt price is 0");
+    }
+
+    const maxCollateralFromDebt = HealthFactorMath.getMinCollateralRequiredOnLooping(
+      actualMaxBorrowable,
+      debtPrice.price,
+      ctx.targetHealthFactor,
+      maxLTV,
+      collateralPrice.price,
+      collateral,
+    );
+    const maxDepositAmount = amount ? amount.minimum(maxCollateralFromDebt) : maxCollateralFromDebt;
+    const usdValue = await ctx.getUSDValue(collateral, maxDepositAmount);
+    const apys = await Promise.all([
+      getVesuCommonAPY(ctx, { asset: collateral, isDebt: false }),
+      getVesuCommonAPY(ctx, { asset: debt, isDebt: true }),
+    ]);
+
+    const borrowAmountUSD = actualMaxBorrowable.multipliedBy(debtPrice.price);
+    const netCollateralUSD = usdValue + borrowAmountUSD.toNumber();
+    const netAPY =
+      (apys[0].apy * netCollateralUSD + apys[1].apy * borrowAmountUSD.toNumber()) /
+      usdValue;
+
+    return {
+      tokenInfo: collateral,
+      amount: maxDepositAmount,
+      usdValue,
+      remarks: "Max deposit based on available debt capacity",
+      apy: { apy: netAPY, type: APYType.BASE },
+      protocol: ctx.protocol,
+    };
+  } catch (error) {
+    logger.error(`${ctx.adapterName}: Error calculating max deposit:`, error);
+    throw error;
+  }
+}
+
+export async function getVesuCommonMaxWithdraw(
+  ctx: VesuPositionCommonContext,
+): Promise<PositionInfo> {
+  const collateral = ctx.collateral;
+  const debt = ctx.debt;
+  try {
+    ctx.vesuAdapter.networkConfig = ctx.networkConfig;
+    ctx.vesuAdapter.pricer = ctx.pricer as any;
+    const positions = await ctx.vesuAdapter.getPositions(ctx.networkConfig);
+    const collateralPosition = positions.find((p) => p.token.address.eq(collateral.address));
+    const debtPosition = positions.find((p) => p.token.address.eq(debt.address));
+    if (!collateralPosition || !debtPosition) {
+      throw new Error("Could not find current positions");
+    }
+
+    const collateralPrice = collateralPosition.usdValue / collateralPosition.amount.toNumber();
+    const debtInCollateral = debtPosition.usdValue / collateralPrice;
+    const maxWithdrawable = collateralPosition.amount.minus(debtInCollateral);
+    const result = maxWithdrawable.greaterThan(0)
+      ? maxWithdrawable
+      : new Web3Number("0", collateral.decimals);
+    const usdValue = await ctx.getUSDValue(collateral, result);
+    const debtUSD = debtPosition.usdValue;
+    const apys = await Promise.all([
+      getVesuCommonAPY(ctx, { asset: collateral, isDebt: false }),
+      getVesuCommonAPY(ctx, { asset: debt, isDebt: true }),
+    ]);
+    const netAPY =
+      usdValue - debtUSD > 0
+        ? (apys[0].apy * usdValue + apys[1].apy * debtUSD) / (usdValue - debtUSD)
+        : 0;
+
+    return {
+      tokenInfo: collateral,
+      amount: result,
+      usdValue,
+      remarks: "Max withdraw based on health factor",
+      apy: { apy: netAPY, type: APYType.BASE },
+      protocol: ctx.protocol,
+    };
+  } catch (error) {
+    logger.error(`${ctx.adapterName}: Error calculating max withdraw:`, error);
+    throw error;
+  }
+}

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

@@ -24,6 +24,18 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawPa
     this.tokenMarketData = new TokenMarketData(this.config.pricer, this.config.networkConfig);
   }
 
+  private _depositApproveProofReadableId(): string {
+    return `appr_dep_vtkn_${this.config.vTokenContract.shortString()}`;
+  }
+
+  private _depositCallProofReadableId(): string {
+    return `deposit_vtoken_${this.config.vTokenContract.shortString()}`;
+  }
+
+  private _withdrawCallProofReadableId(): string {
+    return `withdraw_vtoken_${this.config.vTokenContract.shortString()}`;
+  }
+
   protected async getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY> {
     const CACHE_KEY = `apy_${this.config.vTokenContract.address}`;
     const cacheData = this.getCache<PositionAPY>(CACHE_KEY);
@@ -193,7 +205,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawPa
           vTokenContract.toBigInt(), // spender
         ],
         sanitizer: SIMPLE_SANITIZER,
-        id: `appr_dep_vtkn_${this.config.vTokenContract.shortString()}`
+        id: this._depositApproveProofReadableId()
       },
       // Deposit step
       {
@@ -203,7 +215,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawPa
           this.config.vaultAllocator.toBigInt(),
         ],
         sanitizer: SIMPLE_SANITIZER,
-        id: `deposit_vtoken_${this.config.vTokenContract.shortString()}`
+        id: this._depositCallProofReadableId()
       }
     ];
   }
@@ -227,7 +239,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawPa
           this.config.vaultAllocator.toBigInt(),
         ],
         sanitizer: SIMPLE_SANITIZER,
-        id: `withdraw_vtoken_${this.config.vTokenContract.shortString()}`
+        id: this._withdrawCallProofReadableId()
       }
     ];
   }
@@ -272,6 +284,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawPa
     return [
       // Approval call
       {
+        proofReadableId: this._depositApproveProofReadableId(),
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: baseToken.address,
@@ -285,6 +298,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawPa
       },
       // Deposit call
       {
+        proofReadableId: this._depositCallProofReadableId(),
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: vTokenContract,
@@ -308,6 +322,7 @@ export class VesuSupplyOnlyAdapter extends BaseAdapter<DepositParams, WithdrawPa
     return [
       // Withdraw call
       {
+        proofReadableId: this._withdrawCallProofReadableId(),
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: vTokenContract,