@gearbox-protocol/sdk 14.12.0-next.2 → 14.12.0-next.20

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

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import { type RWAOperationArgs } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext } from "./types.js";
+/**
+ * For RWA-factory open-account operations (e.g. `RWAOpenCreditAccount`),
+ * builds a prerequisite per RWA token the multicall touches; each one checks
+ * the factory's open-account requirements (issuer-side token registration,
+ * EIP-712 signatures) at verify time.
+ *
+ * The `providedArgs` params are the registration values decoded from the
+ * transaction calldata itself: signatures already included there satisfy the
+ * signature requirement, so a fully built transaction is not reported as
+ * missing signatures. In the template flow they are empty and the verified
+ * result's `detail.missing` describes what is still unfulfilled; acting on it
+ * (signing, rebuilding calldata) is up to the consumer.
+ *
+ * Returns nothing for non-RWA markets.
+ */
+export declare function buildRWAPrerequisites(multicall: InnerOperation[], creditManager: Address, providedArgs: RWAOperationArgs, ctx: PrerequisiteContext): Prerequisite[];

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

@@ -0,0 +1,19 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { PrerequisiteResult } from "./types.js";
+/**
+ * Derives and verifies 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, RWA
+ * open-account requirements).
+ *
+ * Each prerequisite performs its own reads and resolves into a
+ * {@link PrerequisiteResult} (`satisfied` or `error`).
+ *
+ * Only *sender-actionable* prerequisites belong here: conditions the LP
+ * provider or borrower can fix themselves before retrying (e.g. approve a
+ * token, sign the RWA factory's messages). Non-actionable protocol/admin state
+ * (e.g. pool is paused) is intentionally out of scope, since the user cannot
+ * resolve it.
+ */
+export declare function checkPrerequisites<P extends PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<PrerequisiteResult[]>;

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

@@ -0,0 +1,7 @@
+import { type AllowanceDetail } from "./AllowancePrerequisite.js";
+import type { Prerequisite } from "./Prerequisite.js";
+/**
+ * The most common prerequisite pair: `owner` must have approved `spender` for
+ * `required` of `token` and must hold at least that much of it.
+ */
+export declare function allowanceAndBalance(props: Omit<AllowanceDetail, "actual">): Prerequisite[];

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

@@ -1,7 +1,6 @@
 export * from "./AllowancePrerequisite.js";
 export * from "./BalancePrerequisite.js";
-export * from "./buildPrerequisites.js";
+export * from "./checkPrerequisites.js";
 export * from "./Prerequisite.js";
-export * from "./prepareAction.js";
-export * from "./runPrerequisites.js";
+export * from "./RWAOpenRequirementsPrerequisite.js";
 export * from "./types.js";

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

@@ -1,40 +1,8 @@
 import type { Address } from "viem";
 import type { OnchainSDK } 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.
- */
-export interface PrerequisiteDetailMap {
-    /** ERC-20 allowance from `owner` to `spender` must cover `required`. */
-    allowance: {
-        token: Address;
-        owner: Address;
-        spender: Address;
-        required: bigint;
-        /** On-chain allowance read; only present when the read succeeded. */
-        actual?: bigint;
-    };
-    /** ERC-20 balance of `owner` must cover `required`. */
-    balance: {
-        token: Address;
-        owner: Address;
-        required: bigint;
-        /** On-chain balance read; only present when the read succeeded. */
-        actual?: bigint;
-    };
-}
-export type PrerequisiteKind = keyof PrerequisiteDetailMap;
-export type PrerequisiteDetail<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteDetailMap[K];
+import type { AllowanceResult } from "./AllowancePrerequisite.js";
+import type { BalanceResult } from "./BalancePrerequisite.js";
+import type { RWAOpenRequirementsResult } from "./RWAOpenRequirementsPrerequisite.js";
 /** Failure of the underlying on-chain read (revert, decode error, RPC error). */
 export interface PrerequisiteError {
     /** Decoded revert reason / error name, human-readable. */
@@ -42,32 +10,27 @@ export interface PrerequisiteError {
     /** Original error, kept for debugging. */
     cause?: unknown;
 }
-export interface PrerequisiteBase<K extends PrerequisiteKind> {
-    id: string;
-    kind: K;
-    title: string;
-    detail: PrerequisiteDetail<K>;
-}
 /**
  * Outcome of verifying a single prerequisite: either the read succeeded (a
  * `satisfied` boolean) or it reverted/failed (an `error` with the revert
- * reason). The two variants are mutually exclusive.
+ * reason).
  */
-export type PrerequisiteResult<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteBase<K> & ({
+export type PrerequisiteOutcome = {
     satisfied: boolean;
     error?: undefined;
 } | {
     satisfied?: undefined;
     error: PrerequisiteError;
-});
+};
 /**
- * Discriminated union over every prerequisite kind. Switching on `kind`
- * narrows `detail` to the matching payload, so React components can render
- * kind-specific details with full type safety.
+ * Discriminated union over every prerequisite kind
+ *
+ * Only add prerequisites that are actionable by tx sender.
+ * A valid prerequisite is one the user can resolve themselves before retrying,
+ * e.g. approve a token (`allowance`) or perform offchain KYC verification.
  */
-export type AnyPrerequisiteResult = {
-    [K in PrerequisiteKind]: PrerequisiteResult<K>;
-}[PrerequisiteKind];
+export type PrerequisiteResult = AllowanceResult | BalanceResult | RWAOpenRequirementsResult;
+export type PrerequisiteKind = PrerequisiteResult["kind"];
 /** Shared inputs for building and verifying prerequisites. */
 export interface PrerequisiteContext {
     sdk: OnchainSDK;

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

@@ -0,0 +1,84 @@
+import { type SdkWithAdapters } from "../../plugins/adapters/index.js";
+import { type Asset, AssetsMap, type PluginsMap } from "../../sdk/index.js";
+import type { InnerOperation } 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), so
+ * their guaranteed balance change is zero.
+ *
+ * The exception is RWA wrap/unwrap calls emitted by
+ * `CreditAccountsServiceV310`: out-of-bracket ERC4626 adapter calls whose
+ * share token is an RWA underlying. Their outcome is essential to the preview
+ * (the conversion between the market underlying and its asset); RWA
+ * underlyings always convert 1-to-1 with their vault asset, so the conversion
+ * is applied directly, see {@link applyRWAWrapUnwrap}.
+ *
+ * @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/applyRWAWrapUnwrap.d.ts

@@ -0,0 +1,13 @@
+import { type Hex } from "viem";
+import type { ERC4626AdapterContract } from "../../plugins/adapters/index.js";
+import type { AssetsMap } from "../../sdk/index.js";
+/**
+ * Applies an RWA wrap/unwrap adapter call (ERC4626 `deposit`/`redeem` and
+ * their diff variants, as emitted by `CreditAccountsServiceV310`) to the
+ * running credit-account balances.
+ *
+ * RWA underlyings always convert 1-to-1 with their vault asset, so the
+ * counterpart amount equals the input amount and no on-chain preview read is
+ * needed.
+ */
+export declare function applyRWAWrapUnwrap(adapter: ERC4626AdapterContract, calldata: Hex, balances: AssetsMap): void;

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

@@ -0,0 +1,18 @@
+import type { Address } from "viem";
+import type { InnerOperation } from "../parse/index.js";
+/**
+ * Detects whether a credit-facade multicall fully closes or repays the
+ * account.
+ *
+ * Note that closing/repaying an account whose debt is already zero emits no
+ * `decreaseDebt` call at all and is not detected (previews as an adjustment).
+ */
+export declare function isCloseOrRepay(multicall: InnerOperation[]): boolean;
+/**
+ * Distinguishes a closure from a repayment by how collateral leaves the
+ * account:
+ * - close swaps all assets into underlying and withdraws only the underlying
+ * - repay returns collateral in-kind: it adds collateral from the wallet to
+ *   cover the debt and/or withdraws non-underlying tokens.
+ */
+export declare function classifyCloseOrRepay(multicall: InnerOperation[], underlying: Address): "close" | "repay";

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,7 @@
+export * from "./applyInnerOperations.js";
+export * from "./detectCloseOrRepay.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewCloseOrRepayCreditAccount.js";
+export * from "./previewOperation.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: 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 | RWAMulticallOperation, options?: PreviewOperationOptions): 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 { OperationPreview } 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): Promise<OperationPreview>;

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): 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/types.d.ts

@@ -0,0 +1,181 @@
+import type { Address } from "viem";
+import type { Asset } from "../../sdk/index.js";
+import type { PoolOperationType } from "../parse/index.js";
+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;
+}
+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[];
+}
+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[];
+}
+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;
+}
+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;
+}
+/**
+ * Result of previewing a raw operation calldata: currently pool operations and
+ * credit account opening, adjustment, closure and repayment are supported.
+ */
+export type OperationPreview = PoolOperationPreview | OpenCreditAccountPreview | AdjustCreditAccountPreview | CloseCreditAccountPreview | RepayCreditAccountPreview;

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

@@ -0,0 +1,20 @@
+import type { Address } from "viem";
+import { type Asset } from "../../sdk/index.js";
+/**
+ * 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.
+ *
+ * @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.
+ */
+export declare function unwrapNativeCollateral(collateral: Asset[], nativeAmount: bigint, wethToken: Address): Asset[];

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>;