@gearbox-protocol/sdk 14.12.0-next.4 → 14.12.0-next.41

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

@@ -0,0 +1,29 @@
+import { type DelayedWithdrawalRequest, type SdkWithAdapters } from "../../plugins/adapters/index.js";
+import { type DelayedIntent, type PluginsMap } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+/**
+ * A delayed-withdrawal request detected in a credit-facade multicall,
+ * produced by `detectDelayedOperation`.
+ */
+export interface DetectedDelayedOperation {
+    /**
+     * Phantom/claim tokens from the adapter's `parseDelayedWithdrawalRequest`
+     */
+    request: DelayedWithdrawalRequest;
+    /**
+     * Decoded delayed intent; undefined when the request carries none, in
+     * which case the delayed preview is claim-only
+     */
+    intent?: DelayedIntent;
+}
+/**
+ * Scans a credit-facade multicall for a delayed-withdrawal request.
+ *
+ * @param sdk - SDK with the adapters plugin attached.
+ * @param multicall - Parsed inner operations of the multicall.
+ * @returns The detected request, or `undefined` when
+ * the multicall contains no delayed-withdrawal request.
+ * @throws InvalidDelayedIntentError when a request carries non-empty
+ * `extraData` that cannot be decoded as a `DelayedIntent`.
+ */
+export declare function detectDelayedOperation<P extends PluginsMap>(sdk: SdkWithAdapters<P>, multicall: InnerOperation[]): DetectedDelayedOperation | undefined;

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

@@ -0,0 +1,9 @@
+/**
+ * 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,12 @@
+export * from "./buildDelayedPreview.js";
+export * from "./CreditAccountState.js";
+export * from "./detectCloseOrRepay.js";
+export * from "./detectDelayedClaim.js";
+export * from "./detectDelayedOperation.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewCloseOrRepayCreditAccount.js";
+export * from "./previewOperation.js";
+export * from "./replayInnerOperations.js";
+export * from "./replayMulticall.js";
+export * from "./types.js";

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

@@ -0,0 +1,12 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { MulticallOperation, RWAMulticallOperation } from "../parse/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import { type AdjustCreditAccountPreview } from "./types.js";
+/**
+ * Previews a `multicall`/`botMulticall` operation on an existing credit
+ * account: threads the multicall through {@link replayMulticall} over the
+ * pre-resolved account state (`options.creditAccount`) 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 | RWAMulticallOperation, options: PreviewOperationOptions<true>): Promise<AdjustCreditAccountPreview>;

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

@@ -0,0 +1,11 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { CloseCreditAccountOperation, MulticallOperation, RWAMulticallOperation } from "../parse/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { CloseCreditAccountPreview, RepayCreditAccountPreview } from "./types.js";
+/**
+ * Any parsed operation that fully closes or repays a credit account: the
+ * facade `closeCreditAccount` entry point (permanent closure) or a plain
+ * multicall detected by `isCloseOrRepay` (zero-debt closure/repay).
+ */
+export type CloseOrRepayOperation = CloseCreditAccountOperation | MulticallOperation | RWAMulticallOperation;
+export declare function previewCloseOrRepayCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: CloseOrRepayOperation, permanent: boolean, options: PreviewOperationOptions<true>): Promise<CloseCreditAccountPreview | RepayCreditAccountPreview>;

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

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

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

@@ -0,0 +1,8 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { OperationPreview } 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 { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { PoolOperationPreview } from "./types.js";
+export declare function previewPoolOperation<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: PoolOperation, options?: PreviewOperationOptions): Promise<PoolOperationPreview>;

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

@@ -0,0 +1,334 @@
+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[];
+    /**
+     * 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, 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,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 { AddressBalanceChanges, OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput, PoolOperationSimulationResult, TokenBalanceChange, } from "./types.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>;