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

package/dist/cjs/common-utils/utils/strategies/leverage/calculate-max-strategy-debt.spec.js

@@ -0,0 +1,330 @@
+"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_loss_coefficient = require("./calculate-loss-coefficient.js");
+var import_calculate_max_strategy_debt = require("./calculate-max-strategy-debt.js");
+var import_max_leverage = require("./max-leverage.js");
+import_vitest.vi.mock("./max-leverage");
+import_vitest.vi.mock(
+  "../../utils/strategies/leverage/calculate-loss-coefficient.js",
+  async () => {
+    const actual = await import_vitest.vi.importActual(
+      "../../utils/strategies/leverage/calculate-loss-coefficient.js"
+    );
+    return {
+      ...actual,
+      calculateLossCoefficient: import_vitest.vi.fn(
+        actual.calculateLossCoefficient
+      )
+    };
+  }
+);
+const mockMaxLeverage = import_vitest.vi.mocked(import_max_leverage.maxLeverage);
+const mockCalculateLossCoefficient = import_vitest.vi.mocked(import_calculate_loss_coefficient.calculateLossCoefficient);
+(0, import_vitest.describe)("calculateMaxStrategyDebt", () => {
+  const mockCreditManager = (0, import_test_utils.buildCreditManager)({});
+  (0, import_vitest.beforeEach)(() => {
+    mockMaxLeverage.mockReturnValue(
+      10n * import_math.LEVERAGE_DECIMALS
+    );
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.it)("should return effectiveMaxDebt when amount is zero without calling maxLeverage", () => {
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(mockMaxLeverage).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(result).toEqual(900000n);
+  });
+  (0, import_vitest.it)("should calculate max debt correctly with mocked maxLeverage", () => {
+    const maxLeverageValue = 5n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const targetToken = import_test_utils.mockToken1;
+    const amount = 10000n;
+    const slippage = 100;
+    const constantLoss = 30n;
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage,
+      constantLoss
+    });
+    (0, import_vitest.expect)(mockMaxLeverage).toHaveBeenCalledWith(targetToken, [
+      mockCreditManager
+    ]);
+    (0, import_vitest.expect)(mockMaxLeverage).toHaveBeenCalledTimes(1);
+    (0, import_vitest.expect)(result).toEqual(49350n);
+  });
+  (0, import_vitest.it)("should handle case where effectiveDebt exceeds effectiveMaxDebt", () => {
+    const veryHighLeverage = 100n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(veryHighLeverage);
+    const amount = 100000000000000000000000n;
+    const creditManager = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow: 1000n
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(creditManager.availableToBorrow);
+  });
+  (0, import_vitest.it)("should ensure result is at least minDebt", () => {
+    mockMaxLeverage.mockReturnValue(1n);
+    const amount = 10000n;
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(mockCreditManager.minDebt);
+  });
+  (0, import_vitest.it)("should handle different slippage values correctly", () => {
+    const maxLeverageValue = 10n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const amount = 10000n;
+    const highSlippage = 500;
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: highSlippage,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(94700n);
+  });
+  (0, import_vitest.it)("should handle different constantLoss values correctly", () => {
+    const maxLeverageValue = 10n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const amount = 10000n;
+    const highConstantLoss = 500n;
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: mockCreditManager,
+      slippage: 100,
+      constantLoss: highConstantLoss
+    });
+    (0, import_vitest.expect)(result).toEqual(94000n);
+  });
+  (0, import_vitest.it)("should respect quota limit when quotaLeft is less than availableToBorrow", () => {
+    const maxLeverageValue = 10n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const quotaLimit = 50000n;
+    const totalQuoted = 40000n;
+    const amount = 10000n;
+    const availableToBorrow = 100000n;
+    const creditManagerWithQuota = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow,
+      quotas: {
+        ...mockCreditManager.quotas,
+        [import_test_utils.mockToken1]: {
+          ...mockCreditManager.quotas[import_test_utils.mockToken1],
+          limit: quotaLimit,
+          totalQuoted
+        }
+      }
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: creditManagerWithQuota,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(quotaLimit - totalQuoted);
+  });
+  (0, import_vitest.it)("should use availableToBorrow when quota does not exist for target token", () => {
+    const maxLeverageValue = 10n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const availableToBorrow = 75000n;
+    const tokenWithoutQuota = "0x9999999999999999999999999999999999999999";
+    const creditManagerWithoutQuota = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: tokenWithoutQuota,
+      amount: 10000n,
+      creditManager: creditManagerWithoutQuota,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(creditManagerWithoutQuota.availableToBorrow);
+  });
+  (0, import_vitest.it)("should respect quotaLeft", () => {
+    const maxLeverageValue = 10n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const quotaLimit = 50000n;
+    const totalQuoted = 10000n;
+    const amount = 20000n;
+    const availableToBorrow = 100000n;
+    const creditManagerWithQuota = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow,
+      quotas: {
+        ...mockCreditManager.quotas,
+        [import_test_utils.mockToken1]: {
+          ...mockCreditManager.quotas[import_test_utils.mockToken1],
+          limit: quotaLimit,
+          totalQuoted
+        }
+      }
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: creditManagerWithQuota,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(quotaLimit - totalQuoted);
+  });
+  (0, import_vitest.it)("returns minDebt when quotaLeft would be negative (clamped to 0)", () => {
+    const maxLeverageValue = 10n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const quotaLimit = 50000n;
+    const totalQuoted = 50001n;
+    const amount = 20000n;
+    const availableToBorrow = 100000n;
+    const creditManagerWithQuota = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow,
+      quotas: {
+        ...mockCreditManager.quotas,
+        [import_test_utils.mockToken1]: {
+          ...mockCreditManager.quotas[import_test_utils.mockToken1],
+          limit: quotaLimit,
+          totalQuoted
+        }
+      }
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: creditManagerWithQuota,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(mockCreditManager.minDebt);
+    (0, import_vitest.expect)(mockMaxLeverage).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("returns minDebt when quotaLimit is zero", () => {
+    const maxLeverageValue = 10n * import_math.LEVERAGE_DECIMALS;
+    mockMaxLeverage.mockReturnValue(maxLeverageValue);
+    const quotaLimit = 0n;
+    const totalQuoted = 30000n;
+    const amount = 20000n;
+    const availableToBorrow = 100000n;
+    const creditManagerWithQuota = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow,
+      quotas: {
+        ...mockCreditManager.quotas,
+        [import_test_utils.mockToken1]: {
+          ...mockCreditManager.quotas[import_test_utils.mockToken1],
+          limit: quotaLimit,
+          totalQuoted
+        }
+      }
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount,
+      creditManager: creditManagerWithQuota,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toEqual(mockCreditManager.minDebt);
+    (0, import_vitest.expect)(mockMaxLeverage).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("returns minDebt when effectiveMaxDebt is below minDebt", () => {
+    mockCalculateLossCoefficient.mockReturnValueOnce(import_math.PERCENTAGE_FACTOR);
+    const creditManager = (0, import_test_utils.buildCreditManager)({
+      minDebt: 500n,
+      availableToBorrow: 50n,
+      maxDebt: 200n
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager,
+      slippage: 0,
+      constantLoss: 0n
+    });
+    (0, import_vitest.expect)(result).toEqual(creditManager.minDebt);
+    (0, import_vitest.expect)(mockMaxLeverage).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("clamps leveraged result to minDebt when effective debt is smaller", () => {
+    mockCalculateLossCoefficient.mockReturnValueOnce(import_math.PERCENTAGE_FACTOR);
+    const creditManager = (0, import_test_utils.buildCreditManager)({
+      minDebt: 500n,
+      availableToBorrow: 2000n,
+      maxDebt: 2000n
+    });
+    mockMaxLeverage.mockReturnValue(1n);
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 100n,
+      creditManager,
+      slippage: 0,
+      constantLoss: 0n
+    });
+    (0, import_vitest.expect)(result).toEqual(creditManager.minDebt);
+    (0, import_vitest.expect)(mockMaxLeverage).toHaveBeenCalledTimes(1);
+  });
+  (0, import_vitest.it)("ignores quota when swapCollateral is false", () => {
+    const creditManagerWithQuota = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow: 100000n,
+      quotas: {
+        ...mockCreditManager.quotas,
+        [import_test_utils.mockToken1]: {
+          ...mockCreditManager.quotas[import_test_utils.mockToken1],
+          limit: 50000n,
+          totalQuoted: 40000n
+        }
+      }
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager: creditManagerWithQuota,
+      slippage: 100,
+      constantLoss: 30n,
+      swapCollateral: false
+    });
+    (0, import_vitest.expect)(result).toEqual(creditManagerWithQuota.availableToBorrow);
+    (0, import_vitest.expect)(mockMaxLeverage).not.toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("should respect quota limit when amount is zero", () => {
+    const quotaLimit = 50000n;
+    const totalQuoted = 20000n;
+    const availableToBorrow = 100000n;
+    const creditManagerWithQuota = (0, import_test_utils.buildCreditManager)({
+      availableToBorrow,
+      quotas: {
+        ...mockCreditManager.quotas,
+        [import_test_utils.mockToken1]: {
+          ...mockCreditManager.quotas[import_test_utils.mockToken1],
+          limit: quotaLimit,
+          totalQuoted
+        }
+      }
+    });
+    const result = (0, import_calculate_max_strategy_debt.calculateMaxStrategyDebt)({
+      targetToken: import_test_utils.mockToken1,
+      amount: 0n,
+      creditManager: creditManagerWithQuota,
+      slippage: 100,
+      constantLoss: 30n
+    });
+    (0, import_vitest.expect)(result).toBe(30000n);
+    (0, import_vitest.expect)(mockMaxLeverage).not.toHaveBeenCalled();
+  });
+});

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