@gearbox-protocol/sdk 16.0.0-next.9 → 16.1.0

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

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

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

@@ -1,10 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_constants_math = require("../../../../onchain/constants/math.js");
-//#region src/common-utils/utils/strategies/leverage/get-collateral-by-debt.ts
-function getCollateralByDebt(debt, lt, targetHF = require_onchain_constants_math.PERCENTAGE_FACTOR) {
-	if (lt === 0n) return 0n;
-	if (targetHF === lt) return 0n;
-	return debt * (targetHF - lt) / lt;
-}
-//#endregion
-exports.getCollateralByDebt = getCollateralByDebt;

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

@@ -1,30 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_constants_math = require("../../../../onchain/constants/math.js");
-const require_onchain_utils_formatter = require("../../../../onchain/utils/formatter.js");
-const require_common_utils_utils_strategies_leverage_get_collateral_by_debt = require("./get-collateral-by-debt.js");
-let vitest = require("vitest");
-//#region src/common-utils/utils/strategies/leverage/get-collateral-by-debt.spec.ts
-(0, vitest.describe)("getCollateralByDebt", () => {
-	(0, vitest.it)("returns full debt when target HF equals 1 and LT is 0.5", () => {
-		const debt = 1000000n;
-		const lt = require_onchain_utils_formatter.toBN("0.5", 4);
-		const result = require_common_utils_utils_strategies_leverage_get_collateral_by_debt.getCollateralByDebt(debt, lt);
-		(0, vitest.expect)(result).toBe(debt);
-	});
-	(0, vitest.it)("returns 0 when lt = hf", () => {
-		const result = require_common_utils_utils_strategies_leverage_get_collateral_by_debt.getCollateralByDebt(1000000n, require_onchain_constants_math.PERCENTAGE_FACTOR);
-		(0, vitest.expect)(result).toBe(0n);
-	});
-	(0, vitest.it)("returns when lt = 0", () => {
-		const result = require_common_utils_utils_strategies_leverage_get_collateral_by_debt.getCollateralByDebt(1000000n, 0n);
-		(0, vitest.expect)(result).toBe(0n);
-	});
-	(0, vitest.it)("handles fractional LT and target HF values", () => {
-		const debt = 35n * require_onchain_constants_math.WAD / 2n;
-		const lt = require_onchain_utils_formatter.toBN("0.93", 4);
-		const targetHF = require_onchain_utils_formatter.toBN("1.035", 4);
-		const result = require_common_utils_utils_strategies_leverage_get_collateral_by_debt.getCollateralByDebt(debt, lt, targetHF);
-		(0, vitest.expect)(result).toBe(1975806451612903225n);
-	});
-});
-//#endregion

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

@@ -1,9 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_constants_math = require("../../../../onchain/constants/math.js");
-require("../../../../onchain/index.js");
-//#region src/common-utils/utils/strategies/leverage/get-factor-from-leverage.ts
-function getFactorFromLeverage(leverage) {
-	return leverage - require_onchain_constants_math.LEVERAGE_DECIMALS;
-}
-//#endregion
-exports.getFactorFromLeverage = getFactorFromLeverage;

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

@@ -1,9 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_constants_math = require("../../../../onchain/constants/math.js");
-require("../../../../onchain/index.js");
-//#region src/common-utils/utils/strategies/leverage/get-leverage-from-factor.ts
-function getLeverageFromFactor(factor) {
-	return factor + require_onchain_constants_math.LEVERAGE_DECIMALS;
-}
-//#endregion
-exports.getLeverageFromFactor = getLeverageFromFactor;

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

@@ -1,47 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_constants_math = require("../../../../onchain/constants/math.js");
-const require_common_utils_utils_strategies_leverage_calculate_max_leverage_factor = require("./calculate-max-leverage-factor.js");
-const require_common_utils_utils_strategies_leverage_calculate_max_strategy_debt = require("./calculate-max-strategy-debt.js");
-const require_common_utils_utils_strategies_leverage_get_recommended_leverage_factor = require("./get-recommended-leverage-factor.js");
-//#region src/common-utils/utils/strategies/leverage/get-recommended-debt.ts
-function getRecommendedDebt({ targetToken, amount, creditManager, slippage, maxLeverageConstantLoss, maxDebtConstantLoss, recommendedDebtConstantLoss = 3400n, swapCollateral, leverageLimit }) {
-	const maxDebt = require_common_utils_utils_strategies_leverage_calculate_max_strategy_debt.calculateMaxStrategyDebt({
-		targetToken,
-		amount,
-		creditManager,
-		slippage,
-		constantLoss: maxDebtConstantLoss,
-		swapCollateral
-	});
-	const recommendedLeverageFactor = require_common_utils_utils_strategies_leverage_get_recommended_leverage_factor.getRecommendedLeverageFactor({ maxLeverageFactor: require_common_utils_utils_strategies_leverage_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 = require_common_utils_utils_strategies_leverage_calculate_max_strategy_debt.calculateMaxStrategyDebt({
-		targetToken,
-		amount,
-		creditManager,
-		slippage,
-		constantLoss: recommendedDebtConstantLoss,
-		swapCollateral
-	});
-	return {
-		maxDebt,
-		recommended: {
-			factor: recommendedMaxDebt * require_onchain_constants_math.LEVERAGE_DECIMALS / amount,
-			debt: recommendedMaxDebt
-		}
-	};
-}
-//#endregion
-exports.getRecommendedDebt = getRecommendedDebt;

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

@@ -1,222 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_constants_math = require("../../../../onchain/constants/math.js");
-const require_common_utils_utils_strategies_leverage_calculate_max_leverage_factor = require("./calculate-max-leverage-factor.js");
-const require_common_utils_utils_strategies_leverage_calculate_max_strategy_debt = require("./calculate-max-strategy-debt.js");
-const require_common_utils_utils_strategies_leverage_get_recommended_debt = require("./get-recommended-debt.js");
-const require_common_utils_test_utils_index = require("../../../test-utils/index.js");
-let vitest = require("vitest");
-//#region src/common-utils/utils/strategies/leverage/get-recommended-debt.spec.ts
-vitest.vi.mock("./calculate-max-strategy-debt");
-vitest.vi.mock("../../utils/strategies/leverage/calculate-max-leverage-factor.js", async () => {
-	const actual = await vitest.vi.importActual("../../utils/strategies/leverage/calculate-max-leverage-factor.js");
-	return {
-		...actual,
-		calculateMaxLeverageFactor: vitest.vi.fn(actual.calculateMaxLeverageFactor)
-	};
-});
-const mockCalculateMaxStrategyDebt = vitest.vi.mocked(require_common_utils_utils_strategies_leverage_calculate_max_strategy_debt.calculateMaxStrategyDebt);
-const mockCalculateMaxLeverageFactor = vitest.vi.mocked(require_common_utils_utils_strategies_leverage_calculate_max_leverage_factor.calculateMaxLeverageFactor);
-(0, vitest.describe)("getRecommendedDebt", () => {
-	const mockCreditManager = require_common_utils_test_utils_index.buildCreditManager({});
-	(0, vitest.beforeEach)(() => {
-		mockCalculateMaxStrategyDebt.mockReset();
-		mockCalculateMaxLeverageFactor.mockReset();
-	});
-	(0, vitest.it)("returns zero max debt with recommended factor when maxDebt is zero", () => {
-		const maxDebt = 0n;
-		mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
-		mockCalculateMaxLeverageFactor.mockReturnValue(300n);
-		const result = require_common_utils_utils_strategies_leverage_get_recommended_debt.getRecommendedDebt({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount: 1000n,
-			creditManager: mockCreditManager,
-			slippage: 100,
-			maxDebtConstantLoss: 30n,
-			swapCollateral: true,
-			leverageLimit: void 0
-		});
-		(0, vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount: 1000n,
-			creditManager: mockCreditManager,
-			slippage: 100,
-			constantLoss: 30n,
-			swapCollateral: true
-		});
-		(0, vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			creditManagers: [mockCreditManager],
-			slippage: 100,
-			leverageLimit: void 0
-		});
-		(0, vitest.expect)(result).toEqual({
-			maxDebt,
-			recommended: {
-				factor: 210n,
-				debt: maxDebt
-			}
-		});
-	});
-	(0, vitest.it)("returns zero max debt with recommended factor when amount is zero", () => {
-		const maxDebt = 500n;
-		mockCalculateMaxStrategyDebt.mockReturnValue(maxDebt);
-		mockCalculateMaxLeverageFactor.mockReturnValue(300n);
-		const result = require_common_utils_utils_strategies_leverage_get_recommended_debt.getRecommendedDebt({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount: 0n,
-			creditManager: mockCreditManager,
-			slippage: 100,
-			maxDebtConstantLoss: 30n,
-			swapCollateral: true,
-			leverageLimit: void 0
-		});
-		(0, vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenCalledWith({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount: 0n,
-			creditManager: mockCreditManager,
-			slippage: 100,
-			constantLoss: 30n,
-			swapCollateral: true
-		});
-		(0, vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			creditManagers: [mockCreditManager],
-			slippage: 100,
-			leverageLimit: void 0
-		});
-		(0, vitest.expect)(result).toEqual({
-			maxDebt,
-			recommended: {
-				factor: 210n,
-				debt: maxDebt
-			}
-		});
-	});
-	(0, 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 * require_onchain_constants_math.LEVERAGE_DECIMALS);
-		mockCalculateMaxStrategyDebt.mockReturnValueOnce(maxDebt).mockReturnValueOnce(recommendedMaxDebt);
-		mockCalculateMaxLeverageFactor.mockReturnValue(450n);
-		const result = require_common_utils_utils_strategies_leverage_get_recommended_debt.getRecommendedDebt({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 50,
-			maxDebtConstantLoss: 75n,
-			swapCollateral: false,
-			leverageLimit
-		});
-		(0, vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 50,
-			constantLoss: 75n,
-			swapCollateral: false
-		});
-		(0, vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 50,
-			constantLoss: 3400n,
-			swapCollateral: false
-		});
-		(0, vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			creditManagers: [mockCreditManager],
-			slippage: 50,
-			leverageLimit
-		});
-		(0, vitest.expect)(result).toEqual({
-			maxDebt,
-			recommended: {
-				factor: recommendedMaxDebt * require_onchain_constants_math.LEVERAGE_DECIMALS / amount,
-				debt: recommendedMaxDebt
-			}
-		});
-	});
-	(0, 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 = require_common_utils_utils_strategies_leverage_get_recommended_debt.getRecommendedDebt({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 25,
-			maxLeverageConstantLoss,
-			maxDebtConstantLoss,
-			recommendedDebtConstantLoss,
-			swapCollateral: true,
-			leverageLimit: 123
-		});
-		(0, vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(1, {
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 25,
-			constantLoss: maxDebtConstantLoss,
-			swapCollateral: true
-		});
-		(0, vitest.expect)(mockCalculateMaxLeverageFactor).toHaveBeenCalledWith({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			creditManagers: [mockCreditManager],
-			slippage: 25,
-			leverageLimit: 123,
-			constantLoss: maxLeverageConstantLoss
-		});
-		(0, vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 25,
-			constantLoss: recommendedDebtConstantLoss,
-			swapCollateral: true
-		});
-		(0, vitest.expect)(result).toEqual({
-			maxDebt,
-			recommended: {
-				factor: 200n,
-				debt: recommendedMaxDebt
-			}
-		});
-	});
-	(0, 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 = require_common_utils_utils_strategies_leverage_get_recommended_debt.getRecommendedDebt({
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 15,
-			maxDebtConstantLoss: 60n,
-			maxLeverageConstantLoss: 70n,
-			recommendedDebtConstantLoss,
-			swapCollateral: false,
-			leverageLimit: void 0
-		});
-		(0, vitest.expect)(mockCalculateMaxStrategyDebt).toHaveBeenNthCalledWith(2, {
-			targetToken: require_common_utils_test_utils_index.mockToken1,
-			amount,
-			creditManager: mockCreditManager,
-			slippage: 15,
-			constantLoss: recommendedDebtConstantLoss,
-			swapCollateral: false
-		});
-		(0, vitest.expect)(result.recommended.debt).toBe(recommendedMaxDebt);
-		(0, vitest.expect)(result.recommended.factor).toBe(300n);
-	});
-});
-//#endregion

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

@@ -1,7 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.ts
-function getRecommendedLeverageFactor({ maxLeverageFactor }) {
-	return BigInt(Math.floor(Number(maxLeverageFactor) * .7 / 10)) * 10n;
-}
-//#endregion
-exports.getRecommendedLeverageFactor = getRecommendedLeverageFactor;

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

@@ -1,19 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_common_utils_utils_strategies_leverage_get_recommended_leverage_factor = require("./get-recommended-leverage-factor.js");
-let vitest = require("vitest");
-//#region src/common-utils/utils/strategies/leverage/get-recommended-leverage-factor.spec.ts
-(0, vitest.describe)("getRecommendedLeverageFactor", () => {
-	(0, vitest.it)("returns zero when max factor is zero", () => {
-		const factor = require_common_utils_utils_strategies_leverage_get_recommended_leverage_factor.getRecommendedLeverageFactor({ maxLeverageFactor: 0n });
-		(0, vitest.expect)(factor).toBe(0n);
-	});
-	(0, vitest.it)("returns 70% of max rounded down to tens", () => {
-		const factor = require_common_utils_utils_strategies_leverage_get_recommended_leverage_factor.getRecommendedLeverageFactor({ maxLeverageFactor: 550n });
-		(0, vitest.expect)(factor).toBe(380n);
-	});
-	(0, vitest.it)("rounds down fractional 70% results to nearest ten", () => {
-		const factor = require_common_utils_utils_strategies_leverage_get_recommended_leverage_factor.getRecommendedLeverageFactor({ maxLeverageFactor: 503n });
-		(0, vitest.expect)(factor).toBe(350n);
-	});
-});
-//#endregion