@gearbox-protocol/sdk 16.0.0-next.17 → 16.0.0-next.19

package/dist/esm/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.spec.js

@@ -1,264 +0,0 @@
-import { toBN } from "../../../../onchain/utils/formatter.js";
-import { getCMYouCanEarn } from "./get-cm-you-can-earn.js";
-import { buildCreditManager, buildPool, buildQuota, buildTokenData } from "../../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/strategies/strategy-info/get-cm-you-can-earn.spec.ts
-describe("getCMYouCanEarn", () => {
-	const collateralTokenAddress = "0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee";
-	const targetTokenAddress = "0xe72b141df173b999ae7c1adcbf60cc9833ce56a8";
-	const underlyingTokenAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
-	const deth = "0x871ab8e36cae9af35c6a3488b049965233deb7ed";
-	const nativeTokenAddress = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-	const wrappedNativeTokenAddress = underlyingTokenAddress;
-	const tokenDataList = {
-		[collateralTokenAddress]: buildTokenData(collateralTokenAddress, "weETH"),
-		[targetTokenAddress]: buildTokenData(targetTokenAddress, "ethPlus"),
-		[underlyingTokenAddress]: buildTokenData(underlyingTokenAddress, "WETH"),
-		[nativeTokenAddress]: buildTokenData(nativeTokenAddress, "ETH"),
-		[deth]: buildTokenData(deth, "dETH")
-	};
-	const poolAddress = "0x0000000000000000000000000000000000000POOL";
-	const creditManager = buildCreditManager({
-		address: "0x0000000000000000000000000000000000000CM1",
-		pool: poolAddress,
-		underlyingToken: underlyingTokenAddress,
-		collateralTokens: [
-			collateralTokenAddress,
-			underlyingTokenAddress,
-			targetTokenAddress,
-			deth
-		],
-		supportedTokens: {
-			[collateralTokenAddress]: true,
-			[underlyingTokenAddress]: true,
-			[targetTokenAddress]: true,
-			[deth]: true
-		},
-		liquidationThresholds: {
-			[collateralTokenAddress]: 9300n,
-			[targetTokenAddress]: 9300n,
-			[underlyingTokenAddress]: 9500n,
-			[deth]: 8800n
-		},
-		quotas: {
-			[targetTokenAddress]: buildQuota({
-				isActive: true,
-				limit: 5000000000000000000000n,
-				quotaIncreaseFee: 0n,
-				rate: 100n,
-				token: "0xe72b141df173b999ae7c1adcbf60cc9833ce56a8",
-				totalQuoted: 1708445825184283030000n
-			}),
-			[collateralTokenAddress]: buildQuota({
-				token: collateralTokenAddress,
-				rate: 0n,
-				limit: toBN("1000000", 18)
-			}),
-			[deth]: buildQuota({
-				isActive: true,
-				limit: 500000000000000000000n,
-				quotaIncreaseFee: 0n,
-				rate: 100n,
-				token: deth,
-				totalQuoted: 28666207338545540000n
-			})
-		},
-		isQuoted: (t) => t.toLowerCase() !== underlyingTokenAddress,
-		feeInterest: 2e3,
-		isPaused: false,
-		baseBorrowRate: 18991,
-		maxDebt: 250000000000000000000n,
-		minDebt: 10000000000000000000n,
-		availableToBorrow: 859640767327531138355n
-	});
-	const pools = { [poolAddress]: buildPool({
-		address: poolAddress,
-		chainId: 1,
-		network: "Mainnet",
-		underlyingToken: underlyingTokenAddress,
-		dieselToken: poolAddress,
-		isPaused: false,
-		version: 310,
-		expectedLiquidity: 5596004266940175413222n,
-		expectedLiquidityLimit: 6903325375622920584635n,
-		availableLiquidity: 1307321108682745171413n,
-		interestModel: {
-			interestModel: "0x12e6e5c6fe4b37576dd4052e03a97ee7b9c29e86",
-			U_1: 7000n,
-			U_2: 9200n,
-			R_base: 0n,
-			R_slope1: 113n,
-			R_slope2: 150n,
-			R_slope3: 1236n,
-			version: 310,
-			isBorrowingMoreU2Forbidden: true
-		}
-	}) };
-	const allPrices = { [poolAddress]: {
-		[collateralTokenAddress]: 347896889077n,
-		[targetTokenAddress]: 342474099875n,
-		[underlyingTokenAddress]: 320438727057n,
-		[deth]: 322630065873n
-	} };
-	const walletBalances = {
-		[underlyingTokenAddress]: 0n,
-		[collateralTokenAddress]: 6191758000000000000n,
-		[targetTokenAddress]: 0n
-	};
-	const apyList = {
-		apyList: {
-			[targetTokenAddress]: 24600,
-			[collateralTokenAddress]: 27612,
-			[deth]: 16600
-		},
-		extraCollateralAPYList: { [poolAddress]: { [targetTokenAddress]: {
-			address: targetTokenAddress,
-			pool: poolAddress,
-			symbol: "ETHPlus",
-			type: "relative",
-			value: 0
-		} } },
-		pointsList: {
-			[collateralTokenAddress]: {
-				symbol: "weETH",
-				address: "0xcd5fe23c85820f7b72d0926fc9b05b43e359b7ee",
-				debtRewards: void 0,
-				rewards: [{
-					name: "Ether.fi",
-					units: "points",
-					multiplier: 200n,
-					type: "etherfi"
-				}]
-			},
-			[deth]: {
-				address: "0x871ab8e36cae9af35c6a3488b049965233deb7ed",
-				debtRewards: void 0,
-				rewards: [{
-					name: "Makina",
-					units: "points",
-					multiplier: 36000n,
-					type: "makina"
-				}],
-				symbol: "DETH"
-			}
-		},
-		extraCollateralPointsList: {},
-		poolRewardsList: {},
-		tokenExtraRewardsList: {},
-		poolExternalAPYList: {},
-		poolExtraAPYList: {}
-	};
-	it("computes expected earnings for APY-only scenario", () => {
-		const result = getCMYouCanEarn({
-			creditManager,
-			pools,
-			strategy: {
-				id: "test-strategy",
-				tokenOutAddress: targetTokenAddress,
-				chainId: 1,
-				network: "Mainnet"
-			},
-			delayedPhantoms: {},
-			apyList,
-			tokensList: tokenDataList,
-			walletBalances,
-			nativeTokenAddress,
-			wrappedNativeTokenAddress,
-			allPrices,
-			slippage: 10,
-			quotaReserve: 500
-		});
-		expect(result.status).toEqual("ok");
-		expect(result.data?.info?.maxAPY).toEqual({
-			overallAPY: 7.392,
-			overallAPYBigInt: 73920n,
-			overallAPYStatus: "calculated"
-		});
-		expect(result.data?.earnings).toEqual({
-			earnings: 496914282513333354n,
-			earningsUSD: 1592305801450150145856n
-		});
-	});
-	it("computes expected earnings for APY and points scenario", () => {
-		const result = getCMYouCanEarn({
-			creditManager,
-			pools,
-			strategy: {
-				id: "test-strategy",
-				tokenOutAddress: collateralTokenAddress,
-				chainId: 1,
-				network: "Mainnet"
-			},
-			delayedPhantoms: {},
-			apyList,
-			tokensList: tokenDataList,
-			walletBalances,
-			nativeTokenAddress,
-			wrappedNativeTokenAddress,
-			allPrices,
-			slippage: 10,
-			quotaReserve: 500
-		});
-		expect(result.status).toEqual("ok");
-		expect(result.data?.info?.maxAPY).toEqual({
-			overallAPY: 11.233,
-			overallAPYBigInt: 112330n,
-			overallAPYStatus: "calculated"
-		});
-		expect(result.data?.earnings).toEqual({
-			earnings: 755118795383153892n,
-			earningsUSD: 2419693055693930817344n
-		});
-		expect(result.data?.points?.info).toEqual(apyList.pointsList?.[collateralTokenAddress] || {});
-		expect(result.data?.points).toEqual({
-			debtRates: {
-				rewards: [],
-				rates: []
-			},
-			info: apyList.pointsList?.[collateralTokenAddress] || {},
-			rates: [2454n]
-		});
-	});
-	it("computes expected earnings for points-only scenario", () => {
-		const result = getCMYouCanEarn({
-			creditManager,
-			pools,
-			strategy: {
-				id: "test-strategy",
-				tokenOutAddress: deth,
-				chainId: 1,
-				network: "Mainnet"
-			},
-			delayedPhantoms: {},
-			apyList,
-			tokensList: tokenDataList,
-			walletBalances,
-			nativeTokenAddress,
-			wrappedNativeTokenAddress,
-			allPrices,
-			slippage: 10,
-			quotaReserve: 500
-		});
-		expect(result.status).toEqual("ok");
-		expect(result.data?.info?.maxAPY).toEqual({
-			overallAPY: void 0,
-			overallAPYBigInt: void 0,
-			overallAPYStatus: "negativeForPoints"
-		});
-		expect(result.data?.earnings).toEqual({
-			earnings: null,
-			earningsUSD: null
-		});
-		expect(result.data?.points?.info).toEqual(apyList.pointsList?.[deth] || {});
-		expect(result.data?.points).toEqual({
-			debtRates: {
-				rewards: [],
-				rates: []
-			},
-			info: apyList.pointsList?.[deth] || {},
-			rates: [259920n]
-		});
-	});
-});
-//#endregion
-export {};

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

@@ -1,12 +0,0 @@
-import { MIN_HF_LIMITED, validateHF } from "./validate-hf.js";
-import { validateOpenAccountPoolQuotaStatus } from "./validate-open-account-pool-quota-status.js";
-import { validateOpenAccountPoolStatus } from "./validate-open-account-pool-status.js";
-import { isZeroBalance } from "./is-zero-balance.js";
-import { validateBalance } from "./validate-balance.js";
-import { validateBalances } from "./validate-balances.js";
-import { validateCreditManager } from "./validate-credit-manager.js";
-import { validateQuota } from "./validate-quota.js";
-import { validateOpenAccount } from "./validate-open-account.js";
-import { validateTokenToObtain } from "./validate-token-to-obtain.js";
-import "./validation-types.js";
-export { MIN_HF_LIMITED, isZeroBalance, validateBalance, validateBalances, validateCreditManager, validateHF, validateOpenAccount, validateOpenAccountPoolQuotaStatus, validateOpenAccountPoolStatus, validateQuota, validateTokenToObtain };

package/dist/esm/common-utils/utils/validation/is-zero-balance.js

@@ -1,6 +0,0 @@
-//#region src/common-utils/utils/validation/is-zero-balance.ts
-function isZeroBalance(balance) {
-	return (balance ?? 0n) <= 10n;
-}
-//#endregion
-export { isZeroBalance };

package/dist/esm/common-utils/utils/validation/validate-balance.js

@@ -1,21 +0,0 @@
-import "../constants.js";
-import { isZeroBalance } from "./is-zero-balance.js";
-//#region src/common-utils/utils/validation/validate-balance.ts
-function validateBalance({ amount, tokenAddress, maxAmount = 0n, zeroCheck = true, single }) {
-	const safeAddress = tokenAddress || "";
-	if (!safeAddress) return {
-		message: "unknownToken",
-		token: safeAddress
-	};
-	if (maxAmount < amount) return {
-		message: "insufficientFunds",
-		token: safeAddress
-	};
-	if (zeroCheck && isZeroBalance(amount)) return {
-		message: single ? "enterAmount" : "zeroBalance",
-		token: safeAddress
-	};
-	return null;
-}
-//#endregion
-export { validateBalance };

package/dist/esm/common-utils/utils/validation/validate-balance.spec.js

@@ -1,54 +0,0 @@
-import { validateBalance } from "./validate-balance.js";
-import { mockToken1 } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-balance.spec.ts
-describe("validateBalance", () => {
-	it("returns null when all conditions are met", () => {
-		const result = validateBalance({
-			amount: 1000n,
-			tokenAddress: mockToken1,
-			maxAmount: 2000n,
-			zeroCheck: true,
-			single: false
-		});
-		expect(result).toBeNull();
-	});
-	it("returns error when amount exceeds maxAmount", () => {
-		const result = validateBalance({
-			amount: 3000n,
-			tokenAddress: mockToken1,
-			maxAmount: 2000n,
-			zeroCheck: true,
-			single: false
-		});
-		expect(result).toEqual({
-			message: "insufficientFunds",
-			token: mockToken1
-		});
-	});
-	it("returns error when amount is too small with zeroCheck", () => {
-		const result = validateBalance({
-			amount: 5n,
-			tokenAddress: mockToken1,
-			maxAmount: 2000n,
-			zeroCheck: true,
-			single: false
-		});
-		expect(result).toEqual({
-			message: "zeroBalance",
-			token: mockToken1
-		});
-	});
-	it("returns null when zeroCheck is false and amount is small", () => {
-		const result = validateBalance({
-			amount: 5n,
-			tokenAddress: mockToken1,
-			maxAmount: 2000n,
-			zeroCheck: false,
-			single: false
-		});
-		expect(result).toBeNull();
-	});
-});
-//#endregion
-export {};

package/dist/esm/common-utils/utils/validation/validate-balances.js

@@ -1,16 +0,0 @@
-import { validateBalance } from "./validate-balance.js";
-//#region src/common-utils/utils/validation/validate-balances.ts
-function validateBalances({ balances, assets, zeroCheck = true }) {
-	for (const { token: tokenAddress, balance: amount } of assets) {
-		const e = validateBalance({
-			tokenAddress,
-			amount,
-			maxAmount: balances[(tokenAddress || "").toLowerCase()] || 0n,
-			zeroCheck
-		});
-		if (e !== null) return e;
-	}
-	return null;
-}
-//#endregion
-export { validateBalances };

package/dist/esm/common-utils/utils/validation/validate-balances.spec.js

@@ -1,45 +0,0 @@
-import { validateBalances } from "./validate-balances.js";
-import { mockToken1, mockToken2 } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-balances.spec.ts
-describe("validateBalances", () => {
-	it("returns null when all balances are valid", () => {
-		const result = validateBalances({
-			balances: {
-				[mockToken1]: 2000n,
-				[mockToken2]: 3000n
-			},
-			assets: [{
-				token: mockToken1,
-				balance: 1000n
-			}, {
-				token: mockToken2,
-				balance: 2000n
-			}],
-			zeroCheck: true
-		});
-		expect(result).toBeNull();
-	});
-	it("returns error when any balance is invalid", () => {
-		const result = validateBalances({
-			balances: {
-				[mockToken1]: 500n,
-				[mockToken2]: 3000n
-			},
-			assets: [{
-				token: mockToken1,
-				balance: 1000n
-			}, {
-				token: mockToken2,
-				balance: 2000n
-			}],
-			zeroCheck: true
-		});
-		expect(result).toEqual({
-			message: "insufficientFunds",
-			token: mockToken1
-		});
-	});
-});
-//#endregion
-export {};

package/dist/esm/common-utils/utils/validation/validate-credit-manager.js

@@ -1,7 +0,0 @@
-//#region src/common-utils/utils/validation/validate-credit-manager.ts
-function validateCreditManager({ creditManager, allowPausedCm }) {
-	if (creditManager.isPaused && !allowPausedCm) return { message: "paused" };
-	return null;
-}
-//#endregion
-export { validateCreditManager };

package/dist/esm/common-utils/utils/validation/validate-credit-manager.spec.js

@@ -1,36 +0,0 @@
-import { validateCreditManager } from "./validate-credit-manager.js";
-import { buildCreditManager } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-credit-manager.spec.ts
-const mockCreditManager = buildCreditManager({ isPaused: false });
-describe("validateCreditManager", () => {
-	it("returns null when credit manager is not paused", () => {
-		const result = validateCreditManager({
-			creditManager: mockCreditManager,
-			allowPausedCm: false
-		});
-		expect(result).toBeNull();
-	});
-	it("returns null when credit manager is paused but allowed", () => {
-		const result = validateCreditManager({
-			creditManager: buildCreditManager({
-				...mockCreditManager,
-				isPaused: true
-			}),
-			allowPausedCm: true
-		});
-		expect(result).toBeNull();
-	});
-	it("returns error when credit manager is paused and not allowed", () => {
-		const result = validateCreditManager({
-			creditManager: buildCreditManager({
-				...mockCreditManager,
-				isPaused: true
-			}),
-			allowPausedCm: false
-		});
-		expect(result).toEqual({ message: "paused" });
-	});
-});
-//#endregion
-export {};

package/dist/esm/common-utils/utils/validation/validate-hf.js

@@ -1,8 +0,0 @@
-//#region src/common-utils/utils/validation/validate-hf.ts
-const MIN_HF_LIMITED = 10100n;
-function validateHF({ hf, hfCheck = true }) {
-	if (hfCheck && (hf === void 0 || hf <= 10100n)) return { message: "hfTooLow" };
-	return null;
-}
-//#endregion
-export { MIN_HF_LIMITED, validateHF };

package/dist/esm/common-utils/utils/validation/validate-hf.spec.js

@@ -1,26 +0,0 @@
-import { MIN_HF_LIMITED, validateHF } from "./validate-hf.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-hf.spec.ts
-describe("validateHF", () => {
-	it("returns null when HF is above minimum", () => {
-		const result = validateHF({ hf: 15e3 });
-		expect(result).toBeNull();
-	});
-	it("returns error when HF is undefined", () => {
-		const result = validateHF({ hf: void 0 });
-		expect(result).toEqual({ message: "hfTooLow" });
-	});
-	it("returns error when HF is too low", () => {
-		const result = validateHF({ hf: Number(MIN_HF_LIMITED) });
-		expect(result).toEqual({ message: "hfTooLow" });
-	});
-	it("returns null when hfCheck is false and HF is too low", () => {
-		const result = validateHF({
-			hf: Number(MIN_HF_LIMITED - 1n),
-			hfCheck: false
-		});
-		expect(result).toBeNull();
-	});
-});
-//#endregion
-export {};

package/dist/esm/common-utils/utils/validation/validate-open-account-pool-quota-status.js

@@ -1,13 +0,0 @@
-//#region src/common-utils/utils/validation/validate-open-account-pool-quota-status.ts
-function validateOpenAccountPoolQuotaStatus(targetToken, creditManager, amountToBorrow) {
-	const quota = creditManager.quotas[targetToken];
-	if (quota) {
-		if ((quota.isActive ? quota.limit : 0n) - quota.totalQuoted < amountToBorrow) return {
-			message: "insufficientQuota",
-			token: targetToken
-		};
-	}
-	return null;
-}
-//#endregion
-export { validateOpenAccountPoolQuotaStatus };

package/dist/esm/common-utils/utils/validation/validate-open-account-pool-quota-status.spec.js

@@ -1,29 +0,0 @@
-import { validateOpenAccountPoolQuotaStatus } from "./validate-open-account-pool-quota-status.js";
-import { buildCreditManager, buildQuota, mockToken1 } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-open-account-pool-quota-status.spec.ts
-const mockCreditManager = buildCreditManager({ quotas: { [mockToken1]: buildQuota({
-	token: mockToken1,
-	limit: 1000000n,
-	totalQuoted: 500000n,
-	rate: 0n
-}) } });
-describe("validateOpenAccountPoolQuotaStatus", () => {
-	it("returns null when quota is sufficient", () => {
-		const result = validateOpenAccountPoolQuotaStatus(mockToken1, mockCreditManager, 100000n);
-		expect(result).toBeNull();
-	});
-	it("returns error when quota is insufficient", () => {
-		const result = validateOpenAccountPoolQuotaStatus(mockToken1, mockCreditManager, 600000n);
-		expect(result).toEqual({
-			message: "insufficientQuota",
-			token: mockToken1
-		});
-	});
-	it("returns null when token has no quota", () => {
-		const result = validateOpenAccountPoolQuotaStatus("0x9999999999999999999999999999999999999999", mockCreditManager, 100000n);
-		expect(result).toBeNull();
-	});
-});
-//#endregion
-export {};

package/dist/esm/common-utils/utils/validation/validate-open-account-pool-status.js

@@ -1,36 +0,0 @@
-import { BigIntMath } from "../../../onchain/utils/bigint-math.js";
-import { validateOpenAccountPoolQuotaStatus } from "./validate-open-account-pool-quota-status.js";
-//#region src/common-utils/utils/validation/validate-open-account-pool-status.ts
-function validateOpenAccountPoolStatus(props) {
-	const { debt, creditManager, pool, targetToken } = props;
-	const effectiveDebt = BigIntMath.max(creditManager.minDebt, debt);
-	const hasDebtLimit = creditManager.totalDebtLimit >= 0n;
-	const debtLimitLeft = BigIntMath.max(creditManager.totalDebtLimit - creditManager.totalDebt, 0n);
-	const { totalDebtLimit = 0n, totalBorrowed = 0n } = pool || {};
-	const hasPoolDebtLimit = totalDebtLimit > 0n;
-	const poolDebtLimitLeft = totalDebtLimit - totalBorrowed;
-	const canOpenMinDebt = creditManager.minDebt <= debtLimitLeft && creditManager.minDebt <= poolDebtLimitLeft && creditManager.minDebt <= creditManager.availableToBorrow;
-	const minPositionSize = BigIntMath.min(BigIntMath.min(debtLimitLeft, poolDebtLimitLeft), creditManager.availableToBorrow);
-	if (hasDebtLimit && effectiveDebt > debtLimitLeft) return {
-		message: "insufficientDebtLimit",
-		amount: debtLimitLeft,
-		solutionAmount: canOpenMinDebt ? minPositionSize : void 0
-	};
-	if (hasPoolDebtLimit && effectiveDebt > poolDebtLimitLeft) return {
-		message: "insufficientPoolDebtLimit",
-		amount: poolDebtLimitLeft,
-		solutionAmount: canOpenMinDebt ? minPositionSize : void 0
-	};
-	if (effectiveDebt > creditManager.availableToBorrow) return {
-		message: "insufficientPoolLiquidity",
-		amount: creditManager.availableToBorrow,
-		solutionAmount: canOpenMinDebt ? minPositionSize : void 0
-	};
-	if (targetToken !== null) {
-		const quotaError = validateOpenAccountPoolQuotaStatus(targetToken, creditManager, effectiveDebt);
-		if (quotaError) return quotaError;
-	}
-	return null;
-}
-//#endregion
-export { validateOpenAccountPoolStatus };

package/dist/esm/common-utils/utils/validation/validate-open-account-pool-status.spec.js

@@ -1,98 +0,0 @@
-import { validateOpenAccountPoolStatus } from "./validate-open-account-pool-status.js";
-import { buildCreditManager, buildPool, buildQuota, mockToken1 } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-open-account-pool-status.spec.ts
-const mockCreditManager = buildCreditManager({
-	minDebt: 1000n,
-	maxDebt: 1000000n,
-	totalDebtLimit: 5000000n,
-	totalDebt: 2000000n,
-	availableToBorrow: 3000000n,
-	quotas: { [mockToken1]: buildQuota({
-		token: mockToken1,
-		limit: 1000000n,
-		totalQuoted: 500000n,
-		rate: 0n
-	}) }
-});
-const mockPool = buildPool({
-	totalDebtLimit: 10000000n,
-	totalBorrowed: 5000000n
-});
-describe("validateOpenAccountPoolStatus", () => {
-	it("returns null when all conditions are met", () => {
-		const result = validateOpenAccountPoolStatus({
-			debt: 50000n,
-			creditManager: mockCreditManager,
-			pool: mockPool,
-			targetToken: mockToken1
-		});
-		expect(result).toBeNull();
-	});
-	it("returns error when debt exceeds debt limit", () => {
-		const result = validateOpenAccountPoolStatus({
-			debt: 4000000n,
-			creditManager: mockCreditManager,
-			pool: mockPool,
-			targetToken: mockToken1
-		});
-		expect(result).toEqual({
-			message: "insufficientDebtLimit",
-			amount: 3000000n,
-			solutionAmount: 3000000n
-		});
-	});
-	it("returns error when debt exceeds pool debt limit", () => {
-		const result = validateOpenAccountPoolStatus({
-			debt: 6000000n,
-			creditManager: buildCreditManager({
-				...mockCreditManager,
-				totalDebtLimit: -1n
-			}),
-			pool: mockPool,
-			targetToken: mockToken1
-		});
-		expect(result).toEqual({
-			message: "insufficientPoolDebtLimit",
-			amount: 5000000n
-		});
-	});
-	it("returns error when debt exceeds available liquidity", () => {
-		const result = validateOpenAccountPoolStatus({
-			debt: 4000000n,
-			creditManager: buildCreditManager({
-				...mockCreditManager,
-				totalDebtLimit: -1n
-			}),
-			pool: buildPool({ totalDebtLimit: -1n }),
-			targetToken: mockToken1
-		});
-		expect(result).toEqual({
-			message: "insufficientPoolLiquidity",
-			amount: 3000000n
-		});
-	});
-	it("returns error when quota is insufficient", () => {
-		const result = validateOpenAccountPoolStatus({
-			debt: 600000n,
-			creditManager: mockCreditManager,
-			pool: mockPool,
-			targetToken: mockToken1
-		});
-		expect(result).toEqual({
-			message: "insufficientQuota",
-			token: mockToken1
-		});
-	});
-	it("returns null when targetToken is null", () => {
-		const result = validateOpenAccountPoolStatus({
-			debt: 50000n,
-			creditManager: mockCreditManager,
-			pool: mockPool,
-			targetToken: null
-		});
-		expect(result).toBeNull();
-	});
-});
-//#endregion
-export {};