@gearbox-protocol/sdk 14.12.0-next.6 → 14.12.0-next.61

package/dist/esm/preview/prerequisites/checkPrerequisites.js

@@ -0,0 +1,70 @@
+import { parseOperationCalldata } from "../parse/parseOperationCalldata.js";
+import "../parse/index.js";
+import { buildCollateralPrerequisites } from "./buildCollateralPrerequisites.js";
+import { buildPartialLiquidationPrerequisites } from "./buildPartialLiquidationPrerequisites.js";
+import { buildPoolPrerequisites } from "./buildPoolPrerequisites.js";
+import { buildRWAPrerequisites } from "./buildRWAPrerequisites.js";
+//#region src/preview/prerequisites/checkPrerequisites.ts
+/**
+* Derives and verifies the on-chain prerequisites for an operation given its
+* raw calldata: the conditions that must hold for the call not to revert and
+* that we can verify with the SDK (token approvals, wallet balances, RWA
+* open-account requirements).
+*
+* Each prerequisite performs its own reads and resolves into a
+* {@link PrerequisiteResult} (`satisfied` or `error`).
+*
+* Only *sender-actionable* prerequisites belong here: conditions the LP
+* provider or borrower can fix themselves before retrying (e.g. approve a
+* token, sign the RWA factory's messages). Non-actionable protocol/admin state
+* (e.g. pool is paused) is intentionally out of scope, since the user cannot
+* resolve it.
+*/
+async function checkPrerequisites(input, options) {
+	const { sdk, sender: wallet } = input;
+	const tx = parseOperationCalldata(input);
+	const ctx = {
+		sdk,
+		wallet,
+		blockNumber: options?.blockNumber,
+		value: input.value ?? 0n
+	};
+	const prereqs = await buildPrerequisites(tx, ctx);
+	return Promise.all(prereqs.map((p) => p.verify(ctx)));
+}
+/**
+* Dispatches a parsed operation to the per-operation-family prerequisite
+* builders.
+*/
+async function buildPrerequisites(tx, ctx) {
+	const { wallet } = ctx;
+	switch (tx.operation) {
+		case "Deposit":
+		case "Mint":
+		case "Redeem":
+		case "Withdraw": return buildPoolPrerequisites(tx, wallet);
+		case "MultiCall":
+		case "BotMulticall":
+		case "OpenCreditAccount":
+		case "CloseCreditAccount":
+		case "LiquidateCreditAccount": return buildCollateralPrerequisites(tx.operation === "OpenCreditAccount" ? {
+			creditManager: tx.creditManager,
+			borrower: wallet
+		} : {
+			creditManager: tx.creditManager,
+			creditAccount: tx.creditAccount
+		}, tx.multicall, ctx);
+		case "RWAOpenCreditAccount": return [...await buildCollateralPrerequisites({
+			creditManager: tx.creditManager,
+			borrower: wallet
+		}, tx.multicall, ctx), ...buildRWAPrerequisites(tx.multicall, tx.creditManager, tx.args, ctx)];
+		case "RWAMulticall": return buildCollateralPrerequisites({
+			creditManager: tx.creditManager,
+			creditAccount: tx.creditAccount
+		}, tx.multicall, ctx);
+		case "PartiallyLiquidateCreditAccount": return buildPartialLiquidationPrerequisites(tx, ctx);
+		default: return [];
+	}
+}
+//#endregion
+export { checkPrerequisites };

package/dist/esm/preview/prerequisites/helpers.js

@@ -0,0 +1,22 @@
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+//#region src/preview/prerequisites/helpers.ts
+/**
+* The most common prerequisite pair: `owner` must have approved `spender` for
+* `required` of `token` and must hold at least that much of it.
+*/
+function allowanceAndBalance(props) {
+	const { token, owner, spender, required } = props;
+	return [new AllowancePrerequisite({
+		token,
+		owner,
+		spender,
+		required
+	}), new BalancePrerequisite({
+		token,
+		owner,
+		required
+	})];
+}
+//#endregion
+export { allowanceAndBalance };

package/dist/esm/preview/prerequisites/index.js

@@ -1,8 +1,7 @@
-export * from "./AllowancePrerequisite.js";
-export * from "./BalancePrerequisite.js";
-export * from "./buildPrerequisites.js";
-export * from "./Prerequisite.js";
-export * from "./prepareAction.js";
-export * from "./RWAOpenRequirementsPrerequisite.js";
-export * from "./runPrerequisites.js";
-export * from "./types.js";
+import { Prerequisite } from "./Prerequisite.js";
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+import { RWAOpenRequirementsPrerequisite } from "./RWAOpenRequirementsPrerequisite.js";
+import { checkPrerequisites } from "./checkPrerequisites.js";
+import "./types.js";
+export { AllowancePrerequisite, BalancePrerequisite, Prerequisite, RWAOpenRequirementsPrerequisite, checkPrerequisites };

package/dist/esm/preview/prerequisites/types.js

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

package/dist/esm/preview/preview/CreditAccountState.js

@@ -0,0 +1,133 @@
+import { AssetsMap } from "../../sdk/utils/AssetsMap.js";
+import "../../sdk/constants/math.js";
+import "../../sdk/index.js";
+import { zeroAddress } from "viem";
+//#region src/preview/preview/CreditAccountState.ts
+/**
+* A snapshot of a credit account's economic state (balances, quotas, debt)
+* as used by operation previews, together with the account's identity.
+*
+* Used both as the pre-state seed of a multicall replay and as the running
+* post-state mutated by it; changes are derived by diffing two snapshots.
+*/
+var CreditAccountState = class CreditAccountState {
+	creditAccount;
+	creditManager;
+	/**
+	* Credit manager underlying
+	*/
+	underlying;
+	/**
+	* Per-token balances
+	*/
+	balances;
+	/**
+	* Per-token quotas
+	*/
+	quotas;
+	/**
+	* Debt principal
+	*/
+	debt;
+	/**
+	* Total debt: principal + accrued interest + accrued fees.
+	* `decreaseDebt` amounts operate on total debt (interest and fees are
+	* repaid before principal), so principal alone is not enough to resolve
+	* either the underlying balance decrement or the final principal.
+	*/
+	totalDebt;
+	constructor(props) {
+		this.creditAccount = props.creditAccount;
+		this.creditManager = props.creditManager;
+		this.underlying = props.underlying;
+		this.balances = props.balances ?? new AssetsMap();
+		this.quotas = props.quotas ?? new AssetsMap();
+		this.debt = props.debt ?? 0n;
+		this.totalDebt = props.totalDebt ?? 0n;
+	}
+	/**
+	* The account-opening seed: everything zero/empty. The account doesn't
+	* exist yet at preview time, so `creditAccount` is the zero address;
+	* opening previews take identity from the parsed operation instead.
+	*/
+	static beforeOpen(creditManager, underlying) {
+		return new CreditAccountState({
+			creditAccount: zeroAddress,
+			creditManager,
+			underlying
+		});
+	}
+	/**
+	* Pre-state of an existing account from its on-chain data, with dust
+	* balances and quotas (≤ 1 wei) filtered out.
+	*/
+	static fromCreditAccountData(ca) {
+		const balances = new AssetsMap();
+		const quotas = new AssetsMap();
+		for (const t of ca.tokens) {
+			if (t.balance > 1n) balances.upsert(t.token, t.balance);
+			if (t.quota > 1n) quotas.upsert(t.token, t.quota);
+		}
+		return new CreditAccountState({
+			creditAccount: ca.creditAccount,
+			creditManager: ca.creditManager,
+			underlying: ca.underlying,
+			balances,
+			quotas,
+			debt: ca.debt,
+			totalDebt: ca.debt + ca.accruedInterest + ca.accruedFees
+		});
+	}
+	clone() {
+		return new CreditAccountState({
+			creditAccount: this.creditAccount,
+			creditManager: this.creditManager,
+			underlying: this.underlying,
+			balances: this.balances.clone(),
+			quotas: this.quotas.clone(),
+			debt: this.debt,
+			totalDebt: this.totalDebt
+		});
+	}
+	/**
+	* Borrows `amount` of underlying: debt, total debt and the underlying
+	* balance all increase by it.
+	*/
+	increaseDebt(amount) {
+		this.debt += amount;
+		this.totalDebt += amount;
+		this.balances.inc(this.underlying, amount);
+	}
+	/**
+	* Repays up to `amount` of underlying against the debt, clamped to the
+	* total debt (the facade never repays more than is owed). Interest and
+	* fees are repaid before principal (CreditLogic.calcDecrease), so
+	* principal only decreases once total debt drops below it. The underlying
+	* balance decreases by the repaid amount.
+	*
+	* @returns The actually repaid (post-clamp) amount.
+	*/
+	repay(amount) {
+		const repaid = amount > this.totalDebt ? this.totalDebt : amount;
+		this.balances.dec(this.underlying, repaid);
+		this.totalDebt -= repaid;
+		if (this.debt > this.totalDebt) this.debt = this.totalDebt;
+		return repaid;
+	}
+	/**
+	* Applies a relative `updateQuota` change to the token's quota:
+	* `MIN_INT96` is the facade "disable quota" sentinel and zeroes it, other
+	* changes are added with the result clamped at zero (quotas cannot go
+	* negative on-chain).
+	*/
+	updateQuota(token, change) {
+		if (change === -39614081257132168796771975168n) {
+			this.quotas.upsert(token, 0n);
+			return;
+		}
+		const next = this.quotas.getOrZero(token) + change;
+		this.quotas.upsert(token, next > 0n ? next : 0n);
+	}
+};
+//#endregion
+export { CreditAccountState };

package/dist/esm/preview/preview/applyRWAWrapUnwrap.js

@@ -0,0 +1,66 @@
+import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
+import { decodeFunctionData } from "viem";
+//#region src/preview/preview/applyRWAWrapUnwrap.ts
+/**
+* Maps the decoded adapter call to the conversion it performs. Diff variants
+* spend the running balance down to the calldata leftover, so their input
+* amount comes from `balances`. Returns `undefined` for functions we do not
+* handle (`mint`/`withdraw` are never emitted by the RWA flows).
+*/
+function resolveWrapUnwrap(adapter, calldata, balances) {
+	const decoded = decodeFunctionData({
+		abi: ierc4626AdapterAbi,
+		data: calldata
+	});
+	const { asset, share } = adapter;
+	switch (decoded.functionName) {
+		case "deposit": return {
+			tokenIn: asset,
+			tokenOut: share,
+			amountIn: decoded.args[0]
+		};
+		case "depositDiff": {
+			const [leftoverAmount] = decoded.args;
+			const running = balances.getOrZero(asset);
+			return {
+				tokenIn: asset,
+				tokenOut: share,
+				amountIn: running > leftoverAmount ? running - leftoverAmount : 0n
+			};
+		}
+		case "redeem": return {
+			tokenIn: share,
+			tokenOut: asset,
+			amountIn: decoded.args[0]
+		};
+		case "redeemDiff": {
+			const [leftoverAmount] = decoded.args;
+			const running = balances.getOrZero(share);
+			return {
+				tokenIn: share,
+				tokenOut: asset,
+				amountIn: running > leftoverAmount ? running - leftoverAmount : 0n
+			};
+		}
+		default: return;
+	}
+}
+/**
+* Applies an RWA wrap/unwrap adapter call (ERC4626 `deposit`/`redeem` and
+* their diff variants, as emitted by `CreditAccountsServiceV310`) to the
+* running credit-account balances.
+*
+* RWA underlyings always convert 1-to-1 with their vault asset, so the
+* counterpart amount equals the input amount and no on-chain preview read is
+* needed.
+*/
+function applyRWAWrapUnwrap(adapter, calldata, balances) {
+	const resolved = resolveWrapUnwrap(adapter, calldata, balances);
+	if (!resolved) return;
+	const { tokenIn, tokenOut, amountIn } = resolved;
+	if (amountIn === 0n) return;
+	balances.dec(tokenIn, amountIn);
+	balances.inc(tokenOut, amountIn);
+}
+//#endregion
+export { applyRWAWrapUnwrap };

package/dist/esm/preview/preview/buildDelayedPreview.js

@@ -0,0 +1,192 @@
+import { AssetsMap } from "../../sdk/utils/AssetsMap.js";
+import "../../sdk/index.js";
+import { BigIntMath } from "../../common-utils/utils/bigint-math.js";
+import "../../common-utils/index.js";
+import { ERROR_UNPRICEABLE_TOKEN, PREVIEW_DUST } from "./types.js";
+import { isAddressEqual } from "viem";
+//#region src/preview/preview/buildDelayedPreview.ts
+/**
+* Builds the best-effort preview of the account state after the detected
+* delayed withdrawal is claimed and its intent (if any) is resumed:
+* the claim itself followed by the intent-specific tail
+*
+* Pure function: the input states are never mutated and no network access is performed.
+* Swaps are estimated with the injected conversion; tokens it cannot price contribute
+* nothing and set a non-fatal `ERROR_UNPRICEABLE_TOKEN` error on the
+* preview.
+*
+* The changes (e.g. `debtChange`) are reported relative to the account
+* state before the whole transaction.
+*
+* @param afterInstant - Account state after the instant part of the
+* transaction.
+* @param before - Account state before the transaction (the diff base).
+* @param receivedToken - Token the `CLOSE_ACCOUNT` resume withdraws to the
+* user: the unwrapped underlying (vault asset) for RWA markets, the
+* underlying itself otherwise.
+*/
+function buildDelayedPreview(afterInstant, before, detected, convert, receivedToken) {
+	const { request, intent } = detected;
+	const post = afterInstant.clone();
+	const converter = makeSafeConverter(convert);
+	const claimed = applyClaim(post, request);
+	const collateralWithdrawn = new AssetsMap();
+	switch (intent?.type) {
+		case "CLOSE_ACCOUNT": return buildClosePreview(post, converter, receivedToken);
+		case "DECREASE_LEVERAGE":
+			repayFromClaim(post, request.claimToken, converter.convert, claimed);
+			break;
+		case "WITHDRAW_COLLATERAL": applyWithdrawCollateral(post, request, intent, converter, collateralWithdrawn);
+	}
+	return buildAdjustPreview(post, before, collateralWithdrawn, converter);
+}
+function makeSafeConverter(convert) {
+	let error;
+	return {
+		convert: (token, to, amount) => {
+			try {
+				return convert(token, to, amount);
+			} catch {
+				error ??= {
+					code: ERROR_UNPRICEABLE_TOKEN,
+					message: `cannot price token ${token}`
+				};
+				return 0n;
+			}
+		},
+		get error() {
+			return error;
+		}
+	};
+}
+/**
+* Claim step, common to all intents: burns the phantom token (balance and
+* quota zeroed) and credits the claim token with the same amount 1:1.
+*
+* @returns The claimed amount.
+*/
+function applyClaim(post, request) {
+	const claimed = post.balances.getOrZero(request.phantomToken);
+	post.balances.upsert(request.phantomToken, 0n);
+	post.quotas.upsert(request.phantomToken, 0n);
+	post.balances.inc(request.claimToken, claimed);
+	return claimed;
+}
+/**
+* `WITHDRAW_COLLATERAL` operation tail:
+* after the claim, `withdrawAmount` of `withdrawToken` goes to the
+* user's wallet and the rest of the claim proceeds repay the debt.
+*
+* Tokens involved (Securitize ACRED redemption as the example):
+* - claim token (`request.claimToken`) - the token the claim pays out;
+*   redeeming ACRED pays out USDC.
+* - withdraw token (`intent.withdrawToken`) - the token the user receives
+*   in the wallet. It can be the claim token itself (withdraw USDC) or a
+*   different token (withdraw RLUSD, bought with the claimed USDC).
+* - source token (`intent.sourceToken`) - the token that was sent to
+*   redemption when the withdrawal was requested (ACRED). The user may also
+*   withdraw this token: e.g. redeem part of the ACRED position and
+*   withdraw some of the ACRED still left on the account.
+*
+* The preview models the operation tail in three steps:
+* 1. Take `withdrawAmount` of `withdrawToken` from the account balance.
+*    This handles the two simple cases: the withdraw token is the claim
+*    token (the claim just credited it) or the source token (some of it is
+*    still on the account).
+* 2. If the account holds less than `withdrawAmount` of `withdrawToken`,
+*    buy the missing part with the claim-token balance. This happens when
+*    the withdraw token differs from the claim token: e.g. withdrawing
+*    RLUSD from a claim that paid out USDC - RLUSD is bought with the
+*    claimed USDC. If even the whole claim balance cannot cover it, spend
+*    all of it and withdraw whatever it buys.
+* 3. Convert the claim tokens still left into the underlying and repay the
+*    debt with them, but no more than the intent's `debtRepaid` target;
+*    whatever is not spent on repayment stays on the account as underlying.
+*/
+function applyWithdrawCollateral(post, request, intent, converter, collateralWithdrawn) {
+	const { withdrawToken, withdrawAmount, debtRepaid } = intent;
+	const { claimToken } = request;
+	const sameToken = isAddressEqual(withdrawToken, claimToken);
+	const fromBalance = BigIntMath.min(withdrawAmount, post.balances.getOrZero(withdrawToken));
+	post.balances.dec(withdrawToken, fromBalance);
+	let withdrawn = fromBalance;
+	const missing = withdrawAmount - fromBalance;
+	if (missing > 0n && !sameToken) {
+		const available = post.balances.getOrZero(claimToken);
+		const cost = converter.convert(withdrawToken, claimToken, missing);
+		if (cost > 0n && cost <= available) {
+			post.balances.dec(claimToken, cost);
+			withdrawn += missing;
+		} else if (available > 0n) {
+			post.balances.dec(claimToken, available);
+			withdrawn += converter.convert(claimToken, withdrawToken, available);
+		}
+	}
+	if (withdrawn > 0n) collateralWithdrawn.upsert(withdrawToken, withdrawn);
+	const remaining = post.balances.getOrZero(claimToken);
+	if (remaining > 0n) {
+		const proceeds = converter.convert(claimToken, post.underlying, remaining);
+		post.balances.dec(claimToken, remaining);
+		post.balances.inc(post.underlying, proceeds);
+		post.repay(BigIntMath.min(proceeds, debtRepaid));
+	}
+}
+/**
+* `DECREASE_LEVERAGE` operation tail: swaps `amount` of the claim token
+* (capped at the running balance) into the underlying and repays the debt
+* with it.
+*/
+function repayFromClaim(post, claimToken, convert, amount) {
+	const spent = BigIntMath.min(amount, post.balances.getOrZero(claimToken));
+	if (spent <= 0n) return;
+	const received = convert(claimToken, post.underlying, spent);
+	post.balances.dec(claimToken, spent);
+	post.balances.inc(post.underlying, received);
+	post.repay(received);
+}
+/**
+* Oracle estimate of the account's total value in the underlying, ignoring
+* balances at or below `dust`.
+*/
+function totalValueInUnderlying(post, convert, dust) {
+	return post.balances.sum((token, balance) => balance > dust ? convert(token, post.underlying, balance) : 0n);
+}
+/**
+* `CLOSE_ACCOUNT` operation tail: everything is swapped into the
+* underlying, the debt is repaid in full and the remainder is withdrawn to
+* the user as `receivedToken`.
+*/
+function buildClosePreview(post, converter, receivedToken) {
+	const totalValue = totalValueInUnderlying(post, converter.convert, 0n);
+	return {
+		operation: "CloseCreditAccount",
+		permanent: false,
+		creditManager: post.creditManager,
+		creditAccount: post.creditAccount,
+		receivedAmount: {
+			token: receivedToken,
+			balance: BigIntMath.max(totalValue - post.totalDebt, 0n)
+		},
+		error: converter.error
+	};
+}
+function buildAdjustPreview(post, before, collateralWithdrawn, converter) {
+	const totalValue = totalValueInUnderlying(post, converter.convert, PREVIEW_DUST);
+	return {
+		operation: "AdjustCreditAccount",
+		creditManager: post.creditManager,
+		creditAccount: post.creditAccount,
+		collateralAdded: [],
+		collateralWithdrawn: collateralWithdrawn.toAssets(),
+		totalValue,
+		debt: post.debt,
+		debtChange: post.debt - before.debt,
+		quotas: post.quotas.toAssets(0n),
+		quotasChange: post.quotas.difference(before.quotas).toAssets(),
+		assets: post.balances.toAssets(PREVIEW_DUST),
+		assetsChange: post.balances.difference(before.balances).toAssets(PREVIEW_DUST),
+		error: converter.error
+	};
+}
+//#endregion
+export { buildDelayedPreview };

package/dist/esm/preview/preview/detectCloseOrRepay.js

@@ -0,0 +1,38 @@
+import "../../sdk/constants/math.js";
+import "../../sdk/index.js";
+import { isAddressEqual } from "viem";
+//#region src/preview/preview/detectCloseOrRepay.ts
+/**
+* Detects whether a credit-facade multicall fully closes or repays the
+* account: any multicall that calls `decreaseDebt(MAX_UINT256)`.
+*
+* Note that closing/repaying an account whose debt is already zero emits no
+* `decreaseDebt` call at all and is not detected (previews as an adjustment).
+*/
+function isCloseOrRepay(multicall) {
+	return multicall.some((op) => op.operation === "DecreaseBorrowedAmount" && op.amount === 115792089237316195423570985008687907853269984665640564039457584007913129639935n);
+}
+/**
+* Distinguishes a closure from a repayment by how collateral leaves the
+* account:
+* - close swaps all assets into the market underlying and withdraws only
+*   that token or, on RWA markets, its unwrapped version.
+*   Requires at least one `withdrawCollateral(MAX)` for one of those tokens.
+* - repay returns collateral in-kind: it adds collateral from the wallet to
+*   cover the debt, withdraws tokens other than the market underlying (or
+*   its unwrapped RWA asset), and/or leaves collateral on the account with
+*   no withdrawals at all.
+*/
+function classifyCloseOrRepay(multicall, exitTokens) {
+	let hasExitWithdrawal = false;
+	for (const op of multicall) {
+		if (op.operation === "AddCollateral") return "repay";
+		if (op.operation === "WithdrawCollateral") {
+			if (!exitTokens.some((token) => isAddressEqual(op.token, token))) return "repay";
+			if (op.amount === 115792089237316195423570985008687907853269984665640564039457584007913129639935n) hasExitWithdrawal = true;
+		}
+	}
+	return hasExitWithdrawal ? "close" : "repay";
+}
+//#endregion
+export { classifyCloseOrRepay, isCloseOrRepay };

package/dist/esm/preview/preview/detectDelayedClaim.js

@@ -0,0 +1,44 @@
+import { AbstractAdapterContract } from "../../plugins/adapters/contracts/AbstractAdapter.js";
+import "../../plugins/adapters/index.js";
+//#region src/preview/preview/detectDelayedClaim.ts
+/**
+* Scans a credit-facade multicall for a delayed-withdrawal claim call.
+*
+* @param sdk - SDK with the adapters plugin attached.
+* @param multicall - Parsed inner operations of the multicall.
+* @returns The detected claim, or `undefined` when the multicall contains no
+* delayed-withdrawal claim call.
+*/
+function detectDelayedClaim(sdk, multicall) {
+	for (const op of multicall) {
+		if (op.operation !== "Execute") continue;
+		const adapter = sdk.getContract(op.adapter);
+		if (!(adapter instanceof AbstractAdapterContract)) continue;
+		const claim = adapter.parseDelayedWithdrawalClaim(op.calldata);
+		if (claim) return {
+			adapter: op.adapter,
+			redeemer: claim.redeemer
+		};
+	}
+}
+/**
+* Resolves the delayed intent of the withdrawal a multicall claims: detects
+* the claim call and reads the recorded intent of the claimed redeemer from
+* the `RedemptionLogger` contract.
+*
+* @param sdk - SDK with the adapters plugin attached.
+* @param multicall - Parsed inner operations of the multicall.
+* @param blockNumber - Optional block number to read the log at.
+* @returns The decoded intent, or `undefined` when the multicall claims
+* nothing, the redemption logger is not deployed, or the log carries no
+* intent.
+* @throws InvalidDelayedIntentError when the logged `extraData` is non-empty
+* but cannot be decoded as a `DelayedIntent`.
+*/
+async function resolveDelayedClaimIntent(sdk, multicall, blockNumber) {
+	const claim = detectDelayedClaim(sdk, multicall);
+	if (!claim) return;
+	return sdk.redemptionLogger?.getDelayedIntent(claim.redeemer, blockNumber);
+}
+//#endregion
+export { detectDelayedClaim, resolveDelayedClaimIntent };

package/dist/esm/preview/preview/detectDelayedOperation.js

@@ -0,0 +1,48 @@
+import { decodeDelayedIntent } from "../../sdk/accounts/withdrawal-compressor/intent-codec.js";
+import { InvalidDelayedIntentError } from "../../sdk/accounts/withdrawal-compressor/errors.js";
+import "../../sdk/index.js";
+import { AbstractAdapterContract } from "../../plugins/adapters/contracts/AbstractAdapter.js";
+import "../../plugins/adapters/index.js";
+import { isAddressEqual } from "viem";
+//#region src/preview/preview/detectDelayedOperation.ts
+/**
+* Scans a credit-facade multicall for a delayed-withdrawal request.
+*
+* @param sdk - SDK with the adapters plugin attached.
+* @param multicall - Parsed inner operations of the multicall.
+* @returns The detected request, or `undefined` when
+* the multicall contains no delayed-withdrawal request.
+* @throws InvalidDelayedIntentError when a request carries non-empty
+* `extraData` that cannot be decoded as a `DelayedIntent`.
+*/
+function detectDelayedOperation(sdk, multicall) {
+	let bracketDeltas = [];
+	for (const op of multicall) {
+		if (op.operation === "StoreExpectedBalances") {
+			bracketDeltas = op.deltas;
+			continue;
+		}
+		if (op.operation === "CompareBalances") {
+			bracketDeltas = [];
+			continue;
+		}
+		if (op.operation !== "Execute") continue;
+		const adapter = sdk.getContract(op.adapter);
+		if (!(adapter instanceof AbstractAdapterContract)) continue;
+		const request = adapter.parseDelayedWithdrawalRequest(op.calldata);
+		if (!request) continue;
+		if (!bracketDeltas.some(({ token, balance }) => balance > 0n && isAddressEqual(token, request.phantomToken))) continue;
+		let intent;
+		if (request.extraData && request.extraData !== "0x") try {
+			intent = decodeDelayedIntent(request.extraData);
+		} catch (e) {
+			throw new InvalidDelayedIntentError(request.extraData, e);
+		}
+		return {
+			request,
+			intent
+		};
+	}
+}
+//#endregion
+export { detectDelayedOperation };

package/dist/esm/preview/preview/errors.js

@@ -1,12 +1,16 @@
-class UnsupportedOperationError extends Error {
-  /** The parsed operation kind (the `operation` discriminant). */
-  operation;
-  constructor(operation) {
-    super(`operation "${operation}" is not supported by previewOperation`);
-    this.name = "UnsupportedOperationError";
-    this.operation = operation;
-  }
-}
-export {
-  UnsupportedOperationError
+//#region src/preview/preview/errors.ts
+/**
+* Thrown by `previewOperation` for parsed operations it cannot preview yet.
+* Currently only pool operations and credit account opening are supported.
+*/
+var UnsupportedOperationError = class extends Error {
+	/** The parsed operation kind (the `operation` discriminant). */
+	operation;
+	constructor(operation) {
+		super(`operation "${operation}" is not supported by previewOperation`);
+		this.name = "UnsupportedOperationError";
+		this.operation = operation;
+	}
 };
+//#endregion
+export { UnsupportedOperationError };