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

package/dist/esm/sdk/accounts/intents/testing/expect.js

@@ -0,0 +1,162 @@
+import { CA_OP_CALLS, MOCK_CLAIM_CALL, MOCK_CLOSE_CALL, MOCK_ROUTER_CALL, MOCK_RWA_UNWRAP_CALL, MOCK_RWA_WRAP_CALL } from "./sdk-mock.js";
+import { expect } from "vitest";
+//#region src/sdk/accounts/intents/testing/expect.ts
+function expectedCalls(expected) {
+	return expected.calls ?? [];
+}
+/**
+* Fills sentinel `calls` for onchain resume expectations. Shared fixtures keep
+* `calls: []` for offchain; onchain tests map through this helper.
+*/
+function withOnchainOpCalls(ops) {
+	return ops.map((op) => {
+		switch (op.type) {
+			case "claimDelayedWithdrawal": return {
+				...op,
+				calls: [MOCK_CLAIM_CALL]
+			};
+			case "changeQuota": return {
+				...op,
+				calls: [CA_OP_CALLS.changeQuota]
+			};
+			case "decreaseDebt": return {
+				...op,
+				calls: [CA_OP_CALLS.decreaseDebt]
+			};
+			case "withdrawCollateral": return {
+				...op,
+				calls: [CA_OP_CALLS.withdrawCollateral]
+			};
+			case "swap": return {
+				...op,
+				calls: op.calls?.length ? op.calls : [MOCK_ROUTER_CALL]
+			};
+			case "wrapRwaCollateral": return {
+				...op,
+				calls: op.calls?.length ? op.calls : [MOCK_RWA_WRAP_CALL]
+			};
+			case "unwrapRwaCollateral": return {
+				...op,
+				calls: op.calls?.length ? op.calls : [MOCK_RWA_UNWRAP_CALL]
+			};
+			case "closeCreditAccount": return {
+				...op,
+				calls: op.calls?.length ? op.calls : [MOCK_CLOSE_CALL]
+			};
+			default: return op;
+		}
+	});
+}
+function matchOp(actual, expected, index) {
+	expect(actual.type, `op[${index}].type`).toBe(expected.type);
+	switch (expected.type) {
+		case "claimDelayedWithdrawal":
+			if (actual.type !== "claimDelayedWithdrawal") return;
+			expect(actual.token, `op[${index}].token`).toBe(expected.token);
+			expect(actual.withdrawalPhantomToken, `op[${index}].withdrawalPhantomToken`).toBe(expected.withdrawalPhantomToken);
+			expect(actual.withdrawalTokenSpent, `op[${index}].withdrawalTokenSpent`).toBe(expected.withdrawalTokenSpent);
+			expect(actual.outputs, `op[${index}].outputs`).toEqual(expected.outputs);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+			break;
+		case "changeQuota":
+			if (actual.type !== "changeQuota") return;
+			expect(actual.quotaIncrease, `op[${index}].quotaIncrease`).toEqual(expected.quotaIncrease);
+			expect(actual.quotaDecrease, `op[${index}].quotaDecrease`).toEqual(expected.quotaDecrease);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+			break;
+		case "closeCreditAccount":
+			if (actual.type !== "closeCreditAccount") return;
+			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
+			expect(actual.minAmount, `op[${index}].minAmount`).toBe(expected.minAmount);
+			expect(actual.underlyingBalance, `op[${index}].underlyingBalance`).toBe(expected.underlyingBalance);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+			break;
+		case "swap":
+			if (actual.type !== "swap") return;
+			expect(actual.from, `op[${index}].from`).toEqual(expected.from);
+			expect(actual.tokenOut, `op[${index}].tokenOut`).toBe(expected.tokenOut);
+			expect(actual.amountOut, `op[${index}].amountOut`).toBe(expected.amountOut);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+			break;
+		case "decreaseDebt":
+			if (actual.type !== "decreaseDebt") return;
+			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+			break;
+		case "withdrawCollateral":
+			if (actual.type !== "withdrawCollateral") return;
+			expect(actual.token, `op[${index}].token`).toBe(expected.token);
+			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
+			expect(actual.to, `op[${index}].to`).toBe(expected.to);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+			break;
+		case "unwrapRwaCollateral":
+			if (actual.type !== "unwrapRwaCollateral") return;
+			expect(actual.tokenIn, `op[${index}].tokenIn`).toBe(expected.tokenIn);
+			expect(actual.tokenOut, `op[${index}].tokenOut`).toBe(expected.tokenOut);
+			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
+			expect(actual.amountOut, `op[${index}].amountOut`).toBe(expected.amountOut);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+			break;
+		case "wrapRwaCollateral":
+			if (actual.type !== "wrapRwaCollateral") return;
+			expect(actual.tokenIn, `op[${index}].tokenIn`).toBe(expected.tokenIn);
+			expect(actual.tokenOut, `op[${index}].tokenOut`).toBe(expected.tokenOut);
+			expect(actual.amount, `op[${index}].amount`).toBe(expected.amount);
+			expect(actual.amountOut, `op[${index}].amountOut`).toBe(expected.amountOut);
+			expect(actual.calls, `op[${index}].calls`).toEqual(expectedCalls(expected));
+	}
+}
+/** Asserts exact operations on a raw op array (type + tokens + amounts). */
+function expectOpsArrayExact(ops, expected) {
+	expect(ops.length, "operations.length").toBe(expected.length);
+	for (let i = 0; i < expected.length; i++) {
+		const actual = ops[i];
+		const exp = expected[i];
+		if (actual === void 0 || exp === void 0) {
+			expect.fail(`missing op at index ${i}`);
+			return;
+		}
+		matchOp(actual, exp, i);
+	}
+}
+/** Asserts exact calls on a raw MultiCall array (target + callData). */
+function expectCallsArrayExact(calls, expected, label = "calls") {
+	expect(calls.length, `${label}.length`).toBe(expected.length);
+	for (let i = 0; i < expected.length; i++) {
+		const actual = calls[i];
+		const exp = expected[i];
+		if (actual === void 0 || exp === void 0) {
+			expect.fail(`missing call at index ${i}`);
+			return;
+		}
+		expect(actual.target, `${label}[${i}].target`).toBe(exp.target);
+		expect(actual.callData, `${label}[${i}].callData`).toBe(exp.callData);
+	}
+}
+/**
+* Asserts a successful adjust-style resume preview: ok, instant branch present,
+* exact calls (empty unless `expectedCalls` is provided), metrics from the
+* post-claim CA, and exact operations (incl. changeQuota).
+* Returns the adjust preview state for further asset/quota assertions.
+*/
+function expectAdjustResumePreview(result, args) {
+	expect(result.ok).toBe(true);
+	if (!result.ok) throw new Error("expected ok resume preview");
+	expect(result.instant, "instant branch").toBeDefined();
+	if (!result.instant) throw new Error("expected instant branch");
+	if (args.expectedCalls) expectCallsArrayExact(result.instant.calls, args.expectedCalls);
+	else expect(result.instant.calls).toEqual([]);
+	const state = result.instant.preview.min;
+	expect(state.kind).toBe("adjust");
+	if (state.kind !== "adjust") throw new Error("expected adjust preview state");
+	expect(state.totalValue).toBe(args.totalValue);
+	expect(state.accountDebt).toBe(args.accountDebt);
+	expectOpsArrayExact(result.instant.operations, args.expectedOps);
+	return state;
+}
+function assetBalance(assets, token) {
+	return assets.find((a) => a.token === token)?.balance ?? 0n;
+}
+//#endregion
+export { assetBalance, expectAdjustResumePreview, expectCallsArrayExact, expectOpsArrayExact, withOnchainOpCalls };

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

@@ -0,0 +1,157 @@
+import { toBN } from "../../../utils/formatter.js";
+import "../../../index.js";
+import { MOCK_CLAIM_CALL, buildMockSdk } from "./sdk-mock.js";
+//#region src/sdk/accounts/intents/testing/resume.ts
+/**
+* Shared kit for claim-only resume fixtures (add collateral, increase
+* leverage, deposit, deposit+increase).
+*
+* Unlike the legacy props (which echoed `creditAccount.totalValue`), the
+* service computes totalValue from CA token balances via the price oracle.
+* Each case's base balance is therefore `postClaimTotalValue − claimed value
+* in UND`, so the derived totalValue matches the legacy expectation exactly.
+*/
+const UND_DECIMALS = 8;
+const TOK_DECIMALS = 18;
+const UND = "0x3333333333333333333333333333333333333333";
+const ANY = "0x1111111111111111111111111111111111111111";
+const ANY2 = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+const RWA_ASSET = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+const RESUME_FIXTURE_PHANTOM = "0xcccccccccccccccccccccccccccccccccccccccc";
+const CREDIT_MANAGER = "0xdddddddddddddddddddddddddddddddddddddddd";
+const CREDIT_FACADE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+const CREDIT_ACCOUNT = "0xacacacacacacacacacacacacacacacacacacacac";
+const PRICES = {
+	[UND]: toBN("2", 8),
+	[ANY]: toBN("1", 8),
+	[ANY2]: toBN("1", 8),
+	[RWA_ASSET]: toBN("2", 8)
+};
+const DECIMALS = {
+	[UND]: 8,
+	[ANY]: 18,
+	[ANY2]: 18,
+	[RWA_ASSET]: 8
+};
+const QUOTAS = {
+	[ANY]: {
+		token: ANY,
+		rate: 500n,
+		limit: toBN("999999999999999", 18),
+		isActive: true
+	},
+	[ANY2]: {
+		token: ANY2,
+		rate: 500n,
+		limit: toBN("999999999999999", 18),
+		isActive: true
+	},
+	[RWA_ASSET]: {
+		token: RWA_ASSET,
+		rate: 500n,
+		limit: toBN("999999999999999", 8),
+		isActive: true
+	}
+};
+const LIQUIDATION_THRESHOLDS = {
+	[UND]: 9800,
+	[ANY]: 9200,
+	[ANY2]: 9200,
+	[RWA_ASSET]: 9200
+};
+const MAX_DEBT = toBN("200000", 8);
+/** Claimed proceeds converted to UND (mirrors the mock price oracle). */
+function claimedValueInUnd(amount, token) {
+	return amount * PRICES[token] * 10n ** BigInt(8) / (PRICES[UND] * 10n ** BigInt(DECIMALS[token]));
+}
+/**
+* Mock sdk for a resume case. The fixture phantom token gets the claimed
+* token's decimals so the offchain `toTargetDecimals` rescale stays identity
+* (its `10n * decimals` factor is only correct for equal decimals).
+* `closePath` configures the router `findBestClosePath` result (close resume).
+*/
+function buildResumeSdk(c, extras) {
+	const phantom = extras?.phantom ?? "0xcccccccccccccccccccccccccccccccccccccccc";
+	return buildMockSdk({
+		prices: {
+			...PRICES,
+			...extras?.extraPrices
+		},
+		decimals: {
+			...DECIMALS,
+			...extras?.extraDecimals,
+			[phantom]: extras?.extraDecimals?.[c.claimedToken] ?? DECIMALS[c.claimedToken]
+		},
+		quotas: QUOTAS,
+		liquidationThresholds: LIQUIDATION_THRESHOLDS,
+		maxDebt: MAX_DEBT,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		closePath: extras?.closePath,
+		rwaAssets: extras?.rwaAssets
+	});
+}
+function buildOffchainOptions(c) {
+	return {
+		kind: "offchain",
+		phantomSpent: c.claimedAmount,
+		withdrawalConfig: {
+			creditManager: CREDIT_MANAGER,
+			token: c.claimedToken,
+			withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
+			underlying: c.claimedToken,
+			withdrawalLength: 0n
+		}
+	};
+}
+function buildOnchainOptions(c) {
+	return {
+		kind: "onchain",
+		claimableWithdrawal: {
+			token: c.claimedToken,
+			withdrawalPhantomToken: RESUME_FIXTURE_PHANTOM,
+			withdrawalTokenSpent: c.claimedAmount,
+			outputs: [{
+				token: c.claimedToken,
+				amount: c.claimedAmount,
+				isDelayed: false
+			}],
+			claimCalls: [MOCK_CLAIM_CALL]
+		}
+	};
+}
+function buildClaimResumeProps(args) {
+	const { intent, case: c, sdk, options } = args;
+	return {
+		intent,
+		creditAccount: {
+			creditAccount: CREDIT_ACCOUNT,
+			creditManager: CREDIT_MANAGER,
+			creditFacade: CREDIT_FACADE,
+			underlying: UND,
+			enabledTokensMask: 0n,
+			totalDebtUSD: 0n,
+			accountDebt: c.postClaimDebt,
+			tokens: [{
+				token: RESUME_FIXTURE_PHANTOM,
+				balance: c.claimedAmount,
+				quota: 0n,
+				mask: 0n,
+				success: true
+			}, ...c.baseAssets ?? [{
+				token: "0x3333333333333333333333333333333333333333",
+				balance: c.postClaimTotalValue - claimedValueInUnd(c.claimedAmount, c.claimedToken),
+				quota: 0n,
+				mask: 0n,
+				success: true
+			}]]
+		},
+		sdk,
+		quotaReserve: void 0,
+		options,
+		slippage: void 0
+	};
+}
+//#endregion
+export { ANY, ANY2, CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, RESUME_FIXTURE_PHANTOM, RWA_ASSET, TOK_DECIMALS, UND, UND_DECIMALS, buildClaimResumeProps, buildOffchainOptions, buildOnchainOptions, buildResumeSdk, claimedValueInUnd };

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

@@ -0,0 +1,172 @@
+import { vi } from "vitest";
+//#region src/sdk/accounts/intents/testing/sdk-mock.ts
+/**
+* Test kit for intent-service specs.
+*
+* 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
+* 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. */
+const MOCK_ROUTER_CALL = {
+	target: "0x9999999999999999999999999999999999999999",
+	callData: "0x"
+};
+/** Returned by the `getRWAWrapCalls` mock; passes through per wrap op. */
+const MOCK_RWA_WRAP_CALL = {
+	target: "0x8888888888888888888888888888888888888888",
+	callData: "0x"
+};
+/** Router-produced call for an RWA underlying → asset unwrap leg. */
+const MOCK_RWA_UNWRAP_CALL = {
+	target: "0x7777777777777777777777777777777777777777",
+	callData: "0x"
+};
+/** Returned by the `assembleCloseCreditAccountCalls` mock. */
+const MOCK_CLOSE_CALL = {
+	target: "0x5555555555555555555555555555555555555555",
+	callData: "0x"
+};
+/** One sentinel call per plain encodable op type. */
+const CA_OP_CALLS = {
+	addCollateral: {
+		target: "0xa1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1",
+		callData: "0x"
+	},
+	increaseDebt: {
+		target: "0xd1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1",
+		callData: "0x"
+	},
+	decreaseDebt: {
+		target: "0xd2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2",
+		callData: "0x"
+	},
+	withdrawCollateral: {
+		target: "0xc1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1c1",
+		callData: "0x"
+	},
+	changeQuota: {
+		target: "0xc2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2",
+		callData: "0x"
+	}
+};
+function echoEncodableOpCalls(op) {
+	if ("calls" in op) return [...op.calls];
+	return [CA_OP_CALLS[op.type]];
+}
+/**
+* Mock `OnchainSDK` covering exactly what the intent-service touches:
+* price conversion, quota params, CM/facade lookup and call assembly.
+* Conversion mirrors the legacy price-based math:
+* `amount * price[from] * 10^dec(to) / (price[to] * 10^dec(from))`.
+*/
+function buildMockSdk(args) {
+	const decimalsOf = (token) => args.decimals[token.toLowerCase()] ?? 18;
+	const convert = (token, to, amount) => {
+		const from = token.toLowerCase();
+		const target = to.toLowerCase();
+		const fromPrice = args.prices[from];
+		const toPrice = args.prices[target];
+		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) => ({
+		cumulativeIndexLU: 0n,
+		totalQuoted: 0n,
+		quotaIncreaseFee: 0n,
+		...q
+	})) };
+	const liquidationThresholds = { entries: () => Object.entries(args.liquidationThresholds) };
+	const market = {
+		priceOracle: { convert },
+		pool: {
+			pqk: { quotas },
+			underlying: args.underlying
+		}
+	};
+	const creditManagerSuite = {
+		creditManager: {
+			address: args.creditManager,
+			liquidationThresholds,
+			collateralTokens: []
+		},
+		creditFacade: {
+			address: args.creditFacade,
+			maxDebt: args.maxDebt
+		}
+	};
+	const routeCalls = (tokenIn, tokenOut) => {
+		const underlying = args.underlying.toLowerCase();
+		const asset = args.rwaAssets?.[args.underlying.toLowerCase()]?.toLowerCase();
+		const from = tokenIn.toLowerCase();
+		const to = tokenOut.toLowerCase();
+		if (asset && from === asset && to === underlying) return [MOCK_RWA_WRAP_CALL];
+		if (asset && from === underlying && to === asset) return [MOCK_RWA_UNWRAP_CALL];
+		return [MOCK_ROUTER_CALL];
+	};
+	const router = {
+		findBestClosePath: vi.fn(async () => {
+			if (!args.closePath) throw new Error("mock router: closePath not configured");
+			return args.closePath;
+		}),
+		findOneTokenPath: vi.fn(async ({ amount, tokenIn, tokenOut }) => ({
+			amount,
+			minAmount: amount,
+			calls: routeCalls(tokenIn, tokenOut)
+		})),
+		findManyToOnePath: vi.fn(async ({ expectedBalances, leftoverBalances, target }) => {
+			const spent = expectedBalances.reduce((acc, a) => acc + a.balance, 0n) - leftoverBalances.reduce((acc, a) => acc + a.balance, 0n);
+			const tokenIn = expectedBalances[0]?.token ?? target;
+			return {
+				amount: spent,
+				minAmount: spent,
+				calls: routeCalls(tokenIn, target)
+			};
+		}),
+		findOpenStrategyPath: vi.fn(async ({ expectedBalances, leftoverBalances }) => {
+			const spent = expectedBalances.reduce((acc, a) => acc + a.balance, 0n) - leftoverBalances.reduce((acc, a) => acc + a.balance, 0n);
+			return {
+				amount: spent,
+				minAmount: spent,
+				calls: [MOCK_ROUTER_CALL],
+				minAssets: [],
+				averageAssets: []
+			};
+		})
+	};
+	return {
+		tokensMeta: {
+			get: (token) => ({ decimals: decimalsOf(token) }),
+			rwaUnderlyings: { get: (token) => {
+				const asset = args.rwaAssets?.[token.toLowerCase()];
+				return asset ? { asset } : void 0;
+			} }
+		},
+		marketRegister: {
+			findByCreditManager: vi.fn(() => market),
+			findCreditManager: vi.fn(() => creditManagerSuite)
+		},
+		routerFor: vi.fn(() => router),
+		accounts: {
+			assembleCaOperations: vi.fn(({ operations }) => operations.flatMap(echoEncodableOpCalls)),
+			prepareIncreaseDebt: vi.fn(() => CA_OP_CALLS.increaseDebt),
+			prepareChangeDebt: vi.fn(() => CA_OP_CALLS.decreaseDebt),
+			prepareAddCollateral: vi.fn(() => [CA_OP_CALLS.addCollateral]),
+			prepareWithdrawToken: vi.fn(() => CA_OP_CALLS.withdrawCollateral),
+			prepareUpdateQuotas: vi.fn(() => [CA_OP_CALLS.changeQuota]),
+			assembleClaimDelayedCalls: vi.fn(({ claimableNow }) => [...claimableNow.claimCalls]),
+			assembleCloseCreditAccountCalls: vi.fn(async () => [MOCK_CLOSE_CALL]),
+			getRWAWrapCalls: vi.fn(async () => [MOCK_RWA_WRAP_CALL]),
+			getRWAUnwrapCalls: vi.fn(async () => [MOCK_RWA_UNWRAP_CALL])
+		}
+	};
+}
+//#endregion
+export { CA_OP_CALLS, MOCK_CLAIM_CALL, MOCK_CLOSE_CALL, MOCK_ROUTER_CALL, MOCK_RWA_UNWRAP_CALL, MOCK_RWA_WRAP_CALL, buildMockSdk };

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

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

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

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

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

@@ -0,0 +1,12 @@
+//#region src/sdk/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/sdk/accounts/intents/utils/common.js

@@ -0,0 +1,40 @@
+import { AddressMap } from "../../../utils/AddressMap.js";
+//#region src/sdk/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/sdk/accounts/intents/utils/convert-amount.js

@@ -0,0 +1,36 @@
+import { toTargetDecimals } from "./common.js";
+//#region src/sdk/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/sdk/accounts/intents/utils/index.js

@@ -0,0 +1,9 @@
+import { assembleOperationCalls } from "./assemble-operation-calls.js";
+import { calcBorrowedAmountPlusInterestAndFees } from "./borrowed-amount-plus-interest-and-fees.js";
+import { eq, toRouterCaSlice, toTargetDecimals } from "./common.js";
+import { convertAmount } from "./convert-amount.js";
+import { getQuotasForUpdate } from "./quotas-for-update.js";
+import { simulateOperationAssets } from "./simulate-assets.js";
+import { simulateState } from "./simulate-adjust-state.js";
+import { getOperationsWithQuotaUpdate } from "./with-quota-update.js";
+export { assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, convertAmount, eq, getOperationsWithQuotaUpdate, getQuotasForUpdate, simulateOperationAssets, simulateState, toRouterCaSlice, toTargetDecimals };