@gearbox-protocol/sdk 14.12.0-next.3 → 14.12.0-next.30

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

@@ -0,0 +1,38 @@
+import type { Address } from "viem";
+import type { SdkWithAdapters } from "../../plugins/adapters/index.js";
+import type { PluginsMap } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { PreviewOperationOptions } from "../types.js";
+import { CreditAccountState } from "./CreditAccountState.js";
+import { type ReplayState } from "./replayInnerOperations.js";
+import type { OperationPreviewError } from "./types.js";
+/**
+ * Parsed operation on an existing credit account whose multicall can be
+ * replayed: the facade `closeCreditAccount` entry point and
+ * plain/bot/RWA multicalls all fit structurally.
+ */
+export interface ReplayableOperation {
+    creditAccount: Address;
+    multicall: InnerOperation[];
+}
+/**
+ * Result of {@link replayMulticall}: the account's pre-state and the replayed
+ * (minimal guaranteed) post-state.
+ */
+export interface ReplayMulticallResult {
+    /**
+     * Account state before the operation, dust-filtered
+     */
+    before: CreditAccountState;
+    /**
+     * Post-operation state and per-multicall bookkeeping, mutated by the
+     * replay in facade execution order
+     */
+    after: ReplayState;
+    error?: OperationPreviewError;
+}
+/**
+ * Replays the operation's multicall over the account's pre-resolved
+ * pre-state (`options.creditAccount`) via {@link replayInnerOperations}.
+ */
+export declare function replayMulticall<P extends PluginsMap>(sdk: SdkWithAdapters<P>, operation: ReplayableOperation, options: PreviewOperationOptions<true>): Promise<ReplayMulticallResult>;

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

@@ -0,0 +1,317 @@
+import type { Address } from "viem";
+import type { Asset, DelayedIntent } from "../../sdk/index.js";
+import type { PoolOperationType } from "../parse/index.js";
+/**
+ * Broken `storeExpectedBalances`/`compareBalances` bracket structure:
+ * `storeExpectedBalances` without a matching `compareBalances`, nested
+ * brackets, or `compareBalances` without a preceding `storeExpectedBalances`.
+ * We expect transactions that were generated by our frontend using router/withdrawal compressor
+ **/
+export declare const ERROR_MALFORMED_BRACKET = 1001;
+/**
+ * Adapter call outside a `storeExpectedBalances`/`compareBalances` bracket
+ * We expect transactions that were generated by our frontend using router/withdrawal compressor,
+ **/
+export declare const ERROR_ADAPTER_CALL_OUTSIDE_BRACKET = 1002;
+/**
+ * Bracketed call whose target is not an adapter (or adapter that is not known to the SDK)
+ **/
+export declare const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
+/**
+ * Bracketed adapter call cannot be replayed (undecodable/unsupported calldata)
+ **/
+export declare const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
+/**
+ * Out-of-bracket RWA wrap/unwrap calldata cannot be decoded
+ **/
+export declare const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
+/**
+ * `msg.value` does not fit into the declared WETH collateral
+ * Transactions can have arbitrary value, but the ones that we create
+ * using our frontend should have a value that fits into the declared WETH collateral.
+ **/
+export declare const ERROR_INVALID_TRANSACTION_VALUE = 1006;
+/** A token in the preview could not be priced by the oracle */
+export declare const ERROR_UNPRICEABLE_TOKEN = 2001;
+/**
+ * Dust threshold for replayed preview balances and balance changes.
+ *
+ * Multicalls assembled by `CreditAccountsServiceV310` subtract a 10-unit
+ * safety buffer from every expected output token in their
+ * `storeExpectedBalances` deltas (`amount - 10n` in
+ * `assembleStartDelayedWithdrawalCalls`/`assembleClaimDelayedCalls`), while
+ * subsequent calls in the same multicall spend exact on-chain amounts. A
+ * replay that credits only the min-guarantee can therefore be off by up to
+ * 10 units per token, including small negative residues that are impossible
+ * on-chain. Amounts within this threshold (in absolute value) are filtered
+ * from preview outputs; anything beyond it is a genuine discrepancy and is
+ * reported.
+ */
+export declare const PREVIEW_DUST = 10n;
+/**
+ * Non-throwing preview failure. When set on a preview, all fields are still
+ * computed best-effort, but some of them may be unreliable.
+ */
+export interface OperationPreviewError {
+    /**
+     * Numeric http-style error code, see the `ERROR_*` constants:
+     * - 1xxx: the transaction is malformed (we expect transactions
+     *   that were generated by our fromtend using router/withdrawal compressor)
+     *   and fields derived from replayed balances
+     *   may be unreliable;
+     * - 2xxx: the transaction may be fine, but the SDK could not fully
+     *   evaluate the preview (e.g. a token could not be priced).
+     */
+    code: number;
+    /**
+     * Human-readable details of the specific failure
+     */
+    message: string;
+}
+export interface PoolOperationPreview {
+    operation: PoolOperationType;
+    /**
+     * Pool address
+     */
+    pool: Address;
+    /**
+     * Token that goes from user to pool
+     * In case of deposit, underlying for direct deposit, zapper input for zapper-routed deposit
+     * In case of withdraw, pool shares (diesel token) for direct withdraw or zapper token out
+     *
+     * For mint/withdraw the amount of tokenIn cannot be determined from
+     * transaction calldata alone and requires an additional async call
+     * (previewMint/previewWithdraw).
+     */
+    tokenIn: Asset;
+    /**
+     * Token that goes from pool to user
+     * In case of deposit, pool shares (diesel token) for direct deposit or zapper token out
+     * In case of withdraw, underlying for direct withdraw or zapper token in
+     *
+     * For deposit/redeem the amount of tokenOut cannot be determined from
+     * transaction calldata alone and requires an additional async call
+     * (previewDeposit/previewRedeem).
+     */
+    tokenOut: Asset;
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort
+     */
+    error?: OperationPreviewError;
+}
+export interface OpenCreditAccountPreview {
+    operation: "OpenCreditAccount" | "RWAOpenCreditAccount";
+    /**
+     * Credit manager the account is opened in
+     */
+    creditManager: Address;
+    /**
+     * Target token of strategy: the first quoted token, with its balance taken
+     * from `assets`. Undefined when nothing is quoted.
+     */
+    target?: Asset;
+    /**
+     * Tokens that were added as collateral during account opening.
+     *
+     * When the transaction has native value attached, it is represented as a
+     * `NATIVE_ADDRESS` entry, with the wrapped native token amount reduced
+     * accordingly (omitted entirely when it reaches zero).
+     */
+    collateral: Asset[];
+    /**
+     * Sum of collateral tokens in underlying
+     */
+    collateralValue: bigint;
+    /**
+     * Borrowed amount in underlying
+     */
+    debt: bigint;
+    /**
+     * Desired quotas
+     */
+    quotas: Asset[];
+    /**
+     * Minimum amount of assets on credit account after it's opened,
+     * as estimated by router
+     */
+    assets: Asset[];
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but derived fields (`assets`, `target`,
+     * `collateralValue`) may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
+}
+export interface AdjustCreditAccountPreview {
+    operation: "AdjustCreditAccount";
+    /**
+     * Credit manager the account is opened in
+     */
+    creditManager: Address;
+    /**
+     * Credit account that is being adjusted
+     */
+    creditAccount: Address;
+    /**
+     * Tokens that were added as collateral during account opening.
+     *
+     * When the transaction has native value attached, it is represented as a
+     * `NATIVE_ADDRESS` entry, with the wrapped native token amount reduced
+     * accordingly (omitted entirely when it reaches zero).
+     */
+    collateralAdded: Asset[];
+    /**
+     * Tokens that were withdrawn as collateral during account adjustment.
+     */
+    collateralWithdrawn: Asset[];
+    /**
+     * Sum of collateral tokens in underlying
+     */
+    totalValue: bigint;
+    /**
+     * Borrowed amount in underlying
+     */
+    debt: bigint;
+    /**
+     * Debt after minus debt before
+     */
+    debtChange: bigint;
+    /**
+     * Desired quotas
+     */
+    quotas: Asset[];
+    /**
+     * Quotas after minus quotas before
+     */
+    quotasChange: Asset[];
+    /**
+     * Minimum amount of assets on credit account after the operation,
+     * as estimated by router
+     */
+    assets: Asset[];
+    /**
+     * Assets after minus assets before
+     */
+    assetsChange: Asset[];
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but derived fields (`assets`, `assetsChange`,
+     * `totalValue`) may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
+}
+export interface CloseCreditAccountPreview {
+    operation: "CloseCreditAccount";
+    /**
+     * True when the account is closed permanently (facade `closeCreditAccount`
+     * entry point), false when the debt is zeroed but the account stays open
+     * (plain multicall).
+     */
+    permanent: boolean;
+    /**
+     * Credit manager the account belongs to
+     */
+    creditManager: Address;
+    /**
+     * Credit account that is being closed
+     */
+    creditAccount: Address;
+    /**
+     * Underlying withdrawn to the user: minimal guaranteed amount, from the
+     * multicall replay (all collateral is swapped into underlying before
+     * withdrawal)
+     */
+    receivedAmount: bigint;
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but the
+     * balance-derived `receivedAmount` may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
+}
+export interface RepayCreditAccountPreview {
+    operation: "RepayCreditAccount";
+    /**
+     * True when the account is closed permanently (facade `closeCreditAccount`
+     * entry point), false when the debt is zeroed but the account stays open
+     * (plain multicall).
+     */
+    permanent: boolean;
+    /**
+     * Credit manager the account belongs to
+     */
+    creditManager: Address;
+    /**
+     * Credit account that is being repaid
+     */
+    creditAccount: Address;
+    /**
+     * Tokens added from the wallet to cover the debt (`addCollateral` calls).
+     *
+     * When the transaction has native value attached, it is represented as a
+     * `NATIVE_ADDRESS` entry, with the wrapped native token amount reduced
+     * accordingly (omitted entirely when it reaches zero).
+     */
+    collateralAdded: Asset[];
+    /**
+     * Tokens returned to the user in-kind (`withdrawCollateral` calls, with the
+     * MAX_UINT256 sentinel resolved against replayed balances)
+     */
+    collateralWithdrawn: Asset[];
+    /**
+     * Total debt repaid: principal + accrued interest + fees, in underlying
+     */
+    debtRepaid: bigint;
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort, but the
+     * balance-derived `collateralWithdrawn` may be unreliable in that case.
+     */
+    error?: OperationPreviewError;
+}
+/**
+ * Preview of the "instant" part of an operation on an existing credit
+ * account: what the transaction does in the same block, before any delayed
+ * withdrawal is claimed.
+ */
+export type InstantOperationPreview = AdjustCreditAccountPreview | CloseCreditAccountPreview | RepayCreditAccountPreview;
+/**
+ * Preview of a multicall that requests a delayed withdrawal (e.g. Securitize
+ * redemption): the source token is spent now and a withdrawal phantom token is received;
+ * the actual claim token materializes later, when the withdrawal is claimed and
+ * the recorded (if any) is resumed
+ */
+export interface DelayedCreditAccountOperationPreview {
+    operation: "DelayedCreditAccountOperation";
+    /**
+     * Credit account the operation is performed on
+     */
+    creditAccount: Address;
+    /**
+     * Credit manager the account belongs to
+     */
+    creditManager: Address;
+    /**
+     * Decoded from the withdrawal request's extraData; undefined when the
+     * request carries no intent (e.g. Mellow)
+     */
+    intent?: DelayedIntent;
+    /**
+     * What this transaction does right now: the delayed withdrawal is
+     * represented by the phantom token among the account's assets
+     */
+    instantPreview: InstantOperationPreview;
+    /**
+     * Best-effort state after the withdrawal is claimed and the intent is
+     * resumed; claim-only (phantom burned, claim token received) when
+     * `intent` is undefined
+     */
+    delayedPreview: InstantOperationPreview;
+}
+/**
+ * Result of previewing a raw operation calldata: currently pool operations and
+ * credit account opening, adjustment, closure, repayment and delayed
+ * withdrawal operations are supported.
+ */
+export type OperationPreview = PoolOperationPreview | OpenCreditAccountPreview | AdjustCreditAccountPreview | CloseCreditAccountPreview | RepayCreditAccountPreview | DelayedCreditAccountOperationPreview;

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

@@ -0,0 +1,35 @@
+import type { Address } from "viem";
+import { type Asset } from "../../sdk/index.js";
+import { type OperationPreviewError } from "./types.js";
+export interface UnwrapNativeCollateralResult {
+    /**
+     * Collateral with the native amount unwrapped from the WETH entry.
+     */
+    assets: Asset[];
+    /**
+     * Error set when the transaction value is malformed.
+     */
+    error?: OperationPreviewError;
+}
+/**
+ * Represents the transaction's attached native value as a `NATIVE_ADDRESS`
+ * entry in the collateral list.
+ *
+ * The credit facade wraps `msg.value` into WETH before `AddCollateral(WETH)`
+ * pulls it, so the WETH collateral amount already includes the attached native
+ * value. This helper splits the WETH entry back: the native amount is shown as
+ * `NATIVE_ADDRESS` and the WETH entry is reduced accordingly (dropped when it
+ * reaches zero). Other entries are preserved.
+ *
+ * When `nativeAmount` is positive but the WETH collateral is missing or
+ * smaller than it, the transaction is malformed: the collateral is returned
+ * as-is (no unwrapping) together with an `ERROR_INVALID_TRANSACTION_VALUE`
+ * error.
+ *
+ * @param collateral - Collateral assets as declared by the multicall.
+ * @param nativeAmount - Transaction `msg.value`.
+ * @param wethToken - Wrapped native token address.
+ * @returns Collateral with the native amount unwrapped from the WETH entry,
+ * plus the error on a malformed transaction value.
+ */
+export declare function unwrapNativeCollateral(collateral: Asset[], nativeAmount: bigint, wethToken: Address): UnwrapNativeCollateralResult;

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

@@ -1,8 +1,7 @@
 export type { SimulationError, SimulationFlowFailure, SimulationFlowSource, } from "./errors.js";
 export { PreviewSimulationError } from "./errors.js";
-export type { SimulateFacadeOperationInput } from "./simulateFacadeOperation.js";
 export { simulateFacadeOperation } from "./simulateFacadeOperation.js";
-export type { SimulateOperationInput } from "./simulateOperation.js";
 export { simulateOperation } from "./simulateOperation.js";
 export { simulatePoolOperation } from "./simulatePoolOperation.js";
-export type { AddressBalanceChanges, OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput, PoolOperationSimulationResult, TokenBalanceChange, } from "./types.js";
+export { simulateRWAOperation } from "./simulateRWAOperation.js";
+export type { PoolOperationSimulationResult, SimulationInput, } from "./types.js";

package/dist/types/preview/simulate/simulateFacadeOperation.d.ts

@@ -1,19 +1,6 @@
-import type { Address, Hex } from "viem";
-import type { OnchainSDK } from "../../sdk/index.js";
 import type { OuterFacadeOperation } from "../parse/index.js";
-import type { OperationSimulationOptions, PoolOperationSimulation } from "./types.js";
-export interface SimulateFacadeOperationInput {
-    /** Only `client`/`networkType` are used, so any OnchainSDK works. */
-    sdk: OnchainSDK;
-    /** Parsed credit-facade operation to simulate. */
-    operation: OuterFacadeOperation;
-    /** Target contract the calldata is sent to (the credit facade). */
-    to: Address;
-    /** Raw credit-facade calldata to simulate. */
-    calldata: Hex;
-    /** Wallet whose balance changes and transfers we track. */
-    wallet: Address;
-}
+import type { PreviewOperationOptions } from "../types.js";
+import type { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 /**
  * Simulates a credit-facade operation.
  *
@@ -22,4 +9,4 @@ export interface SimulateFacadeOperationInput {
  * signature mirrors {@link simulatePoolOperation} so the
  * {@link simulateOperation} wrapper can delegate uniformly once implemented.
  */
-export declare function simulateFacadeOperation(_input: SimulateFacadeOperationInput, _options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;
+export declare function simulateFacadeOperation(_input: SimulationInput<OuterFacadeOperation>, _options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;

package/dist/types/preview/simulate/simulateOperation.d.ts

@@ -1,20 +1,6 @@
-import type { Address, Hex } from "viem";
-import type { OnchainSDK } from "../../sdk/index.js";
-import { type Operation } from "../parse/index.js";
-import type { OperationSimulationOptions, PoolOperationSimulation } from "./types.js";
-export interface SimulateOperationInput {
-    /** Gearbox SDK instance. */
-    sdk: OnchainSDK;
-    /** Parsed pool or credit account operation */
-    operation: Operation;
-    /** Target contract the calldata is sent to. */
-    to: Address;
-    /** Raw operation calldata to simulate. */
-    calldata: Hex;
-    /** Wallet whose balance changes and transfers we track. */
-    wallet: Address;
-}
+import type { PreviewOperationOptions } from "../types.js";
+import type { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 /**
- * Simulates a parsed pool or credit account operation {@link Operation}
+ * Simulates a parsed pool or credit account operation
  */
-export declare function simulateOperation(input: SimulateOperationInput, options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;
+export declare function simulateOperation(input: SimulationInput, options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;

package/dist/types/preview/simulate/simulatePoolOperation.d.ts

@@ -1,26 +1,18 @@
-import type { Address } from "viem";
 import type { PoolOperation } from "../parse/index.js";
-import type { AddressBalanceChanges, OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput } from "./types.js";
-/** Reads a watched holder's "before" balance of a token. */
-export type BalanceLookup = (token: Address, holder: Address) => bigint;
+import type { PreviewOperationOptions } from "../types.js";
+import type { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 /**
  * Simulates a pool deposit/mint/withdraw/redeem (direct or zapper-routed) and
- * returns the resulting balance changes, or a decoded failure.
+ * returns the resulting token amounts going in and out. Throws a
+ * {@link PreviewSimulationError} with the decoded revert when the preview read
+ * fails.
  *
- * Reads the watched holders' "before" balances together with the matching
- * preview (the pool's ERC4626 `previewDeposit`/`previewMint`/`previewWithdraw`/
- * `previewRedeem`, or the zapper's `previewDeposit`/`previewRedeem`) in a single
- * multicall, then computes the theoretical balance changes via
- * {@link computePoolOpBalanceChanges}. It works on every network the SDK
- * supports.
+ * Performs the matching preview read (the pool's ERC4626
+ * `previewDeposit`/`previewMint`/`previewWithdraw`/`previewRedeem`, or the
+ * zapper's `previewDeposit`/`previewRedeem`) to convert the calldata-known
+ * amount into its counterpart. It works on every network the SDK supports.
  *
  * It does not execute the calldata, so it ignores balance/allowance
  * prerequisites (preview reads succeed regardless).
  */
-export declare function simulatePoolOperation(input: PoolOperationSimulationInput, options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;
-/**
- * Pure computation of {@link AddressBalanceChanges} for a pool operation from
- * its preview result and the watched holders' "before" balances. Legs sharing
- * the same address are grouped together.
- */
-export declare function computePoolOpBalanceChanges(operation: PoolOperation, wallet: Address, previewAmount: bigint, before: BalanceLookup): AddressBalanceChanges[];
+export declare function simulatePoolOperation(input: SimulationInput<PoolOperation>, options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;

package/dist/types/preview/simulate/simulateRWAOperation.d.ts

@@ -0,0 +1,12 @@
+import type { RWAOperation } from "../parse/index.js";
+import type { PreviewOperationOptions } from "../types.js";
+import type { PoolOperationSimulationResult, SimulationInput } from "./types.js";
+/**
+ * Simulates an RWA-factory operation.
+ *
+ * Not yet implemented: like credit-facade simulation, it requires
+ * multicall-aware balance/transfer accounting that the pool simulation does
+ * not cover. The signature mirrors {@link simulatePoolOperation} so the
+ * {@link simulateOperation} wrapper can delegate uniformly once implemented.
+ */
+export declare function simulateRWAOperation(_input: SimulationInput<RWAOperation>, _options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;

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

@@ -1,66 +1,35 @@
 import type { Address, Hex } from "viem";
 import type { OnchainSDK } from "../../sdk/index.js";
-import type { ILogger } from "../../sdk/types/logger.js";
-import type { PoolOperation } from "../parse/index.js";
-import type { PreviewSimulationError } from "./errors.js";
+import type { Operation } from "../parse/index.js";
 /**
- * Change in an address's balance of a single token over the simulated call.
- * `delta` is `after - before` (negative when the address spent the token).
+ * Input of the simulation functions, generic over the parsed operation kind
+ * so each specialized simulation narrows `operation` while sharing the same
+ * shape.
  */
-export interface TokenBalanceChange {
-    token: Address;
-    before: bigint;
-    after: bigint;
-    delta: bigint;
-}
-/**
- * Balance changes for a single watched address (e.g. the wallet or the
- * operation recipient). Keyed purely by address; UI labeling is resolved
- * separately by the presentation layer.
- */
-export interface AddressBalanceChanges {
-    address: Address;
-    changes: TokenBalanceChange[];
-}
-export interface PoolOperationSimulationInput {
+export interface SimulationInput<Op extends Operation = Operation> {
     /** Only `client`/`networkType` are used, so any OnchainSDK works. */
     sdk: OnchainSDK;
-    /** Parsed operation, used to resolve the underlying and pool tokens. */
-    operation: PoolOperation;
-    /** Target contract the calldata is sent to (the pool). */
+    /** Parsed operation to simulate. */
+    operation: Op;
+    /** Target contract the calldata is sent to. */
     to: Address;
-    /** Raw deposit/mint/withdraw/redeem calldata to simulate. */
+    /** Raw operation calldata to simulate. */
     calldata: Hex;
-    /** Wallet whose balance changes and transfers we track. */
-    wallet: Address;
-}
-export interface OperationSimulationOptions {
-    /** Block to simulate at; defaults to latest. */
-    blockNumber?: bigint;
-    /**
-     * Optional logger.
-     **/
-    logger?: ILogger;
 }
 /**
- * Successful simulation of a pool operation: the balance changes grouped by
- * watched address. This is the success payload of
- * {@link PoolOperationSimulation} without the `status` discriminant.
+ * Result of simulating a pool operation: the amounts of tokens going in
+ * and out. One side comes from calldata, the other from the matching ERC4626
+ * preview read.
  */
 export interface PoolOperationSimulationResult {
     /**
-     * Balance changes grouped by watched address (wallet, recipient, owner).
+     * Amount of tokens going from the user to the pool (underlying or zapper
+     * input token for deposit/mint, pool shares for withdraw/redeem).
+     **/
+    amountIn: bigint;
+    /**
+     * Amount of tokens going from the pool to the user (pool shares or zapper
+     * output token for deposit/mint, underlying for withdraw/redeem).
      **/
-    balanceChanges: AddressBalanceChanges[];
+    amountOut: bigint;
 }
-/**
- * Outcome of simulating a pool operation. On success it carries a
- * {@link PoolOperationSimulationResult}; on failure it carries a
- * {@link PreviewSimulationError}.
- */
-export type PoolOperationSimulation = ({
-    status: "success";
-} & PoolOperationSimulationResult) | {
-    status: "failure";
-    error: PreviewSimulationError;
-};

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

@@ -0,0 +1,63 @@
+import type { Address, Hex } from "viem";
+import type { SdkWithAdapters } from "../plugins/adapters/index.js";
+import type { CreditAccountData, PluginsMap } from "../sdk/index.js";
+import type { ILogger } from "../sdk/types/logger.js";
+/**
+ * Raw-calldata operation input shared by `parseOperationCalldata`,
+ * `previewOperation` and `checkPrerequisites`.
+ */
+export interface PreviewOperationInput<P extends PluginsMap = PluginsMap> {
+    /**
+     * Already-attached SDK; chain, RPC and block are baked in at attach time.
+     * Must be created with the adapters plugin (enforced at compile time) so
+     * adapter contracts resolve during multicall classification.
+     */
+    sdk: SdkWithAdapters<P>;
+    /**
+     * Contract address that was called
+     */
+    to: Address;
+    /**
+     * Raw calldata of the operation
+     */
+    calldata: Hex;
+    /**
+     * Transaction sender
+     */
+    sender: Address;
+    /**
+     * Transaction `msg.value`, required for native-token zapper deposits.
+     **/
+    value?: bigint;
+}
+interface PreviewOperationOptionsBase {
+    /**
+     * Block to read/simulate at; defaults to latest. Only set for testnet
+     * forks.
+     */
+    blockNumber?: bigint;
+    /**
+     * Optional logger.
+     **/
+    logger?: ILogger;
+}
+/**
+ * Options shared by the preview, simulation and prerequisite-check flows.
+ * Each flow uses the subset it needs and ignores the rest.
+ *
+ * `WithAccount = true` marks options whose credit account state has already
+ * been resolved (internal preview paths on an existing credit account).
+ */
+export type PreviewOperationOptions<WithAccount extends boolean = false> = WithAccount extends true ? PreviewOperationOptionsBase & {
+    /**
+     * Pre-resolved state of the credit account the operation targets
+     */
+    creditAccount: CreditAccountData;
+} : PreviewOperationOptionsBase & {
+    /**
+     * @internal
+     * Credit account state for testing purposes
+     */
+    creditAccount?: CreditAccountData;
+};
+export {};