@gearbox-protocol/sdk 14.12.0-next.8 → 14.12.0-test.1

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

@@ -0,0 +1,44 @@
+import { type SdkWithAdapters } from "../../plugins/adapters/index.js";
+import { AssetsMap, type PluginsMap } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { CreditAccountState } from "./CreditAccountState.js";
+import { type OperationPreviewError } from "./types.js";
+/**
+ * Running state threaded through a credit-facade multicall by
+ * {@link replayInnerOperations}: the account's post-state being mutated in
+ * facade execution order, plus per-multicall bookkeeping that is not account
+ * state (what was added from / withdrawn to the wallet).
+ */
+export interface ReplayState {
+    /**
+     * Running account state, mutated in facade execution order. Seeded by the
+     * caller: `CreditAccountState.beforeOpen` for account opening, a clone of
+     * `CreditAccountState.fromCreditAccountData` for an existing account.
+     */
+    account: CreditAccountState;
+    /**
+     * 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;
+}
+/**
+ * Creates a {@link ReplayState} around the given account seed, with empty
+ * bookkeeping.
+ */
+export declare function makeReplayState(account: CreditAccountState): ReplayState;
+/**
+ * Replays a credit-facade multicall over `state`, mutating it in place in
+ * facade execution order. The result is the *minimal guaranteed* post-state.
+ *
+ * The function assumes that the call was generated by our frontend using
+ * router/withdrawal compressor, otherwise it returns an error, but still
+ * proceeds best-effort.
+ *
+ * @returns `undefined` on success, the error on a malformed multicall.
+ */
+export declare function replayInnerOperations<P extends PluginsMap>(sdk: SdkWithAdapters<P>, multicall: InnerOperation[], state: ReplayState): Promise<OperationPreviewError | undefined>;

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

@@ -1,43 +1,73 @@
-import type { Address, Hex } from "viem";
-import type { Asset, PluginsMap } from "../../sdk/index.js";
-import type { PoolOperationType, SdkWithAdapters } from "../parse/index.js";
+import type { Address } from "viem";
+import type { Asset, DelayedIntent } from "../../sdk/index.js";
+import type { PoolOperationType } from "../parse/index.js";
 /**
- * Input of {@link previewOperation}: the raw operation calldata plus the
- * already-attached SDK
+ * 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 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;
+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 {
     /**
-     * Raw calldata of the operation
+     * 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).
      */
-    calldata: Hex;
+    code: number;
     /**
-     * Transaction sender
+     * Human-readable details of the specific failure
      */
-    sender: Address;
-    /**
-     * Transaction `msg.value`
-     **/
-    value?: bigint;
+    message: string;
 }
-/**
- * A token amount that may require an additional async call (e.g. an ERC4626
- * preview read) to determine. When that call fails, only the token address and
- * the error are returned.
- */
-export type PreviewedAsset = Asset | {
-    token: Address;
-    error: Error;
-};
 export interface PoolOperationPreview {
     operation: PoolOperationType;
     /**
@@ -51,10 +81,9 @@ export interface PoolOperationPreview {
      *
      * For mint/withdraw the amount of tokenIn cannot be determined from
      * transaction calldata alone and requires an additional async call
-     * (previewMint/previewWithdraw). In case of error only the token address is
-     * returned.
+     * (previewMint/previewWithdraw).
      */
-    tokenIn: PreviewedAsset;
+    tokenIn: Asset;
     /**
      * Token that goes from pool to user
      * In case of deposit, pool shares (diesel token) for direct deposit or zapper token out
@@ -62,13 +91,21 @@ export interface PoolOperationPreview {
      *
      * For deposit/redeem the amount of tokenOut cannot be determined from
      * transaction calldata alone and requires an additional async call
-     * (previewDeposit/previewRedeem). In case of error only the token address is
-     * returned.
+     * (previewDeposit/previewRedeem).
+     */
+    tokenOut: Asset;
+    /**
+     * Set when preview encountered non-fatal errors, all fields are
+     * still computed best-effort
      */
-    tokenOut: PreviewedAsset;
+    error?: OperationPreviewError;
 }
 export interface OpenCreditAccountPreview {
-    operation: "OpenCreditAccount" | "SecuritizeOpenCreditAccount";
+    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.
@@ -99,9 +136,199 @@ export interface OpenCreditAccountPreview {
      * 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[];
+    /**
+     * Intent of the delayed withdrawal this transaction claims; set when the
+     * multicall claims a delayed withdrawal
+     */
+    intent?: DelayedIntent;
+    /**
+     * 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;
+    /**
+     * Token withdrawn to the user and its minimal guaranteed amount, from the
+     * multicall replay (all collateral is swapped into the received token
+     * before withdrawal). The token is the market underlying or, on RWA
+     * markets, the unwrapped RWA underlying (the ERC4626 vault asset the
+     * underlying share converts 1:1 into)
+     */
+    receivedAmount: Asset;
+    /**
+     * Intent of the delayed withdrawal this transaction claims; set when the
+     * multicall claims a delayed withdrawal
+     */
+    intent?: DelayedIntent;
+    /**
+     * 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;
+    /**
+     * Intent of the delayed withdrawal this transaction claims; set when the
+     * multicall claims a delayed withdrawal
+     */
+    intent?: DelayedIntent;
+    /**
+     * 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 are supported.
+ * credit account opening, adjustment, closure, repayment and delayed
+ * withdrawal operations are supported.
  */
-export type OperationPreview = PoolOperationPreview | OpenCreditAccountPreview;
+export type OperationPreview = PoolOperationPreview | OpenCreditAccountPreview | AdjustCreditAccountPreview | CloseCreditAccountPreview | RepayCreditAccountPreview | DelayedCreditAccountOperationPreview;

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

@@ -1,5 +1,16 @@
-import { type Address } from "viem";
+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.
@@ -8,13 +19,17 @@ import { type Asset } from "../../sdk/index.js";
  * 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 and their order are preserved.
+ * 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.
- * @throws InvalidTransactionValueError when `nativeAmount` is positive but the
- * WETH collateral is missing or smaller than it.
+ * @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): Asset[];
+export declare function unwrapNativeCollateral(collateral: Asset[], nativeAmount: bigint, wethToken: Address): UnwrapNativeCollateralResult;

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

@@ -1,10 +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 { SimulateRWAOperationInput } from "./simulateRWAOperation.js";
 export { simulateRWAOperation } from "./simulateRWAOperation.js";
-export type { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput, PoolOperationSimulationResult, } from "./types.js";
+export type { PoolOperationSimulationResult, SimulationInput, } from "./types.js";

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

@@ -1,17 +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;
-}
+import type { PreviewOperationOptions } from "../types.js";
+import type { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 /**
  * Simulates a credit-facade operation.
  *
@@ -20,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,18 +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;
-}
+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,7 +1,11 @@
-import type { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput } from "./types.js";
+import type { PoolOperation } from "../parse/index.js";
+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 token amounts going in and out, 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.
  *
  * Performs the matching preview read (the pool's ERC4626
  * `previewDeposit`/`previewMint`/`previewWithdraw`/`previewRedeem`, or the
@@ -11,4 +15,4 @@ import type { OperationSimulationOptions, PoolOperationSimulation, PoolOperation
  * 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>;
+export declare function simulatePoolOperation(input: SimulationInput<PoolOperation>, options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;

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

@@ -1,17 +1,6 @@
-import type { Address, Hex } from "viem";
-import type { OnchainSDK } from "../../sdk/index.js";
 import type { RWAOperation } from "../parse/index.js";
-import type { OperationSimulationOptions, PoolOperationSimulation } from "./types.js";
-export interface SimulateRWAOperationInput {
-    /** Only `client`/`networkType` are used, so any OnchainSDK works. */
-    sdk: OnchainSDK;
-    /** Parsed RWA-factory operation to simulate. */
-    operation: RWAOperation;
-    /** Target contract the calldata is sent to (the RWA factory). */
-    to: Address;
-    /** Raw RWA-factory calldata to simulate. */
-    calldata: Hex;
-}
+import type { PreviewOperationOptions } from "../types.js";
+import type { PoolOperationSimulationResult, SimulationInput } from "./types.js";
 /**
  * Simulates an RWA-factory operation.
  *
@@ -20,4 +9,4 @@ export interface SimulateRWAOperationInput {
  * not cover. The signature mirrors {@link simulatePoolOperation} so the
  * {@link simulateOperation} wrapper can delegate uniformly once implemented.
  */
-export declare function simulateRWAOperation(_input: SimulateRWAOperationInput, _options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;
+export declare function simulateRWAOperation(_input: SimulationInput<RWAOperation>, _options?: PreviewOperationOptions): Promise<PoolOperationSimulationResult>;

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

@@ -1,31 +1,25 @@
 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";
-export interface PoolOperationSimulationInput {
+import type { Operation } from "../parse/index.js";
+/**
+ * Input of the simulation functions, generic over the parsed operation kind
+ * so each specialized simulation narrows `operation` while sharing the same
+ * shape.
+ */
+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;
 }
-export interface OperationSimulationOptions {
-    /** Block to simulate at; defaults to latest. */
-    blockNumber?: bigint;
-    /**
-     * Optional logger.
-     **/
-    logger?: ILogger;
-}
 /**
- * Successful simulation of a pool operation: the amounts of tokens going in
+ * 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. This is the success payload of {@link PoolOperationSimulation}
- * without the `status` discriminant.
+ * preview read.
  */
 export interface PoolOperationSimulationResult {
     /**
@@ -39,14 +33,3 @@ export interface PoolOperationSimulationResult {
      **/
     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;
-};