@gearbox-protocol/sdk 15.1.0-next.2 → 15.1.0-next.21

package/dist/cjs/sdk/accounts/intents/testing/delayed.js

@@ -0,0 +1,50 @@
+const require_sdk_mock = require("./sdk-mock.js");
+const require_market = require("./market.js");
+//#region src/sdk/accounts/intents/testing/delayed.ts
+const FIXTURE_PHANTOM = "0xcccccccccccccccccccccccccccccccccccccccc";
+/** Claimed proceeds converted to UND (mirrors the mock price oracle). */
+function claimedValueInUnd(amount, token) {
+	return require_market.valueInUnd(amount, token);
+}
+/**
+* Mock sdk for a tail case. The phantom token inherits the claimed token's
+* decimals, so any 1:1 rescale through it stays the identity.
+*/
+function buildTailSdk(c, extras) {
+	const phantom = extras?.phantom ?? "0xcccccccccccccccccccccccccccccccccccccccc";
+	return require_market.buildMarketSdk({
+		...extras,
+		extraDecimals: {
+			...extras?.extraDecimals,
+			[phantom]: extras?.extraDecimals?.[c.claimedToken] ?? require_market.DECIMALS[c.claimedToken]
+		}
+	});
+}
+/** The matured withdrawal a tail case claims. */
+function buildClaimable(c) {
+	return {
+		token: c.claimedToken,
+		withdrawalPhantomToken: FIXTURE_PHANTOM,
+		withdrawalTokenSpent: c.claimedAmount,
+		outputs: [{
+			token: c.claimedToken,
+			amount: c.claimedAmount,
+			isDelayed: false
+		}],
+		claimCalls: [require_sdk_mock.MOCK_CLAIM_CALL]
+	};
+}
+//#endregion
+exports.ANY = require_market.ANY;
+exports.ANY2 = require_market.ANY2;
+exports.CREDIT_ACCOUNT = require_market.CREDIT_ACCOUNT;
+exports.CREDIT_FACADE = require_market.CREDIT_FACADE;
+exports.CREDIT_MANAGER = require_market.CREDIT_MANAGER;
+exports.FIXTURE_PHANTOM = FIXTURE_PHANTOM;
+exports.POS = require_market.POS;
+exports.RWA_ASSET = require_market.RWA_ASSET;
+exports.UND = require_market.UND;
+exports.buildClaimable = buildClaimable;
+exports.buildMarketSdk = require_market.buildMarketSdk;
+exports.buildTailSdk = buildTailSdk;
+exports.claimedValueInUnd = claimedValueInUnd;

package/dist/cjs/sdk/accounts/intents/testing/market.js

@@ -0,0 +1,167 @@
+const require_sdk_utils_formatter = require("../../../utils/formatter.js");
+require("../../../index.js");
+const require_sdk_mock = require("./sdk-mock.js");
+const UND = "0x3333333333333333333333333333333333333333";
+const ANY = "0x1111111111111111111111111111111111111111";
+const ANY2 = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+const RWA_ASSET = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+/**
+* Position token that converts 1:1 with `UND` (same decimals, same price).
+*
+* The mock router echoes the input amount as the output amount, so a 1:1 pair is
+* the only way a swap leg's expected amounts stay decimals-correct. Use `POS`
+* for flows whose amounts cross a swap, and `ANY` where they do not.
+*/
+const POS = "0x2222222222222222222222222222222222222222";
+/** Second 1:1 token, for flows routing between two non-underlying tokens. */
+const POS2 = "0x4444444444444444444444444444444444444444";
+const CREDIT_MANAGER = "0xdddddddddddddddddddddddddddddddddddddddd";
+const CREDIT_FACADE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+const CREDIT_ACCOUNT = "0xacacacacacacacacacacacacacacacacacacacac";
+const WALLET = "0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0";
+const PRICES = {
+	[UND]: require_sdk_utils_formatter.toBN("2", 8),
+	[ANY]: require_sdk_utils_formatter.toBN("1", 8),
+	[ANY2]: require_sdk_utils_formatter.toBN("1", 8),
+	[RWA_ASSET]: require_sdk_utils_formatter.toBN("2", 8),
+	[POS]: require_sdk_utils_formatter.toBN("2", 8),
+	[POS2]: require_sdk_utils_formatter.toBN("2", 8)
+};
+const DECIMALS = {
+	[UND]: 8,
+	[ANY]: 18,
+	[ANY2]: 18,
+	[RWA_ASSET]: 8,
+	[POS]: 8,
+	[POS2]: 8
+};
+const QUOTAS = {
+	[ANY]: {
+		token: ANY,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 18),
+		isActive: true
+	},
+	[ANY2]: {
+		token: ANY2,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 18),
+		isActive: true
+	},
+	[RWA_ASSET]: {
+		token: RWA_ASSET,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 8),
+		isActive: true
+	},
+	[POS]: {
+		token: POS,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 8),
+		isActive: true
+	},
+	[POS2]: {
+		token: POS2,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 8),
+		isActive: true
+	}
+};
+const LIQUIDATION_THRESHOLDS = {
+	[UND]: 9800,
+	[ANY]: 9200,
+	[ANY2]: 9200,
+	[RWA_ASSET]: 9200,
+	[POS]: 9200,
+	[POS2]: 9200
+};
+const MAX_DEBT = require_sdk_utils_formatter.toBN("200000", 8);
+/** Mock SDK on the shared fixture market. */
+function buildMarketSdk(extras) {
+	return require_sdk_mock.buildMockSdk({
+		prices: {
+			...PRICES,
+			...extras?.extraPrices
+		},
+		reservePrices: extras?.reservePrices,
+		decimals: {
+			...DECIMALS,
+			...extras?.extraDecimals
+		},
+		quotas: extras?.quotas ?? QUOTAS,
+		liquidationThresholds: LIQUIDATION_THRESHOLDS,
+		maxDebt: MAX_DEBT,
+		minDebt: extras?.minDebt,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		rwaAssets: extras?.rwaAssets,
+		phantoms: extras?.phantoms,
+		creditAccounts: extras?.creditAccounts,
+		delayed: extras?.delayed,
+		facadePaused: extras?.facadePaused,
+		poolPaused: extras?.poolPaused,
+		expirationDate: extras?.expirationDate,
+		timestamp: extras?.timestamp,
+		availableLiquidity: extras?.availableLiquidity,
+		debtLimitAvailable: extras?.debtLimitAvailable,
+		maxDebtPerBlockMultiplier: extras?.maxDebtPerBlockMultiplier,
+		forbiddenTokens: extras?.forbiddenTokens,
+		strategyTargetCollateral: POS
+	});
+}
+/** Converts an amount to UND at fixture prices (mirrors the mock oracle). */
+function valueInUnd(amount, token, overrides) {
+	const prices = {
+		...PRICES,
+		...overrides?.prices
+	};
+	const decimals = {
+		...DECIMALS,
+		...overrides?.decimals
+	};
+	return amount * prices[token] * 10n ** BigInt(8) / (prices[UND] * 10n ** BigInt(decimals[token]));
+}
+/** Token entry for a fixture CA, with quota defaulting to zero. */
+function caToken(token, balance, quota = 0n) {
+	return {
+		token,
+		balance,
+		quota,
+		mask: 0n,
+		success: true
+	};
+}
+/** Bare CA slice on the fixture market. */
+function buildFixtureCreditAccount(args) {
+	return {
+		creditAccount: CREDIT_ACCOUNT,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: args.accountDebt,
+		tokens: args.tokens
+	};
+}
+//#endregion
+exports.ANY = ANY;
+exports.ANY2 = ANY2;
+exports.CREDIT_ACCOUNT = CREDIT_ACCOUNT;
+exports.CREDIT_FACADE = CREDIT_FACADE;
+exports.CREDIT_MANAGER = CREDIT_MANAGER;
+exports.DECIMALS = DECIMALS;
+exports.LIQUIDATION_THRESHOLDS = LIQUIDATION_THRESHOLDS;
+exports.MAX_DEBT = MAX_DEBT;
+exports.POS = POS;
+exports.POS2 = POS2;
+exports.PRICES = PRICES;
+exports.QUOTAS = QUOTAS;
+exports.RWA_ASSET = RWA_ASSET;
+exports.UND = UND;
+exports.WALLET = WALLET;
+exports.buildFixtureCreditAccount = buildFixtureCreditAccount;
+exports.buildMarketSdk = buildMarketSdk;
+exports.caToken = caToken;
+exports.valueInUnd = valueInUnd;

package/dist/cjs/sdk/accounts/intents/testing/sdk-mock.js

@@ -1,4 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../constants/math.js");
+require("../../../constants/index.js");
+const require_sdk_positions_PositionsService = require("../../../positions/PositionsService.js");
 let vitest = require("vitest");
 //#region src/sdk/accounts/intents/testing/sdk-mock.ts
 /**
@@ -7,19 +9,19 @@ let vitest = require("vitest");
 * The service resolves all market data through `OnchainSDK`
 * (`marketRegister`, `tokensMeta`, `accounts`). `buildMockSdk` builds a mock
 * from plain records; assemble mocks ECHO recognizable sentinel calls derived
-* from their inputs, so `result.instant.calls` pins down which ops reached the
+* from their inputs, so `result.calls` pins down which ops reached the
 * assembler and in which order.
 */
-/** Fixture `claimableWithdrawal.claimCalls` content; echoes through claim ops. */
-const MOCK_CLAIM_CALL = {
-	target: "0x1111111111111111111111111111111111111111",
-	callData: "0x"
-};
-/** Recognizable router call embedded in close path results. */
+/** Recognizable router call embedded in routed leg results. */
 const MOCK_ROUTER_CALL = {
 	target: "0x9999999999999999999999999999999999999999",
 	callData: "0x"
 };
+/** Router call of the many-to-one leg an exit routes. */
+const MOCK_CLOSE_CALL = {
+	target: "0x9595959595959595959595959595959595959595",
+	callData: "0x"
+};
 /** Returned by the `getRWAWrapCalls` mock; passes through per wrap op. */
 const MOCK_RWA_WRAP_CALL = {
 	target: "0x8888888888888888888888888888888888888888",
@@ -30,9 +32,14 @@ const MOCK_RWA_UNWRAP_CALL = {
 	target: "0x7777777777777777777777777777777777777777",
 	callData: "0x"
 };
-/** Returned by the `assembleCloseCreditAccountCalls` mock. */
-const MOCK_CLOSE_CALL = {
-	target: "0x5555555555555555555555555555555555555555",
+/** Fixture `claimableWithdrawal.claimCalls` content; echoes through claim ops. */
+const MOCK_CLAIM_CALL = {
+	target: "0x1111111111111111111111111111111111111111",
+	callData: "0x"
+};
+/** Fixture `requestableWithdrawal.requestCalls`; echoes through request ops. */
+const MOCK_REQUEST_CALL = {
+	target: "0x2222222222222222222222222222222222222222",
 	callData: "0x"
 };
 /** One sentinel call per plain encodable op type. */
@@ -78,30 +85,100 @@ function buildMockSdk(args) {
 		if (fromPrice === void 0 || toPrice === void 0) throw new Error(`mock priceOracle: missing price for ${from} or ${target}`);
 		return amount * fromPrice * 10n ** BigInt(decimalsOf(target)) / (toPrice * 10n ** BigInt(decimalsOf(from)));
 	};
-	const quotas = { values: () => Object.values(args.quotas).map((q) => ({
+	const fullQuota = (q) => ({
 		cumulativeIndexLU: 0n,
 		totalQuoted: 0n,
 		quotaIncreaseFee: 0n,
 		...q
-	})) };
-	const liquidationThresholds = { entries: () => Object.entries(args.liquidationThresholds) };
+	});
+	const quotaOf = (token) => args.quotas[token.toLowerCase()] ?? args.quotas[token];
+	const quotas = {
+		values: () => Object.values(args.quotas).map(fullQuota),
+		get: (token) => {
+			const q = quotaOf(token);
+			return q === void 0 ? void 0 : fullQuota(q);
+		}
+	};
+	const liquidationThresholds = {
+		entries: () => Object.entries(args.liquidationThresholds),
+		get: (token) => args.liquidationThresholds[token.toLowerCase()] ?? args.liquidationThresholds[token]
+	};
+	const mainPriceOf = (token) => {
+		const key = token.toLowerCase();
+		const price = args.prices[key] ?? args.prices[token];
+		if (price === void 0) throw new Error(`mock priceOracle: missing main price for ${token}`);
+		return price;
+	};
+	const reservePriceOf = (token) => {
+		const key = token.toLowerCase();
+		const price = args.reservePrices?.[key] ?? args.reservePrices?.[token];
+		if (price === void 0) throw new Error(`mock priceOracle: missing reserve price for ${token}`);
+		return price;
+	};
+	const poolPaused = args.poolPaused ?? false;
 	const market = {
-		priceOracle: { convert },
+		priceOracle: {
+			convert,
+			mainPrice: mainPriceOf,
+			reservePrice: reservePriceOf,
+			convertToUSD: (token, amount) => {
+				const from = token.toLowerCase();
+				const price = args.prices[from] ?? args.prices[token];
+				if (price === void 0) throw new Error(`mock priceOracle: missing price for ${from}`);
+				return amount * price / 10n ** BigInt(decimalsOf(from));
+			},
+			safeConvertToUSD: (token, amount) => {
+				const from = token.toLowerCase();
+				const price = args.prices[from] ?? args.prices[token];
+				if (price === void 0) return null;
+				return amount * price / 10n ** BigInt(decimalsOf(from));
+			}
+		},
 		pool: {
-			pqk: { quotas },
+			pqk: {
+				quotas,
+				quotaRate: (token) => Number(quotaOf(token)?.rate ?? 0n),
+				hasActiveQuota: (token) => {
+					const q = quotaOf(token);
+					return !!q?.isActive && q.limit > 0n;
+				}
+			},
+			pool: {
+				baseInterestRate: args.baseInterestRate ?? 0n,
+				isPaused: poolPaused,
+				availableLiquidity: args.availableLiquidity ?? 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+				creditManagerDebtParams: { get: () => ({ available: args.debtLimitAvailable ?? 115792089237316195423570985008687907853269984665640564039457584007913129639935n }) }
+			},
+			isPaused: poolPaused,
 			underlying: args.underlying
 		}
 	};
+	const collateralTokens = [args.underlying.toLowerCase(), ...Object.keys(args.liquidationThresholds).map((t) => t.toLowerCase()).filter((t) => t !== args.underlying.toLowerCase())];
+	const forbidden = new Set((args.forbiddenTokens ?? []).map((t) => t.toLowerCase()));
+	const forbiddenTokensMask = collateralTokens.reduce((mask, token, i) => forbidden.has(token) ? mask | 1n << BigInt(i) : mask, 0n);
+	const facadePaused = args.facadePaused ?? false;
+	const expirationDate = args.expirationDate ?? 0;
 	const creditManagerSuite = {
 		creditManager: {
 			address: args.creditManager,
 			liquidationThresholds,
-			collateralTokens: []
+			collateralTokens,
+			feeInterest: args.feeInterest ?? 0
 		},
 		creditFacade: {
 			address: args.creditFacade,
-			maxDebt: args.maxDebt
-		}
+			maxDebt: args.maxDebt,
+			minDebt: args.minDebt ?? 0n,
+			isPaused: facadePaused,
+			expirable: expirationDate > 0,
+			expirationDate,
+			maxDebtPerBlockMultiplier: args.maxDebtPerBlockMultiplier ?? 2,
+			forbiddenTokensMask
+		},
+		market,
+		isPaused: facadePaused || poolPaused,
+		strategyTargetCollateral: args.strategyTargetCollateral ?? collateralTokens.find((t) => t !== args.underlying.toLowerCase()),
+		isExpired: expirationDate > 0 && expirationDate < (args.timestamp ?? 0)
 	};
 	const routeCalls = (tokenIn, tokenOut) => {
 		const underlying = args.underlying.toLowerCase();
@@ -113,10 +190,6 @@ function buildMockSdk(args) {
 		return [MOCK_ROUTER_CALL];
 	};
 	const router = {
-		findBestClosePath: vitest.vi.fn(async () => {
-			if (!args.closePath) throw new Error("mock router: closePath not configured");
-			return args.closePath;
-		}),
 		findOneTokenPath: vitest.vi.fn(async ({ amount, tokenIn, tokenOut }) => ({
 			amount,
 			minAmount: amount,
@@ -131,20 +204,84 @@ function buildMockSdk(args) {
 				calls: routeCalls(tokenIn, target)
 			};
 		}),
-		findOpenStrategyPath: vitest.vi.fn(async ({ expectedBalances, leftoverBalances }) => {
-			const spent = expectedBalances.reduce((acc, a) => acc + a.balance, 0n) - leftoverBalances.reduce((acc, a) => acc + a.balance, 0n);
+		findOpenStrategyPath: vitest.vi.fn(async ({ expectedBalances, leftoverBalances, target }) => {
+			const targetLc = target.toLowerCase();
+			const leftover = new Map(leftoverBalances.map((a) => [a.token.toLowerCase(), a.balance]));
+			const balances = {};
+			let amount = 0n;
+			for (const a of expectedBalances) {
+				const token = a.token.toLowerCase();
+				if (token === targetLc) {
+					balances[token] = (balances[token] ?? 0n) + a.balance;
+					continue;
+				}
+				const keep = leftover.get(token) ?? 0n;
+				const spend = a.balance > keep ? a.balance - keep : 0n;
+				balances[token] = a.balance - spend;
+				amount += convert(token, targetLc, spend);
+			}
+			balances[targetLc] = (balances[targetLc] ?? 0n) + amount;
 			return {
-				amount: spent,
-				minAmount: spent,
-				calls: [MOCK_ROUTER_CALL],
-				minAssets: [],
-				averageAssets: []
+				amount,
+				minAmount: amount,
+				balances,
+				minBalances: { ...balances },
+				calls: [MOCK_ROUTER_CALL]
+			};
+		}),
+		findBestClosePath: vitest.vi.fn(async ({ balances }) => {
+			const underlying = args.underlying.toLowerCase();
+			const sold = (balances?.expectedBalances ?? []).filter((a) => a.token.toLowerCase() !== underlying && a.balance > 10n);
+			const amount = sold.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
+			return {
+				amount,
+				minAmount: amount,
+				underlyingBalance: amount,
+				calls: sold.length === 0 ? [] : [MOCK_CLOSE_CALL]
 			};
 		})
 	};
-	return {
+	const phantoms = new Set((args.phantoms ?? []).map((t) => t.toLowerCase()));
+	const venuesOf = (token) => args.delayed?.[token.toLowerCase()] ?? [];
+	const withdrawalCompressor = args.delayed ? { findWithdrawableAssets: vitest.vi.fn(async (creditManager, token) => venuesOf(token).map((v) => ({
+		creditManager,
+		token,
+		withdrawalPhantomToken: v.withdrawalPhantomToken,
+		underlying: v.underlying ?? args.underlying,
+		withdrawalLength: 172800n
+	}))) } : void 0;
+	const previewDelayedWithdrawal = vitest.vi.fn(async ({ token, amount, withdrawalPhantomToken }) => {
+		const venue = venuesOf(token).find((v) => v.withdrawalPhantomToken === withdrawalPhantomToken) ?? venuesOf(token)[0];
+		if (!venue) throw new Error(`mock compressor: ${token} has no delayed route`);
+		return {
+			token,
+			amountIn: amount,
+			outputs: venue.outputs?.(amount) ?? [{
+				token: venue.withdrawalPhantomToken,
+				amount,
+				isDelayed: true
+			}],
+			requestCalls: [MOCK_REQUEST_CALL],
+			claimableAt: venue.claimableAt ?? 172800n
+		};
+	});
+	const sdk = {
+		chainId: 1,
+		currentBlock: 1n,
+		timestamp: args.timestamp ?? 0,
+		withdrawalCompressor,
 		tokensMeta: {
-			get: (token) => ({ decimals: decimalsOf(token) }),
+			get: (token) => ({
+				decimals: decimalsOf(token),
+				contractType: phantoms.has(token.toLowerCase()) ? "PHANTOM_TOKEN::SECURITIZE_RD" : void 0
+			}),
+			mustGetToken: (token) => ({
+				chainId: 1,
+				address: token,
+				symbol: "TOKEN",
+				name: "TOKEN",
+				decimals: decimalsOf(token)
+			}),
 			rwaUnderlyings: { get: (token) => {
 				const asset = args.rwaAssets?.[token.toLowerCase()];
 				return asset ? { asset } : void 0;
@@ -156,23 +293,53 @@ function buildMockSdk(args) {
 		},
 		routerFor: vitest.vi.fn(() => router),
 		accounts: {
+			getCreditAccountData: vitest.vi.fn(async (address) => {
+				const slice = args.creditAccounts?.find((ca) => ca.creditAccount.toLowerCase() === address.toLowerCase());
+				return slice ? payloadOf(slice) : void 0;
+			}),
 			assembleCaOperations: vitest.vi.fn(({ operations }) => operations.flatMap(echoEncodableOpCalls)),
 			prepareIncreaseDebt: vitest.vi.fn(() => CA_OP_CALLS.increaseDebt),
 			prepareChangeDebt: vitest.vi.fn(() => CA_OP_CALLS.decreaseDebt),
 			prepareAddCollateral: vitest.vi.fn(() => [CA_OP_CALLS.addCollateral]),
 			prepareWithdrawToken: vitest.vi.fn(() => CA_OP_CALLS.withdrawCollateral),
 			prepareUpdateQuotas: vitest.vi.fn(() => [CA_OP_CALLS.changeQuota]),
-			assembleClaimDelayedCalls: vitest.vi.fn(({ claimableNow }) => [...claimableNow.claimCalls]),
-			assembleCloseCreditAccountCalls: vitest.vi.fn(async () => [MOCK_CLOSE_CALL]),
 			assembleRWAWrapCalls: vitest.vi.fn(async () => [MOCK_RWA_WRAP_CALL]),
-			assembleRWAUnwrapCalls: vitest.vi.fn(async () => [MOCK_RWA_UNWRAP_CALL])
+			assembleRWAUnwrapCalls: vitest.vi.fn(async () => [MOCK_RWA_UNWRAP_CALL]),
+			previewDelayedWithdrawal,
+			assembleStartDelayedWithdrawalCalls: vitest.vi.fn(({ preview }) => [...preview.requestCalls]),
+			assembleClaimDelayedCalls: vitest.vi.fn(({ claimableNow }) => [...claimableNow.claimCalls])
 		}
 	};
+	Object.assign(sdk, { positions: new require_sdk_positions_PositionsService.PositionsService(sdk) });
+	return sdk;
+}
+/** A full account payload carrying exactly what the slice builder reads back. */
+function payloadOf(slice) {
+	return {
+		creditAccount: slice.creditAccount,
+		creditManager: slice.creditManager,
+		creditFacade: slice.creditFacade,
+		underlying: slice.underlying,
+		owner: slice.creditAccount,
+		expirationDate: 0,
+		enabledTokensMask: slice.enabledTokensMask,
+		debt: slice.accountDebt,
+		accruedInterest: 0n,
+		accruedFees: 0n,
+		totalDebtUSD: slice.totalDebtUSD,
+		totalValueUSD: 0n,
+		twvUSD: 0n,
+		totalValue: 0n,
+		healthFactor: 0n,
+		success: true,
+		tokens: slice.tokens
+	};
 }
 //#endregion
 exports.CA_OP_CALLS = CA_OP_CALLS;
 exports.MOCK_CLAIM_CALL = MOCK_CLAIM_CALL;
 exports.MOCK_CLOSE_CALL = MOCK_CLOSE_CALL;
+exports.MOCK_REQUEST_CALL = MOCK_REQUEST_CALL;
 exports.MOCK_ROUTER_CALL = MOCK_ROUTER_CALL;
 exports.MOCK_RWA_UNWRAP_CALL = MOCK_RWA_UNWRAP_CALL;
 exports.MOCK_RWA_WRAP_CALL = MOCK_RWA_WRAP_CALL;

package/dist/cjs/sdk/accounts/intents/tests/add-collateral.fixtures.js

@@ -0,0 +1,123 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_market = require("../testing/market.js");
+//#region src/sdk/accounts/intents/tests/add-collateral.fixtures.ts
+/**
+* Start add-collateral fixtures (intent 5).
+*
+* Only the position token can be deposited, so every case is a single
+* `addCollateral` plus the quota increase implied by the new balance. Debt never
+* moves.
+*/
+/** Quota bought for a freshly obtained balance: value in UND scaled by its LT. */
+function quotaFor(amount, token, lt) {
+	return require_market.valueInUnd(amount, token) * lt / 10000n;
+}
+const LT_ANY = 9200n;
+/** 1000 UND of pre-existing collateral, 500 UND of debt. */
+const BASE_UND = 100000000000n;
+const DEBT = 50000000000n;
+/** 2000 ANY = 1000 UND at fixture prices. */
+const ADD_ANY = 2000000000000000000000n;
+/** 500 UND. */
+const ADD_UND = 50000000000n;
+/** 1000 RWA_ASSET = 1000 UND at fixture prices. */
+const ADD_RWA = 100000000000n;
+const QUOTA_ANY = quotaFor(ADD_ANY, require_market.ANY, LT_ANY);
+const QUOTA_RWA = quotaFor(ADD_RWA, require_market.RWA_ASSET, LT_ANY);
+/** Position token with a quota: addCollateral then buy quota for it. */
+const case_position_token = {
+	intent: {
+		type: "ADD_COLLATERAL",
+		token: require_market.ANY,
+		amount: ADD_ANY
+	},
+	tokens: [require_market.caToken(require_market.UND, BASE_UND)],
+	accountDebt: DEBT,
+	totalValue: BASE_UND + require_market.valueInUnd(ADD_ANY, require_market.ANY),
+	ops: [{
+		type: "addCollateral",
+		token: require_market.ANY,
+		amount: ADD_ANY,
+		value: void 0
+	}, {
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: require_market.ANY,
+			balance: QUOTA_ANY
+		}],
+		quotaDecrease: [],
+		desiredQuota: {}
+	}]
+};
+/** Underlying has no quota, so the flow is a bare addCollateral. */
+const case_underlying = {
+	intent: {
+		type: "ADD_COLLATERAL",
+		token: require_market.UND,
+		amount: ADD_UND
+	},
+	tokens: [require_market.caToken(require_market.ANY, ADD_ANY, QUOTA_ANY)],
+	accountDebt: DEBT,
+	totalValue: require_market.valueInUnd(ADD_ANY, require_market.ANY) + ADD_UND,
+	ops: [{
+		type: "addCollateral",
+		token: require_market.UND,
+		amount: ADD_UND,
+		value: void 0
+	}]
+};
+/** RWA market: the rwa asset is deposited as-is, with no wrap leg. */
+const case_rwa_asset = {
+	intent: {
+		type: "ADD_COLLATERAL",
+		token: require_market.RWA_ASSET,
+		amount: ADD_RWA
+	},
+	tokens: [require_market.caToken(require_market.UND, BASE_UND)],
+	accountDebt: DEBT,
+	totalValue: BASE_UND + require_market.valueInUnd(ADD_RWA, require_market.RWA_ASSET),
+	ops: [{
+		type: "addCollateral",
+		token: require_market.RWA_ASSET,
+		amount: ADD_RWA,
+		value: void 0
+	}, {
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: require_market.RWA_ASSET,
+			balance: QUOTA_RWA
+		}],
+		quotaDecrease: [],
+		desiredQuota: {}
+	}],
+	rwaAssets: { [require_market.UND]: require_market.RWA_ASSET }
+};
+function buildAddCollateralSdk(c) {
+	return require_market.buildMarketSdk({ rwaAssets: c.rwaAssets });
+}
+function buildAddCollateralProps(c, sdk) {
+	return {
+		intent: c.intent,
+		creditAccount: require_market.buildFixtureCreditAccount({
+			accountDebt: c.accountDebt,
+			tokens: c.tokens
+		}),
+		sdk,
+		quotaReserve: void 0,
+		slippage: void 0
+	};
+}
+//#endregion
+exports.ADD_ANY = ADD_ANY;
+exports.ADD_RWA = ADD_RWA;
+exports.ADD_UND = ADD_UND;
+exports.BASE_UND = BASE_UND;
+exports.DEBT = DEBT;
+exports.LT_ANY = LT_ANY;
+exports.QUOTA_ANY = QUOTA_ANY;
+exports.QUOTA_RWA = QUOTA_RWA;
+exports.buildAddCollateralProps = buildAddCollateralProps;
+exports.buildAddCollateralSdk = buildAddCollateralSdk;
+exports.case_position_token = case_position_token;
+exports.case_rwa_asset = case_rwa_asset;
+exports.case_underlying = case_underlying;