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

package/dist/esm/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.js

@@ -0,0 +1,9 @@
+function getRecommendedLeverageFactor({
+  maxLeverageFactor
+}) {
+  const l = BigInt(Math.floor(Number(maxLeverageFactor) * 0.7 / 10)) * 10n;
+  return l;
+}
+export {
+  getRecommendedLeverageFactor
+};

package/dist/esm/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.spec.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { getRecommendedLeverageFactor } from "./get-recommended-leverage-factor.js";
+describe("getRecommendedLeverageFactor", () => {
+  it("returns zero when max factor is zero", () => {
+    const factor = getRecommendedLeverageFactor({
+      maxLeverageFactor: 0n
+    });
+    expect(factor).toBe(0n);
+  });
+  it("returns 70% of max rounded down to tens", () => {
+    const factor = getRecommendedLeverageFactor({
+      maxLeverageFactor: 550n
+    });
+    expect(factor).toBe(380n);
+  });
+  it("rounds down fractional 70% results to nearest ten", () => {
+    const factor = getRecommendedLeverageFactor({
+      maxLeverageFactor: 503n
+    });
+    expect(factor).toBe(350n);
+  });
+});

package/dist/esm/common-utils/utils/strategies/leverage/max-leverage.js

@@ -3,8 +3,8 @@ import { getFactorFromLeverage } from "./get-factor-from-leverage.js";
 import { maxLeverageThreshold } from "./max-leverage-threshold.js";
 function maxLeverage(lpToken, cms, targetHF = PERCENTAGE_FACTOR) {
   const [maxThreshold] = maxLeverageThreshold(lpToken, cms);
-  const maxLeverageValue = targetHF * LEVERAGE_DECIMALS / (targetHF - maxThreshold);
-  return getFactorFromLeverage(maxLeverageValue);
+  const maxLeverage2 = targetHF * LEVERAGE_DECIMALS / (targetHF - maxThreshold);
+  return getFactorFromLeverage(maxLeverage2);
 }
 export {
   maxLeverage

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

@@ -0,0 +1,88 @@
+import { PERCENTAGE_FACTOR } from "../../../../sdk/constants/math.js";
+import { EMPTY_ADDRESS } from "../../constants.js";
+import { calcOverallAPY } from "../../creditAccount/calc-overall-apy.js";
+import { isApyWithPointsException } from "../tokens/is-apy-with-points-exception.js";
+function calculateTotalAPY({
+  caAssets,
+  lpAPY,
+  pointsInfo,
+  isValueTo,
+  debt,
+  totalValue,
+  effectiveBorrowRate,
+  showAPY,
+  prices,
+  quotaRates,
+  quotas,
+  feeInterest,
+  underlyingToken,
+  tokensList
+}) {
+  const pointsWithAPY = (lpAPY?.[pointsInfo?.address || EMPTY_ADDRESS] || 0) > 0;
+  const pointsWithoutAPY = pointsInfo?.address && !pointsWithAPY;
+  if (pointsWithoutAPY && !isApyWithPointsException(pointsInfo?.address)) {
+    return isValueTo ? {
+      overallAPY: null,
+      overallAPYBigInt: null,
+      overallAPYStatus: "pointsNoAPY"
+    } : {
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "pointsNoAPY"
+    };
+  }
+  if (pointsWithAPY && (debt === 0n || totalValue === 0n || caAssets.length === 0 || effectiveBorrowRate === 0)) {
+    return {
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "noAPY"
+    };
+  }
+  if (!showAPY) {
+    return {
+      overallAPY: null,
+      overallAPYBigInt: null,
+      overallAPYStatus: "notEnoughFarmAssets"
+    };
+  }
+  const r = calcOverallAPY({
+    caAssets,
+    lpAPY,
+    prices,
+    quotaRates,
+    quotas,
+    feeInterest,
+    totalValue,
+    debt,
+    baseRateWithFee: effectiveBorrowRate,
+    underlyingToken,
+    tokensList
+  });
+  if (r === void 0) {
+    return {
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "noAPY"
+    };
+  }
+  const apy = Number(r) / Number(PERCENTAGE_FACTOR);
+  if (pointsWithAPY && !isApyWithPointsException(pointsInfo?.address) && apy <= 0) {
+    return isValueTo ? {
+      overallAPY: null,
+      overallAPYBigInt: null,
+      overallAPYStatus: "negativeForPoints"
+    } : {
+      overallAPY: void 0,
+      overallAPYBigInt: void 0,
+      overallAPYStatus: "negativeForPoints"
+    };
+  }
+  return {
+    overallAPYStatus: "calculated",
+    overallAPY: apy,
+    overallAPYBigInt: r
+  };
+}
+export {
+  calculateTotalAPY
+};

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