@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.10

package/dist/types/preview/parse/types-pools.d.ts

@@ -0,0 +1,143 @@
+import type { Address } from "viem";
+/**
+ * ERC4626 `deposit` into a Gearbox pool.
+ *
+ * A deposit can reach the pool directly (an ERC4626 call sent straight to the
+ * pool contract) or through a zapper (e.g. RWA-default pools and classic zapper
+ * pools). When routed through a zapper, `zapper` is the call target and
+ * `tokenIn` is the zapper's input token rather than the pool underlying.
+ */
+export interface PoolDepositOperation {
+    /** ERC4626 operation kind. */
+    operation: "Deposit";
+    /** Destination pool the assets are deposited into. */
+    pool: Address;
+    /** Address credited with the minted pool shares. */
+    receiver: Address;
+    /** Amount of underlying assets supplied to the pool. */
+    assets: bigint;
+    /** Underlying token of the destination pool. */
+    underlying: Address;
+    /**
+     * Token actually supplied by the caller: the pool underlying for direct
+     * deposits, or the zapper's input token for zapper-routed deposits.
+     */
+    tokenIn: Address;
+    /**
+     * Token minted to the receiver: the pool's diesel token for direct
+     * deposits, or the zapper's output token (e.g. a farmed/staked diesel
+     * wrapper) for zapper-routed deposits.
+     */
+    tokenOut: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct deposits. */
+    zapper?: Address;
+    /** Referral code, present only for `depositWithReferral` calls. */
+    referralCode?: bigint;
+}
+/**
+ * ERC4626 `mint` into a Gearbox pool. Unlike `deposit`, the caller specifies the
+ * amount of shares to mint; the assets pulled are resolved by the pool.
+ */
+export interface PoolMintOperation {
+    /** ERC4626 operation kind. */
+    operation: "Mint";
+    /** Destination pool the shares are minted from. */
+    pool: Address;
+    /** Address credited with the minted pool shares. */
+    receiver: Address;
+    /** Pool shares (diesel) minted to the receiver. */
+    shares: bigint;
+    /** Underlying token of the destination pool. */
+    underlying: Address;
+    /**
+     * Token actually supplied by the caller: the pool underlying for direct
+     * mints, or the zapper's input token for zapper-routed mints.
+     */
+    tokenIn: Address;
+    /**
+     * Token minted to the receiver: the pool's diesel token for direct mints,
+     * or the zapper's output token for zapper-routed mints.
+     */
+    tokenOut: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct mints. */
+    zapper?: Address;
+    /** Referral code, present only for `mintWithReferral` calls. */
+    referralCode?: bigint;
+}
+/**
+ * ERC4626 `withdraw` from a Gearbox pool. Unlike `redeem`, the caller specifies
+ * the amount of underlying assets to withdraw; the shares burned are resolved by
+ * the pool.
+ */
+export interface PoolWithdrawOperation {
+    /** ERC4626 operation kind. */
+    operation: "Withdraw";
+    /** Source pool the assets are withdrawn from. */
+    pool: Address;
+    /** Address that receives the withdrawn tokens. */
+    receiver: Address;
+    /** Address whose pool shares are burned. */
+    owner: Address;
+    /** Underlying assets withdrawn to the receiver. */
+    assets: bigint;
+    /** Underlying token of the source pool. */
+    underlying: Address;
+    /**
+     * Token burned from `owner`: the pool's diesel token for direct
+     * withdrawals, or the zapper's share-side token for zapper-routed
+     * withdrawals.
+     */
+    tokenIn: Address;
+    /**
+     * Token actually returned to the receiver: the pool underlying for direct
+     * withdrawals, or the zapper's output token for zapper-routed withdrawals.
+     */
+    tokenOut: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct withdrawals. */
+    zapper?: Address;
+}
+/**
+ * ERC4626 `redeem` from a Gearbox pool.
+ *
+ * A redeem can reach the pool directly or through a zapper. When routed through
+ * a zapper, `zapper` is the call target and `tokenOut` is the zapper's output
+ * token rather than the pool underlying.
+ */
+export interface PoolRedeemOperation {
+    /** ERC4626 operation kind. */
+    operation: "Redeem";
+    /** Source pool the shares are redeemed from. */
+    pool: Address;
+    /** Address that receives the redeemed tokens. */
+    receiver: Address;
+    /** Address whose pool shares are burned. */
+    owner: Address;
+    /**
+     * Amount of {@link PoolRedeemOperation.tokenIn} burned: pool shares
+     * (diesel) for direct redeems, or the zapper's share-side token amount for
+     * zapper-routed redeems.
+     */
+    shares: bigint;
+    /** Underlying token of the source pool. */
+    underlying: Address;
+    /**
+     * Token burned from `owner`: the pool's diesel token for direct redeems, or
+     * the zapper's share-side token (e.g. a farmed/staked diesel wrapper) for
+     * zapper-routed redeems.
+     */
+    tokenIn: Address;
+    /**
+     * Token actually returned to the receiver: the pool underlying for direct
+     * redeems, or the zapper's output token for zapper-routed redeems.
+     */
+    tokenOut: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct redeems. */
+    zapper?: Address;
+}
+/**
+ * ERC4626 pool operations. Each operation may be sent directly to the pool
+ * contract or routed through a zapper (indicated by the optional `zapper`
+ * field).
+ */
+export type PoolOperation = PoolDepositOperation | PoolMintOperation | PoolWithdrawOperation | PoolRedeemOperation;
+export type PoolOperationType = PoolOperation["operation"];

package/dist/types/preview/parse/types-rwa.d.ts

@@ -0,0 +1,48 @@
+import type { Address } from "viem";
+import type { SecuritizeRegisterMessage } from "../../sdk/index.js";
+import type { InnerOperation } from "./types-facades.js";
+/**
+ * Metadata shared by all RWA factory operations. RWA credit accounts are
+ * opened and managed through the market's RWA factory rather than the credit
+ * facade, but the inner `calls` still target the facade/adapters, so the
+ * credit suite is known.
+ */
+export interface RWAOperationMetadata {
+    /** RWA factory contract the transaction is sent to. */
+    factory: Address;
+    creditManager: Address;
+    creditFacade: Address;
+}
+export interface SecuritizeOpenCreditAccountOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "SecuritizeOpenCreditAccount";
+    multicall: InnerOperation<Ext>[];
+    /**
+     * DSToken addresses to register, decoded from calldata. Empty in the
+     * template flow, where the real value comes from the factory's open-account
+     * requirements.
+     */
+    tokensToRegister: Address[];
+    /**
+     * EIP-712 registration signatures to store on-chain, decoded from calldata.
+     * Empty in the template flow.
+     */
+    signaturesToCache: SecuritizeRegisterMessage[];
+}
+/**
+ * `SecuritizeRWAFactory.multicall` call: like the facade's `multicall`, plus
+ * the factory-specific registration args.
+ */
+export interface SecuritizeMulticallOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "SecuritizeMulticall";
+    creditAccount: Address;
+    multicall: InnerOperation<Ext>[];
+    /** DSToken addresses to register, decoded from calldata. */
+    tokensToRegister: Address[];
+    /** EIP-712 registration signatures to store on-chain, decoded from calldata. */
+    signaturesToCache: SecuritizeRegisterMessage[];
+}
+/**
+ * Discriminated union of all RWA factory operation types. Extend it when
+ * adding support for a new RWA factory type.
+ */
+export type RWAOperation<Ext extends object = {}> = SecuritizeOpenCreditAccountOperation<Ext> | SecuritizeMulticallOperation<Ext>;

package/dist/types/preview/parse/types.d.ts

@@ -0,0 +1,49 @@
+import type { AdaptersPlugin } from "../../plugins/adapters/index.js";
+import type { OnchainSDK, PluginsMap } from "../../sdk/index.js";
+import type { OuterFacadeOperation } from "./types-facades.js";
+import type { PoolOperation } from "./types-pools.js";
+import type { RWAOperation } from "./types-rwa.js";
+export * from "./types-adapters.js";
+export * from "./types-facades.js";
+export * from "./types-pools.js";
+export * from "./types-rwa.js";
+/**
+ * True when the plugin map `P` contains the {@link AdaptersPlugin} under any
+ * key. Matched nominally (the plugin's private fields make it non-structural),
+ * so unrelated plugins never satisfy it.
+ */
+export type HasAdaptersPlugin<P extends PluginsMap> = Extract<P[keyof P], AdaptersPlugin> extends never ? false : true;
+/**
+ * Compile-time guard for the adapters plugin. Resolves to a no-op (`unknown`)
+ * when `P` includes the {@link AdaptersPlugin}, otherwise to an error-shaped
+ * type that makes the surrounding call fail to type-check.
+ *
+ * Intended to be intersected with a function argument so callers must pass an
+ * SDK whose adapter contracts are registered (required for multicall
+ * classification).
+ */
+export type RequireAdaptersPlugin<P extends PluginsMap> = HasAdaptersPlugin<P> extends true ? unknown : {
+    "OnchainSDK must be created with the AdaptersPlugin": never;
+};
+/**
+ * {@link OnchainSDK} whose plugin map is guaranteed at compile time to include
+ * the {@link AdaptersPlugin}.
+ */
+export type SdkWithAdapters<P extends PluginsMap = PluginsMap> = OnchainSDK<P> & RequireAdaptersPlugin<P>;
+/**
+ * Result of decoding a single raw operation calldata: a pool deposit/redeem,
+ * one of the credit-facade operations, or an RWA-factory operation.
+ */
+export type Operation = PoolOperation | OuterFacadeOperation | RWAOperation;
+/**
+ * Narrows an {@link Operation} to a {@link PoolOperation} (deposit, mint,
+ * withdraw or redeem). Used by the UI to decide whether a custom view exists for
+ * the parsed result; everything else falls back to the raw JSON view.
+ */
+export declare function isPoolOperation(tx: Operation): tx is PoolOperation;
+/**
+ * Narrows an {@link Operation} to an {@link RWAOperation} (an RWA-factory
+ * open-account or multicall). Used to route parsed operations to the
+ * RWA-specific simulation path.
+ */
+export declare function isRWAOperation(tx: Operation): tx is RWAOperation;

package/dist/types/preview/prerequisites/AllowancePrerequisite.d.ts

@@ -0,0 +1,22 @@
+import { type Address, type ContractFunctionParameters } from "viem";
+import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+export interface AllowancePrerequisiteProps {
+    token: Address;
+    owner: Address;
+    spender: Address;
+    required: bigint;
+    title?: string;
+    id?: string;
+}
+/** Checks that `owner` granted `spender` an ERC-20 allowance >= `required`. */
+export declare class AllowancePrerequisite extends Prerequisite<"allowance"> {
+    #private;
+    constructor(props: AllowancePrerequisiteProps);
+    get id(): string;
+    get kind(): "allowance";
+    get title(): string;
+    get detail(): PrerequisiteDetail<"allowance">;
+    calls(): ContractFunctionParameters[];
+    resolve(slice: MulticallCallResult[]): PrerequisiteResult<"allowance">;
+}

package/dist/types/preview/prerequisites/BalancePrerequisite.d.ts

@@ -0,0 +1,26 @@
+import { type Address, type ContractFunctionParameters } from "viem";
+import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+export interface BalancePrerequisiteProps {
+    token: Address;
+    owner: Address;
+    required: bigint;
+    title?: string;
+    id?: string;
+}
+/**
+ * Checks that `owner` holds a token balance >= `required`. The token is read
+ * as an ERC-20, except for the native pseudo-address ({@link NATIVE_ADDRESS},
+ * e.g. ETH-zapper deposits) whose balance is read via multicall3's
+ * `getEthBalance`.
+ */
+export declare class BalancePrerequisite extends Prerequisite<"balance"> {
+    #private;
+    constructor(props: BalancePrerequisiteProps);
+    get id(): string;
+    get kind(): "balance";
+    get title(): string;
+    get detail(): PrerequisiteDetail<"balance">;
+    calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
+    resolve(slice: MulticallCallResult[]): PrerequisiteResult<"balance">;
+}

package/dist/types/preview/prerequisites/Prerequisite.d.ts

@@ -0,0 +1,60 @@
+import { type ContractFunctionParameters } from "viem";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteError, PrerequisiteKind, PrerequisiteResult } from "./types.js";
+/**
+ * One entry of a viem `multicall({ allowFailure: true })` response: either a
+ * decoded `result` or the `error` that the call reverted with.
+ */
+export type MulticallCallResult = {
+    status: "success";
+    result: unknown;
+    error?: undefined;
+} | {
+    status: "failure";
+    result?: undefined;
+    error: Error;
+};
+/**
+ * Decodes an unknown error into a {@link PrerequisiteError} with a
+ * human-readable revert reason. Mirrors the SDK's `extractCallError`: walk the
+ * viem error chain for a {@link ContractFunctionRevertedError} and use its
+ * `errorName`, otherwise fall back to the error's short message / name.
+ */
+export declare function toPrerequisiteError(cause: unknown): PrerequisiteError;
+/**
+ * A single verifiable prerequisite for a transaction. Subclasses describe the
+ * on-chain reads they need ({@link calls}) and how to turn the multicall slice
+ * into a {@link PrerequisiteResult} ({@link resolve}).
+ *
+ * Identity (`id`, `kind`, `title`) and build-time `detail` are exposed as
+ * read-only accessors; subclasses back them with private fields. The shared
+ * {@link satisfiedResult}/{@link errorResult} helpers are `protected` so each
+ * subclass builds results consistently.
+ *
+ * The same instance can be verified standalone via {@link verify} or batched
+ * together with others by `verifyPrerequisites`.
+ */
+export declare abstract class Prerequisite<K extends PrerequisiteKind> {
+    /** Stable identifier, used as a React key and for deduplication. */
+    abstract get id(): string;
+    /** Discriminant tying this check to its detail payload. */
+    abstract get kind(): K;
+    /** Human-readable label shown in the UI. */
+    abstract get title(): string;
+    /** Inputs known before reading the chain (no `actual` yet). */
+    abstract get detail(): PrerequisiteDetail<K>;
+    /** Contract reads this check needs (usually one). */
+    abstract calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
+    /** Maps this check's slice of the multicall response into a result. */
+    abstract resolve(slice: MulticallCallResult[]): PrerequisiteResult<K>;
+    /**
+     * Verifies this prerequisite on its own using an `allowFailure` multicall.
+     * Prefer `verifyPrerequisites` to batch several checks into one round-trip.
+     */
+    verify(ctx: PrerequisiteContext): Promise<PrerequisiteResult<K>>;
+    /** Builds a successful result; `detail` carries the on-chain `actual`. */
+    protected satisfiedResult(satisfied: boolean, detail: PrerequisiteDetail<K>): PrerequisiteResult<K>;
+    /** Builds a failed result from a decoded read error. */
+    protected errorResult(error: PrerequisiteError): PrerequisiteResult<K>;
+}
+/** Any prerequisite regardless of its kind, used for heterogeneous lists. */
+export type AnyPrerequisite = Prerequisite<PrerequisiteKind>;

package/dist/types/preview/prerequisites/RWAOpenRequirementsPrerequisite.d.ts

@@ -0,0 +1,36 @@
+import type { Address, ContractFunctionParameters } from "viem";
+import type { RWAOpenAccountRequirements } from "../../sdk/index.js";
+import { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+export interface RWAOpenRequirementsPrerequisiteProps {
+    /** Requirements already resolved via `sdk.accounts.getOpenAccountRequirements`. */
+    requirements: RWAOpenAccountRequirements;
+    /** RWA token (e.g. Securitize DSToken) the requirements were computed for. */
+    token: Address;
+    /** RWA factory that produced the requirements. */
+    factory: Address;
+    title?: string;
+    id?: string;
+}
+/**
+ * Checks that the borrower has fulfilled the RWA factory's open-account
+ * requirements (issuer-side token registration, EIP-712 signatures).
+ *
+ * Unlike `allowance`/`balance`, the requirements cannot be derived from plain
+ * ERC-20 multicall reads: they come from an async compressor read performed by
+ * `sdk.accounts.getOpenAccountRequirements`. The prerequisite is therefore
+ * *pre-resolved*: it is constructed with the requirements already computed,
+ * contributes no calls to the verification multicall, and `resolve` only
+ * interprets the stored payload.
+ */
+export declare class RWAOpenRequirementsPrerequisite extends Prerequisite<"rwaOpenRequirements"> {
+    #private;
+    constructor(props: RWAOpenRequirementsPrerequisiteProps);
+    get id(): string;
+    get kind(): "rwaOpenRequirements";
+    get title(): string;
+    get detail(): PrerequisiteDetail<"rwaOpenRequirements">;
+    /** Pre-resolved: no on-chain reads to contribute. */
+    calls(): ContractFunctionParameters[];
+    resolve(): PrerequisiteResult<"rwaOpenRequirements">;
+}

package/dist/types/preview/prerequisites/buildPrerequisites.d.ts

@@ -0,0 +1,25 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import { type ParseOperationCalldataInput } from "../parse/parseOperationCalldata.js";
+import type { AnyPrerequisite } from "./Prerequisite.js";
+/**
+ * Input of {@link buildPrerequisites}: the same raw-calldata input as the
+ * internal calldata parser, plus an optional block to read at.
+ */
+export type BuildPrerequisitesInput<P extends PluginsMap = PluginsMap> = ParseOperationCalldataInput<P> & {
+    /** Block to read at; defaults to latest. Only set for testnet forks. */
+    blockNumber?: bigint;
+};
+/**
+ * Derives 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). The calldata is
+ * decoded internally via `parseOperationCalldata`.
+ *
+ * Only *sender-actionable* prerequisites belong here: conditions the LP
+ * provider or borrower can fix themselves before retrying (e.g. approve a
+ * token, top up a balance). Non-actionable protocol/admin state (pool pause,
+ * available pool liquidity, health factor, liquidatability, degen NFT gating,
+ * bot permissions) is intentionally out of scope, since the user cannot
+ * resolve it. New {@link AnyPrerequisite} subclasses must follow the same rule.
+ */
+export declare function buildPrerequisites<P extends PluginsMap>(input: BuildPrerequisitesInput<P>): Promise<AnyPrerequisite[]>;

package/dist/types/preview/prerequisites/index.d.ts

@@ -0,0 +1,8 @@
+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";

package/dist/types/preview/prerequisites/prepareAction.d.ts

@@ -0,0 +1,52 @@
+import { type Address, type Hex } from "viem";
+import type { AnyPrerequisiteResult } from "./types.js";
+/**
+ * A single transaction that satisfies a sender-actionable prerequisite.
+ *
+ * The shape is intentionally minimal (`to`/`data`/optional `value`) so it maps
+ * directly onto wallet send primitives (e.g. viem `sendTransaction`, wagmi
+ * `useSendTransaction`/`useWriteContract`). It is deliberately *not* the heavier
+ * {@link import("../../sdk/types/transactions.js").RawTx} used for Safe batches.
+ *
+ * The `kind` mirrors the prerequisite kind it remediates, so consumers can label
+ * the action (e.g. "Approve") without re-deriving it.
+ */
+export interface PrerequisiteAction {
+    /** Prerequisite kind this action remediates. */
+    kind: "allowance";
+    /** Contract the transaction is sent to (the ERC-20 token for allowances). */
+    to: Address;
+    /** Encoded calldata (e.g. `approve(spender, required)`). */
+    data: Hex;
+    /** Native value to send; omitted (treated as 0) for ERC-20 approvals. */
+    value?: bigint;
+}
+/**
+ * Builds the transaction that resolves an unsatisfied, sender-actionable
+ * prerequisite, or returns `null` when the prerequisite cannot be fixed with a
+ * single wallet transaction.
+ *
+ * Currently only `allowance` is actionable: it returns an ERC-20
+ * `approve(spender, required)` for the exact required amount. `balance`
+ * shortfalls (the user must acquire/free up funds) and errored reads are not
+ * actionable and return `null`. New actionable kinds (permits, native unwrap,
+ * approve-reset-to-zero for non-standard tokens, ...) should be encoded here so
+ * consumers do not have to special-case them.
+ *
+ * Operates on the serializable {@link AnyPrerequisiteResult} produced by
+ * `verifyPrerequisites` (not on {@link import("./Prerequisite.js").Prerequisite}
+ * instances), so it works against cached/persisted results.
+ *
+ * @param result - A verified prerequisite result.
+ * @returns The remediation transaction, or `null` if not auto-actionable.
+ */
+export declare function preparePrerequisiteAction(result: AnyPrerequisiteResult): PrerequisiteAction | null;
+/**
+ * Whether a prerequisite result represents something the sender can fix with a
+ * single wallet transaction (i.e. {@link preparePrerequisiteAction} returns a
+ * transaction for it).
+ *
+ * Useful for UIs that distinguish "approve to continue" (actionable) from hard
+ * blocks like an insufficient balance (not actionable).
+ */
+export declare function isActionablePrerequisite(result: AnyPrerequisiteResult): boolean;

package/dist/types/preview/prerequisites/runPrerequisites.d.ts

@@ -0,0 +1,12 @@
+import type { AnyPrerequisite } from "./Prerequisite.js";
+import type { AnyPrerequisiteResult, PrerequisiteContext } from "./types.js";
+/**
+ * Verifies all prerequisites in a single resilient multicall.
+ *
+ * Every prereq contributes its reads to one `multicall({ allowFailure: true })`
+ * batch, then resolves its own slice of the response. A read that reverts
+ * isolates to that prerequisite (an `error` result) without affecting the
+ * others; if the whole round-trip fails (RPC/network), every prerequisite
+ * resolves to an `error` carrying that reason.
+ */
+export declare function verifyPrerequisites(prereqs: AnyPrerequisite[], ctx: PrerequisiteContext): Promise<AnyPrerequisiteResult[]>;

package/dist/types/preview/prerequisites/types.d.ts

@@ -0,0 +1,80 @@
+import type { Address } from "viem";
+import type { OnchainSDK, RWAOpenAccountRequirements } from "../../sdk/index.js";
+/**
+ * Extension point that ties each prerequisite kind to its detail payload.
+ *
+ * IMPORTANT: only add prerequisites that are *actionable by the transaction
+ * sender* (the LP provider or borrower). A valid prerequisite is one the user
+ * can resolve themselves before retrying, e.g. approve a token (`allowance`)
+ * or perform offchain KYC verification.
+ *
+ * Do NOT add protocol- or admin-level state the user cannot change.
+ */
+export interface PrerequisiteDetailMap {
+    /** ERC-20 allowance from `owner` to `spender` must cover `required`. */
+    allowance: {
+        token: Address;
+        owner: Address;
+        spender: Address;
+        required: bigint;
+        /** On-chain allowance read; only present when the read succeeded. */
+        actual?: bigint;
+    };
+    /** ERC-20 balance of `owner` must cover `required`. */
+    balance: {
+        token: Address;
+        owner: Address;
+        required: bigint;
+        /** On-chain balance read; only present when the read succeeded. */
+        actual?: bigint;
+    };
+    /**
+     * RWA (e.g. Securitize) open-account requirements: off-chain token
+     * registration and/or EIP-712 signatures the borrower must provide before
+     * opening a credit account in an RWA market.
+     */
+    rwaOpenRequirements: RWAOpenAccountRequirements;
+}
+export type PrerequisiteKind = keyof PrerequisiteDetailMap;
+export type PrerequisiteDetail<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteDetailMap[K];
+/** Failure of the underlying on-chain read (revert, decode error, RPC error). */
+export interface PrerequisiteError {
+    /** Decoded revert reason / error name, human-readable. */
+    reason: string;
+    /** Original error, kept for debugging. */
+    cause?: unknown;
+}
+export interface PrerequisiteBase<K extends PrerequisiteKind> {
+    id: string;
+    kind: K;
+    title: string;
+    detail: PrerequisiteDetail<K>;
+}
+/**
+ * Outcome of verifying a single prerequisite: either the read succeeded (a
+ * `satisfied` boolean) or it reverted/failed (an `error` with the revert
+ * reason). The two variants are mutually exclusive.
+ */
+export type PrerequisiteResult<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteBase<K> & ({
+    satisfied: boolean;
+    error?: undefined;
+} | {
+    satisfied?: undefined;
+    error: PrerequisiteError;
+});
+/**
+ * Discriminated union over every prerequisite kind. Switching on `kind`
+ * narrows `detail` to the matching payload, so React components can render
+ * kind-specific details with full type safety.
+ */
+export type AnyPrerequisiteResult = {
+    [K in PrerequisiteKind]: PrerequisiteResult<K>;
+}[PrerequisiteKind];
+/** Shared inputs for building and verifying prerequisites. */
+export interface PrerequisiteContext {
+    sdk: OnchainSDK;
+    /** Address whose balances/allowances are checked (the tx sender). */
+    wallet: Address;
+    /** Block to read at; defaults to latest. Only set for testnet forks. */
+    blockNumber?: bigint;
+}

package/dist/types/preview/preview/applyInnerOperations.d.ts

@@ -0,0 +1,77 @@
+import { type Asset, AssetsMap, type PluginsMap } from "../../sdk/index.js";
+import type { InnerOperation, SdkWithAdapters } from "../parse/index.js";
+/**
+ * Running state threaded through a credit-facade multicall by
+ * {@link applyInnerOperations}. Seeded by the caller:
+ * - account opening: everything zero/empty (the account doesn't exist yet);
+ * - account adjustment: `balances` from the account's current token balances,
+ *   `debt` from the principal, `totalDebt` from principal + accrued interest +
+ *   accrued fees.
+ */
+export interface InnerOperationsState {
+    /**
+     * Cumulative credit-account balances, mutated in facade execution order.
+     */
+    balances: AssetsMap;
+    /**
+     * Debt principal
+     */
+    debt: bigint;
+    /**
+     * 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: bigint;
+    /**
+     * Cumulative amounts added via `addCollateral`.
+     */
+    collateralAdded: AssetsMap;
+    /**
+     * Cumulative amounts withdrawn via `withdrawCollateral`, with `MAX_UINT256`
+     * resolved against the running balance at the point of the call.
+     */
+    collateralWithdrawn: AssetsMap;
+    /**
+     * Raw `updateQuota` changes, one entry per op. Entries are relative signed
+     * changes (with the `MIN_INT96` "disable" sentinel kept as-is), not final
+     * quotas: folding them requires pre-state quotas, see
+     * {@link applyQuotaChanges}.
+     */
+    quotaChanges: Asset[];
+}
+/**
+ * Creates an all-zero {@link InnerOperationsState} (the account-opening seed).
+ */
+export declare function makeInnerOperationsState(): InnerOperationsState;
+/**
+ * Replays a credit-facade multicall over `state`, mutating it in place in
+ * facade execution order. The result is the *minimal guaranteed* post-state:
+ * exact deltas for explicit facade calls, exact leftovers for diff-style
+ * adapter calls inside `storeExpectedBalances`/`compareBalances` brackets and
+ * enforced minimums for bracket targets. Adapter calls outside a bracket are
+ * ignored: nothing enforces their outcome on-chain (e.g. reward claims and RWA
+ * wrap/unwrap calls emitted by `CreditAccountsServiceV310`), so their
+ * guaranteed balance change is zero.
+ *
+ * @throws On malformed `storeExpectedBalances`/`compareBalances` brackets and
+ * on bracketed calls to non-adapter targets.
+ */
+export declare function applyInnerOperations<P extends PluginsMap>(sdk: SdkWithAdapters<P>, multicall: InnerOperation[], state: InnerOperationsState): void;
+/**
+ * Applies raw `updateQuota` changes to the account's initial quotas.
+ *
+ * Each change is applied sequentially: `MIN_INT96` disables the quota, other
+ * changes are added to the running quota with the result clamped at zero
+ * (quotas cannot go negative on-chain).
+ *
+ * @param initialQuotas - Per-token quotas before the operation.
+ * @param changes - Raw changes recorded by {@link applyInnerOperations}.
+ * @returns `quotas` - final non-zero per-token quotas; `quotasChange` -
+ * applied (post-clamp) per-token deltas, non-zero entries only.
+ */
+export declare function applyQuotaChanges(initialQuotas: AssetsMap, changes: Asset[]): {
+    quotas: Asset[];
+    quotasChange: Asset[];
+};