@gearbox-protocol/sdk 16.0.0-next.21 → 16.0.0-next.22

package/dist/esm/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list.js

@@ -1,14 +0,0 @@
-import { createLegacyStrategyDataSource } from "../types/legacy-strategy-data-source.js";
-import "../types.js";
-import { getStrategyCreditManagersListCore } from "./get-strategy-credit-managers-list-core.js";
-//#region src/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers-list.ts
-function getStrategyCreditManagersList(strategies, sdkStateByChain, curatorFilter) {
-	if (!sdkStateByChain) return sdkStateByChain;
-	return getStrategyCreditManagersListCore({
-		strategies,
-		source: createLegacyStrategyDataSource(sdkStateByChain),
-		curatorFilter
-	});
-}
-//#endregion
-export { getStrategyCreditManagersList };

package/dist/esm/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers.js

@@ -1,22 +0,0 @@
-import { isUsableToken } from "../tokens/is-usable-token.js";
-import { isCreditManagerUsable } from "./is-credit-manager-usable.js";
-//#region src/common-utils/utils/strategies/credit-managers/get-strategy-credit-managers.ts
-const lc = (address) => address.toLowerCase();
-function getStrategyCreditManagers({ strategy, allCreditManagers }) {
-	const lpAddress = lc(strategy.tokenOutAddress);
-	return (strategy?.creditManagers || []).reduce((acc, cmAddress) => {
-		const cm = allCreditManagers[cmAddress] ?? allCreditManagers[lc(cmAddress)];
-		if (cm && isCreditManagerUsable(cm)) {
-			const usable = isUsableToken({
-				address: lpAddress,
-				creditManager: cm
-			});
-			const limit = cm.quotas[lpAddress]?.limit || 0n;
-			const limitZero = lpAddress === cm.underlyingToken ? false : limit === 0n;
-			if (usable && !cm.isBorrowingForbidden && !limitZero) acc[cm.address] = cm;
-		}
-		return acc;
-	}, {});
-}
-//#endregion
-export { getStrategyCreditManagers };

package/dist/esm/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.js

@@ -1,28 +0,0 @@
-import { sortBalances } from "../../creditAccount/sort.js";
-import { wrapTokenAddress } from "../tokens/wrap-token-address.js";
-//#region src/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.ts
-function getWalletBalancesAllowedOnCM({ walletBalances, collateralRecord, nativeTokenAddress, wrappedNativeTokenAddress, prices, tokensList, isPaused = false }) {
-	const { list, record } = sortBalances(walletBalances || {}, prices, tokensList).reduce((acc, [token, balance]) => {
-		if (isPaused && token === nativeTokenAddress) return acc;
-		const wrappedAddress = wrapTokenAddress(token, nativeTokenAddress, wrappedNativeTokenAddress);
-		if (collateralRecord[wrappedAddress]) {
-			const asset = {
-				token,
-				balance
-			};
-			acc.list.push(asset);
-			acc.record[wrappedAddress] = asset;
-		}
-		return acc;
-	}, {
-		list: [],
-		record: {}
-	});
-	const missingAssets = Object.values(collateralRecord).filter((token) => isPaused ? token !== nativeTokenAddress && !record[token] : !record[token]).map((token) => ({
-		token,
-		balance: 0n
-	}));
-	return [...list, ...missingAssets];
-}
-//#endregion
-export { getWalletBalancesAllowedOnCM };

package/dist/esm/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.spec.js

@@ -1,95 +0,0 @@
-import { TokenData } from "../../../charts/token-data.js";
-import { sortBalances } from "../../creditAccount/sort.js";
-import { getWalletBalancesAllowedOnCM } from "./get-wallet-balances-allowed-on-cm.js";
-import { mockNativeTokenAddress, mockToken1, mockWrappedNativeTokenAddress } from "../../../test-utils/index.js";
-import { afterEach, describe, expect, it, vi } from "vitest";
-//#region src/common-utils/utils/strategies/credit-managers/get-wallet-balances-allowed-on-cm.spec.ts
-vi.mock("../../utils/creditAccount/sort.js", async () => {
-	return {
-		...await vi.importActual("../../utils/creditAccount/sort.js"),
-		sortBalances: vi.fn()
-	};
-});
-const mockSortBalances = vi.mocked(sortBalances);
-describe("getWalletBalancesAllowedOnCM", () => {
-	const allowed = mockToken1;
-	const prices = {};
-	const tokensList = {
-		[mockNativeTokenAddress]: new TokenData({
-			addr: mockNativeTokenAddress,
-			symbol: "ETH",
-			name: "Native",
-			decimals: 18,
-			isPhantom: false
-		}),
-		[mockWrappedNativeTokenAddress]: new TokenData({
-			addr: mockWrappedNativeTokenAddress,
-			symbol: "WETH",
-			name: "Wrapped",
-			decimals: 18,
-			isPhantom: false
-		}),
-		[allowed]: new TokenData({
-			addr: allowed,
-			symbol: "DAI",
-			name: "Allowed",
-			decimals: 18,
-			isPhantom: false
-		})
-	};
-	afterEach(() => {
-		vi.restoreAllMocks();
-		vi.clearAllMocks();
-	});
-	it("wraps native token when allowed and keeps sorted balances", () => {
-		const collateralRecord = {
-			[mockWrappedNativeTokenAddress]: mockWrappedNativeTokenAddress,
-			[allowed]: allowed
-		};
-		mockSortBalances.mockReturnValue([[mockNativeTokenAddress, 2n], [allowed, 1n]]);
-		const result = getWalletBalancesAllowedOnCM({
-			walletBalances: {
-				[mockNativeTokenAddress]: 2n,
-				[allowed]: 1n
-			},
-			collateralRecord,
-			nativeTokenAddress: mockNativeTokenAddress,
-			wrappedNativeTokenAddress: mockWrappedNativeTokenAddress,
-			prices,
-			tokensList
-		});
-		expect(result).toEqual([{
-			token: mockNativeTokenAddress,
-			balance: 2n
-		}, {
-			token: allowed,
-			balance: 1n
-		}]);
-	});
-	it("skips native token when paused and fills missing collaterals with zero", () => {
-		const collateralRecord = {
-			[mockWrappedNativeTokenAddress]: mockWrappedNativeTokenAddress,
-			[allowed]: allowed,
-			[mockNativeTokenAddress]: mockNativeTokenAddress
-		};
-		mockSortBalances.mockReturnValue([[mockNativeTokenAddress, 5n]]);
-		const result = getWalletBalancesAllowedOnCM({
-			walletBalances: { [mockNativeTokenAddress]: 5n },
-			collateralRecord,
-			nativeTokenAddress: mockNativeTokenAddress,
-			wrappedNativeTokenAddress: mockWrappedNativeTokenAddress,
-			prices,
-			tokensList,
-			isPaused: true
-		});
-		expect(result).toEqual([{
-			token: mockWrappedNativeTokenAddress,
-			balance: 0n
-		}, {
-			token: allowed,
-			balance: 0n
-		}]);
-	});
-});
-//#endregion
-export {};

package/dist/esm/common-utils/utils/strategies/credit-managers/index.js

@@ -1,7 +0,0 @@
-import { getCMAllowedCollaterals } from "./get-cm-allowed-collaterals.js";
-import { isCreditManagerUsable } from "./is-credit-manager-usable.js";
-import { getStrategyCreditManagers } from "./get-strategy-credit-managers.js";
-import { getStrategyCreditManagersListCore } from "./get-strategy-credit-managers-list-core.js";
-import { getStrategyCreditManagersList } from "./get-strategy-credit-managers-list.js";
-import { getWalletBalancesAllowedOnCM } from "./get-wallet-balances-allowed-on-cm.js";
-export { getCMAllowedCollaterals, getStrategyCreditManagers, getStrategyCreditManagersList, getStrategyCreditManagersListCore, getWalletBalancesAllowedOnCM, isCreditManagerUsable };

package/dist/esm/common-utils/utils/strategies/credit-managers/is-credit-manager-usable.js

@@ -1,8 +0,0 @@
-import { isV310 } from "../../../../onchain/constants/versions.js";
-import "../../../../onchain/index.js";
-//#region src/common-utils/utils/strategies/credit-managers/is-credit-manager-usable.ts
-function isCreditManagerUsable(cm) {
-	return !cm.isBorrowingForbidden && isV310(cm.version);
-}
-//#endregion
-export { isCreditManagerUsable };

package/dist/esm/common-utils/utils/strategies/eligibility/index.js

@@ -1,3 +0,0 @@
-import { isStrategyEligible } from "./is-strategy-eligible.js";
-import { isStrategyReleased } from "./is-strategy-released.js";
-export { isStrategyEligible, isStrategyReleased };

package/dist/esm/common-utils/utils/strategies/eligibility/is-strategy-eligible.js

@@ -1,19 +0,0 @@
-//#region src/common-utils/utils/strategies/eligibility/is-strategy-eligible.ts
-const EMPTY_ADDRESS = "";
-function isStrategyEligible(s, allowedChains, showHiddenStrategies, sdkStateByChain, curatorFilter) {
-	const network = s?.chainId !== void 0 ? allowedChains[s.chainId] : void 0;
-	const isNetworkCorrect = !!network && network === s.network;
-	const isHidden = !showHiddenStrategies && s.hideInProd;
-	const networkConditionMet = isNetworkCorrect && !isHidden;
-	const isTokensCorrect = !!(sdkStateByChain?.[s.chainId]?.tokens?.tokenDataList)?.[s?.tokenOutAddress || EMPTY_ADDRESS];
-	const showInMainApp = s.showInMainApp ?? true;
-	return networkConditionMet && isTokensCorrect && (curatorFilter || showInMainApp) ? {
-		isEligible: true,
-		network
-	} : {
-		isEligible: false,
-		network: void 0
-	};
-}
-//#endregion
-export { isStrategyEligible };

package/dist/esm/common-utils/utils/strategies/eligibility/is-strategy-released.js

@@ -1,7 +0,0 @@
-//#region src/common-utils/utils/strategies/eligibility/is-strategy-released.ts
-function isStrategyReleased(releaseAt, currentTimestamp) {
-	if (releaseAt === void 0) return true;
-	return currentTimestamp > releaseAt;
-}
-//#endregion
-export { isStrategyReleased };

package/dist/esm/common-utils/utils/strategies/index.js

@@ -1,66 +0,0 @@
-import { calculateLossCoefficient } from "./leverage/calculate-loss-coefficient.js";
-import { getFactorFromLeverage } from "./leverage/get-factor-from-leverage.js";
-import { maxLeverageThreshold } from "./leverage/max-leverage-threshold.js";
-import { maxLeverage } from "./leverage/max-leverage.js";
-import { calculateMaxLeverageFactor } from "./leverage/calculate-max-leverage-factor.js";
-import { calculateMaxStrategyDebt } from "./leverage/calculate-max-strategy-debt.js";
-import { getCollateralByDebt } from "./leverage/get-collateral-by-debt.js";
-import { getLeverageFromFactor } from "./leverage/get-leverage-from-factor.js";
-import { getRecommendedLeverageFactor } from "./leverage/get-recommended-leverage-factor.js";
-import { getRecommendedDebt } from "./leverage/get-recommended-debt.js";
-import "./leverage/index.js";
-import { getDefaultAsset } from "./assets/assets.js";
-import "./assets/index.js";
-import { checkBoolean } from "./availability/check-boolean.js";
-import { checkDegenNFT } from "./availability/check-degen-nft.js";
-import "./availability/index.js";
-import { isActivatedToken } from "./tokens/is-activated-token.js";
-import { isForbiddenToken } from "./tokens/is-forbidden-token.js";
-import { isUsableToken } from "./tokens/is-usable-token.js";
-import { isObtainableToken } from "./tokens/is-obtainable-token.js";
-import { isValidExtraCollateralToken } from "./tokens/is-valid-extra-collateral-token.js";
-import { isCollateralToken } from "./tokens/is-collateral-token.js";
-import { getCMAllowedCollaterals } from "./credit-managers/get-cm-allowed-collaterals.js";
-import { isCreditManagerUsable } from "./credit-managers/is-credit-manager-usable.js";
-import { getStrategyCreditManagers } from "./credit-managers/get-strategy-credit-managers.js";
-import { createLegacyStrategyDataSource } from "./types/legacy-strategy-data-source.js";
-import "./types.js";
-import { addAmountInTarget } from "./tokens/add-amount-in-target.js";
-import { getChainPhantomTokens } from "./tokens/get-chain-phantom-tokens.js";
-import { getListWithAmountInTarget } from "./tokens/get-list-with-amount-in-target.js";
-import { getNativeTokenAddress } from "./tokens/get-native-token-address.js";
-import { RST_ETH_ADDRESS, isApyWithPointsException } from "./tokens/is-apy-with-points-exception.js";
-import { wrapTokenAddress } from "./tokens/wrap-token-address.js";
-import "./tokens/index.js";
-import { getStrategyCreditManagersListCore } from "./credit-managers/get-strategy-credit-managers-list-core.js";
-import { getStrategyCreditManagersList } from "./credit-managers/get-strategy-credit-managers-list.js";
-import { getWalletBalancesAllowedOnCM } from "./credit-managers/get-wallet-balances-allowed-on-cm.js";
-import "./credit-managers/index.js";
-import { isStrategyEligible } from "./eligibility/is-strategy-eligible.js";
-import { isStrategyReleased } from "./eligibility/is-strategy-released.js";
-import "./eligibility/index.js";
-import { isStrategyCMDisabled } from "./strategy-info/is-strategy-cm-disabled.js";
-import { isStrategyDisabled } from "./strategy-state/is-strategy-disabled.js";
-import { getAvailableAndDisabledStrategies } from "./lists/get-available-and-disabled-strategies.js";
-import { getReleasedStrategiesListCore } from "./lists/get-released-strategies-list-core.js";
-import { getReleasedStrategiesList } from "./lists/get-released-strategies-list.js";
-import "./lists/index.js";
-import { getComplexPointsList } from "./points/get-complex-points-list.js";
-import { getPointsInfo } from "./points/get-points-info.js";
-import { getPointsRates } from "./points/get-points-rates.js";
-import { getStrategyPoints } from "./points/get-strategy-points.js";
-import "./points/index.js";
-import { checkCreditManagerUsable, checkOpenAccountCeilings } from "./strategy-info/credit-manager-issues.js";
-import { cmAvailabilityCondition } from "./strategy-info/cm-availability-condition.js";
-import { getStrategyMaxAPY } from "./strategy-info/get-strategy-max-apy.js";
-import { sortStrategyCMsByAvailability } from "./sort-strategy-cms-by-availability/sort-strategy-cms-by-availability.js";
-import "./sort-strategy-cms-by-availability/index.js";
-import { calculateTotalAPY } from "./strategy-info/calculate-total-apy.js";
-import { calculateTotalPoints } from "./strategy-info/calculate-total-points.js";
-import { getCMYouCanEarn } from "./strategy-info/get-cm-you-can-earn.js";
-import { getStrategyInfoCore } from "./strategy-info/get-strategy-info-core.js";
-import { getStrategyInfo } from "./strategy-info/get-strategy-info.js";
-import { getStrategyYouCanEarn } from "./strategy-info/get-strategy-you-can-earn.js";
-import "./strategy-info/index.js";
-import "./strategy-state/index.js";
-export { RST_ETH_ADDRESS, addAmountInTarget, calculateLossCoefficient, calculateMaxLeverageFactor, calculateMaxStrategyDebt, calculateTotalAPY, calculateTotalPoints, checkBoolean, checkCreditManagerUsable, checkDegenNFT, checkOpenAccountCeilings, cmAvailabilityCondition, createLegacyStrategyDataSource, getAvailableAndDisabledStrategies, getCMAllowedCollaterals, getCMYouCanEarn, getChainPhantomTokens, getCollateralByDebt, getComplexPointsList, getDefaultAsset, getFactorFromLeverage, getLeverageFromFactor, getListWithAmountInTarget, getNativeTokenAddress, getPointsInfo, getPointsRates, getRecommendedDebt, getRecommendedLeverageFactor, getReleasedStrategiesList, getReleasedStrategiesListCore, getStrategyCreditManagers, getStrategyCreditManagersList, getStrategyCreditManagersListCore, getStrategyInfo, getStrategyInfoCore, getStrategyMaxAPY, getStrategyPoints, getStrategyYouCanEarn, getWalletBalancesAllowedOnCM, isActivatedToken, isApyWithPointsException, isCollateralToken, isCreditManagerUsable, isForbiddenToken, isObtainableToken, isStrategyCMDisabled, isStrategyDisabled, isStrategyEligible, isStrategyReleased, isUsableToken, isValidExtraCollateralToken, maxLeverage, maxLeverageThreshold, sortStrategyCMsByAvailability, wrapTokenAddress };

package/dist/esm/common-utils/utils/strategies/leverage/calculate-loss-coefficient.js

@@ -1,9 +0,0 @@
-import { SLIPPAGE_DECIMALS } from "../../../../onchain/constants/math.js";
-import { toBigInt } from "../../../../onchain/utils/formatter.js";
-import "../../../../onchain/index.js";
-//#region src/common-utils/utils/strategies/leverage/calculate-loss-coefficient.ts
-function calculateLossCoefficient(slippage, constantLoss = 30n) {
-	return 100n * SLIPPAGE_DECIMALS - toBigInt(slippage) - constantLoss;
-}
-//#endregion
-export { calculateLossCoefficient };

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

@@ -1,15 +0,0 @@
-import { BigIntMath } from "../../../../onchain/utils/bigint-math.js";
-import { PERCENTAGE_FACTOR } from "../../../../onchain/constants/math.js";
-import "../../../../onchain/index.js";
-import { calculateLossCoefficient } from "./calculate-loss-coefficient.js";
-import { maxLeverage } from "./max-leverage.js";
-//#region src/common-utils/utils/strategies/leverage/calculate-max-leverage-factor.ts
-const DEFAULT_LEVERAGE_CONSTANT_LOSS = 500n;
-function calculateMaxLeverageFactor({ targetToken, slippage, creditManagers, constantLoss = DEFAULT_LEVERAGE_CONSTANT_LOSS, leverageLimit }) {
-	const maxPossibleLeverage = maxLeverage(targetToken, creditManagers);
-	const coefficient = calculateLossCoefficient(slippage, constantLoss);
-	const maxLeverageValue = BigInt(maxPossibleLeverage) * coefficient / PERCENTAGE_FACTOR;
-	return leverageLimit !== void 0 ? BigIntMath.min(BigInt(leverageLimit), maxLeverageValue) : maxLeverageValue;
-}
-//#endregion
-export { calculateMaxLeverageFactor };

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

@@ -1,20 +0,0 @@
-import { BigIntMath } from "../../../../onchain/utils/bigint-math.js";
-import { LEVERAGE_DECIMALS, PERCENTAGE_FACTOR } from "../../../../onchain/constants/math.js";
-import { calculateLossCoefficient } from "./calculate-loss-coefficient.js";
-import { maxLeverage } from "./max-leverage.js";
-//#region src/common-utils/utils/strategies/leverage/calculate-max-strategy-debt.ts
-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 effectiveDebt = amount * BigInt(maxPossibleLeverage) / LEVERAGE_DECIMALS * coefficient / PERCENTAGE_FACTOR;
-	return BigIntMath.max(BigIntMath.min(effectiveDebt, effectiveMaxDebt), creditManager.minDebt);
-}
-//#endregion
-export { calculateMaxStrategyDebt };

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

@@ -1,304 +0,0 @@
-import { LEVERAGE_DECIMALS, PERCENTAGE_FACTOR } from "../../../../onchain/constants/math.js";
-import { calculateLossCoefficient } from "./calculate-loss-coefficient.js";
-import { maxLeverage } from "./max-leverage.js";
-import { calculateMaxStrategyDebt } from "./calculate-max-strategy-debt.js";
-import { buildCreditManager, mockToken1 } from "../../../test-utils/index.js";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-//#region src/common-utils/utils/strategies/leverage/calculate-max-strategy-debt.spec.ts
-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 result = calculateMaxStrategyDebt({
-			targetToken: mockToken1,
-			amount: 10000n,
-			creditManager: mockCreditManager,
-			slippage: 100,
-			constantLoss: 30n
-		});
-		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 result = calculateMaxStrategyDebt({
-			targetToken: mockToken1,
-			amount: 10000n,
-			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 result = calculateMaxStrategyDebt({
-			targetToken: mockToken1,
-			amount: 10000n,
-			creditManager: mockCreditManager,
-			slippage: 500,
-			constantLoss: 30n
-		});
-		expect(result).toEqual(94700n);
-	});
-	it("should handle different constantLoss values correctly", () => {
-		const maxLeverageValue = 10n * LEVERAGE_DECIMALS;
-		mockMaxLeverage.mockReturnValue(maxLeverageValue);
-		const result = calculateMaxStrategyDebt({
-			targetToken: mockToken1,
-			amount: 10000n,
-			creditManager: mockCreditManager,
-			slippage: 100,
-			constantLoss: 500n
-		});
-		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 creditManagerWithQuota = buildCreditManager({
-			availableToBorrow: 100000n,
-			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 creditManagerWithQuota = buildCreditManager({
-			availableToBorrow: 100000n,
-			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 creditManagerWithQuota = buildCreditManager({
-			availableToBorrow: 100000n,
-			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 creditManagerWithQuota = buildCreditManager({
-			availableToBorrow: 100000n,
-			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 creditManagerWithQuota = buildCreditManager({
-			availableToBorrow: 100000n,
-			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();
-	});
-});
-//#endregion
-export {};

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

@@ -1,9 +0,0 @@
-import { PERCENTAGE_FACTOR } from "../../../../onchain/constants/math.js";
-//#region src/common-utils/utils/strategies/leverage/get-collateral-by-debt.ts
-function getCollateralByDebt(debt, lt, targetHF = PERCENTAGE_FACTOR) {
-	if (lt === 0n) return 0n;
-	if (targetHF === lt) return 0n;
-	return debt * (targetHF - lt) / lt;
-}
-//#endregion
-export { getCollateralByDebt };