@gearbox-protocol/sdk 14.10.0 → 14.10.2-next.1

package/dist/esm/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.js

@@ -0,0 +1,389 @@
+import {
+  LEVERAGE_DECIMALS,
+  WAD_DECIMALS_POW
+} from "../../../../sdk/constants/math.js";
+import { formatBN, toBigInt, toBN } from "../../../../sdk/utils/formatter.js";
+import { calculateEarnings } from "../../apy/calculate-earnings.js";
+import { calculateEffectiveBorrowRate } from "../../apy/calculate-effective-borrow-rate.js";
+import { getComplexAPYList } from "../../apy/get-complex-apy-list.js";
+import { getSafeBaseBorrowRate } from "../../apy/get-safe-base-borrow-rate.js";
+import { AssetUtils } from "../../assets-math.js";
+import { BigIntMath } from "../../bigint-math.js";
+import { EMPTY_ADDRESS, EMPTY_OBJECT } from "../../constants.js";
+import { calcHealthFactor } from "../../creditAccount/calc-health-factor.js";
+import { calcQuotaUpdate } from "../../creditAccount/quota-utils.js";
+import { PriceUtils } from "../../price-math.js";
+import { isZeroBalance } from "../../validation/is-zero-balance.js";
+import { validateBalances } from "../../validation/validate-balances.js";
+import { validateCreditManager } from "../../validation/validate-credit-manager.js";
+import { validateHF } from "../../validation/validate-hf.js";
+import { validateOpenAccount } from "../../validation/validate-open-account.js";
+import { validateOpenAccountPoolStatus } from "../../validation/validate-open-account-pool-status.js";
+import { validateTokenToObtain } from "../../validation/validate-token-to-obtain.js";
+import { getCMAllowedCollaterals } from "../credit-managers/get-cm-allowed-collaterals.js";
+import { getWalletBalancesAllowedOnCM } from "../credit-managers/get-wallet-balances-allowed-on-cm.js";
+import { getCollateralByDebt } from "../leverage/get-collateral-by-debt.js";
+import { getLeverageFromFactor } from "../leverage/get-leverage-from-factor.js";
+import { getRecommendedDebt } from "../leverage/get-recommended-debt.js";
+import { getComplexPointsList } from "../points/get-complex-points-list.js";
+import { getPointsInfo } from "../points/get-points-info.js";
+import { getListWithAmountInTarget } from "../tokens/get-list-with-amount-in-target.js";
+import { calculateTotalAPY } from "./calculate-total-apy.js";
+import { calculateTotalPoints } from "./calculate-total-points.js";
+function getCMYouCanEarn({
+  allPrices,
+  creditManager,
+  tokensList,
+  delayedPhantoms,
+  nativeTokenAddress,
+  wrappedNativeTokenAddress,
+  walletBalances,
+  strategy,
+  slippage,
+  quotaReserve,
+  apyList,
+  pools
+}) {
+  const baseInfo = {
+    strategy: strategy.name,
+    strategyChainId: strategy.chainId,
+    strategyNetwork: strategy.network,
+    strategyType: strategy.strategyType,
+    creditManager: creditManager.address,
+    cmName: creditManager.name,
+    underlyingToken: tokensList[creditManager.underlyingToken]?.title || creditManager.underlyingToken,
+    targetToken: tokensList[strategy.tokenOutAddress]?.title || strategy.tokenOutAddress
+  };
+  if (!walletBalances) {
+    return {
+      status: "error",
+      description: "No wallet balances",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const targetTokenAddress = strategy.tokenOutAddress;
+  const targetDecimals = tokensList[targetTokenAddress]?.decimals || 18;
+  const prices = allPrices?.[creditManager?.pool || EMPTY_ADDRESS];
+  if (!prices) {
+    return {
+      status: "error",
+      description: "No prices for cm pool",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const collateralRecord = getCMAllowedCollaterals({
+    creditManager,
+    tokensList,
+    zeroDebt: false,
+    delayedPhantoms,
+    nativeTokenAddress,
+    wrappedNativeTokenAddress,
+    extraCollaterals: {
+      list: strategy.additionalCollaterals,
+      prices
+    }
+  });
+  const walletBalancesSorted = getWalletBalancesAllowedOnCM({
+    walletBalances,
+    collateralRecord,
+    nativeTokenAddress,
+    wrappedNativeTokenAddress,
+    tokensList,
+    prices,
+    isPaused: creditManager?.isPaused
+  });
+  const filtered = walletBalancesSorted.filter((a) => !isZeroBalance(a.balance));
+  const collateral_initial = filtered[0];
+  if (!collateral_initial || collateral_initial.balance === 0n) {
+    return {
+      status: "error",
+      description: `Initial collateral is zero`,
+      otherInfo: {
+        ...baseInfo,
+        walletBalancesSorted,
+        filtered
+      },
+      data: void 0
+    };
+  }
+  const collateralPrice = prices[collateral_initial.token] || 0n;
+  const collateralDecimals = tokensList[collateral_initial.token]?.decimals || 18;
+  const underlyingPrice = prices[creditManager.underlyingToken] || 0n;
+  const underlyingDecimals = tokensList[creditManager.underlyingToken]?.decimals || 18;
+  const assetValueFrom_initial = PriceUtils.convertByPrice(
+    PriceUtils.calcTotalPrice(
+      collateralPrice,
+      collateral_initial.balance,
+      collateralDecimals
+    ),
+    {
+      price: underlyingPrice,
+      decimals: underlyingDecimals
+    }
+  );
+  if (!assetValueFrom_initial || assetValueFrom_initial === 0n) {
+    return {
+      status: "error",
+      description: "Initial asset value from is zero",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const recommendedDebt_initial = getRecommendedDebt({
+    targetToken: targetTokenAddress,
+    amount: assetValueFrom_initial,
+    creditManager,
+    slippage,
+    swapCollateral: true,
+    leverageLimit: strategy.maxLeverage
+  });
+  const lt = creditManager.liquidationThresholds[targetTokenAddress] || 0n;
+  const recommendedAssetValueFrom = getCollateralByDebt(
+    recommendedDebt_initial.maxDebt,
+    lt,
+    toBN("1.013", 4)
+  );
+  const assetValueFrom = BigIntMath.min(
+    assetValueFrom_initial,
+    recommendedAssetValueFrom
+  );
+  if (!assetValueFrom || assetValueFrom === 0n) {
+    return {
+      status: "error",
+      description: "Asset value from is zero",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const assetValueFromTarget = PriceUtils.convertByPrice(
+    PriceUtils.calcTotalPrice(
+      underlyingPrice,
+      assetValueFrom,
+      underlyingDecimals
+    ),
+    {
+      price: collateralPrice,
+      decimals: collateralDecimals
+    }
+  );
+  const collateral = [
+    { token: collateral_initial.token, balance: assetValueFromTarget }
+  ];
+  const recommendedDebt = getRecommendedDebt({
+    targetToken: targetTokenAddress,
+    amount: assetValueFrom,
+    creditManager,
+    slippage,
+    swapCollateral: true,
+    leverageLimit: strategy.maxLeverage
+  });
+  const debt = recommendedDebt.maxDebt;
+  const totalAmount = assetValueFrom + debt;
+  const targetPrice = prices[targetTokenAddress] || 0n;
+  const totalAmountInTarget = PriceUtils.convertByPrice(
+    PriceUtils.calcTotalPrice(underlyingPrice, totalAmount, underlyingDecimals),
+    {
+      price: targetPrice,
+      decimals: targetDecimals
+    }
+  );
+  const assets = [
+    {
+      token: targetTokenAddress,
+      balance: totalAmountInTarget
+    }
+  ];
+  const assetsWithAmountInTarget = getListWithAmountInTarget({
+    assets,
+    targetToken: creditManager.underlyingToken,
+    prices,
+    tokensList
+  });
+  const assetsWithAmountInTargetRecord = AssetUtils.constructAssetRecord(
+    assetsWithAmountInTarget
+  );
+  const quotasAfter = calcQuotaUpdate({
+    quotas: creditManager.quotas,
+    initialQuotas: EMPTY_OBJECT,
+    assetsAfterUpdate: assetsWithAmountInTargetRecord,
+    allowedToObtain: assetsWithAmountInTargetRecord,
+    allowedToSpend: EMPTY_OBJECT,
+    quotaReserve: toBigInt(quotaReserve),
+    maxDebt: creditManager.maxDebt,
+    calcModification: void 0,
+    liquidationThresholds: creditManager.liquidationThresholds
+  });
+  const desiredQuota = quotasAfter.desiredQuota;
+  const quotaDecrease = quotasAfter.quotaDecrease;
+  const quotaIncrease = quotasAfter.quotaIncrease;
+  const quotaUpdate = [...quotaDecrease, ...quotaIncrease];
+  const hf = calcHealthFactor({
+    assets: assetsWithAmountInTarget,
+    quotas: desiredQuota,
+    prices,
+    liquidationThresholds: creditManager.liquidationThresholds,
+    underlyingToken: creditManager.underlyingToken,
+    debt,
+    quotasInfo: creditManager.quotas,
+    tokensList
+  });
+  const pool = pools?.[creditManager.pool];
+  const error = validateCreditManager({ creditManager }) || validateOpenAccountPoolStatus({
+    pool,
+    creditManager,
+    debt,
+    targetToken: targetTokenAddress
+  }) || validateTokenToObtain({
+    targetToken: strategy.tokenOutAddress,
+    creditManager
+  }) || validateBalances({
+    balances: walletBalances,
+    assets: collateral
+  }) || validateOpenAccount({
+    desiredQuota,
+    quotaUpdate,
+    debt,
+    creditManager,
+    loading: false
+  }) || validateHF({ hf });
+  if (error) {
+    return {
+      status: "error",
+      description: `Resulting CA did not pass validation: ${error.message}`,
+      otherInfo: {
+        ...baseInfo,
+        hf
+      },
+      data: void 0
+    };
+  }
+  const apyRecord = getComplexAPYList(
+    apyList?.apyList,
+    apyList?.extraCollateralAPYList,
+    creditManager.pool
+  );
+  if (!apyRecord) {
+    return {
+      status: "error",
+      description: "No complex apy record",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const pointsList = getComplexPointsList(
+    apyList?.pointsList,
+    apyList?.extraCollateralPointsList,
+    pool?.address
+  );
+  if (!pointsList) {
+    return {
+      status: "error",
+      description: "No complex points record",
+      otherInfo: baseInfo,
+      data: void 0
+    };
+  }
+  const pointsInfo = getPointsInfo({
+    chainId: strategy.chainId,
+    pointsList,
+    token: strategy.tokenOutAddress,
+    creditManagers: {
+      [creditManager.address]: creditManager
+    }
+  });
+  const baseBorrowRateTo = pool ? getSafeBaseBorrowRate({
+    creditManager,
+    pool,
+    availableLiquidityChange: debt * -1n
+  }) : creditManager.baseBorrowRate;
+  const effectiveBorrowRate = calculateEffectiveBorrowRate({
+    underlyingTokenAddress: creditManager.underlyingToken,
+    baseRateWithFee: baseBorrowRateTo,
+    apyList: apyRecord
+  });
+  const totalAPY = calculateTotalAPY({
+    caAssets: assetsWithAmountInTarget,
+    lpAPY: apyRecord,
+    prices,
+    quotaRates: creditManager.quotas,
+    quotas: desiredQuota,
+    feeInterest: creditManager.feeInterest,
+    totalValue: totalAmount,
+    debt,
+    underlyingToken: creditManager.underlyingToken,
+    tokensList,
+    pointsInfo,
+    effectiveBorrowRate,
+    showAPY: true
+  });
+  const earn = calculateEarnings({
+    overallAPYBigInt: totalAPY.overallAPYBigInt,
+    targetAmount: assetValueFrom,
+    targetToken: creditManager.underlyingToken,
+    tokensList,
+    prices
+  });
+  const points = calculateTotalPoints({
+    pointsAsset: pointsInfo ? assetsWithAmountInTarget[0] : void 0,
+    cmAddress: creditManager.address,
+    info: pointsInfo,
+    totalValue: totalAmount,
+    assetValue: assetValueFrom,
+    prices,
+    tokensList,
+    underlyingToken: creditManager.underlyingToken
+  });
+  const leverage = getLeverageFromFactor(
+    debt * LEVERAGE_DECIMALS / assetValueFrom
+  );
+  const info = {
+    info: {
+      strategy,
+      creditManager,
+      collateral,
+      assetsWithAmountInTarget,
+      assetValue: assetValueFrom,
+      debt,
+      totalAmount,
+      assetValueInUSD: PriceUtils.calcTotalPrice(
+        underlyingPrice,
+        assetValueFrom,
+        underlyingDecimals
+      ),
+      maxAPY: totalAPY,
+      bonusAPY: void 0,
+      extraAPY: [],
+      maxLeverage: leverage
+    },
+    earnings: earn,
+    points,
+    otherInfo: {
+      ...baseInfo,
+      collateral: collateral.map((c) => ({
+        token: tokensList[c.token]?.title || c.token,
+        balance: formatBN(c.balance, WAD_DECIMALS_POW, 4)
+      })),
+      apy: formatBN(totalAPY.overallAPYBigInt || 0, 4, 4),
+      earningsUSD: formatBN(earn.earningsUSD || 0n, WAD_DECIMALS_POW, 4),
+      assetValue: formatBN(assetValueFrom, targetDecimals, 4),
+      debt: formatBN(debt, targetDecimals, 4),
+      totalAmount: formatBN(totalAmount, underlyingDecimals, 4),
+      assetValueFrom_initial: formatBN(
+        assetValueFrom_initial,
+        targetDecimals,
+        4
+      ),
+      debt_initial: formatBN(
+        recommendedDebt_initial.maxDebt,
+        targetDecimals,
+        4
+      )
+    }
+  };
+  return { status: "ok", description: "ok", data: info };
+}
+export {
+  getCMYouCanEarn
+};

package/dist/esm/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.spec.js

@@ -0,0 +1,278 @@
+import { describe, expect, it } from "vitest";
+import { toBN } from "../../../../sdk/utils/formatter.js";
+import {
+  buildCreditManager,
+  buildPool,
+  buildQuota,
+  buildTokenData
+} from "../../../test-utils/index.js";
+import { getCMYouCanEarn } from "./get-cm-you-can-earn.js";
+describe("getCMYouCanEarn", () => {
+  const collateralTokenAddress = "0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee";
+  const targetTokenAddress = "0xe72b141df173b999ae7c1adcbf60cc9833ce56a8";
+  const underlyingTokenAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+  const deth = "0x871ab8e36cae9af35c6a3488b049965233deb7ed";
+  const nativeTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+  const wrappedNativeTokenAddress = underlyingTokenAddress;
+  const tokenDataList = {
+    [collateralTokenAddress]: buildTokenData(collateralTokenAddress, "weETH"),
+    [targetTokenAddress]: buildTokenData(targetTokenAddress, "ethPlus"),
+    [underlyingTokenAddress]: buildTokenData(underlyingTokenAddress, "WETH"),
+    [nativeTokenAddress]: buildTokenData(nativeTokenAddress, "ETH"),
+    [deth]: buildTokenData(deth, "dETH")
+  };
+  const poolAddress = "0x0000000000000000000000000000000000000POOL";
+  const creditManagerAddress = "0x0000000000000000000000000000000000000CM1";
+  const creditManager = buildCreditManager({
+    address: creditManagerAddress,
+    pool: poolAddress,
+    underlyingToken: underlyingTokenAddress,
+    collateralTokens: [
+      collateralTokenAddress,
+      underlyingTokenAddress,
+      targetTokenAddress,
+      deth
+    ],
+    supportedTokens: {
+      [collateralTokenAddress]: true,
+      [underlyingTokenAddress]: true,
+      [targetTokenAddress]: true,
+      [deth]: true
+    },
+    liquidationThresholds: {
+      [collateralTokenAddress]: 9300n,
+      [targetTokenAddress]: 9300n,
+      [underlyingTokenAddress]: 9500n,
+      [deth]: 8800n
+    },
+    quotas: {
+      [targetTokenAddress]: buildQuota({
+        isActive: true,
+        limit: 5000000000000000000000n,
+        quotaIncreaseFee: 0n,
+        rate: 100n,
+        token: "0xe72b141df173b999ae7c1adcbf60cc9833ce56a8",
+        totalQuoted: 1708445825184283030000n
+      }),
+      [collateralTokenAddress]: buildQuota({
+        token: collateralTokenAddress,
+        rate: 0n,
+        limit: toBN("1000000", 18)
+      }),
+      [deth]: buildQuota({
+        isActive: true,
+        limit: 500000000000000000000n,
+        quotaIncreaseFee: 0n,
+        rate: 100n,
+        token: deth,
+        totalQuoted: 28666207338545540000n
+      })
+    },
+    isQuoted: (t) => t.toLowerCase() !== underlyingTokenAddress,
+    feeInterest: 2e3,
+    isPaused: false,
+    baseBorrowRate: 18991,
+    maxDebt: 250000000000000000000n,
+    minDebt: 10000000000000000000n,
+    availableToBorrow: 859640767327531138355n
+  });
+  const pools = {
+    [poolAddress]: buildPool({
+      address: poolAddress,
+      chainId: 1,
+      network: "Mainnet",
+      underlyingToken: underlyingTokenAddress,
+      dieselToken: poolAddress,
+      isPaused: false,
+      version: 310,
+      expectedLiquidity: 5596004266940175413222n,
+      expectedLiquidityLimit: 6903325375622920584635n,
+      availableLiquidity: 1307321108682745171413n,
+      interestModel: {
+        interestModel: "0x12e6e5c6fe4b37576dd4052e03a97ee7b9c29e86",
+        U_1: 7000n,
+        U_2: 9200n,
+        R_base: 0n,
+        R_slope1: 113n,
+        R_slope2: 150n,
+        R_slope3: 1236n,
+        version: 310,
+        isBorrowingMoreU2Forbidden: true
+      }
+    })
+  };
+  const allPrices = {
+    [poolAddress]: {
+      [collateralTokenAddress]: 347896889077n,
+      [targetTokenAddress]: 342474099875n,
+      [underlyingTokenAddress]: 320438727057n,
+      [deth]: 322630065873n
+    }
+  };
+  const walletBalances = {
+    [underlyingTokenAddress]: 0n,
+    [collateralTokenAddress]: 6191758000000000000n,
+    [targetTokenAddress]: 0n
+  };
+  const apyList = {
+    apyList: {
+      [targetTokenAddress]: 24600,
+      [collateralTokenAddress]: 27612,
+      [deth]: 16600
+    },
+    extraCollateralAPYList: {
+      [poolAddress]: {
+        [targetTokenAddress]: {
+          address: targetTokenAddress,
+          pool: poolAddress,
+          symbol: "ETHPlus",
+          type: "relative",
+          value: 0
+        }
+      }
+    },
+    pointsList: {
+      [collateralTokenAddress]: {
+        symbol: "weETH",
+        address: "0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee",
+        debtRewards: void 0,
+        rewards: [
+          {
+            name: "Ether.fi",
+            units: "points",
+            multiplier: 200n,
+            type: "etherfi"
+          }
+        ]
+      },
+      [deth]: {
+        address: "0x871ab8e36cae9af35c6a3488b049965233deb7ed",
+        debtRewards: void 0,
+        rewards: [
+          {
+            name: "Makina",
+            units: "points",
+            multiplier: 36000n,
+            type: "makina"
+          }
+        ],
+        symbol: "DETH"
+      }
+    },
+    extraCollateralPointsList: {},
+    poolRewardsList: {},
+    tokenExtraRewardsList: {},
+    poolExternalAPYList: {},
+    poolExtraAPYList: {}
+  };
+  it("computes expected earnings for APY-only scenario", () => {
+    const strategy = {
+      id: "test-strategy",
+      tokenOutAddress: targetTokenAddress,
+      chainId: 1,
+      network: "Mainnet"
+    };
+    const result = getCMYouCanEarn({
+      creditManager,
+      pools,
+      strategy,
+      delayedPhantoms: {},
+      apyList,
+      tokensList: tokenDataList,
+      walletBalances,
+      nativeTokenAddress,
+      wrappedNativeTokenAddress,
+      allPrices,
+      slippage: 10,
+      quotaReserve: 500
+    });
+    expect(result.status).toEqual("ok");
+    expect(result.data?.info?.maxAPY).toEqual({
+      overallAPY: 7.392,
+      overallAPYBigInt: 73920n,
+      overallAPYStatus: "calculated"
+    });
+    expect(result.data?.earnings).toEqual({
+      earnings: 496914282513333354n,
+      earningsUSD: 1592305801450150145856n
+    });
+  });
+  it("computes expected earnings for APY and points scenario", () => {
+    const strategy = {
+      id: "test-strategy",
+      tokenOutAddress: collateralTokenAddress,
+      chainId: 1,
+      network: "Mainnet"
+    };
+    const result = getCMYouCanEarn({
+      creditManager,
+      pools,
+      strategy,
+      delayedPhantoms: {},
+      apyList,
+      tokensList: tokenDataList,
+      walletBalances,
+      nativeTokenAddress,
+      wrappedNativeTokenAddress,
+      allPrices,
+      slippage: 10,
+      quotaReserve: 500
+    });
+    expect(result.status).toEqual("ok");
+    expect(result.data?.info?.maxAPY).toEqual({
+      overallAPY: 11.233,
+      overallAPYBigInt: 112330n,
+      overallAPYStatus: "calculated"
+    });
+    expect(result.data?.earnings).toEqual({
+      earnings: 755118795383153892n,
+      earningsUSD: 2419693055693930817344n
+    });
+    expect(result.data?.points?.info).toEqual(
+      apyList.pointsList?.[collateralTokenAddress] || {}
+    );
+    expect(result.data?.points).toEqual({
+      debtRates: { rewards: [], rates: [] },
+      info: apyList.pointsList?.[collateralTokenAddress] || {},
+      rates: [2454n]
+    });
+  });
+  it("computes expected earnings for points-only scenario", () => {
+    const strategy = {
+      id: "test-strategy",
+      tokenOutAddress: deth,
+      chainId: 1,
+      network: "Mainnet"
+    };
+    const result = getCMYouCanEarn({
+      creditManager,
+      pools,
+      strategy,
+      delayedPhantoms: {},
+      apyList,
+      tokensList: tokenDataList,
+      walletBalances,
+      nativeTokenAddress,
+      wrappedNativeTokenAddress,
+      allPrices,
+      slippage: 10,
+      quotaReserve: 500
+    });
+    expect(result.status).toEqual("ok");
+    expect(result.data?.info?.maxAPY).toEqual({
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "negativeForPoints"
+    });
+    expect(result.data?.earnings).toEqual({
+      earnings: null,
+      earningsUSD: null
+    });
+    expect(result.data?.points?.info).toEqual(apyList.pointsList?.[deth] || {});
+    expect(result.data?.points).toEqual({
+      debtRates: { rewards: [], rates: [] },
+      info: apyList.pointsList?.[deth] || {},
+      rates: [259920n]
+    });
+  });
+});