@gearbox-protocol/sdk 15.0.0-next.2 → 15.0.0-pyth.1

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

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

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

@@ -0,0 +1,54 @@
+import {
+  LEVERAGE_DECIMALS,
+  PERCENTAGE_FACTOR,
+  PRICE_DECIMALS
+} from "../../../../sdk/constants/math.js";
+import { BigIntMath } from "../../bigint-math.js";
+import { PriceUtils } from "../../price-math.js";
+import { getPointsRates } from "../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 = PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
+  const underlyingPrice = prices[underlyingToken] ?? PRICE_DECIMALS;
+  const { decimals: underlyingDecimals = 18 } = tokensList[underlyingToken] || {};
+  const assetAmountInUnderlying = PriceUtils.convertByPrice(money, {
+    price: underlyingPrice || PRICE_DECIMALS,
+    decimals: underlyingDecimals
+  });
+  const percent = assetAmountInUnderlying * PERCENTAGE_FACTOR / totalValue;
+  if (percent < THRESHOLD_POINTS) return null;
+  const leverage = assetAmountInUnderlying * LEVERAGE_DECIMALS / assetValue;
+  const rates = getPointsRates(info.rewards, leverage);
+  const debt = totalValue - assetValue;
+  const leverageDebt = BigIntMath.min(assetAmountInUnderlying, debt > 0 ? debt : 0n) * LEVERAGE_DECIMALS / assetValue;
+  const debtRewardsAvailable = (info.debtRewards || []).filter(
+    (r) => r.cm === cmAddress || r.cm === "any"
+  );
+  const debtRates = getPointsRates(debtRewardsAvailable, leverageDebt);
+  return {
+    info,
+    rates,
+    debtRates: {
+      rewards: debtRewardsAvailable,
+      rates: debtRates
+    }
+  };
+}
+export {
+  calculateTotalPoints
+};

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

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

package/dist/esm/common-utils/utils/strategies/strategy-info/cm-availability-condition.js

@@ -0,0 +1,40 @@
+import { validateOpenAccountPoolStatus } from "../../validation/validate-open-account-pool-status.js";
+import { checkBoolean, checkDegenNFT } from "../availability/index.js";
+function cmAvailabilityCondition(targetToken, cmA, cmB, pools) {
+  const aHasMinError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmA.pool],
+    debt: cmA.minDebt,
+    creditManager: cmA,
+    targetToken
+  });
+  const bHasMinError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmB.pool],
+    debt: cmB.minDebt,
+    creditManager: cmB,
+    targetToken
+  });
+  const minSort = checkBoolean(!aHasMinError, !bHasMinError);
+  if (minSort !== 0) return minSort;
+  const { freeOfNFT: aFreeOfNFT } = checkDegenNFT(cmA);
+  const { freeOfNFT: bFreeOfNFT } = checkDegenNFT(cmB);
+  const nftSort = checkBoolean(aFreeOfNFT, bFreeOfNFT);
+  if (nftSort !== 0) return nftSort;
+  const aHasMaxError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmA.pool],
+    debt: cmA.maxDebt,
+    creditManager: cmA,
+    targetToken
+  });
+  const bHasMaxError = validateOpenAccountPoolStatus({
+    pool: pools?.[cmB.pool],
+    debt: cmB.maxDebt,
+    creditManager: cmB,
+    targetToken
+  });
+  const maxSort = checkBoolean(!aHasMaxError, !bHasMaxError);
+  if (maxSort !== 0) return maxSort;
+  return 0;
+}
+export {
+  cmAvailabilityCondition
+};