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

package/dist/cjs/common-utils/utils/strategies/leverage/get-collateral-by-debt.js

@@ -0,0 +1,34 @@
+"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_collateral_by_debt_exports = {};
+__export(get_collateral_by_debt_exports, {
+  getCollateralByDebt: () => getCollateralByDebt
+});
+module.exports = __toCommonJS(get_collateral_by_debt_exports);
+var import_math = require("../../../../sdk/constants/math.js");
+function getCollateralByDebt(debt, lt, targetHF = import_math.PERCENTAGE_FACTOR) {
+  if (lt === 0n) return 0n;
+  if (targetHF === lt) return 0n;
+  const a = debt * (targetHF - lt) / lt;
+  return a;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCollateralByDebt
+});

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

@@ -0,0 +1,30 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_math = require("../../../../sdk/constants/math.js");
+var import_formatter = require("../../../../sdk/utils/formatter.js");
+var import_get_collateral_by_debt = require("./get-collateral-by-debt.js");
+(0, import_vitest.describe)("getCollateralByDebt", () => {
+  (0, import_vitest.it)("returns full debt when target HF equals 1 and LT is 0.5", () => {
+    const debt = 1000000n;
+    const lt = (0, import_formatter.toBN)("0.5", 4);
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, lt);
+    (0, import_vitest.expect)(result).toBe(debt);
+  });
+  (0, import_vitest.it)("returns 0 when lt = hf", () => {
+    const debt = 1000000n;
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, import_math.PERCENTAGE_FACTOR);
+    (0, import_vitest.expect)(result).toBe(0n);
+  });
+  (0, import_vitest.it)("returns when lt = 0", () => {
+    const debt = 1000000n;
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, 0n);
+    (0, import_vitest.expect)(result).toBe(0n);
+  });
+  (0, import_vitest.it)("handles fractional LT and target HF values", () => {
+    const debt = 35n * import_math.WAD / 2n;
+    const lt = (0, import_formatter.toBN)("0.93", 4);
+    const targetHF = (0, import_formatter.toBN)("1.035", 4);
+    const result = (0, import_get_collateral_by_debt.getCollateralByDebt)(debt, lt, targetHF);
+    (0, import_vitest.expect)(result).toBe(1975806451612903225n);
+  });
+});

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

@@ -0,0 +1,85 @@
+"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_debt_exports = {};
+__export(get_recommended_debt_exports, {
+  getRecommendedDebt: () => getRecommendedDebt
+});
+module.exports = __toCommonJS(get_recommended_debt_exports);
+var import_math = require("../../../../sdk/constants/math.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_leverage_factor = require("./get-recommended-leverage-factor.js");
+function getRecommendedDebt({
+  targetToken,
+  amount,
+  creditManager,
+  slippage,
+  maxLeverageConstantLoss,
+  maxDebtConstantLoss,
+  recommendedDebtConstantLoss = 3400n,
+  swapCollateral,
+  leverageLimit
+}) {
+  const maxDebt = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+    targetToken,
+    amount,
+    creditManager,
+    slippage,
+    constantLoss: maxDebtConstantLoss,
+    swapCollateral
+  });
+  const recommendedLeverageFactor = (0, import_get_recommended_leverage_factor.getRecommendedLeverageFactor)({
+    maxLeverageFactor: (0, import_calculate_max_leverage_factor.calculateMaxLeverageFactor)({
+      targetToken,
+      creditManagers: [creditManager],
+      slippage,
+      leverageLimit,
+      constantLoss: maxLeverageConstantLoss
+    })
+  });
+  if (maxDebt === 0n || amount === 0n) {
+    return {
+      maxDebt,
+      recommended: {
+        factor: recommendedLeverageFactor,
+        debt: maxDebt
+      }
+    };
+  }
+  const recommendedMaxDebt = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+    targetToken,
+    amount,
+    creditManager,
+    slippage,
+    constantLoss: recommendedDebtConstantLoss,
+    swapCollateral
+  });
+  const leverageFactorOfMaxDebt = recommendedMaxDebt * import_math.LEVERAGE_DECIMALS / amount;
+  return {
+    maxDebt,
+    recommended: {
+      factor: leverageFactorOfMaxDebt,
+      debt: recommendedMaxDebt
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRecommendedDebt
+});

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