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

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

@@ -0,0 +1,61 @@
+import { LEVERAGE_DECIMALS } from "../../../../sdk/constants/math.js";
+import { calculateMaxLeverageFactor } from "./calculate-max-leverage-factor.js";
+import { calculateMaxStrategyDebt } from "./calculate-max-strategy-debt.js";
+import { getRecommendedLeverageFactor } from "./get-recommended-leverage-factor.js";
+function getRecommendedDebt({
+  targetToken,
+  amount,
+  creditManager,
+  slippage,
+  maxLeverageConstantLoss,
+  maxDebtConstantLoss,
+  recommendedDebtConstantLoss = 3400n,
+  swapCollateral,
+  leverageLimit
+}) {
+  const maxDebt = calculateMaxStrategyDebt({
+    targetToken,
+    amount,
+    creditManager,
+    slippage,
+    constantLoss: maxDebtConstantLoss,
+    swapCollateral
+  });
+  const recommendedLeverageFactor = getRecommendedLeverageFactor({
+    maxLeverageFactor: calculateMaxLeverageFactor({
+      targetToken,
+      creditManagers: [creditManager],
+      slippage,
+      leverageLimit,
+      constantLoss: maxLeverageConstantLoss
+    })
+  });
+  if (maxDebt === 0n || amount === 0n) {
+    return {
+      maxDebt,
+      recommended: {
+        factor: recommendedLeverageFactor,
+        debt: maxDebt
+      }
+    };
+  }
+  const recommendedMaxDebt = calculateMaxStrategyDebt({
+    targetToken,
+    amount,
+    creditManager,
+    slippage,
+    constantLoss: recommendedDebtConstantLoss,
+    swapCollateral
+  });
+  const leverageFactorOfMaxDebt = recommendedMaxDebt * LEVERAGE_DECIMALS / amount;
+  return {
+    maxDebt,
+    recommended: {
+      factor: leverageFactorOfMaxDebt,
+      debt: recommendedMaxDebt
+    }
+  };
+}
+export {
+  getRecommendedDebt
+};

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

@@ -0,0 +1,226 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { LEVERAGE_DECIMALS } from "../../../../sdk/constants/math.js";
+import { buildCreditManager, mockToken1 } from "../../../test-utils/index.js";
+import { calculateMaxLeverageFactor } from "./calculate-max-leverage-factor.js";
+import { calculateMaxStrategyDebt } from "./calculate-max-strategy-debt.js";
+import { getRecommendedDebt } from "./get-recommended-debt.js";
+vi.mock("./calculate-max-strategy-debt");
+vi.mock(
+  "../../utils/strategies/leverage/calculate-max-leverage-factor.js",
+  async () => {
+    const actual = await vi.importActual(
+      "../../utils/strategies/leverage/calculate-max-leverage-factor.js"
+    );
+    return {
+      ...actual,
+      calculateMaxLeverageFactor: vi.fn(
+        actual.calculateMaxLeverageFactor
+      )
+    };
+  }
+);
+const mockCalculateMaxStrategyDebt = vi.mocked(calculateMaxStrategyDebt);
+const mockCalculateMaxLeverageFactor = vi.mocked(calculateMaxLeverageFactor);
+describe("getRecommendedDebt", () => {
+  const mockCreditManager = buildCreditManager({});
+  beforeEach(() => {
+    mockCalculateMaxStrategyDebt.mockReset();
+    mockCalculateMaxLeverageFactor.mockReset();
+  });
+  it("returns zero max debt with recommended factor when maxDebt is zero", () => {
+    const maxDebt = 0n;
+    mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(300n);
+    const result = getRecommendedDebt({
+      targetToken: mockToken1,
+      amount: 1000n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      maxDebtConstantLoss: 30n,
+      swapCollateral: true,
+      leverageLimit: void 0
+    });
+    expect(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
+      targetToken: mockToken1,
+      amount: 1000n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n,
+      swapCollateral: true
+    });
+    expect(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 100,
+      leverageLimit: void 0
+    });
+    expect(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 210n,
+        debt: maxDebt
+      }
+    });
+  });
+  it("returns zero max debt with recommended factor when amount is zero", () => {
+    const maxDebt = 500n;
+    mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(300n);
+    const result = getRecommendedDebt({
+      targetToken: mockToken1,
+      amount: 0n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      maxDebtConstantLoss: 30n,
+      swapCollateral: true,
+      leverageLimit: void 0
+    });
+    expect(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
+      targetToken: mockToken1,
+      amount: 0n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n,
+      swapCollateral: true
+    });
+    expect(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 100,
+      leverageLimit: void 0
+    });
+    expect(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 210n,
+        debt: maxDebt
+      }
+    });
+  });
+  it("returns recommended debt using adjusted constant loss when amount and maxDebt are positive", () => {
+    const maxDebt = 5000n;
+    const recommendedMaxDebt = 3500n;
+    const amount = 1000n;
+    const leverageLimit = Number(4n * LEVERAGE_DECIMALS);
+    mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(450n);
+    const result = getRecommendedDebt({
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      maxDebtConstantLoss: 75n,
+      swapCollateral: false,
+      leverageLimit
+    });
+    expect(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      constantLoss: 75n,
+      swapCollateral: false
+    });
+    expect(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      constantLoss: 3400n,
+      swapCollateral: false
+    });
+    expect(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 50,
+      leverageLimit
+    });
+    expect(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: recommendedMaxDebt * LEVERAGE_DECIMALS / amount,
+        debt: recommendedMaxDebt
+      }
+    });
+  });
+  it("passes maxLeverageConstantLoss through to leverage calculation", () => {
+    const maxDebt = 2000n;
+    const recommendedMaxDebt = 1000n;
+    const amount = 500n;
+    const maxLeverageConstantLoss = 999n;
+    const maxDebtConstantLoss = 55n;
+    const recommendedDebtConstantLoss = 777n;
+    mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(420n);
+    const result = getRecommendedDebt({
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      maxLeverageConstantLoss,
+      maxDebtConstantLoss,
+      recommendedDebtConstantLoss,
+      swapCollateral: true,
+      leverageLimit: 123
+    });
+    expect(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      constantLoss: maxDebtConstantLoss,
+      swapCollateral: true
+    });
+    expect(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 25,
+      leverageLimit: 123,
+      constantLoss: maxLeverageConstantLoss
+    });
+    expect(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      constantLoss: recommendedDebtConstantLoss,
+      swapCollateral: true
+    });
+    expect(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 200n,
+        debt: recommendedMaxDebt
+      }
+    });
+  });
+  it("uses custom recommendedDebtConstantLoss when provided", () => {
+    const maxDebt = 10000n;
+    const recommendedMaxDebt = 6000n;
+    const amount = 2000n;
+    const recommendedDebtConstantLoss = 1234n;
+    mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(800n);
+    const result = getRecommendedDebt({
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 15,
+      maxDebtConstantLoss: 60n,
+      maxLeverageConstantLoss: 70n,
+      recommendedDebtConstantLoss,
+      swapCollateral: false,
+      leverageLimit: void 0
+    });
+    expect(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 15,
+      constantLoss: recommendedDebtConstantLoss,
+      swapCollateral: false
+    });
+    expect(result.recommended.debt).toBe(recommendedMaxDebt);
+    expect(result.recommended.factor).toBe(300n);
+  });
+});

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/index.js

@@ -1,6 +1,10 @@
 export * from "./calculate-loss-coefficient.js";
 export * from "./calculate-max-leverage-factor.js";
+export * from "./calculate-max-strategy-debt.js";
+export * from "./get-collateral-by-debt.js";
 export * from "./get-factor-from-leverage.js";
 export * from "./get-leverage-from-factor.js";
+export * from "./get-recommended-debt.js";
+export * from "./get-recommended-leverage-factor.js";
 export * from "./max-leverage.js";
 export * from "./max-leverage-threshold.js";

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