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

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

@@ -1,14 +1,36 @@
 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;
-    /** Underlying assets supplied to the pool. */
+    /** 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;
 }
@@ -17,12 +39,28 @@ export interface PoolDepositOperation {
  * 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;
 }
@@ -32,24 +70,74 @@ export interface PoolMintOperation {
  * 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;
-    /** Pool shares (diesel) burned. */
+    /**
+     * 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

@@ -2,9 +2,11 @@ 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),
@@ -29,16 +31,19 @@ export type RequireAdaptersPlugin<P extends PluginsMap> = HasAdaptersPlugin<P> e
  */
 export type SdkWithAdapters<P extends PluginsMap = PluginsMap> = OnchainSDK<P> & RequireAdaptersPlugin<P>;
 /**
- * Result of decoding a single raw operation calldata: either a pool
- * deposit/redeem or one of the credit-facade operations.
- *
- * Calldata-only parse produces base (descriptor) adapter operations, so the
- * facade operations are used with the default `Ext = {}`.
+ * 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;
+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

@@ -11,9 +11,7 @@ export interface AllowancePrerequisiteProps {
 }
 /** Checks that `owner` granted `spender` an ERC-20 allowance >= `required`. */
 export declare class AllowancePrerequisite extends Prerequisite<"allowance"> {
-    private readonly _id;
-    private readonly _title;
-    private readonly _detail;
+    #private;
     constructor(props: AllowancePrerequisiteProps);
     get id(): string;
     get kind(): "allowance";

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

@@ -1,6 +1,6 @@
 import { type Address, type ContractFunctionParameters } from "viem";
 import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
-import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
 export interface BalancePrerequisiteProps {
     token: Address;
     owner: Address;
@@ -8,16 +8,19 @@ export interface BalancePrerequisiteProps {
     title?: string;
     id?: string;
 }
-/** Checks that `owner` holds an ERC-20 balance >= `required`. */
+/**
+ * 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 readonly _id;
-    private readonly _title;
-    private readonly _detail;
+    #private;
     constructor(props: BalancePrerequisiteProps);
     get id(): string;
     get kind(): "balance";
     get title(): string;
     get detail(): PrerequisiteDetail<"balance">;
-    calls(): ContractFunctionParameters[];
+    calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
     resolve(slice: MulticallCallResult[]): PrerequisiteResult<"balance">;
 }

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

@@ -1,10 +1,19 @@
-import type { Operation } from "../parse/index.js";
+import { type PluginsMap } from "../../sdk/index.js";
+import { type ParseOperationCalldataInput } from "../parse/parseOperationCalldata.js";
 import type { AnyPrerequisite } from "./Prerequisite.js";
-import type { PrerequisiteContext } from "./types.js";
 /**
- * Derives the on-chain prerequisites for a parsed operation: the conditions
- * that must hold for the call not to revert and that we can verify with the
- * SDK (token approvals, wallet balances).
+ * 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
@@ -13,4 +22,4 @@ import type { PrerequisiteContext } from "./types.js";
  * 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(tx: Operation, ctx: PrerequisiteContext): AnyPrerequisite[];
+export declare function buildPrerequisites<P extends PluginsMap>(input: BuildPrerequisitesInput<P>): Promise<AnyPrerequisite[]>;

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

@@ -3,5 +3,6 @@ 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/types.d.ts

@@ -1,18 +1,14 @@
 import type { Address } from "viem";
-import type { OnchainSDK } from "../../sdk/index.js";
+import type { OnchainSDK, RWAOpenAccountRequirements } from "../../sdk/index.js";
 /**
  * Extension point that ties each prerequisite kind to its detail payload.
  *
- * Adding a new prerequisite kind only requires a new entry here: the generic
- * machinery below and the UI renderer registry both key off this map, so TS
- * forces every consumer to handle the new kind.
- *
  * 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 acquire/free up funds (`balance`). Do NOT add protocol- or admin-level
- * state the user cannot change, such as pool pause status or available pool
- * liquidity; those are not actionable and must not be listed as prerequisites.
+ * 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`. */
@@ -32,6 +28,12 @@ export interface PrerequisiteDetailMap {
         /** 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];

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[];
+};

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

@@ -0,0 +1,21 @@
+/**
+ * Thrown when a transaction's attached native value (`msg.value`) does not fit
+ * into the WETH collateral declared by the multicall: such a transaction is
+ * malformed and would not execute successfully.
+ */
+export declare class InvalidTransactionValueError extends Error {
+    /** Transaction `msg.value`. */
+    readonly value: bigint;
+    /** Amount of wrapped native token added as collateral. */
+    readonly wethCollateral: bigint;
+    constructor(value: bigint, wethCollateral: bigint);
+}
+/**
+ * Thrown by `previewOperation` for parsed operations it cannot preview yet.
+ * Currently only pool operations and credit account opening are supported.
+ */
+export declare class UnsupportedOperationError extends Error {
+    /** The parsed operation kind (the `operation` discriminant). */
+    readonly operation: string;
+    constructor(operation: string);
+}

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

@@ -0,0 +1,5 @@
+export * from "./applyInnerOperations.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewOperation.js";
+export * from "./types.js";

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

@@ -0,0 +1,11 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { MulticallOperation, SecuritizeMulticallOperation } from "../parse/index.js";
+import type { AdjustCreditAccountPreview, PreviewOperationInput, PreviewOperationOptions } from "./types.js";
+/**
+ * Previews a `multicall`/`botMulticall` operation on an existing credit
+ * account: fetches the account's pre-state (unless provided via options),
+ * threads the multicall through {@link applyInnerOperations} and reports the
+ * minimal guaranteed post-state alongside the changes relative to the
+ * pre-state.
+ */
+export declare function previewAdjustCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: MulticallOperation | SecuritizeMulticallOperation, options?: PreviewOperationOptions): Promise<AdjustCreditAccountPreview>;

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

@@ -0,0 +1,4 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { OpenCreditAccountOperation, SecuritizeOpenCreditAccountOperation } from "../parse/index.js";
+import type { OpenCreditAccountPreview, PreviewOperationInput } from "./types.js";
+export declare function previewOpenCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: OpenCreditAccountOperation | SecuritizeOpenCreditAccountOperation): OpenCreditAccountPreview;

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

@@ -0,0 +1,7 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { OperationPreview, PreviewOperationInput, PreviewOperationOptions } from "./types.js";
+/**
+ * Previews a raw operation calldata: decodes it into a typed operation and
+ * assembles an operation-specific, human-displayable preview.
+ */
+export declare function previewOperation<P extends PluginsMap = PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<OperationPreview>;

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

@@ -0,0 +1,5 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { PoolOperation } from "../parse/index.js";
+import { type OperationSimulationOptions } from "../simulate/index.js";
+import type { PoolOperationPreview, PreviewOperationInput } from "./types.js";
+export declare function previewPoolOperation<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: PoolOperation, options?: OperationSimulationOptions): Promise<PoolOperationPreview>;