@gearbox-protocol/sdk 14.12.0-next.69 → 14.12.0-next.70

package/dist/esm/sdk/accounts/intents/intents/resume/withdraw/withdraw.js

@@ -0,0 +1,160 @@
+import { BigIntMath } from "../../../../../utils/bigint-math.js";
+import { eq } from "../../../utils/common.js";
+import { convertAmount } from "../../../utils/convert-amount.js";
+import { simulateState } from "../../../utils/simulate-adjust-state.js";
+import "../../../utils/index.js";
+import { buildClaimDelayedWithdrawalOperation, primaryInstantOutput } from "../../../operations/claim-delayed/index.js";
+import { buildDecreaseDebtOperation } from "../../../operations/decrease-debt/index.js";
+import { buildSwapOperation } from "../../../operations/swap/index.js";
+import { buildWithdrawCollateralOperation } from "../../../operations/withdraw-collateral/index.js";
+import "../../../operations/index.js";
+//#region src/sdk/accounts/intents/intents/resume/withdraw/withdraw.ts
+const ZERO_QUOTE = {
+	amount: 0n,
+	minAmount: 0n,
+	calls: []
+};
+/**
+* Resume withdraw — linear op chain following the W-first matrix:
+* claim → (swap?) → decreaseDebt? → (unwrapRwa?) → withdrawCollateral.
+* Only the underlying token (or the unwrapped rwa.asset on RWA markets) can
+* be withdrawn (enforced below).
+* The delayed lean intent records debt already paid at start; only its
+* residual `debtRepaid` may consume claimed proceeds.
+*
+* Matrix arithmetic (split sizing) is oracle-priced; emitted swap legs go
+* through the given quoter (`amountOut` on the op, `minAmountOut` caps the
+* debt repay funded by the leg). Mirrors legacy
+* `buildWithdrawResumeLogicalOps` + `resolveSwapBranches` (simplified: no
+* min/avg op branches).
+*/
+async function buildResumeWithdrawOperations(props, quoter) {
+	const { intent, options, creditAccount, sdk } = props;
+	const underlying = creditAccount.underlying;
+	const rwaMeta = sdk.tokensMeta.rwaUnderlyings.get(underlying);
+	if (!eq(intent.withdrawToken, underlying) && !eq(intent.withdrawToken, rwaMeta?.asset ?? "")) throw new Error("Withdraw intent should withdraw underlying token only");
+	const claimOp = buildClaimDelayedWithdrawalOperation({
+		creditAccount,
+		sdk
+	}, options);
+	const primary = primaryInstantOutput(claimOp.outputs);
+	if (!primary || primary.amount <= 0n) throw new Error("No claimable assets");
+	const convert = convertAmount(sdk, creditAccount.creditManager);
+	const operations = [claimOp];
+	const swap = async (tokenIn, amountIn, tokenOut) => {
+		if (amountIn <= 0n) return ZERO_QUOTE;
+		const { state } = simulateState({
+			operations,
+			creditAccount,
+			sdk,
+			quotaReserve: props.quotaReserve
+		});
+		const tokenInBalance = state.assets.find((asset) => eq(asset.token, tokenIn))?.balance ?? 0n;
+		const quote = await quoter({
+			from: [{
+				token: tokenIn,
+				balance: amountIn
+			}],
+			tokenOut,
+			tokenInBalance
+		});
+		operations.push(buildSwapOperation({
+			tokenIn,
+			amountIn,
+			tokenOut,
+			amountOut: quote.minAmount,
+			calls: quote.calls,
+			creditAccount,
+			sdk
+		}, options));
+		return quote;
+	};
+	const decreaseDebt = (amount) => {
+		if (amount > 0n) operations.push(buildDecreaseDebtOperation({
+			amount,
+			creditAccount,
+			sdk
+		}, options));
+	};
+	const withdrawCollateral = async (amount) => {
+		const withdrawOperations = await buildWithdrawCollateralOperation({
+			token: intent.withdrawToken,
+			amount,
+			to: intent.to,
+			underlying,
+			creditAccount,
+			sdk
+		}, options);
+		operations.push(...withdrawOperations);
+	};
+	if (intent.debtRepaid === 0n) {
+		/**
+		* 2.2.x: debtRepaid === 0n means that debt was repayed on withdrawal start,
+		* So all claimed amount should be withdrawn
+		*/
+		const available = eq(primary.token, intent.withdrawToken) ? primary.amount : (await swap(primary.token, primary.amount, intent.withdrawToken)).minAmount;
+		await withdrawCollateral(BigIntMath.min(intent.withdrawAmount, available));
+	} else if (eq(intent.sourceToken, intent.withdrawToken)) {
+		/**
+		* 2.5.x: This can happen when source=target and source has delayedConfig.
+		* In this case claimed amount should be used only to repay debt
+		* and withdrawAmount can be withdrawn as is
+		*/
+		const undQuote = eq(primary.token, underlying) ? {
+			...ZERO_QUOTE,
+			amount: primary.amount,
+			minAmount: primary.amount
+		} : await swap(primary.token, primary.amount, underlying);
+		decreaseDebt(BigIntMath.min(undQuote.minAmount, intent.debtRepaid));
+		await withdrawCollateral(intent.withdrawAmount);
+	} else if (eq(intent.withdrawToken, underlying)) {
+		/**
+		* 2.3.x: Special case - withdrawToken = underlying,
+		* so the full claim amount can be swapped int underlying;
+		* reserve W from the U result, then repay from the remainder.
+		*/
+		const undQuote = eq(primary.token, underlying) ? {
+			...ZERO_QUOTE,
+			amount: primary.amount,
+			minAmount: primary.amount
+		} : await swap(primary.token, primary.amount, underlying);
+		const withdrawn = BigIntMath.min(intent.withdrawAmount, undQuote.minAmount);
+		decreaseDebt(BigIntMath.min(BigIntMath.max(undQuote.minAmount - withdrawn, 0n), intent.debtRepaid));
+		withdrawCollateral(withdrawn);
+	} else if (eq(primary.token, intent.withdrawToken)) {
+		/**
+		* 2.4.2: Special case - withdrawToken = claimedToken,
+		* so we can take part of claimed amount without conversion and swap the rest into underlying;
+		* reserve claimed T for W; only the remainder funds debt.
+		*/
+		const withdrawn = BigIntMath.min(intent.withdrawAmount, primary.amount);
+		const undQuote = await swap(primary.token, primary.amount - withdrawn, underlying);
+		decreaseDebt(BigIntMath.min(undQuote.minAmount, intent.debtRepaid));
+		withdrawCollateral(withdrawn);
+	} else if (eq(primary.token, underlying)) {
+		/**
+		* 2.4.1: Special case - underlying = claimedToken,
+		* so we can decrease debt using part of claimed amount and swap the rest into target;
+		* reserve U equivalent of W, repay with the rest, then swap W.
+		*/
+		const withdrawInUnderlying = BigIntMath.min(convert(intent.withdrawToken, primary.token, intent.withdrawAmount), primary.amount);
+		decreaseDebt(BigIntMath.min(primary.amount - withdrawInUnderlying, intent.debtRepaid));
+		const withdrawQuote = await swap(primary.token, withdrawInUnderlying, intent.withdrawToken);
+		withdrawCollateral(BigIntMath.min(intent.withdrawAmount, withdrawQuote.minAmount));
+	} else {
+		/**
+		* 2.4.3: Common case - both target and claimed token are independent tokens;
+		* Here we should reserve part of claimed amount for withdrawal and
+		* use the rest for debt repayment.
+		* split a third-token claim into independent debt and W legs.
+		*/
+		const withdrawInClaim = BigIntMath.min(convert(intent.withdrawToken, primary.token, intent.withdrawAmount), primary.amount);
+		const debtQuote = await swap(primary.token, BigIntMath.max(primary.amount - withdrawInClaim, 0n), underlying);
+		decreaseDebt(BigIntMath.min(debtQuote.minAmount, intent.debtRepaid));
+		const withdrawQuote = await swap(primary.token, withdrawInClaim, intent.withdrawToken);
+		withdrawCollateral(BigIntMath.min(intent.withdrawAmount, withdrawQuote.minAmount));
+	}
+	return operations;
+}
+//#endregion
+export { buildResumeWithdrawOperations };

package/dist/esm/sdk/accounts/intents/operations/add-collateral/index.js

@@ -0,0 +1,16 @@
+//#region src/sdk/accounts/intents/operations/add-collateral/index.ts
+function buildAddCollateralOperation(input, option) {
+	const calls = option.kind === "onchain" ? input.sdk.accounts.prepareAddCollateral(input.creditAccount.creditFacade, [{
+		token: input.token,
+		balance: input.amount
+	}], {}) : [];
+	return {
+		type: "addCollateral",
+		token: input.token,
+		amount: input.amount,
+		value: input.value,
+		calls
+	};
+}
+//#endregion
+export { buildAddCollateralOperation };

package/dist/esm/sdk/accounts/intents/operations/claim-delayed/index.js

@@ -0,0 +1,52 @@
+import { eq, toTargetDecimals } from "../../utils/common.js";
+import "../../utils/index.js";
+//#region src/sdk/accounts/intents/operations/claim-delayed/index.ts
+/**
+* Build the claim op from a matured claimable, or a simulation-only op from
+* resume claimedToken/amount when claimable is not attached.
+* Stores balances for raw call
+*/
+function buildClaimDelayedWithdrawalOperation(input, option) {
+	if (option.kind === "onchain") {
+		const calls = input.sdk.accounts.assembleClaimDelayedCalls({
+			creditFacade: input.creditAccount.creditFacade,
+			claimableNow: option.claimableWithdrawal
+		});
+		return {
+			type: "claimDelayedWithdrawal",
+			token: option.claimableWithdrawal.token.toLowerCase(),
+			withdrawalPhantomToken: option.claimableWithdrawal.withdrawalPhantomToken.toLowerCase(),
+			withdrawalTokenSpent: option.claimableWithdrawal.withdrawalTokenSpent,
+			outputs: option.claimableWithdrawal.outputs.map((o) => ({
+				...o,
+				token: o.token.toLowerCase()
+			})),
+			calls
+		};
+	}
+	return {
+		type: "claimDelayedWithdrawal",
+		token: option.withdrawalConfig.token,
+		withdrawalPhantomToken: option.withdrawalConfig.withdrawalPhantomToken,
+		withdrawalTokenSpent: option.phantomSpent,
+		outputs: [{
+			token: option.withdrawalConfig.underlying,
+			amount: toTargetDecimals(option.phantomSpent, option.withdrawalConfig.withdrawalPhantomToken, option.withdrawalConfig.underlying, input.sdk),
+			isDelayed: false
+		}],
+		calls: []
+	};
+}
+/** First positive non-delayed output (optionally restricted to `token`). */
+function primaryInstantOutput(outputs, token) {
+	for (const out of outputs) {
+		if (out.isDelayed || out.amount <= 0n) continue;
+		if (token != null && !eq(out.token, token)) continue;
+		return {
+			token: out.token,
+			amount: out.amount
+		};
+	}
+}
+//#endregion
+export { buildClaimDelayedWithdrawalOperation, primaryInstantOutput };

package/dist/esm/sdk/accounts/intents/operations/close-credit-account/index.js

@@ -0,0 +1,25 @@
+//#region src/sdk/accounts/intents/operations/close-credit-account/index.ts
+async function buildCloseCreditAccountOperation(input, option) {
+	const { quote } = input;
+	if (option.kind === "onchain") {
+		const rwaConfig = input.sdk.tokensMeta.rwaUnderlyings.get(option.creditAccount.underlying);
+		const closeCalls = await input.sdk.accounts.assembleCloseCreditAccountCalls({
+			creditAccount: option.creditAccount,
+			routerCalls: quote.calls,
+			assetsToWithdraw: [(rwaConfig?.asset ?? option.creditAccount.underlying).toLowerCase()],
+			to: option.to
+		});
+		return {
+			...quote,
+			calls: closeCalls,
+			type: "closeCreditAccount"
+		};
+	}
+	return {
+		...quote,
+		calls: [],
+		type: "closeCreditAccount"
+	};
+}
+//#endregion
+export { buildCloseCreditAccountOperation };

package/dist/esm/sdk/accounts/intents/operations/decrease-debt/index.js

@@ -0,0 +1,11 @@
+//#region src/sdk/accounts/intents/operations/decrease-debt/index.ts
+function buildDecreaseDebtOperation(input, option) {
+	const calls = option.kind === "onchain" ? [input.sdk.accounts.prepareChangeDebt(input.creditAccount.creditFacade, input.amount, true)] : [];
+	return {
+		type: "decreaseDebt",
+		amount: input.amount,
+		calls
+	};
+}
+//#endregion
+export { buildDecreaseDebtOperation };

package/dist/esm/sdk/accounts/intents/operations/increase-debt/index.js

@@ -0,0 +1,11 @@
+//#region src/sdk/accounts/intents/operations/increase-debt/index.ts
+function buildIncreaseDebtOperation(input, option) {
+	const calls = option.kind === "onchain" ? [input.sdk.accounts.prepareIncreaseDebt(input.creditAccount.creditFacade, input.amount)] : [];
+	return {
+		type: "increaseDebt",
+		amount: input.amount,
+		calls
+	};
+}
+//#endregion
+export { buildIncreaseDebtOperation };

package/dist/esm/sdk/accounts/intents/operations/index.js

@@ -0,0 +1,14 @@
+import { buildAddCollateralOperation } from "./add-collateral/index.js";
+import { buildClaimDelayedWithdrawalOperation, primaryInstantOutput } from "./claim-delayed/index.js";
+import { buildCloseCreditAccountOperation } from "./close-credit-account/index.js";
+import { buildDecreaseDebtOperation } from "./decrease-debt/index.js";
+import { buildIncreaseDebtOperation } from "./increase-debt/index.js";
+import { buildQuotaUpdateOperation } from "./quota-update/index.js";
+import { buildRepayCreditAccountOperation } from "./repay-credit-account/index.js";
+import { buildStartDelayedWithdrawalOperation } from "./start-delayed-withdrawal/index.js";
+import { buildSwapOperation } from "./swap/index.js";
+import "./types.js";
+import { buildUnwrapRwaCollateralOperation } from "./unwrap-rwa-collateral/index.js";
+import { buildWithdrawCollateralOperation } from "./withdraw-collateral/index.js";
+import { buildWrapRwaCollateralOperation } from "./wrap-rwa-collateral/index.js";
+export { buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseCreditAccountOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildRepayCreditAccountOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, primaryInstantOutput };

package/dist/esm/sdk/accounts/intents/operations/quota-update/index.js

@@ -0,0 +1,21 @@
+//#region src/sdk/accounts/intents/operations/quota-update/index.ts
+function buildQuotaUpdateOperation(input, option) {
+	const { update, creditAccount, sdk } = input;
+	let calls = [];
+	if (option.kind === "onchain") {
+		const quotaAssets = [...update.quotaIncrease, ...update.quotaDecrease];
+		if (quotaAssets.length > 0) calls = sdk.accounts.prepareUpdateQuotas(creditAccount.creditFacade, {
+			averageQuota: quotaAssets,
+			minQuota: quotaAssets
+		});
+	}
+	return {
+		type: "changeQuota",
+		desiredQuota: update.desiredQuota,
+		quotaIncrease: update.quotaIncrease,
+		quotaDecrease: update.quotaDecrease,
+		calls
+	};
+}
+//#endregion
+export { buildQuotaUpdateOperation };

package/dist/esm/sdk/accounts/intents/operations/repay-credit-account/index.js

@@ -0,0 +1,21 @@
+//#region src/sdk/accounts/intents/operations/repay-credit-account/index.ts
+async function buildRepayCreditAccountOperation(input, option) {
+	const calls = option.kind === "onchain" ? await input.sdk.accounts.assembleRepayCreditAccountCalls({
+		collateralAssets: input.expectedRepayAsset ?? [],
+		assetsToWithdraw: input.expectedWithdrawAssets ?? [],
+		creditAccount: option.creditAccount,
+		permits: option.permits,
+		to: option.to,
+		tokensToClaim: option.tokensToClaim,
+		calls: option.wrapCalls
+	}) : [];
+	return {
+		type: "repayCreditAccount",
+		expectedRepayAsset: input.expectedRepayAsset,
+		expectedWithdrawAssets: input.expectedWithdrawAssets,
+		value: input.value,
+		calls
+	};
+}
+//#endregion
+export { buildRepayCreditAccountOperation };

package/dist/esm/sdk/accounts/intents/operations/start-delayed-withdrawal/index.js

@@ -0,0 +1,17 @@
+//#region src/sdk/accounts/intents/operations/start-delayed-withdrawal/index.ts
+function buildStartDelayedWithdrawalOperation(input, option) {
+	const calls = option.kind === "onchain" ? input.sdk.accounts.assembleStartDelayedWithdrawalCalls({
+		creditFacade: input.creditAccount.creditFacade,
+		preview: input.preview
+	}) : [];
+	return {
+		type: "startDelayedWithdrawal",
+		token: input.preview.token,
+		amountIn: input.preview.amountIn,
+		outputs: [...input.preview.outputs],
+		settlement: input.settlement,
+		calls
+	};
+}
+//#endregion
+export { buildStartDelayedWithdrawalOperation };

package/dist/esm/sdk/accounts/intents/operations/swap/index.js

@@ -0,0 +1,17 @@
+//#region src/sdk/accounts/intents/operations/swap/index.ts
+/** One-to-one swap op (withdraw resume conversion legs). */
+function buildSwapOperation(input, option) {
+	if (option.kind === "onchain" && input.calls.length === 0) throw new Error("swap: missing router calls");
+	return {
+		type: "swap",
+		from: [{
+			token: input.tokenIn,
+			balance: input.amountIn
+		}],
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls: input.calls
+	};
+}
+//#endregion
+export { buildSwapOperation };

package/dist/esm/sdk/accounts/intents/operations/types.js

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

package/dist/esm/sdk/accounts/intents/operations/unwrap-rwa-collateral/index.js

@@ -0,0 +1,26 @@
+//#region src/sdk/accounts/intents/operations/unwrap-rwa-collateral/index.ts
+/** One-to-one swap op (withdraw resume conversion legs). */
+async function buildUnwrapRwaCollateralOperation(input, option) {
+	if (option.kind === "onchain") {
+		const calls = await input.sdk.accounts.getRWAUnwrapCalls(input.amountIn, input.creditAccount.creditManager);
+		if (!calls) throw new Error("unwrapRwaCollateral: no wrap calls found");
+		return {
+			type: "unwrapRwaCollateral",
+			tokenIn: input.tokenIn,
+			amount: input.amountIn,
+			tokenOut: input.tokenOut,
+			amountOut: input.amountOut,
+			calls
+		};
+	}
+	return {
+		type: "unwrapRwaCollateral",
+		tokenIn: input.tokenIn,
+		amount: input.amountIn,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls: []
+	};
+}
+//#endregion
+export { buildUnwrapRwaCollateralOperation };

package/dist/esm/sdk/accounts/intents/operations/withdraw-collateral/index.js

@@ -0,0 +1,42 @@
+import { eq, toTargetDecimals } from "../../utils/common.js";
+import "../../utils/index.js";
+import { buildUnwrapRwaCollateralOperation } from "../unwrap-rwa-collateral/index.js";
+//#region src/sdk/accounts/intents/operations/withdraw-collateral/index.ts
+/**
+* Partial-withdraw tail: RWA forced unwrap, then withdrawCollateral to wallet.
+*
+* When withdrawing the wrapped RWA underlying, forces unwrap to `rwa.asset`
+* and withdraws the unwrapped asset instead — even if the intent asked for
+* underlying (mirrors legacy `resolveRwaForcedUnwrapWithdraw`).
+*/
+async function buildWithdrawCollateralOperation(input, option) {
+	const { token, amount, to, underlying, creditAccount, sdk } = input;
+	if (amount <= 0n) throw new Error("Nothing to withdraw");
+	const buildWithdraw = (withdrawToken, withdrawAmount) => {
+		let calls = [];
+		if (option.kind === "onchain") {
+			if (to === void 0) throw new Error("withdrawCollateral.to is required for onchain calls");
+			calls = [sdk.accounts.prepareWithdrawToken(creditAccount.creditFacade, withdrawToken, withdrawAmount, to)];
+		}
+		return {
+			type: "withdrawCollateral",
+			token: withdrawToken,
+			amount: withdrawAmount,
+			to,
+			calls
+		};
+	};
+	const rwa = eq(token, underlying) ? sdk.tokensMeta.rwaUnderlyings.get(underlying) : void 0;
+	if (!rwa) return [buildWithdraw(token, amount)];
+	const amountOut = toTargetDecimals(amount, underlying, rwa.asset, sdk);
+	return [await buildUnwrapRwaCollateralOperation({
+		amountIn: amount,
+		tokenIn: underlying,
+		tokenOut: rwa.asset,
+		amountOut,
+		creditAccount,
+		sdk
+	}, option), buildWithdraw(rwa.asset, amountOut)];
+}
+//#endregion
+export { buildWithdrawCollateralOperation };

package/dist/esm/sdk/accounts/intents/operations/wrap-rwa-collateral/index.js

@@ -0,0 +1,26 @@
+//#region src/sdk/accounts/intents/operations/wrap-rwa-collateral/index.ts
+/** One-to-one wrap op (decrease-leverage resume repay from rwa.asset). */
+async function buildWrapRwaCollateralOperation(input, option) {
+	if (option.kind === "onchain") {
+		const calls = await input.sdk.accounts.getRWAWrapCalls(input.amountIn, input.creditAccount.creditManager);
+		if (!calls) throw new Error("wrapRwaCollateral: no wrap calls found");
+		return {
+			type: "wrapRwaCollateral",
+			tokenIn: input.tokenIn,
+			amount: input.amountIn,
+			tokenOut: input.tokenOut,
+			amountOut: input.amountOut,
+			calls
+		};
+	}
+	return {
+		type: "wrapRwaCollateral",
+		tokenIn: input.tokenIn,
+		amount: input.amountIn,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls: []
+	};
+}
+//#endregion
+export { buildWrapRwaCollateralOperation };

package/dist/esm/sdk/accounts/intents/quoters/close.js

@@ -0,0 +1,56 @@
+import { BigIntMath } from "../../../utils/bigint-math.js";
+import { eq, toRouterCaSlice } from "../utils/common.js";
+import { convertAmount } from "../utils/convert-amount.js";
+import "../utils/index.js";
+//#region src/sdk/accounts/intents/quoters/close.ts
+/**
+* Offchain quoter: debt is repaid from NON-underlying value
+* (`amount = Σ convert(non-underlying → underlying) − debt`, clamped at 0),
+* underlying already on the account goes straight to the wallet
+* (`underlyingBalance = underlying + amount`). No router involved.
+*/
+function createCloseOracleQuoter(args) {
+	const { sdk, creditAccount } = args;
+	const underlyingLc = creditAccount.underlying.toLowerCase();
+	return async ({ assets, debt }) => {
+		const convert = convertAmount(sdk, creditAccount.creditManager);
+		const underlyingBalance = assets.find((a) => eq(a.token, underlyingLc))?.balance ?? 0n;
+		const assetsSum = assets.reduce((acc, a) => acc + convert(a.token, creditAccount.underlying, a.balance), 0n);
+		const totalToRepay = BigIntMath.max(assetsSum - underlyingBalance, 0n);
+		const amount = BigIntMath.max(totalToRepay - debt, 0n);
+		return {
+			amount,
+			minAmount: amount,
+			underlyingBalance: underlyingBalance + amount,
+			calls: []
+		};
+	};
+}
+/**
+* Onchain quoter: router close path over post-claim balances
+* (phantom already spent). `amount` mirrors legacy
+* `patchCloseOperationReceiveAmount` (debt 0n — closed preview is zeroed).
+*/
+function createRouterCloseQuoter(args) {
+	const { sdk, creditAccount, slippage } = args;
+	const creditManager = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const router = sdk.routerFor({ creditFacade: creditAccount.creditFacade });
+	return async ({ assets }) => {
+		return await router.findBestClosePath({
+			creditAccount: toRouterCaSlice(creditAccount, assets),
+			creditManager: {
+				address: creditManager.creditManager.address.toLowerCase(),
+				creditFacade: creditManager.creditFacade.address.toLowerCase(),
+				collateralTokens: creditManager.creditManager.collateralTokens.map((t) => t.toLowerCase())
+			},
+			slippage,
+			balances: {
+				expectedBalances: assets,
+				leftoverBalances: [],
+				tokensToClaim: []
+			}
+		});
+	};
+}
+//#endregion
+export { createCloseOracleQuoter, createRouterCloseQuoter };

package/dist/esm/sdk/accounts/intents/quoters/index.js

@@ -0,0 +1,3 @@
+import { createCloseOracleQuoter, createRouterCloseQuoter } from "./close.js";
+import { createOracleSwapQuoter, createRouterSwapQuoter } from "./swap.js";
+export { createCloseOracleQuoter, createOracleSwapQuoter, createRouterCloseQuoter, createRouterSwapQuoter };

package/dist/esm/sdk/accounts/intents/quoters/swap.js

@@ -0,0 +1,77 @@
+import { toRouterCaSlice } from "../utils/common.js";
+import { convertAmount } from "../utils/convert-amount.js";
+import "../utils/index.js";
+//#region src/sdk/accounts/intents/quoters/swap.ts
+/**
+* Offchain quoter: oracle prices via {@link convertAmount} (with an RWA
+* bridge through the wrapped underlying when `rwa.asset` has no direct pool
+* price).
+*/
+function createOracleSwapQuoter(args) {
+	const { sdk, creditAccount } = args;
+	const { creditManager } = creditAccount;
+	const convert = convertAmount(sdk, creditManager);
+	return async ({ from, tokenOut }) => {
+		if (!from[0]) return {
+			amount: 0n,
+			minAmount: 0n,
+			calls: []
+		};
+		let amount = 0n;
+		for (const entry of from) amount += convert(entry.token, tokenOut, entry.balance);
+		return {
+			amount,
+			minAmount: amount,
+			calls: []
+		};
+	};
+}
+/**
+* Onchain quoter: a full token-in spend uses `findOneTokenPath`; a partial
+* spend uses `findManyToOnePath` with the exact post-operations balance and
+* leftover. RWA wrap/unwrap calls are resolved by the router.
+*/
+function createRouterSwapQuoter(args) {
+	const { sdk, creditAccount, slippage } = args;
+	const creditManager = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const cmSlice = {
+		address: creditManager.creditManager.address.toLowerCase(),
+		creditFacade: creditManager.creditFacade.address.toLowerCase(),
+		collateralTokens: creditManager.creditManager.collateralTokens.map((t) => t.toLowerCase())
+	};
+	const router = sdk.routerFor({ creditFacade: creditManager.creditFacade.address });
+	return async (request) => {
+		const input = request.from[0];
+		if (!input) return {
+			amount: 0n,
+			minAmount: 0n,
+			calls: []
+		};
+		const leftover = request.tokenInBalance - input.balance;
+		if (leftover < 0n) throw new Error("createRouterSwapQuoter: swap amount exceeds token-in balance");
+		if (leftover > 0n) return await router.findManyToOnePath({
+			creditAccount: toRouterCaSlice(creditAccount),
+			creditManager: cmSlice,
+			expectedBalances: [{
+				token: input.token,
+				balance: request.tokenInBalance
+			}],
+			leftoverBalances: [{
+				token: input.token,
+				balance: leftover
+			}],
+			target: request.tokenOut,
+			slippage
+		});
+		return await router.findOneTokenPath({
+			creditAccount: toRouterCaSlice(creditAccount),
+			creditManager: cmSlice,
+			tokenIn: input.token,
+			tokenOut: request.tokenOut,
+			amount: input.balance,
+			slippage
+		});
+	};
+}
+//#endregion
+export { createOracleSwapQuoter, createRouterSwapQuoter };