unify get pool apy

packages/huma-shared/src/solana/utils/poolUtils.ts

@@ -1,5 +1,6 @@
 import { BN } from '@coral-xyz/anchor'
 
+import { getPoolApyV2 } from '../../utils/apy'
 import { SOLANA_BP_FACTOR } from '../const'
 
 export const getSolanaPoolApy = (
@@ -17,74 +18,20 @@ export const getSolanaPoolApy = (
   blendedApy: number
   seniorTrancheApy: number
   juniorTrancheApy: number
-} => {
-  const BP_FACTOR_NUMBER = SOLANA_BP_FACTOR.toNumber()
-  const APY = yieldInBps / BP_FACTOR_NUMBER
-
-  const totalDeployedAssets = seniorDeployedAssets.add(juniorDeployedAssets)
-  const seniorMaxAssets = liquidityCap
-    .sub(totalDeployedAssets)
-    .add(seniorDeployedAssets)
-  const currentMaxSeniorJuniorRatio = seniorMaxAssets
-    .div(juniorDeployedAssets)
-    .toNumber()
-
-  let juniorAssets = liquidityCap.div(new BN(defaultMaxSeniorJuniorRatio + 1))
-  let seniorAssets = liquidityCap.sub(juniorAssets)
-  if (currentMaxSeniorJuniorRatio < defaultMaxSeniorJuniorRatio) {
-    juniorAssets = juniorDeployedAssets
-    seniorAssets = seniorMaxAssets
-  }
-
-  const totalProfit = liquidityCap
-    .mul(new BN(Math.round(APY * BP_FACTOR_NUMBER)))
-    .div(SOLANA_BP_FACTOR)
-  const postPoolProfitRatio =
-    (1 - protocolFeeInBps / BP_FACTOR_NUMBER) *
-    (1 -
-      rewardRateInBpsForPoolOwner / BP_FACTOR_NUMBER -
-      rewardRateInBpsForEA / BP_FACTOR_NUMBER)
-  const poolPostProfit = totalProfit
-    .mul(new BN(Math.round(postPoolProfitRatio * BP_FACTOR_NUMBER)))
-    .div(SOLANA_BP_FACTOR)
-  const blendedApy =
-    poolPostProfit.mul(SOLANA_BP_FACTOR).div(liquidityCap).toNumber() /
-    BP_FACTOR_NUMBER
-
-  let seniorTrancheApy = 0
-  let juniorProfit = new BN(0)
-  if (fixedSeniorYieldInBps > 0) {
-    seniorTrancheApy = fixedSeniorYieldInBps / BP_FACTOR_NUMBER
-    juniorProfit = poolPostProfit.sub(
-      seniorAssets
-        .mul(new BN(Math.round(seniorTrancheApy * BP_FACTOR_NUMBER)))
-        .div(SOLANA_BP_FACTOR),
-    )
-  } else {
-    const riskAdjustment = tranchesRiskAdjustmentInBps / BP_FACTOR_NUMBER
-    const seniorProfit = seniorAssets
-      .mul(
-        new BN(
-          Math.round(
-            postPoolProfitRatio * (1 - riskAdjustment) * APY * BP_FACTOR_NUMBER,
-          ),
-        ),
-      )
-      .div(SOLANA_BP_FACTOR)
-    seniorTrancheApy = postPoolProfitRatio * (1 - riskAdjustment) * APY
-    juniorProfit = poolPostProfit.sub(seniorProfit)
-  }
-
-  const juniorTrancheApy =
-    juniorProfit.mul(SOLANA_BP_FACTOR).div(juniorAssets).toNumber() /
-    BP_FACTOR_NUMBER
-
-  return {
-    blendedApy,
-    seniorTrancheApy,
-    juniorTrancheApy,
-  }
-}
+} =>
+  getPoolApyV2(
+    protocolFeeInBps,
+    yieldInBps,
+    rewardRateInBpsForPoolOwner,
+    rewardRateInBpsForEA,
+    liquidityCap.toString(),
+    seniorDeployedAssets.toString(),
+    juniorDeployedAssets.toString(),
+    defaultMaxSeniorJuniorRatio,
+    fixedSeniorYieldInBps,
+    tranchesRiskAdjustmentInBps,
+    SOLANA_BP_FACTOR.toNumber(),
+  )
 
 export const getSolanaUtilizationRate = (
   seniorTrancheAssets: BN | undefined,

packages/huma-shared/src/utils/apy.ts

@@ -0,0 +1,155 @@
+import { BigNumber } from 'ethers'
+
+export interface FclConfig {
+  minLiquidity: string
+  riskYieldMultiplierInBps: number
+  flcIndex: number
+  maxLiquidity: string
+}
+
+export interface FclConfigWithApy extends FclConfig {
+  apy: number
+  firstLossCoverIndex: number
+}
+
+export interface PoolApy {
+  flcConfigsWithApy: FclConfigWithApy[]
+  blendedApy: number
+  seniorTrancheApy: number
+  juniorTrancheApy: number
+}
+
+const getFlcTotalAssetsAfterRisk = (
+  flcConfigs: {
+    minLiquidity: string
+    riskYieldMultiplierInBps: number
+  }[],
+  BP_FACTOR: number,
+): BigNumber => {
+  const flcTotalAssetsAfterRisk = flcConfigs.reduce(
+    (acc, flcConfig) =>
+      acc.add(
+        BigNumber.from(flcConfig.minLiquidity)
+          .mul(flcConfig.riskYieldMultiplierInBps)
+          .div(BP_FACTOR),
+      ),
+    BigNumber.from(0),
+  )
+  return flcTotalAssetsAfterRisk
+}
+
+export const getPoolApyV2 = (
+  protocolFeeInBps: number,
+  yieldInBps: number,
+  rewardRateInBpsForPoolOwner: number,
+  rewardRateInBpsForEA: number,
+  liquidityCap: string,
+  seniorDeployedAssets: string,
+  juniorDeployedAssets: string,
+  maxSeniorJuniorRatio: number,
+  fixedSeniorYieldInBps: number,
+  tranchesRiskAdjustmentInBps: number,
+  BP_FACTOR: number,
+  FirstLossCoverIndexes: string[] = [],
+  flcConfigs: FclConfig[] = [],
+): PoolApy => {
+  const APY = yieldInBps / BP_FACTOR
+
+  const liquidityCapBN = BigNumber.from(liquidityCap)
+  const seniorDeployedAssetsBN = BigNumber.from(seniorDeployedAssets)
+  const juniorDeployedAssetsBN = BigNumber.from(juniorDeployedAssets)
+  const totalDeployedAssetsBN = seniorDeployedAssetsBN.add(
+    juniorDeployedAssetsBN,
+  )
+  const seniorMaxAssetsBN = liquidityCapBN
+    .sub(totalDeployedAssetsBN)
+    .add(seniorDeployedAssetsBN)
+  const currentMaxSeniorJuniorRatio = seniorMaxAssetsBN
+    .div(juniorDeployedAssetsBN)
+    .toNumber()
+
+  let juniorAssetsBN = liquidityCapBN.div(maxSeniorJuniorRatio + 1)
+  let seniorAssetsBN = liquidityCapBN.sub(juniorAssetsBN)
+  if (currentMaxSeniorJuniorRatio < maxSeniorJuniorRatio) {
+    juniorAssetsBN = juniorDeployedAssetsBN
+    seniorAssetsBN = seniorMaxAssetsBN
+  }
+
+  const totalProfitBN = liquidityCapBN
+    .mul(Math.round(APY * BP_FACTOR))
+    .div(BP_FACTOR)
+  const postPoolProfitRatio =
+    (1 - protocolFeeInBps / BP_FACTOR) *
+    (1 -
+      rewardRateInBpsForPoolOwner / BP_FACTOR -
+      rewardRateInBpsForEA / BP_FACTOR)
+  const poolPostProfitBN = totalProfitBN
+    .mul(Math.round(postPoolProfitRatio * BP_FACTOR))
+    .div(BP_FACTOR)
+  const blendedApy =
+    poolPostProfitBN.mul(BP_FACTOR).div(liquidityCap).toNumber() / BP_FACTOR
+
+  let seniorTrancheApy = 0
+  let seniorPostProfitBN = BigNumber.from(0)
+  if (fixedSeniorYieldInBps > 0) {
+    seniorTrancheApy = fixedSeniorYieldInBps / BP_FACTOR
+    seniorPostProfitBN = poolPostProfitBN.sub(
+      seniorAssetsBN
+        .mul(Math.round(seniorTrancheApy * BP_FACTOR))
+        .div(BP_FACTOR),
+    )
+  } else {
+    const riskAdjustment = tranchesRiskAdjustmentInBps / BP_FACTOR
+    const seniorProfitBN = seniorAssetsBN
+      .mul(
+        Math.round(
+          postPoolProfitRatio * (1 - riskAdjustment) * APY * BP_FACTOR,
+        ),
+      )
+      .div(BP_FACTOR)
+    seniorTrancheApy = postPoolProfitRatio * (1 - riskAdjustment) * APY
+    seniorPostProfitBN = poolPostProfitBN.sub(seniorProfitBN)
+  }
+
+  const flcTotalAssetsAfterRiskBN = getFlcTotalAssetsAfterRisk(
+    flcConfigs,
+    BP_FACTOR,
+  )
+  const weightBN = juniorAssetsBN.add(flcTotalAssetsAfterRiskBN)
+
+  const juniorProfitBN = juniorAssetsBN.mul(seniorPostProfitBN).div(weightBN)
+  const juniorTrancheApy =
+    juniorProfitBN.mul(BP_FACTOR).div(juniorAssetsBN).toNumber() / BP_FACTOR
+  const flcTotalProfitBN = flcTotalAssetsAfterRiskBN
+    .mul(seniorPostProfitBN)
+    .div(weightBN)
+  const flcConfigsWithApy = flcConfigs.map((flcConfig) => {
+    const minLiquidityBN = BigNumber.from(flcConfig.minLiquidity)
+    const flcAssetsAfterRiskBN = minLiquidityBN
+      .mul(flcConfig.riskYieldMultiplierInBps)
+      .div(BP_FACTOR)
+
+    let apy = 0
+    if (minLiquidityBN.gt(0) && flcAssetsAfterRiskBN.gt(0)) {
+      const flcProfitBN = flcAssetsAfterRiskBN
+        .mul(flcTotalProfitBN)
+        .div(flcTotalAssetsAfterRiskBN)
+      apy =
+        flcProfitBN.mul(BP_FACTOR).div(flcConfig.minLiquidity).toNumber() /
+        BP_FACTOR
+    }
+
+    return {
+      ...flcConfig,
+      firstLossCoverIndex: Number(FirstLossCoverIndexes[flcConfig.flcIndex]),
+      apy,
+    }
+  })
+
+  return {
+    flcConfigsWithApy,
+    blendedApy,
+    seniorTrancheApy,
+    juniorTrancheApy,
+  }
+}

packages/huma-shared/src/utils/index.ts

@@ -1,21 +1,22 @@
-export * from './JsonRpcConnector'
+export * from './apy'
 export * from './chain'
 export * from './common'
 export * from './config'
 export * from './const'
 export * from './credit'
+export * from './env'
 export * from './errors'
+export * from './JsonRpcConnector'
 export * from './jsonRpcEndpoints'
+export * from './notifi'
 export * from './number'
 export * from './pool'
 export * from './poolContract'
+export * from './realWorldReceivable'
 export * from './request'
 export * from './scientificToDecimal'
 export * from './string'
 export * from './style'
 export * from './time'
 export * from './transaction'
 export * from './web3'
-export * from './notifi'
-export * from './realWorldReceivable'
-export * from './env'