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

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

@@ -0,0 +1,42 @@
+import {
+  LEVERAGE_DECIMALS,
+  PERCENTAGE_FACTOR
+} from "../../../../sdk/constants/math.js";
+import { BigIntMath } from "../../bigint-math.js";
+import { calculateLossCoefficient } from "./calculate-loss-coefficient.js";
+import { maxLeverage } from "./max-leverage.js";
+const DEFAULT_DEBT_CONSTANT_LOSS = 1500n;
+function calculateMaxStrategyDebt({
+  targetToken,
+  amount,
+  creditManager,
+  slippage,
+  constantLoss = DEFAULT_DEBT_CONSTANT_LOSS,
+  swapCollateral = true
+}) {
+  const targetQuota = creditManager.quotas[targetToken];
+  const quotaLeft = swapCollateral && targetQuota ? BigIntMath.max(0n, targetQuota.limit - targetQuota.totalQuoted) : void 0;
+  if (quotaLeft === 0n) {
+    return creditManager.minDebt;
+  }
+  const availableLiquidity = quotaLeft !== void 0 ? BigIntMath.min(quotaLeft, creditManager.availableToBorrow) : creditManager.availableToBorrow;
+  const coefficient = calculateLossCoefficient(slippage, constantLoss);
+  const effectiveMaxDebt = BigIntMath.max(
+    BigIntMath.min(availableLiquidity, creditManager.maxDebt),
+    creditManager.minDebt
+  );
+  if (amount === 0n) {
+    return effectiveMaxDebt;
+  }
+  const maxPossibleLeverage = maxLeverage(targetToken, [creditManager]);
+  const debt = amount * BigInt(maxPossibleLeverage) / LEVERAGE_DECIMALS;
+  const effectiveDebt = debt * coefficient / PERCENTAGE_FACTOR;
+  const result = BigIntMath.max(
+    BigIntMath.min(effectiveDebt, effectiveMaxDebt),
+    creditManager.minDebt
+  );
+  return result;
+}
+export {
+  calculateMaxStrategyDebt
+};

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

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

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

@@ -0,0 +1,10 @@
+import { PERCENTAGE_FACTOR } from "../../../../sdk/constants/math.js";
+function getCollateralByDebt(debt, lt, targetHF = PERCENTAGE_FACTOR) {
+  if (lt === 0n) return 0n;
+  if (targetHF === lt) return 0n;
+  const a = debt * (targetHF - lt) / lt;
+  return a;
+}
+export {
+  getCollateralByDebt
+};

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

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

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