@gearbox-protocol/sdk 16.0.0-next.3 → 16.0.0-next.5

package/dist/esm/onchain/accounts/intents/tests/withdraw.fixtures.js

@@ -0,0 +1,402 @@
+import { POS, POS2, RWA_ASSET, UND, WALLET, buildFixtureCreditAccount, buildMarketSdk, caToken } from "../testing/market.js";
+//#region src/onchain/accounts/intents/tests/withdraw.fixtures.ts
+/**
+* Start withdraw fixtures (intent 2.1) — one per row of the S/T matrix.
+*
+* Every case starts from 2000 UND of TVL against 1000 UND of debt: 1000 UND of
+* collateral at 2x. Withdrawing 100 UND of value therefore repays 100 of debt
+* (`dD = D0 * W / C0`), so 200 UND of value must be liquidated in total and the
+* account settles at 1800 TVL / 900 debt — still 2x.
+*
+* `POS` and `POS2` both convert 1:1 with `UND`, keeping swap amounts honest
+* against the mock router, which echoes its input amount.
+*/
+const LT = 9200n;
+const quotaOf = (balance) => balance * LT / 10000n;
+/** 100 UND of value leaving the account. */
+const W = 10000000000n;
+/** Payout plus proportional repayment. */
+const SPEND = 2n * W;
+const TVL_BEFORE = 200000000000n;
+const DEBT_BEFORE = 100000000000n;
+const TVL_AFTER = TVL_BEFORE - SPEND;
+const DEBT_AFTER = DEBT_BEFORE - W;
+const QUOTA_BEFORE = quotaOf(TVL_BEFORE);
+const QUOTA_AFTER = quotaOf(TVL_AFTER);
+/** Quota ops carry signed deltas. */
+const QUOTA_DELTA = QUOTA_AFTER - QUOTA_BEFORE;
+const base = {
+	accountDebt: DEBT_BEFORE,
+	totalValue: TVL_AFTER,
+	accountDebtAfter: DEBT_AFTER
+};
+/** Row 1 — S = U, T = U: repay, then hand over the underlying. */
+const case_und_und = {
+	...base,
+	intent: {
+		type: "WITHDRAW",
+		amount: W,
+		to: WALLET
+	},
+	tokens: [caToken(UND, TVL_BEFORE)],
+	ops: [{
+		type: "decreaseDebt",
+		amount: W
+	}, {
+		type: "withdrawCollateral",
+		token: UND,
+		amount: W,
+		to: WALLET
+	}]
+};
+/** Row 2 — S = U, T = POS: repay, then route the payout out of the underlying. */
+const case_und_pos = {
+	...base,
+	intent: {
+		type: "WITHDRAW",
+		amount: W,
+		to: WALLET,
+		tokenOut: POS
+	},
+	tokens: [caToken(UND, TVL_BEFORE)],
+	ops: [
+		{
+			type: "decreaseDebt",
+			amount: W
+		},
+		{
+			type: "swap",
+			from: [{
+				token: UND,
+				balance: W
+			}],
+			tokenOut: POS,
+			amountOut: W
+		},
+		{
+			type: "withdrawCollateral",
+			token: POS,
+			amount: W,
+			to: WALLET
+		}
+	]
+};
+/** Row 3 — S = POS, T = U: both legs land in the underlying, so one swap covers them. */
+const case_pos_und = {
+	...base,
+	intent: {
+		type: "WITHDRAW",
+		amount: W,
+		to: WALLET,
+		sourceToken: POS
+	},
+	tokens: [caToken(POS, TVL_BEFORE, QUOTA_BEFORE)],
+	ops: [
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: SPEND
+			}],
+			tokenOut: UND,
+			amountOut: SPEND
+		},
+		{
+			type: "decreaseDebt",
+			amount: W
+		},
+		{
+			type: "withdrawCollateral",
+			token: UND,
+			amount: W,
+			to: WALLET
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: POS,
+				balance: QUOTA_DELTA
+			}],
+			desiredQuota: {}
+		}
+	]
+};
+/** Row 4 — S = T = POS: only the repayment needs routing. */
+const case_pos_pos = {
+	...base,
+	intent: {
+		type: "WITHDRAW",
+		amount: W,
+		to: WALLET,
+		sourceToken: POS,
+		tokenOut: POS
+	},
+	tokens: [caToken(POS, TVL_BEFORE, QUOTA_BEFORE)],
+	ops: [
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: W
+			}],
+			tokenOut: UND,
+			amountOut: W
+		},
+		{
+			type: "decreaseDebt",
+			amount: W
+		},
+		{
+			type: "withdrawCollateral",
+			token: POS,
+			amount: W,
+			to: WALLET
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: POS,
+				balance: QUOTA_DELTA
+			}],
+			desiredQuota: {}
+		}
+	]
+};
+/** Row 5 — S = POS, T = POS2: two independent legs out of the same source. */
+const case_pos_pos2 = {
+	...base,
+	intent: {
+		type: "WITHDRAW",
+		amount: W,
+		to: WALLET,
+		sourceToken: POS,
+		tokenOut: POS2
+	},
+	tokens: [caToken(POS, TVL_BEFORE, QUOTA_BEFORE)],
+	ops: [
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: W
+			}],
+			tokenOut: UND,
+			amountOut: W
+		},
+		{
+			type: "decreaseDebt",
+			amount: W
+		},
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: W
+			}],
+			tokenOut: POS2,
+			amountOut: W
+		},
+		{
+			type: "withdrawCollateral",
+			token: POS2,
+			amount: W,
+			to: WALLET
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: POS,
+				balance: QUOTA_DELTA
+			}],
+			desiredQuota: {}
+		}
+	]
+};
+/** RWA market: the underlying payout is force-unwrapped to the asset. */
+const case_rwa_payout = {
+	...base,
+	intent: {
+		type: "WITHDRAW",
+		amount: W,
+		to: WALLET,
+		sourceToken: POS
+	},
+	tokens: [caToken(POS, TVL_BEFORE, QUOTA_BEFORE)],
+	ops: [
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: SPEND
+			}],
+			tokenOut: UND,
+			amountOut: SPEND
+		},
+		{
+			type: "decreaseDebt",
+			amount: W
+		},
+		{
+			type: "unwrapRwaCollateral",
+			tokenIn: UND,
+			amount: W,
+			tokenOut: RWA_ASSET,
+			amountOut: W
+		},
+		{
+			type: "withdrawCollateral",
+			token: RWA_ASSET,
+			amount: W,
+			to: WALLET
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: POS,
+				balance: QUOTA_DELTA
+			}],
+			desiredQuota: {}
+		}
+	],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+/** Matrix baseline: 10A of position against 8U of debt (2U collateral at 5x). */
+const M4_BALANCE = 1000000000n;
+const M4_DEBT = 800000000n;
+/** Matrix payout W: 1U. */
+const M4_W = 100000000n;
+/** Proportional repayment `dD = D0 * W / C0` = 4U. */
+const M4_DD = 400000000n;
+/** Payout plus repayment: 5U liquidated in total. */
+const M4_SPEND = 500000000n;
+/**
+* Matrix 4.1 — withdraw 1U, source `POS`, payout `UND`.
+*
+* MATRIX MISMATCH: the matrix pays out first — `swap → withdrawCollateral →
+* decreaseDebt → changeQuota`. The engine repays before paying out
+* (`repay(dD, keep: W)` precedes the payout leg in `planWithdraw`):
+* `swap → decreaseDebt → withdrawCollateral → changeQuota`. Amounts are
+* identical; only the order differs.
+*/
+const case_matrix_4_1 = {
+	intent: {
+		type: "WITHDRAW",
+		amount: M4_W,
+		to: WALLET,
+		sourceToken: POS
+	},
+	tokens: [caToken(POS, M4_BALANCE, quotaOf(M4_BALANCE))],
+	accountDebt: M4_DEBT,
+	totalValue: M4_SPEND,
+	accountDebtAfter: M4_DD,
+	ops: [
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: M4_SPEND
+			}],
+			tokenOut: UND,
+			amountOut: M4_SPEND
+		},
+		{
+			type: "decreaseDebt",
+			amount: M4_DD
+		},
+		{
+			type: "withdrawCollateral",
+			token: UND,
+			amount: M4_W,
+			to: WALLET
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: POS,
+				balance: quotaOf(M4_SPEND) - quotaOf(M4_BALANCE)
+			}],
+			desiredQuota: {}
+		}
+	]
+};
+/**
+* Matrix 4.2 — 4.1 on the RWA market: the payout is unwrapped on the way out.
+*
+* MATRIX MISMATCH: same ordering divergence as 4.1 — the matrix expects
+* `swap → unwrapRwaCollateral → withdrawCollateral(RWA) → decreaseDebt →
+* changeQuota`, the engine repays first:
+* `swap → decreaseDebt → unwrapRwaCollateral → withdrawCollateral(RWA) →
+* changeQuota`.
+*/
+const case_matrix_4_2 = {
+	intent: {
+		type: "WITHDRAW",
+		amount: M4_W,
+		to: WALLET,
+		sourceToken: POS
+	},
+	tokens: [caToken(POS, M4_BALANCE, quotaOf(M4_BALANCE))],
+	accountDebt: M4_DEBT,
+	totalValue: M4_SPEND,
+	accountDebtAfter: M4_DD,
+	ops: [
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: M4_SPEND
+			}],
+			tokenOut: UND,
+			amountOut: M4_SPEND
+		},
+		{
+			type: "decreaseDebt",
+			amount: M4_DD
+		},
+		{
+			type: "unwrapRwaCollateral",
+			tokenIn: UND,
+			amount: M4_W,
+			tokenOut: RWA_ASSET,
+			amountOut: M4_W
+		},
+		{
+			type: "withdrawCollateral",
+			token: RWA_ASSET,
+			amount: M4_W,
+			to: WALLET
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: POS,
+				balance: quotaOf(M4_SPEND) - quotaOf(M4_BALANCE)
+			}],
+			desiredQuota: {}
+		}
+	],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+function buildWithdrawSdk(c) {
+	return buildMarketSdk({ rwaAssets: c.rwaAssets });
+}
+function buildWithdrawProps(c, sdk) {
+	return {
+		intent: c.intent,
+		creditAccount: buildFixtureCreditAccount({
+			accountDebt: c.accountDebt,
+			tokens: c.tokens
+		}),
+		sdk,
+		quotaReserve: void 0,
+		slippage: void 0
+	};
+}
+//#endregion
+export { DEBT_AFTER, DEBT_BEFORE, M4_BALANCE, M4_DD, M4_DEBT, M4_SPEND, M4_W, QUOTA_AFTER, QUOTA_BEFORE, QUOTA_DELTA, SPEND, TVL_AFTER, TVL_BEFORE, W, buildWithdrawProps, buildWithdrawSdk, case_matrix_4_1, case_matrix_4_2, case_pos_pos, case_pos_pos2, case_pos_und, case_rwa_payout, case_und_pos, case_und_und };

package/dist/esm/onchain/accounts/intents/types.js

@@ -0,0 +1,16 @@
+//#region src/onchain/accounts/intents/types.ts
+/**
+* Validation failure that maps onto {@link PreviewErrorReason} rather than
+* crashing the caller: thrown by builders, converted to `{ ok: false }` by
+* `CreditAccountOperationsService.startIntent`.
+*/
+var IntentPreviewError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message ?? reason);
+		this.name = "IntentPreviewError";
+		this.reason = reason;
+	}
+};
+//#endregion
+export { IntentPreviewError };

package/dist/esm/onchain/accounts/intents/utils/adjust-state-to-snapshot.js

@@ -0,0 +1,20 @@
+//#region src/onchain/accounts/intents/utils/adjust-state-to-snapshot.ts
+/**
+* Maps an intents {@link OperationState} onto the {@link AccountSnapshot} that
+* position-metric functions take. `accountDebt` is treated as total debt
+* (principal plus accrued interest and fees).
+**/
+function adjustStateToSnapshot(creditManager, state) {
+	return {
+		creditManager,
+		assets: state.assets.map((a) => ({
+			token: a.token.address,
+			balance: a.value
+		})),
+		quotas: Object.values(state.quotas),
+		totalDebt: state.accountDebt,
+		totalValue: state.totalValue
+	};
+}
+//#endregion
+export { adjustStateToSnapshot };

package/dist/esm/onchain/accounts/intents/utils/assemble-operation-calls.js

@@ -0,0 +1,6 @@
+//#region src/onchain/accounts/intents/utils/assemble-operation-calls.ts
+function assembleOperationCalls({ operations }) {
+	return operations.flatMap((operation) => operation.calls);
+}
+//#endregion
+export { assembleOperationCalls };

package/dist/esm/onchain/accounts/intents/utils/borrowed-amount-plus-interest-and-fees.js

@@ -0,0 +1,12 @@
+//#region src/onchain/accounts/intents/utils/borrowed-amount-plus-interest-and-fees.ts
+/**
+* Total debt of a credit account: principal + accrued interest + accrued fees.
+*
+* On the v3 SDK `CreditAccountData` the parts
+* come as separate `debt` / `accruedInterest` / `accruedFees` fields.
+*/
+function calcBorrowedAmountPlusInterestAndFees(ca) {
+	return ca.debt + ca.accruedInterest + ca.accruedFees;
+}
+//#endregion
+export { calcBorrowedAmountPlusInterestAndFees };

package/dist/esm/onchain/accounts/intents/utils/common.js

@@ -0,0 +1,40 @@
+import { AddressMap } from "../../../utils/AddressMap.js";
+//#region src/onchain/accounts/intents/utils/common.ts
+/** Case-insensitive address equality. */
+const eq = (a, b) => a.toLowerCase() === b.toLowerCase();
+function toTargetDecimals(fromAmount, fromToken, toToken, sdk) {
+	const fromDecimals = sdk.tokensMeta.get(fromToken)?.decimals ?? 18;
+	const toDecimals = sdk.tokensMeta.get(toToken)?.decimals ?? 18;
+	return fromAmount * 10n ** BigInt(toDecimals) / 10n ** BigInt(fromDecimals);
+}
+/**
+* Router CA slice from the account slice. RouterV310 reads `ca.tokens` for
+* underlyingBalance, so balances are overlaid with the post-claim projection
+* (legacy `overlayExpectedBalancesOntoCaTokens`): existing tokens keep quota
+* with balance from the projection (0n when absent), new tokens get quota 0n.
+*/
+function toRouterCaSlice(creditAccount, expectedBalances = []) {
+	const { accountDebt, underlying, creditFacade, creditManager, creditAccount: creditAccountAddress, tokens: _, ...restCA } = creditAccount;
+	const expected = new AddressMap([]);
+	for (const asset of expectedBalances ?? []) expected.upsert(asset.token, (expected.get(asset.token) ?? 0n) + asset.balance);
+	const tokens = creditAccount.tokens.map((t) => {
+		const token = t.token.toLowerCase();
+		const balance = expected.get(token) ?? t.balance;
+		return {
+			...t,
+			token,
+			balance
+		};
+	});
+	return {
+		...restCA,
+		underlying: underlying.toLowerCase(),
+		creditAccount: creditAccountAddress.toLowerCase(),
+		creditFacade: creditFacade.toLowerCase(),
+		creditManager: creditManager.toLowerCase(),
+		debt: creditAccount.accountDebt,
+		tokens
+	};
+}
+//#endregion
+export { eq, toRouterCaSlice, toTargetDecimals };

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

@@ -0,0 +1,36 @@
+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 };

package/dist/esm/onchain/accounts/intents/utils/credit-account-slice.js

@@ -0,0 +1,43 @@
+import { calcBorrowedAmountPlusInterestAndFees } from "./borrowed-amount-plus-interest-and-fees.js";
+//#region src/onchain/accounts/intents/utils/credit-account-slice.ts
+/**
+* Narrows full account data down to the slice the intent engine operates on.
+*
+* `accountDebt` is the total repayable debt (principal + accrued interest +
+* accrued fees) rather than the principal, because every debt-touching intent
+* settles the full outstanding amount.
+*
+* Addresses are lowercased so that `eq` comparisons and `AddressMap` lookups
+* behave consistently everywhere downstream.
+*/
+function toCreditAccountSlice(ca) {
+	return {
+		creditAccount: ca.creditAccount.toLowerCase(),
+		creditManager: ca.creditManager.toLowerCase(),
+		creditFacade: ca.creditFacade.toLowerCase(),
+		underlying: ca.underlying.toLowerCase(),
+		enabledTokensMask: ca.enabledTokensMask,
+		totalDebtUSD: ca.totalDebtUSD,
+		accountDebt: calcBorrowedAmountPlusInterestAndFees(ca),
+		tokens: ca.tokens.map((t) => ({
+			...t,
+			token: t.token.toLowerCase()
+		}))
+	};
+}
+/**
+* Reads an account by address and narrows it to {@link CreditAccountSlice}.
+*
+* The shared read model's `StrategyPosition` carries neither `tokens` nor
+* `enabledTokensMask` / `creditFacade` / `totalDebtUSD`, so simulating against
+* an existing position costs one account read.
+*
+* @throws When the account is not found in the connected markets.
+*/
+async function fetchCreditAccountSlice(sdk, creditAccount) {
+	const data = await sdk.accounts.getCreditAccountData(creditAccount);
+	if (!data) throw new Error(`credit account not found: ${creditAccount}`);
+	return toCreditAccountSlice(data);
+}
+//#endregion
+export { fetchCreditAccountSlice, toCreditAccountSlice };

package/dist/esm/onchain/accounts/intents/utils/ledger.js

@@ -0,0 +1,93 @@
+import { BigIntMath } from "../../../utils/bigint-math.js";
+//#region src/onchain/accounts/intents/utils/ledger.ts
+/**
+* Running account state, advanced one operation at a time.
+*
+* Exists because the amounts an operation is built from depend on the balances
+* the previous ones left behind: a swap has to know how much of its input token
+* is genuinely swap input, so the router does not sweep collateral that must
+* stay put. Applying each op as it is built keeps that a single forward pass —
+* a builder that re-simulated the chain from the start for every leg would be
+* quadratic in the number of legs and easy to desynchronise.
+*/
+var OperationLedger = class {
+	#balances = /* @__PURE__ */ new Map();
+	#underlying;
+	#convert;
+	#debt;
+	constructor(args) {
+		this.#underlying = args.underlying;
+		this.#convert = args.convert;
+		this.#debt = args.debt;
+		for (const asset of args.initialAssets) {
+			const token = asset.token.toLowerCase();
+			this.#balances.set(token, (this.#balances.get(token) ?? 0n) + asset.balance);
+		}
+	}
+	get debt() {
+		return this.#debt;
+	}
+	balanceOf(token) {
+		return this.#balances.get(token.toLowerCase()) ?? 0n;
+	}
+	applyAll(operations) {
+		for (const op of operations) this.apply(op);
+		return this;
+	}
+	snapshot() {
+		const assets = [...this.#balances.entries()].map(([token, balance]) => ({
+			token,
+			balance
+		}));
+		return {
+			assets,
+			totalValue: assets.reduce((acc, a) => acc + this.#convert(a.token, this.#underlying, a.balance), 0n),
+			debt: this.#debt
+		};
+	}
+	/** Advances the state by one operation; quota changes move no balance. */
+	apply(op) {
+		switch (op.type) {
+			case "changeQuota": break;
+			case "increaseDebt":
+				this.#debt += op.amount;
+				this.#add(this.#underlying, op.amount);
+				break;
+			case "decreaseDebt":
+				this.#debt = BigIntMath.max(0n, this.#debt - op.amount);
+				this.#add(this.#underlying, -op.amount);
+				break;
+			case "addCollateral":
+				this.#add(op.token, op.amount);
+				break;
+			case "withdrawCollateral":
+				this.#add(op.token, -op.amount);
+				break;
+			case "swap":
+				for (const input of op.from) this.#add(input.token, -input.balance);
+				this.#add(op.tokenOut, op.amountOut);
+				break;
+			case "wrapRwaCollateral":
+			case "unwrapRwaCollateral":
+				this.#add(op.tokenIn, -op.amount);
+				this.#add(op.tokenOut, op.amountOut);
+				break;
+			case "startDelayedWithdrawal":
+				this.#add(op.token, -op.amountIn);
+				for (const out of op.outputs) this.#add(out.token, out.amount);
+				break;
+			case "claimDelayedWithdrawal":
+				this.#add(op.withdrawalPhantomToken, -op.withdrawalTokenSpent);
+				for (const out of op.outputs) this.#add(out.token, out.amount);
+		}
+		return this;
+	}
+	#add(token, delta) {
+		const key = token.toLowerCase();
+		const balance = (this.#balances.get(key) ?? 0n) + delta;
+		if (balance <= 0n) this.#balances.delete(key);
+		else this.#balances.set(key, balance);
+	}
+};
+//#endregion
+export { OperationLedger };