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

package/dist/cjs/common-utils/utils/strategies/strategy-info/calculate-total-apy.spec.js

@@ -0,0 +1,183 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_math = require("../../../../sdk/constants/math.js");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_calc_overall_apy = require("../../creditAccount/calc-overall-apy.js");
+var import_calculate_total_apy = require("./calculate-total-apy.js");
+import_vitest.vi.mock("../../utils/creditAccount/calc-overall-apy.js", async () => {
+  const actual = await import_vitest.vi.importActual(
+    "../../utils/creditAccount/calc-overall-apy.js"
+  );
+  return {
+    ...actual,
+    calcOverallAPY: import_vitest.vi.fn(
+      actual.calcOverallAPY
+    )
+  };
+});
+const buildLpAPYList = (entries) => entries.reduce(
+  (acc, { token, apy }) => {
+    acc[token] = apy;
+    return acc;
+  },
+  {}
+);
+(0, import_vitest.describe)("calculateTotalAPY", () => {
+  const baseArgs = {
+    caAssets: [{ token: import_test_utils.mockToken1, balance: 1n }],
+    lpAPY: buildLpAPYList([{ token: import_test_utils.mockToken1, apy: 1 }]),
+    pointsInfo: { address: import_test_utils.mockToken1 },
+    isValueTo: false,
+    debt: 1n,
+    totalValue: 1n,
+    effectiveBorrowRate: 1,
+    showAPY: true,
+    prices: import_test_utils.mockPrices,
+    quotaRates: {},
+    quotas: {},
+    feeInterest: 0,
+    underlyingToken: import_test_utils.mockUnderlyingToken,
+    tokensList: import_test_utils.mockTokenData
+  };
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.clearAllMocks();
+    import_vitest.vi.restoreAllMocks();
+  });
+  (0, import_vitest.it)("returns pointsNoAPY undefined for valueFrom when points have no APY", () => {
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)({
+      ...baseArgs,
+      lpAPY: buildLpAPYList([])
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "pointsNoAPY"
+    });
+  });
+  (0, import_vitest.it)("returns pointsNoAPY null for valueTo when points have no APY", () => {
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)({
+      ...baseArgs,
+      lpAPY: buildLpAPYList([]),
+      isValueTo: true
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPY: null,
+      overallAPYBigInt: null,
+      overallAPYStatus: "pointsNoAPY"
+    });
+  });
+  (0, import_vitest.it)("returns noAPY when pointsWithAPY but missing required values", () => {
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)({
+      ...baseArgs,
+      debt: 0n
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "noAPY"
+    });
+  });
+  (0, import_vitest.it)("returns notEnoughFarmAssets when showAPY is false", () => {
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)({
+      ...baseArgs,
+      showAPY: false
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPY: null,
+      overallAPYBigInt: null,
+      overallAPYStatus: "notEnoughFarmAssets"
+    });
+  });
+  (0, import_vitest.it)("returns noAPY when calcOverallAPY returns undefined", () => {
+    import_vitest.vi.mocked(import_calc_overall_apy.calcOverallAPY).mockReturnValue(void 0);
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)(baseArgs);
+    (0, import_vitest.expect)(import_calc_overall_apy.calcOverallAPY).toHaveBeenCalledWith({
+      caAssets: baseArgs.caAssets,
+      lpAPY: baseArgs.lpAPY,
+      prices: baseArgs.prices,
+      quotaRates: baseArgs.quotaRates,
+      quotas: baseArgs.quotas,
+      feeInterest: baseArgs.feeInterest,
+      totalValue: baseArgs.totalValue,
+      debt: baseArgs.debt,
+      baseRateWithFee: baseArgs.effectiveBorrowRate,
+      underlyingToken: baseArgs.underlyingToken,
+      tokensList: baseArgs.tokensList
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "noAPY"
+    });
+  });
+  (0, import_vitest.it)("returns negativeForPoints undefined when APY <= 0 and valueFrom", () => {
+    import_vitest.vi.mocked(import_calc_overall_apy.calcOverallAPY).mockReturnValue(0n);
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)(baseArgs);
+    (0, import_vitest.expect)(import_calc_overall_apy.calcOverallAPY).toHaveBeenCalledWith({
+      caAssets: baseArgs.caAssets,
+      lpAPY: baseArgs.lpAPY,
+      prices: baseArgs.prices,
+      quotaRates: baseArgs.quotaRates,
+      quotas: baseArgs.quotas,
+      feeInterest: baseArgs.feeInterest,
+      totalValue: baseArgs.totalValue,
+      debt: baseArgs.debt,
+      baseRateWithFee: baseArgs.effectiveBorrowRate,
+      underlyingToken: baseArgs.underlyingToken,
+      tokensList: baseArgs.tokensList
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "negativeForPoints"
+    });
+  });
+  (0, import_vitest.it)("returns negativeForPoints null when APY <= 0 and valueTo", () => {
+    import_vitest.vi.mocked(import_calc_overall_apy.calcOverallAPY).mockReturnValue(0n);
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)({
+      ...baseArgs,
+      isValueTo: true
+    });
+    (0, import_vitest.expect)(import_calc_overall_apy.calcOverallAPY).toHaveBeenCalledWith({
+      caAssets: baseArgs.caAssets,
+      lpAPY: baseArgs.lpAPY,
+      prices: baseArgs.prices,
+      quotaRates: baseArgs.quotaRates,
+      quotas: baseArgs.quotas,
+      feeInterest: baseArgs.feeInterest,
+      totalValue: baseArgs.totalValue,
+      debt: baseArgs.debt,
+      baseRateWithFee: baseArgs.effectiveBorrowRate,
+      underlyingToken: baseArgs.underlyingToken,
+      tokensList: baseArgs.tokensList
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPY: null,
+      overallAPYBigInt: null,
+      overallAPYStatus: "negativeForPoints"
+    });
+  });
+  (0, import_vitest.it)("returns calculated when APY is positive", () => {
+    const apyBigInt = 2n * import_math.PERCENTAGE_FACTOR;
+    import_vitest.vi.mocked(import_calc_overall_apy.calcOverallAPY).mockReturnValue(apyBigInt);
+    const result = (0, import_calculate_total_apy.calculateTotalAPY)(baseArgs);
+    (0, import_vitest.expect)(import_calc_overall_apy.calcOverallAPY).toHaveBeenCalledWith({
+      caAssets: baseArgs.caAssets,
+      lpAPY: baseArgs.lpAPY,
+      prices: baseArgs.prices,
+      quotaRates: baseArgs.quotaRates,
+      quotas: baseArgs.quotas,
+      feeInterest: baseArgs.feeInterest,
+      totalValue: baseArgs.totalValue,
+      debt: baseArgs.debt,
+      baseRateWithFee: baseArgs.effectiveBorrowRate,
+      underlyingToken: baseArgs.underlyingToken,
+      tokensList: baseArgs.tokensList
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      overallAPYStatus: "calculated",
+      overallAPY: 2,
+      overallAPYBigInt: apyBigInt
+    });
+  });
+});

package/dist/cjs/common-utils/utils/strategies/strategy-info/calculate-total-points.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var calculate_total_points_exports = {};
+__export(calculate_total_points_exports, {
+  calculateTotalPoints: () => calculateTotalPoints
+});
+module.exports = __toCommonJS(calculate_total_points_exports);
+var import_math = require("../../../../sdk/constants/math.js");
+var import_bigint_math = require("../../bigint-math.js");
+var import_price_math = require("../../price-math.js");
+var import_get_points_rates = require("../points/get-points-rates.js");
+const THRESHOLD_POINTS = 1e3;
+function calculateTotalPoints({
+  pointsAsset,
+  cmAddress,
+  info,
+  totalValue,
+  assetValue,
+  prices,
+  tokensList,
+  underlyingToken
+}) {
+  if (!pointsAsset || !info) return null;
+  if (totalValue === void 0 || totalValue <= 0n) return null;
+  if (assetValue === void 0 || assetValue <= 0n) return null;
+  const { token: tokenAddress, balance: amount } = pointsAsset;
+  const price = prices[tokenAddress] || 0n;
+  const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
+  const money = import_price_math.PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
+  const underlyingPrice = prices[underlyingToken] ?? import_math.PRICE_DECIMALS;
+  const { decimals: underlyingDecimals = 18 } = tokensList[underlyingToken] || {};
+  const assetAmountInUnderlying = import_price_math.PriceUtils.convertByPrice(money, {
+    price: underlyingPrice || import_math.PRICE_DECIMALS,
+    decimals: underlyingDecimals
+  });
+  const percent = assetAmountInUnderlying * import_math.PERCENTAGE_FACTOR / totalValue;
+  if (percent < THRESHOLD_POINTS) return null;
+  const leverage = assetAmountInUnderlying * import_math.LEVERAGE_DECIMALS / assetValue;
+  const rates = (0, import_get_points_rates.getPointsRates)(info.rewards, leverage);
+  const debt = totalValue - assetValue;
+  const leverageDebt = import_bigint_math.BigIntMath.min(assetAmountInUnderlying, debt > 0 ? debt : 0n) * import_math.LEVERAGE_DECIMALS / assetValue;
+  const debtRewardsAvailable = (info.debtRewards || []).filter(
+    (r) => r.cm === cmAddress || r.cm === "any"
+  );
+  const debtRates = (0, import_get_points_rates.getPointsRates)(debtRewardsAvailable, leverageDebt);
+  return {
+    info,
+    rates,
+    debtRates: {
+      rewards: debtRewardsAvailable,
+      rates: debtRates
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateTotalPoints
+});

package/dist/cjs/common-utils/utils/strategies/strategy-info/calculate-total-points.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_math = require("../../../../sdk/constants/math.js");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_calculate_total_points = require("./calculate-total-points.js");
+(0, import_vitest.describe)("calculateTotalPoints", () => {
+  const pointsInfo = {
+    symbol: "PTS",
+    address: import_test_utils.mockToken1,
+    rewards: [
+      {
+        name: "points",
+        units: "pts",
+        multiplier: import_math.LEVERAGE_DECIMALS,
+        type: "base"
+      }
+    ],
+    debtRewards: [
+      {
+        name: "debt",
+        units: "pts",
+        multiplier: import_math.LEVERAGE_DECIMALS,
+        type: "debt",
+        cm: import_test_utils.mockCMAddress
+      }
+    ]
+  };
+  const baseArgs = {
+    pointsAsset: { token: import_test_utils.mockToken1, balance: 1n },
+    cmAddress: import_test_utils.mockCMAddress,
+    info: pointsInfo,
+    totalValue: 10n * import_math.PRICE_DECIMALS,
+    assetValue: 1n,
+    prices: import_test_utils.mockPrices,
+    tokensList: import_test_utils.mockTokenData,
+    underlyingToken: import_test_utils.mockUnderlyingToken
+  };
+  (0, import_vitest.it)("returns null when no pointsAsset or info", () => {
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        pointsAsset: void 0
+      })
+    ).toBeNull();
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        info: void 0
+      })
+    ).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when no totalValue", () => {
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        totalValue: void 0
+      })
+    ).toBeNull();
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        totalValue: 0n
+      })
+    ).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when no assetValue", () => {
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        assetValue: void 0
+      })
+    ).toBeNull();
+    (0, import_vitest.expect)(
+      (0, import_calculate_total_points.calculateTotalPoints)({
+        ...baseArgs,
+        assetValue: 0n
+      })
+    ).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when below threshold", () => {
+    const result = (0, import_calculate_total_points.calculateTotalPoints)({
+      ...baseArgs,
+      totalValue: 10n * import_math.PRICE_DECIMALS
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns points data when above threshold with matching debt rewards", () => {
+    const assetAmount = import_math.PRICE_DECIMALS;
+    const totalValue = 4n * import_math.PRICE_DECIMALS;
+    const assetValue = import_math.PRICE_DECIMALS;
+    const result = (0, import_calculate_total_points.calculateTotalPoints)({
+      pointsAsset: { token: import_test_utils.mockToken1, balance: assetAmount },
+      cmAddress: import_test_utils.mockCMAddress,
+      info: pointsInfo,
+      totalValue,
+      assetValue,
+      prices: {
+        ...import_test_utils.mockPrices,
+        [import_test_utils.mockToken1]: 2n * import_math.PRICE_DECIMALS
+      },
+      tokensList: import_test_utils.mockTokenData,
+      underlyingToken: import_test_utils.mockUnderlyingToken
+    });
+    (0, import_vitest.expect)(result?.info).toBe(pointsInfo);
+    (0, import_vitest.expect)(result?.rates).toEqual([2n * import_math.LEVERAGE_DECIMALS]);
+    (0, import_vitest.expect)(result?.debtRates.rewards).toHaveLength(1);
+    (0, import_vitest.expect)(result?.debtRates.rates).toEqual([2n * import_math.LEVERAGE_DECIMALS]);
+  });
+  (0, import_vitest.it)("returns points data when above threshold with matching debt rewards when debt is lower than asset amount", () => {
+    const assetAmount = import_math.PRICE_DECIMALS;
+    const totalValue = 4n * import_math.PRICE_DECIMALS;
+    const assetValue = import_math.PRICE_DECIMALS;
+    const result = (0, import_calculate_total_points.calculateTotalPoints)({
+      pointsAsset: { token: import_test_utils.mockToken1, balance: assetAmount },
+      cmAddress: import_test_utils.mockCMAddress,
+      info: pointsInfo,
+      totalValue,
+      assetValue,
+      prices: {
+        ...import_test_utils.mockPrices,
+        [import_test_utils.mockToken1]: 4n * import_math.PRICE_DECIMALS
+      },
+      tokensList: import_test_utils.mockTokenData,
+      underlyingToken: import_test_utils.mockUnderlyingToken
+    });
+    (0, import_vitest.expect)(result?.info).toBe(pointsInfo);
+    (0, import_vitest.expect)(result?.rates).toEqual([4n * import_math.LEVERAGE_DECIMALS]);
+    (0, import_vitest.expect)(result?.debtRates.rewards).toHaveLength(1);
+    (0, import_vitest.expect)(result?.debtRates.rates).toEqual([3n * import_math.LEVERAGE_DECIMALS]);
+  });
+});