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

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

@@ -0,0 +1,227 @@
+"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_max_leverage_factor = require("./calculate-max-leverage-factor.js");
+var import_calculate_max_strategy_debt = require("./calculate-max-strategy-debt.js");
+var import_get_recommended_debt = require("./get-recommended-debt.js");
+import_vitest.vi.mock("./calculate-max-strategy-debt");
+import_vitest.vi.mock(
+  "../../utils/strategies/leverage/calculate-max-leverage-factor.js",
+  async () => {
+    const actual = await import_vitest.vi.importActual(
+      "../../utils/strategies/leverage/calculate-max-leverage-factor.js"
+    );
+    return {
+      ...actual,
+      calculateMaxLeverageFactor: import_vitest.vi.fn(
+        actual.calculateMaxLeverageFactor
+      )
+    };
+  }
+);
+const mockCalculateMaxStrategyDebt = import_vitest.vi.mocked(import_calculate_max_strategy_debt.calculateMaxStrategyDebt);
+const mockCalculateMaxLeverageFactor = import_vitest.vi.mocked(import_calculate_max_leverage_factor.calculateMaxLeverageFactor);
+(0, import_vitest.describe)("getRecommendedDebt", () => {
+  const mockCreditManager = (0, import_test_utils.buildCreditManager)({});
+  (0, import_vitest.beforeEach)(() => {
+    mockCalculateMaxStrategyDebt.mockReset();
+    mockCalculateMaxLeverageFactor.mockReset();
+  });
+  (0, import_vitest.it)("returns zero max debt with recommended factor when maxDebt is zero", () => {
+    const maxDebt = 0n;
+    mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(300n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 1000n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      maxDebtConstantLoss: 30n,
+      swapCollateral: true,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      amount: 1000n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 100,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 210n,
+        debt: maxDebt
+      }
+    });
+  });
+  (0, import_vitest.it)("returns zero max debt with recommended factor when amount is zero", () => {
+    const maxDebt = 500n;
+    mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(300n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      maxDebtConstantLoss: 30n,
+      swapCollateral: true,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 100,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 210n,
+        debt: maxDebt
+      }
+    });
+  });
+  (0, import_vitest.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 * import_math.LEVERAGE_DECIMALS);
+    mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
+    mockCalculateMaxLeverageFactor.mockReturnValue(450n);
+    const result = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      maxDebtConstantLoss: 75n,
+      swapCollateral: false,
+      leverageLimit
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      constantLoss: 75n,
+      swapCollateral: false
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 50,
+      constantLoss: 3400n,
+      swapCollateral: false
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 50,
+      leverageLimit
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: recommendedMaxDebt * import_math.LEVERAGE_DECIMALS / amount,
+        debt: recommendedMaxDebt
+      }
+    });
+  });
+  (0, import_vitest.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 = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      maxLeverageConstantLoss,
+      maxDebtConstantLoss,
+      recommendedDebtConstantLoss,
+      swapCollateral: true,
+      leverageLimit: 123
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      constantLoss: maxDebtConstantLoss,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
+      targetToken: import_test_utils.mockToken1,
+      creditManagers: [mockCreditManager],
+      slippage: 25,
+      leverageLimit: 123,
+      constantLoss: maxLeverageConstantLoss
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 25,
+      constantLoss: recommendedDebtConstantLoss,
+      swapCollateral: true
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      maxDebt,
+      recommended: {
+        factor: 200n,
+        debt: recommendedMaxDebt
+      }
+    });
+  });
+  (0, import_vitest.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 = (0, import_get_recommended_debt.getRecommendedDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 15,
+      maxDebtConstantLoss: 60n,
+      maxLeverageConstantLoss: 70n,
+      recommendedDebtConstantLoss,
+      swapCollateral: false,
+      leverageLimit: void 0
+    });
+    (0, import_vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 15,
+      constantLoss: recommendedDebtConstantLoss,
+      swapCollateral: false
+    });
+    (0, import_vitest.expect)(result.recommended.debt).toBe(recommendedMaxDebt);
+    (0, import_vitest.expect)(result.recommended.factor).toBe(300n);
+  });
+});

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

@@ -0,0 +1,33 @@
+"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 get_recommended_leverage_factor_exports = {};
+__export(get_recommended_leverage_factor_exports, {
+  getRecommendedLeverageFactor: () => getRecommendedLeverageFactor
+});
+module.exports = __toCommonJS(get_recommended_leverage_factor_exports);
+function getRecommendedLeverageFactor({
+  maxLeverageFactor
+}) {
+  const l = BigInt(Math.floor(Number(maxLeverageFactor) * 0.7 / 10)) * 10n;
+  return l;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRecommendedLeverageFactor
+});

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

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

package/dist/cjs/common-utils/utils/strategies/leverage/index.js

@@ -17,16 +17,24 @@ var leverage_exports = {};
 module.exports = __toCommonJS(leverage_exports);
 __reExport(leverage_exports, require("./calculate-loss-coefficient.js"), module.exports);
 __reExport(leverage_exports, require("./calculate-max-leverage-factor.js"), module.exports);
+__reExport(leverage_exports, require("./calculate-max-strategy-debt.js"), module.exports);
+__reExport(leverage_exports, require("./get-collateral-by-debt.js"), module.exports);
 __reExport(leverage_exports, require("./get-factor-from-leverage.js"), module.exports);
 __reExport(leverage_exports, require("./get-leverage-from-factor.js"), module.exports);
+__reExport(leverage_exports, require("./get-recommended-debt.js"), module.exports);
+__reExport(leverage_exports, require("./get-recommended-leverage-factor.js"), module.exports);
 __reExport(leverage_exports, require("./max-leverage.js"), module.exports);
 __reExport(leverage_exports, require("./max-leverage-threshold.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./calculate-loss-coefficient.js"),
   ...require("./calculate-max-leverage-factor.js"),
+  ...require("./calculate-max-strategy-debt.js"),
+  ...require("./get-collateral-by-debt.js"),
   ...require("./get-factor-from-leverage.js"),
   ...require("./get-leverage-from-factor.js"),
+  ...require("./get-recommended-debt.js"),
+  ...require("./get-recommended-leverage-factor.js"),
   ...require("./max-leverage.js"),
   ...require("./max-leverage-threshold.js")
 });

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

@@ -26,8 +26,8 @@ var import_get_factor_from_leverage = require("./get-factor-from-leverage.js");
 var import_max_leverage_threshold = require("./max-leverage-threshold.js");
 function maxLeverage(lpToken, cms, targetHF = import_sdk.PERCENTAGE_FACTOR) {
   const [maxThreshold] = (0, import_max_leverage_threshold.maxLeverageThreshold)(lpToken, cms);
-  const maxLeverageValue = targetHF * import_sdk.LEVERAGE_DECIMALS / (targetHF - maxThreshold);
-  return (0, import_get_factor_from_leverage.getFactorFromLeverage)(maxLeverageValue);
+  const maxLeverage2 = targetHF * import_sdk.LEVERAGE_DECIMALS / (targetHF - maxThreshold);
+  return (0, import_get_factor_from_leverage.getFactorFromLeverage)(maxLeverage2);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -0,0 +1,112 @@
+"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_apy_exports = {};
+__export(calculate_total_apy_exports, {
+  calculateTotalAPY: () => calculateTotalAPY
+});
+module.exports = __toCommonJS(calculate_total_apy_exports);
+var import_math = require("../../../../sdk/constants/math.js");
+var import_constants = require("../../constants.js");
+var import_calc_overall_apy = require("../../creditAccount/calc-overall-apy.js");
+var import_is_apy_with_points_exception = require("../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 || import_constants.EMPTY_ADDRESS] || 0) > 0;
+  const pointsWithoutAPY = pointsInfo?.address && !pointsWithAPY;
+  if (pointsWithoutAPY && !(0, import_is_apy_with_points_exception.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 = (0, import_calc_overall_apy.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(import_math.PERCENTAGE_FACTOR);
+  if (pointsWithAPY && !(0, import_is_apy_with_points_exception.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateTotalAPY
+});

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