@gearbox-protocol/sdk 15.1.0-next.1 → 15.1.0-next.10

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

@@ -0,0 +1,300 @@
+import { calcPositionLeverage } from "../../market/math.js";
+import { IntentPreviewError } from "./types.js";
+import { eq, toTargetDecimals } from "./utils/common.js";
+import { convertAmount } from "./utils/convert-amount.js";
+import { isRedemptionPhantomToken } from "./utils/pick-token.js";
+import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertQuotaHeadroom } from "./guards.js";
+import { OperationLedger } from "./utils/ledger.js";
+import { clearedQuotas, getQuotasForUpdate } from "./utils/quotas-for-update.js";
+import { createRouterPaths } from "./utils/router-path.js";
+import { buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput } from "./operations.js";
+//#region src/sdk/accounts/intents/realize.ts
+/**
+* Turns a plan into operations: the one place that talks to the router, knows
+* how an RWA leg differs from a swap, and keeps the running balances.
+*
+* Steps are applied to a ledger as they are built, so every leg sees the
+* balances the previous ones left behind: a swap only spends what the plan
+* says and keeps the rest of its input token in place, a repayment never
+* exceeds the underlying actually raised. Once the walk is done the projected
+* balances yield the quota update and the reported state.
+*/
+async function realize(steps, props) {
+	const { creditAccount, sdk, slippage, quotaReserve } = props;
+	const { underlying } = creditAccount;
+	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset;
+	const price = convertAmount(sdk, creditAccount.creditManager);
+	const paths = createRouterPaths({
+		sdk,
+		creditAccount,
+		slippage
+	});
+	const market = sdk.marketRegister.findByCreditManager(creditAccount.creditManager);
+	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const ledger = new OperationLedger({
+		initialAssets: creditAccount.tokens,
+		underlying,
+		debt: creditAccount.accountDebt,
+		convert: price
+	});
+	const operations = [];
+	const push = (op) => {
+		operations.push(op);
+		ledger.apply(op);
+	};
+	/** Output of the last convert or claim, for `RAISED` amounts. */
+	let raised = 0n;
+	let delayed;
+	/**
+	* Set by a `clearQuotas` step, which settles the quotas mid-walk instead of
+	* at the end — and settles them at none, whatever the balances turn out to be.
+	*/
+	let cleared;
+	/**
+	* Whether anything leaves the account, which is what makes the credit manager
+	* judge the closing collateral check at safe prices.
+	*/
+	let paysOut = false;
+	const amountOf = (a) => typeof a === "bigint" ? a : min(raised, a.max ?? raised);
+	const assertHolds = (token, amount, what) => {
+		const held = ledger.balanceOf(token);
+		if (amount <= 0n || held < amount) throw new IntentPreviewError("insufficientSourceBalance", `${what}: needs ${amount} of ${token}, account holds ${held}`);
+	};
+	for (const step of steps) switch (step.kind) {
+		case "add":
+			push(buildAddCollateralOperation({
+				token: step.token,
+				amount: step.amount,
+				value: step.value,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "borrow":
+			assertCanBorrow(suite, step.amount);
+			push(buildIncreaseDebtOperation({
+				amount: step.amount,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "repay": {
+			const amount = min(amountOf(step.amount), ledger.balanceOf(underlying) - (step.keep ?? 0n));
+			if (amount > 0n) push(buildDecreaseDebtOperation({
+				amount,
+				full: amount >= ledger.debt,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+		case "clearQuotas":
+			cleared = clearedQuotas(creditAccount.tokens);
+			if (cleared.quotaDecrease.length > 0) push(buildQuotaUpdateOperation({
+				update: cleared,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "convert": {
+			const amount = amountOf(step.amount);
+			if (amount <= 0n) {
+				raised = 0n;
+				break;
+			}
+			assertHolds(step.from, amount, "convert");
+			if (eq(step.from, step.to)) {
+				raised = amount;
+				break;
+			}
+			const wrap = rwaAsset && eq(step.from, rwaAsset) && eq(step.to, underlying);
+			const unwrap = rwaAsset && eq(step.from, underlying) && eq(step.to, rwaAsset);
+			if (wrap || unwrap) {
+				const amountOut = toTargetDecimals(amount, step.from, step.to, sdk);
+				push(await (wrap ? buildWrapRwaCollateralOperation : buildUnwrapRwaCollateralOperation)({
+					tokenIn: step.from,
+					amountIn: amount,
+					tokenOut: step.to,
+					amountOut,
+					creditAccount,
+					sdk
+				}));
+				raised = amountOut;
+				break;
+			}
+			const held = ledger.balanceOf(step.from);
+			const leg = await paths.swap({
+				tokenIn: step.from,
+				tokenOut: step.to,
+				amount,
+				keep: held - amount
+			});
+			push(buildSwapOperation({
+				tokenIn: step.from,
+				amountIn: amount,
+				tokenOut: step.to,
+				amountOut: leg.minAmount,
+				calls: leg.calls
+			}));
+			raised = leg.minAmount;
+			break;
+		}
+		case "closeAll": {
+			const balances = ledger.snapshot().assets.filter((a) => !eq(a.token, underlying) && a.balance > DUST);
+			const pending = balances.find((a) => isRedemptionPhantomToken(sdk, a.token));
+			if (pending) throw new IntentPreviewError("withdrawalInProgress", `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
+			if (balances.length > 0) {
+				const leg = await paths.closeAll({ balances });
+				if (leg.calls.length > 0) push(buildCloseSwapOperation({
+					from: balances,
+					tokenOut: underlying,
+					amountOut: leg.minAmount,
+					calls: leg.calls
+				}));
+			}
+			raised = ledger.balanceOf(underlying);
+			break;
+		}
+		case "withdraw": {
+			const amount = amountOf(step.amount);
+			assertHolds(step.token, amount, "withdraw");
+			paysOut = true;
+			push(buildWithdrawCollateralOperation({
+				token: step.token,
+				amount,
+				to: step.to,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+		case "request": {
+			const asset = await delayedConfig(sdk, creditAccount, step.token);
+			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new IntentPreviewError("withdrawalInProgress", `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
+			assertHolds(step.token, step.amount + step.reserve, "request");
+			const preview = await sdk.accounts.previewDelayedWithdrawal({
+				creditAccount: creditAccount.creditAccount,
+				token: step.token,
+				amount: step.amount,
+				withdrawalPhantomToken: asset.withdrawalPhantomToken,
+				intent: step.record
+			});
+			push(buildStartDelayedWithdrawalOperation({
+				preview,
+				creditAccount,
+				sdk
+			}));
+			delayed = {
+				record: step.record,
+				claimableAt: preview.claimableAt,
+				settlement: preview.outputs.some((o) => o.isDelayed) ? "delayed" : "instant"
+			};
+			raised = instantOutput(preview.outputs)?.amount ?? 0n;
+			break;
+		}
+		case "claim":
+			push(buildClaimDelayedWithdrawalOperation({
+				claimable: step.claimable,
+				creditAccount,
+				sdk
+			}));
+			raised = instantOutput(step.claimable.outputs)?.amount ?? 0n;
+			break;
+		case "sweep": {
+			paysOut = true;
+			const wrapped = ledger.balanceOf(underlying);
+			if (rwaAsset && wrapped > 0n) push(await buildUnwrapRwaCollateralOperation({
+				tokenIn: underlying,
+				amountIn: wrapped,
+				tokenOut: rwaAsset,
+				amountOut: toTargetDecimals(wrapped, underlying, rwaAsset, sdk),
+				creditAccount,
+				sdk
+			}));
+			for (const { token, balance } of ledger.snapshot().assets) push(buildWithdrawCollateralOperation({
+				token,
+				amount: balance,
+				to: step.to,
+				all: true,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+	}
+	const { assets, totalValue, debt } = ledger.snapshot();
+	assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: creditAccount.tokens,
+		after: assets
+	});
+	const quotas = cleared ?? getQuotasForUpdate({
+		assetsBefore: creditAccount.tokens,
+		assetsAfter: assets,
+		initialQuotas: creditAccount.tokens,
+		quotaReserve,
+		underlyingToken: underlying,
+		liquidationThresholds: suite.creditManager.liquidationThresholds,
+		quotas: market.pool.pqk.quotas,
+		maxDebt: suite.creditFacade.maxDebt,
+		convert: price
+	});
+	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
+		assertQuotaHeadroom(market, quotas.quotaIncrease);
+		push(buildQuotaUpdateOperation({
+			update: quotas,
+			creditAccount,
+			sdk
+		}));
+	}
+	const snapshot = {
+		creditManager: creditAccount.creditManager,
+		assets,
+		quotas: Object.values(quotas.desiredQuota),
+		totalDebt: debt,
+		totalValue
+	};
+	const metrics = {
+		healthFactor: sdk.positions.healthFactor(snapshot),
+		overallApy: 0,
+		borrowRate: sdk.positions.borrowRate(snapshot),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot),
+		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
+	};
+	assertCollateralised(paysOut ? sdk.positions.healthFactor(snapshot, { safePrices: true }) : metrics.healthFactor);
+	return {
+		operations,
+		state: {
+			totalValue,
+			accountDebt: debt,
+			leverage: calcPositionLeverage(totalValue, debt),
+			assets,
+			quotas: quotas.desiredQuota,
+			...metrics
+		},
+		calls: callsOf(operations),
+		delayed
+	};
+}
+/**
+* The redemption config for `token`, when the credit manager offers exactly one.
+*
+* Several configs mean several venues with different delays and outputs, and
+* nothing in the intent says which one was meant.
+*/
+async function delayedConfig(sdk, creditAccount, token) {
+	const compressor = sdk.withdrawalCompressor;
+	if (!compressor) throw new IntentPreviewError("noDelayedRoute", "request: chain has no withdrawal compressor");
+	const assets = await compressor.findWithdrawableAssets(creditAccount.creditManager, token);
+	if (assets.length === 0) throw new IntentPreviewError("noDelayedRoute", `request: ${token} has no delayed withdrawal config`);
+	if (assets.length > 1) throw new IntentPreviewError("multipleDelayedWithdrawals", `request: ${token} has ${assets.length} delayed withdrawal configs`);
+	return assets[0];
+}
+const callsOf = (operations) => operations.flatMap((op) => op.calls);
+const min = (a, b) => a < b ? a : b;
+/** Balance the router's close path refuses to route, and leaves in place. */
+const DUST = 10n;
+//#endregion
+export { realize };

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

@@ -0,0 +1,38 @@
+import { MOCK_CLAIM_CALL } from "./sdk-mock.js";
+import { ANY, ANY2, CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, DECIMALS, POS, RWA_ASSET, UND, buildMarketSdk, valueInUnd } from "./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 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 buildMarketSdk({
+		...extras,
+		extraDecimals: {
+			...extras?.extraDecimals,
+			[phantom]: extras?.extraDecimals?.[c.claimedToken] ?? 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: [MOCK_CLAIM_CALL]
+	};
+}
+//#endregion
+export { ANY, ANY2, CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, FIXTURE_PHANTOM, POS, RWA_ASSET, UND, buildClaimable, buildMarketSdk, buildTailSdk, claimedValueInUnd };

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

@@ -0,0 +1,148 @@
+import { toBN } from "../../../utils/formatter.js";
+import "../../../index.js";
+import { buildMockSdk } from "./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]: toBN("2", 8),
+	[ANY]: toBN("1", 8),
+	[ANY2]: toBN("1", 8),
+	[RWA_ASSET]: toBN("2", 8),
+	[POS]: toBN("2", 8),
+	[POS2]: 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: 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
+	},
+	[POS]: {
+		token: POS,
+		rate: 500n,
+		limit: toBN("999999999999999", 8),
+		isActive: true
+	},
+	[POS2]: {
+		token: POS2,
+		rate: 500n,
+		limit: toBN("999999999999999", 8),
+		isActive: true
+	}
+};
+const LIQUIDATION_THRESHOLDS = {
+	[UND]: 9800,
+	[ANY]: 9200,
+	[ANY2]: 9200,
+	[RWA_ASSET]: 9200,
+	[POS]: 9200,
+	[POS2]: 9200
+};
+const MAX_DEBT = toBN("200000", 8);
+/** Mock SDK on the shared fixture market. */
+function buildMarketSdk(extras) {
+	return 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
+	});
+}
+/** 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
+export { ANY, ANY2, CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, DECIMALS, LIQUIDATION_THRESHOLDS, MAX_DEBT, POS, POS2, PRICES, QUOTAS, RWA_ASSET, UND, WALLET, buildFixtureCreditAccount, buildMarketSdk, caToken, valueInUnd };