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

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 {};

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

@@ -1,17 +0,0 @@
-import { validateQuota } from "./validate-quota.js";
-//#region src/common-utils/utils/validation/validate-open-account.ts
-function validateOpenAccount(props) {
-	const { debt, creditManager, loading } = props;
-	if (loading) return { message: "loading" };
-	if (debt < creditManager.minDebt) return {
-		message: "amountLessMin",
-		amount: creditManager.minDebt
-	};
-	if (debt > creditManager.maxDebt) return {
-		message: "debtGreaterMax",
-		amount: creditManager.maxDebt
-	};
-	return validateQuota(props);
-}
-//#endregion
-export { validateOpenAccount };

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

@@ -1,56 +0,0 @@
-import { validateOpenAccount } from "./validate-open-account.js";
-import { buildCreditManager, mockUnderlyingToken } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-open-account.spec.ts
-const mockCreditManager = buildCreditManager({
-	minDebt: 1000n,
-	maxDebt: 1000000n,
-	underlyingToken: mockUnderlyingToken
-});
-describe("validateOpenAccount", () => {
-	it("returns null when all conditions are met", () => {
-		const result = validateOpenAccount({
-			debt: 50000n,
-			creditManager: mockCreditManager,
-			desiredQuota: {},
-			quotaUpdate: []
-		});
-		expect(result).toBeNull();
-	});
-	it("returns loading error when loading is true", () => {
-		const result = validateOpenAccount({
-			debt: 50000n,
-			creditManager: mockCreditManager,
-			desiredQuota: {},
-			quotaUpdate: [],
-			loading: true
-		});
-		expect(result).toEqual({ message: "loading" });
-	});
-	it("returns error when debt is less than min", () => {
-		const result = validateOpenAccount({
-			debt: 500n,
-			creditManager: mockCreditManager,
-			desiredQuota: {},
-			quotaUpdate: []
-		});
-		expect(result).toEqual({
-			message: "amountLessMin",
-			amount: 1000n
-		});
-	});
-	it("returns error when debt is greater than max", () => {
-		const result = validateOpenAccount({
-			debt: 2000000n,
-			creditManager: mockCreditManager,
-			desiredQuota: {},
-			quotaUpdate: []
-		});
-		expect(result).toEqual({
-			message: "debtGreaterMax",
-			amount: 1000000n
-		});
-	});
-});
-//#endregion
-export {};

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

@@ -1,22 +0,0 @@
-//#region src/common-utils/utils/validation/validate-quota.ts
-function validateQuota(props) {
-	const desiredQuotasList = Object.values(props.desiredQuota).filter((a) => a.balance > 0n);
-	if (desiredQuotasList.length > props.creditManager.maxEnabledTokensLength) return {
-		message: "maxQuotasLengthReached",
-		count: desiredQuotasList.length,
-		max: props.creditManager.maxEnabledTokensLength
-	};
-	if (props.quotaUpdate.length === 0 && props.throwOnZeroQuotaUpdate) return { message: "quotaShouldBeUpdated" };
-	for (const { token, balance: updateBy } of props.quotaUpdate) {
-		const quota = props.creditManager.quotas[token];
-		if (updateBy > 0 && quota) {
-			if ((quota.isActive ? quota.limit : 0n) - quota.totalQuoted < updateBy) return {
-				message: "insufficientQuota",
-				token
-			};
-		}
-	}
-	return null;
-}
-//#endregion
-export { validateQuota };

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

@@ -1,88 +0,0 @@
-import { validateQuota } from "./validate-quota.js";
-import { buildCreditManager, buildQuota, mockToken1, mockToken2 } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-quota.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
-		}),
-		[mockToken2]: buildQuota({
-			token: mockToken2,
-			limit: 2000000n,
-			totalQuoted: 1000000n,
-			rate: 0n
-		})
-	},
-	maxEnabledTokensLength: 2
-});
-describe("validateQuota", () => {
-	it("returns null when all conditions are met", () => {
-		const result = validateQuota({
-			desiredQuota: {},
-			quotaUpdate: [],
-			creditManager: mockCreditManager,
-			throwOnZeroQuotaUpdate: false
-		});
-		expect(result).toBeNull();
-	});
-	it("returns error when max quotas length is reached", () => {
-		const result = validateQuota({
-			desiredQuota: {
-				[mockToken1]: {
-					token: mockToken1,
-					balance: 1000n
-				},
-				[mockToken2]: {
-					token: mockToken2,
-					balance: 1000n
-				}
-			},
-			quotaUpdate: [],
-			creditManager: buildCreditManager({
-				...mockCreditManager,
-				maxEnabledTokensLength: 1
-			}),
-			throwOnZeroQuotaUpdate: false
-		});
-		expect(result).toEqual({
-			message: "maxQuotasLengthReached",
-			count: 2,
-			max: 1
-		});
-	});
-	it("returns error when quota update is empty and throwOnZeroQuotaUpdate is true", () => {
-		const result = validateQuota({
-			desiredQuota: {},
-			quotaUpdate: [],
-			creditManager: mockCreditManager,
-			throwOnZeroQuotaUpdate: true
-		});
-		expect(result).toEqual({ message: "quotaShouldBeUpdated" });
-	});
-	it("returns error when quota is insufficient", () => {
-		const result = validateQuota({
-			desiredQuota: {},
-			quotaUpdate: [{
-				token: mockToken1,
-				balance: 600000n
-			}],
-			creditManager: mockCreditManager,
-			throwOnZeroQuotaUpdate: false
-		});
-		expect(result).toEqual({
-			message: "insufficientQuota",
-			token: mockToken1
-		});
-	});
-});
-//#endregion
-export {};

package/dist/esm/common-utils/utils/validation/validate-token-to-obtain.js

@@ -1,17 +0,0 @@
-//#region src/common-utils/utils/validation/validate-token-to-obtain.ts
-function validateTokenToObtain({ creditManager, targetToken }) {
-	if (Array.isArray(targetToken)) {
-		for (const asset of targetToken) if (creditManager.forbiddenTokens[asset.token]) return {
-			message: "tokenIsForbidden",
-			token: asset.token
-		};
-		return null;
-	}
-	if (targetToken !== null && creditManager.forbiddenTokens[targetToken]) return {
-		message: "tokenIsForbidden",
-		token: targetToken
-	};
-	return null;
-}
-//#endregion
-export { validateTokenToObtain };

package/dist/esm/common-utils/utils/validation/validate-token-to-obtain.spec.js

@@ -1,36 +0,0 @@
-import { validateTokenToObtain } from "./validate-token-to-obtain.js";
-import { buildCreditManager, mockToken1 } from "../../test-utils/index.js";
-import { describe, expect, it } from "vitest";
-//#region src/common-utils/utils/validation/validate-token-to-obtain.spec.ts
-const mockCreditManager = buildCreditManager({ forbiddenTokens: {} });
-describe("validateTokenToObtain", () => {
-	it("returns null when targetToken is null", () => {
-		const result = validateTokenToObtain({
-			targetToken: null,
-			creditManager: mockCreditManager
-		});
-		expect(result).toBeNull();
-	});
-	it("returns null when targetToken is not forbidden", () => {
-		const result = validateTokenToObtain({
-			targetToken: mockToken1,
-			creditManager: mockCreditManager
-		});
-		expect(result).toBeNull();
-	});
-	it("returns error when targetToken is forbidden", () => {
-		const result = validateTokenToObtain({
-			targetToken: mockToken1,
-			creditManager: buildCreditManager({
-				...mockCreditManager,
-				forbiddenTokens: { [mockToken1]: true }
-			})
-		});
-		expect(result).toEqual({
-			message: "tokenIsForbidden",
-			token: mockToken1
-		});
-	});
-});
-//#endregion
-export {};

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

@@ -1 +0,0 @@
-export {};

package/dist/esm/onchain/accounts/intents/utils/convert-amount.js

@@ -1,36 +0,0 @@
-import { toTargetDecimals } from "./common.js";
-//#region src/onchain/accounts/intents/utils/convert-amount.ts
-/**
-* Converts an amount from one token to another using oracle prices of the
-* given credit manager's market. When the direct oracle path is missing
-* (e.g. `rwa.asset` has no pool price), bridges via the wrapped underlying
-* (1:1 wrap + decimals rescale) — mirrors legacy `convertAmountWithRwaBridge`.
-*/
-const convertAmount = (sdk, creditManager) => (fromTokenRaw, toTokenRaw, amount) => {
-	const fromToken = fromTokenRaw.toLowerCase();
-	const toToken = toTokenRaw.toLowerCase();
-	if (amount === 0n || fromToken === toToken) return amount;
-	const market = sdk.marketRegister.findByCreditManager(creditManager);
-	const underlying = market.pool.underlying.toLowerCase();
-	let direct = 0n;
-	try {
-		direct = market.priceOracle.convert(fromToken, toToken, amount);
-	} catch {}
-	if (direct > 0n) return direct;
-	const rwa = sdk.tokensMeta.rwaUnderlyings.get(underlying);
-	if (!rwa) return 0n;
-	const asset = rwa.asset.toLowerCase();
-	if (fromToken === asset && toToken === underlying) return toTargetDecimals(amount, fromToken, toToken, sdk);
-	if (fromToken === underlying && toToken === asset) return toTargetDecimals(amount, fromToken, toToken, sdk);
-	if (fromToken === asset) {
-		const asUnd = toTargetDecimals(amount, fromToken, underlying, sdk);
-		return convertAmount(sdk, creditManager)(underlying, toTokenRaw, asUnd);
-	}
-	if (toToken === asset) {
-		const asUnd = convertAmount(sdk, creditManager)(fromToken, underlying, amount);
-		return asUnd === 0n ? 0n : toTargetDecimals(asUnd, underlying, toToken, sdk);
-	}
-	return 0n;
-};
-//#endregion
-export { convertAmount };