@gearbox-protocol/sdk 14.10.1 → 14.10.2-next.2

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

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

@@ -0,0 +1,84 @@
+import { isStrategyCMDisabled } from "../../strategies/strategy-info/is-strategy-cm-disabled.js";
+import { getChainPhantomTokens } from "../tokens/get-chain-phantom-tokens.js";
+import { getNativeTokenAddress } from "../tokens/get-native-token-address.js";
+import { getCMYouCanEarn } from "./get-cm-you-can-earn.js";
+function getStrategyYouCanEarn({
+  strategy,
+  creditManagers,
+  sdkState,
+  apyList,
+  quotaReserve,
+  slippage,
+  allPrices,
+  walletBalances
+}) {
+  const strategyCMs = creditManagers;
+  const baseInfo = {
+    strategy: strategy.name,
+    strategyChainId: strategy.chainId,
+    strategyNetwork: strategy.network,
+    strategyType: strategy.strategyType,
+    strategyTokenOutAddress: strategy.tokenOutAddress
+  };
+  if (!strategyCMs || !walletBalances || !allPrices || !apyList || !sdkState) {
+    return [
+      {
+        status: "error",
+        description: "No strategy cms or wallet balances or all prices or apy list or sdk state",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const openableCMsList = Object.values(strategyCMs).filter(
+    (cm) => !isStrategyCMDisabled(cm, cm.quotas[strategy.tokenOutAddress])
+  );
+  if (openableCMsList.length === 0) {
+    return [
+      {
+        status: "error",
+        description: "No openable cms list",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const pools = sdkState.pools;
+  const tokensList = sdkState.tokens?.tokenDataList;
+  if (!tokensList || !pools || Object.keys(pools).length === 0) {
+    return [
+      {
+        status: "error",
+        description: "No pools or tokens list",
+        otherInfo: baseInfo,
+        data: void 0
+      }
+    ];
+  }
+  const ap = sdkState.addressProvider;
+  const nativeTokenAddress = getNativeTokenAddress();
+  const delayedPhantoms = getChainPhantomTokens(sdkState.withdrawableAssets);
+  const results = openableCMsList.map(
+    (creditManager) => {
+      const info = getCMYouCanEarn({
+        allPrices,
+        creditManager,
+        tokensList,
+        delayedPhantoms,
+        nativeTokenAddress,
+        wrappedNativeTokenAddress: ap.wrappedNativeToken,
+        walletBalances,
+        strategy,
+        slippage,
+        quotaReserve,
+        apyList,
+        pools
+      });
+      return info;
+    }
+  );
+  return results;
+}
+export {
+  getStrategyYouCanEarn
+};

package/dist/esm/common-utils/utils/strategies/strategy-info/index.js

@@ -1,6 +1,10 @@
+export * from "./calculate-total-apy.js";
+export * from "./calculate-total-points.js";
 export * from "./cm-availability-condition.js";
+export * from "./get-cm-you-can-earn.js";
 export * from "./get-strategy-info.js";
 export * from "./get-strategy-info-core.js";
 export * from "./get-strategy-max-apy.js";
+export * from "./get-strategy-you-can-earn.js";
 export * from "./is-strategy-cm-disabled.js";
 export * from "./types.js";

package/dist/esm/common-utils/utils/strategies/tokens/add-amount-in-target.js

@@ -0,0 +1,17 @@
+import { PriceUtils } from "../../price-math.js";
+function addAmountInTarget(asset, tokensList, prices, toPrice, toDecimals) {
+  const { balance: fromAmount, token: fromToken } = asset;
+  const { decimals: fromDecimals = 18, address: fromAddress } = tokensList[fromToken] || {};
+  const fromPrice = prices[fromAddress] || 0n;
+  const inTarget = PriceUtils.convertByPrice(
+    PriceUtils.calcTotalPrice(fromPrice, fromAmount, fromDecimals),
+    {
+      price: toPrice,
+      decimals: toDecimals
+    }
+  );
+  return { ...asset, amountInTarget: inTarget };
+}
+export {
+  addAmountInTarget
+};

package/dist/esm/common-utils/utils/strategies/tokens/add-amount-in-target.spec.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import {
+  mockPrices,
+  mockToken1,
+  mockTokenData
+} from "../../../test-utils/index.js";
+import { getDefaultAsset } from "../assets/assets.js";
+import { addAmountInTarget } from "./add-amount-in-target.js";
+describe("addAmountInTarget", () => {
+  const fromToken = mockToken1;
+  const toPrice = 4n;
+  const toDecimals = 18;
+  it("converts amount to target token using prices", () => {
+    const asset = {
+      ...getDefaultAsset(fromToken),
+      balance: 10n ** 18n
+    };
+    const result = addAmountInTarget(
+      asset,
+      mockTokenData,
+      mockPrices,
+      toPrice,
+      toDecimals
+    );
+    expect(result.amountInTarget).toBe(75000000000000000000000000n);
+  });
+  it("handles missing price data gracefully", () => {
+    const asset = { ...getDefaultAsset(fromToken), balance: 10n ** 18n };
+    const tokensList = {
+      [fromToken]: mockTokenData[fromToken]
+    };
+    const result = addAmountInTarget(
+      asset,
+      tokensList,
+      {},
+      toPrice,
+      toDecimals
+    );
+    expect(result.amountInTarget).toBe(0n);
+  });
+});

package/dist/esm/common-utils/utils/strategies/tokens/get-chain-phantom-tokens.js

@@ -0,0 +1,11 @@
+function getChainPhantomTokens(config) {
+  const allConfigs = Object.values(config || {}).flat(1);
+  const r = allConfigs.reduce((acc, cfg) => {
+    acc[cfg.withdrawalPhantomToken] = true;
+    return acc;
+  }, {});
+  return r;
+}
+export {
+  getChainPhantomTokens
+};

package/dist/esm/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.js

@@ -0,0 +1,18 @@
+import { addAmountInTarget } from "./add-amount-in-target.js";
+function getListWithAmountInTarget({
+  assets,
+  targetToken,
+  prices,
+  tokensList
+}) {
+  const { decimals: toDecimals = 18 } = tokensList[targetToken] || {};
+  const toPrice = prices[targetToken] || 0n;
+  const withAmount = assets.map((asset) => {
+    const a = addAmountInTarget(asset, tokensList, prices, toPrice, toDecimals);
+    return a;
+  });
+  return withAmount;
+}
+export {
+  getListWithAmountInTarget
+};

package/dist/esm/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.spec.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import {
+  mockPrices,
+  mockToken1,
+  mockToken2,
+  mockTokenData
+} from "../../../test-utils/index.js";
+import { getDefaultAsset } from "../assets/assets.js";
+import { getListWithAmountInTarget } from "./get-list-with-amount-in-target.js";
+describe("getListWithAmountInTarget", () => {
+  const targetToken = mockToken2;
+  it("converts multiple assets to target token using prices", () => {
+    const assets = [
+      { ...getDefaultAsset(mockToken1), balance: 10n ** 18n },
+      { ...getDefaultAsset(mockToken2), balance: 10n ** 18n }
+    ];
+    const result = getListWithAmountInTarget({
+      assets,
+      targetToken,
+      prices: mockPrices,
+      tokensList: mockTokenData
+    });
+    expect(result).toHaveLength(2);
+    expect(result[0].amountInTarget).toBe(1500000000000000000n);
+    expect(result[1].amountInTarget).toBe(1000000000000000000n);
+  });
+  it("returns empty array for empty assets", () => {
+    const result = getListWithAmountInTarget({
+      assets: [],
+      targetToken,
+      prices: mockPrices,
+      tokensList: mockTokenData
+    });
+    expect(result).toEqual([]);
+  });
+});

package/dist/esm/common-utils/utils/strategies/tokens/get-native-token-address.js

@@ -0,0 +1,7 @@
+const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE".toLowerCase();
+function getNativeTokenAddress() {
+  return NATIVE_ADDRESS;
+}
+export {
+  getNativeTokenAddress
+};

package/dist/esm/common-utils/utils/strategies/tokens/index.js

@@ -1,3 +1,12 @@
+export * from "./add-amount-in-target.js";
+export * from "./get-chain-phantom-tokens.js";
+export * from "./get-list-with-amount-in-target.js";
+export * from "./get-native-token-address.js";
 export * from "./is-activated-token.js";
+export * from "./is-apy-with-points-exception.js";
+export * from "./is-collateral-token.js";
 export * from "./is-forbidden-token.js";
+export * from "./is-obtainable-token.js";
 export * from "./is-usable-token.js";
+export * from "./is-valid-extra-collateral-token.js";
+export * from "./wrap-token-address.js";

package/dist/esm/common-utils/utils/strategies/tokens/is-apy-with-points-exception.js

@@ -0,0 +1,11 @@
+const RST_ETH_ADDRESS = "0x7a4EffD87C2f3C55CA251080b1343b605f327E3a".toLowerCase();
+const SHOW_APY_FOR_TOKENS_WITH_POINTS = {
+  [RST_ETH_ADDRESS]: RST_ETH_ADDRESS
+};
+function isApyWithPointsException(token) {
+  return !!SHOW_APY_FOR_TOKENS_WITH_POINTS[(token || "").toLowerCase()];
+}
+export {
+  RST_ETH_ADDRESS,
+  isApyWithPointsException
+};

package/dist/esm/common-utils/utils/strategies/tokens/is-collateral-token.js

@@ -0,0 +1,35 @@
+import { isObtainableToken } from "./is-obtainable-token.js";
+import { isValidExtraCollateralToken } from "./is-valid-extra-collateral-token.js";
+function isCollateralToken({
+  address,
+  tokensList,
+  creditManager,
+  zeroDebt = false,
+  delayedPhantoms,
+  extraCollateralConfigs,
+  prices
+}) {
+  if (creditManager && address === creditManager.underlyingToken) return true;
+  if (zeroDebt && creditManager) return false;
+  const token = tokensList[address];
+  const cmCheckPassed = isObtainableToken({
+    address,
+    creditManager,
+    delayedPhantoms
+  });
+  const { isPhantom = false } = token || {};
+  const allowedAsMain = !isPhantom && cmCheckPassed;
+  const allowedAsExtra = isValidExtraCollateralToken({
+    address,
+    extraCollateralConfigs,
+    creditManager,
+    delayedPhantoms,
+    tokensList,
+    zeroDebt,
+    prices
+  });
+  return allowedAsMain || allowedAsExtra;
+}
+export {
+  isCollateralToken
+};