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

package/dist/esm/preview/simulate/simulatePoolOperation.js

@@ -1,13 +1,6 @@
 import { iPoolV310Abi } from "../../abi/310/generated.js";
-import { ierc20Abi } from "../../abi/iERC20.js";
 import { iZapperAbi } from "../../abi/iZapper.js";
-import { AddressMap } from "../../sdk/index.js";
-import {
-  asPreviewSimulationError,
-  decodeSimulationError,
-  PreviewSimulationError
-} from "./errors.js";
-import { watchedHolders } from "./holders.js";
+import { asPreviewSimulationError } from "./errors.js";
 function previewRead(operation) {
   switch (operation.operation) {
     case "Deposit":
@@ -20,16 +13,6 @@ function previewRead(operation) {
       return { functionName: "previewRedeem", amount: operation.shares };
   }
 }
-function outsideToken(operation) {
-  switch (operation.operation) {
-    case "Deposit":
-    case "Mint":
-      return operation.tokenIn;
-    case "Withdraw":
-    case "Redeem":
-      return operation.tokenOut;
-  }
-}
 function previewContract(operation) {
   const { functionName, amount } = previewRead(operation);
   if (operation.zapper) {
@@ -47,60 +30,31 @@ function previewContract(operation) {
     args: [amount]
   };
 }
+function amountsInOut(operation, previewAmount) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { amountIn: operation.assets, amountOut: previewAmount };
+    case "Mint":
+      return { amountIn: previewAmount, amountOut: operation.shares };
+    case "Withdraw":
+      return { amountIn: previewAmount, amountOut: operation.assets };
+    case "Redeem":
+      return { amountIn: operation.shares, amountOut: previewAmount };
+  }
+}
 async function simulatePoolOperation(input, options = {}) {
-  const { sdk, operation, wallet } = input;
+  const { sdk, operation } = input;
   const { blockNumber, logger } = options;
-  const { pool } = operation;
   try {
-    const holders = watchedHolders(operation, wallet);
-    const tokens = [outsideToken(operation), pool];
-    const balanceCalls = holders.flatMap(
-      (holder) => tokens.map((token) => ({ holder, token }))
-    );
-    const balanceContracts = balanceCalls.map(
-      ({ holder, token }) => ({
-        address: token,
-        abi: ierc20Abi,
-        functionName: "balanceOf",
-        args: [holder]
-      })
-    );
-    const preview = previewContract(operation);
-    let results;
-    try {
-      results = await sdk.client.multicall({
-        allowFailure: false,
-        // `undefined` lets viem read at `latest`; `blockNumber` is only set for
-        // testnet forks pinned to a specific block.
-        blockNumber,
-        contracts: [...balanceContracts, preview]
-      });
-    } catch (cause) {
-      throw new PreviewSimulationError([
-        {
-          source: "multicall",
-          detail: decodeSimulationError({
-            error: cause instanceof Error ? cause : new Error(String(cause))
-          })
-        }
-      ]);
-    }
-    const previewAmount = results[balanceContracts.length];
-    const balances = new AddressMap();
-    for (const [i, { holder, token }] of balanceCalls.entries()) {
-      const tokenBalances = balances.get(holder) ?? new AddressMap();
-      tokenBalances.upsert(token, results[i]);
-      balances.upsert(holder, tokenBalances);
-    }
-    const before = (token, holder) => balances.get(holder)?.get(token) ?? 0n;
+    const previewAmount = await sdk.client.readContract({
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber,
+      ...previewContract(operation)
+    });
     return {
       status: "success",
-      balanceChanges: computePoolOpBalanceChanges(
-        operation,
-        wallet,
-        previewAmount,
-        before
-      )
+      ...amountsInOut(operation, previewAmount)
     };
   } catch (cause) {
     const error = asPreviewSimulationError(cause, "multicall");
@@ -108,59 +62,6 @@ async function simulatePoolOperation(input, options = {}) {
     return { status: "failure", error };
   }
 }
-function balanceLegs(operation, wallet, previewAmount) {
-  const { pool, receiver } = operation;
-  switch (operation.operation) {
-    case "Deposit":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -operation.assets },
-        { address: receiver, token: pool, delta: previewAmount }
-      ];
-    case "Mint":
-      return [
-        { address: wallet, token: operation.tokenIn, delta: -previewAmount },
-        { address: receiver, token: pool, delta: operation.shares }
-      ];
-    case "Withdraw":
-      return [
-        { address: operation.owner, token: pool, delta: -previewAmount },
-        {
-          address: receiver,
-          token: operation.tokenOut,
-          delta: operation.assets
-        }
-      ];
-    case "Redeem":
-      return [
-        { address: operation.owner, token: pool, delta: -operation.shares },
-        { address: receiver, token: operation.tokenOut, delta: previewAmount }
-      ];
-  }
-}
-function computePoolOpBalanceChanges(operation, wallet, previewAmount, before) {
-  const byAddress = new AddressMap();
-  for (const { address, token, delta } of balanceLegs(
-    operation,
-    wallet,
-    previewAmount
-  )) {
-    const beforeBalance = before(token, address);
-    const change = {
-      token,
-      before: beforeBalance,
-      after: beforeBalance + delta,
-      delta
-    };
-    const existing = byAddress.get(address);
-    if (existing) {
-      existing.changes.push(change);
-    } else {
-      byAddress.upsert(address, { address, changes: [change] });
-    }
-  }
-  return byAddress.values();
-}
 export {
-  computePoolOpBalanceChanges,
   simulatePoolOperation
 };

package/dist/esm/sdk/market/zapper/ZapperContract.js

@@ -32,7 +32,6 @@ class ZapperContract extends BaseContract {
     const { rawArgs } = parsed;
     const pool = this.pool;
     const zapper = this.address;
-    const token = this.tokenIn.addr;
     const underlying = this.sdk.marketRegister.findByPool(pool).underlying;
     const receiver = rawArgs.receiver;
     if (parsed.functionName.startsWith("deposit")) {
@@ -42,7 +41,6 @@ class ZapperContract extends BaseContract {
         zapper,
         receiver,
         assets: rawArgs.tokenInAmount ?? value ?? 0n,
-        token,
         underlying,
         referralCode: rawArgs.referralCode
       };
@@ -54,7 +52,6 @@ class ZapperContract extends BaseContract {
         zapper,
         receiver,
         shares: rawArgs.tokenOutAmount,
-        token,
         underlying
       };
     }

package/dist/types/history/types.d.ts

@@ -18,10 +18,10 @@ export type HistoryAdapterExt = TraceAdapterExt & {
 export type HistoryFacadeMetadata = FacadeOperationMetadata & OperationMetadata;
 export type AdapterOperation = BaseAdapterOperation<HistoryAdapterExt>;
 export type InnerOperation = BaseInnerOperation<HistoryAdapterExt>;
-export type MulticallOperation = Omit<BaseMulticallOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type OpenCreditAccountOperation = Omit<BaseOpenCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type CloseCreditAccountOperation = Omit<BaseCloseCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type LiquidateCreditAccountOperation = Omit<BaseLiquidateCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
+export type MulticallOperation = BaseMulticallOperation<HistoryAdapterExt> & OperationMetadata;
+export type OpenCreditAccountOperation = BaseOpenCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
+export type CloseCreditAccountOperation = BaseCloseCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
+export type LiquidateCreditAccountOperation = BaseLiquidateCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
 export type PartialLiquidationOperation = BasePartialLiquidationOperation & OperationMetadata;
 export type DirectTokenTransferOperation = BaseDirectTokenTransferOperation & OperationMetadata;
 export type OuterFacadeOperation = MulticallOperation | OpenCreditAccountOperation | CloseCreditAccountOperation | LiquidateCreditAccountOperation | PartialLiquidationOperation;

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

@@ -1,4 +1,3 @@
-export * from "./parse/index.js";
 export * from "./prerequisites/index.js";
-export * from "./simulate/index.js";
+export * from "./preview/index.js";
 export * from "./trace/index.js";

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

@@ -1,6 +1,5 @@
 export * from "./classifyInnerOperations.js";
 export * from "./errors.js";
-export * from "./extractExpectedBalanceChanges.js";
 export * from "./parseFacadeOperationCalldata.js";
 export * from "./parseOperationCalldata.js";
 export * from "./parsePoolOperationCalldata.js";

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

@@ -71,25 +71,10 @@ export interface FacadeOperationMetadata {
     creditManager: Address;
     creditFacade: Address;
 }
-/**
- * Signed token balance delta recovered from a router-generated
- * `storeExpectedBalances` call (the `BalanceDelta` struct). `amount` is the
- * signed `int256` delta, so it may be negative.
- */
-export interface ExpectedBalanceChange {
-    token: Address;
-    delta: bigint;
-}
 export interface MulticallOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "MultiCall" | "BotMulticall";
     creditAccount: Address;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface OpenCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "OpenCreditAccount";
@@ -97,23 +82,11 @@ export interface OpenCreditAccountOperation<Ext extends object = {}> extends Fac
     onBehalfOf: Address;
     referralCode: bigint;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface CloseCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "CloseCreditAccount";
     creditAccount: Address;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface LiquidateCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
     operation: "LiquidateCreditAccount";
@@ -122,12 +95,6 @@ export interface LiquidateCreditAccountOperation<Ext extends object = {}> extend
     token: Address;
     remainingFunds: bigint;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
 }
 export interface PartialLiquidationOperation extends FacadeOperationMetadata {
     operation: "PartiallyLiquidateCreditAccount";

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

@@ -23,6 +23,12 @@ export interface PoolDepositOperation {
      * deposits, or the zapper's input token for zapper-routed deposits.
      */
     tokenIn: Address;
+    /**
+     * Token minted to the receiver: the pool's diesel token for direct
+     * deposits, or the zapper's output token (e.g. a farmed/staked diesel
+     * wrapper) for zapper-routed deposits.
+     */
+    tokenOut: Address;
     /** Zapper contract the call is sent to; `undefined` for direct deposits. */
     zapper?: Address;
     /** Referral code, present only for `depositWithReferral` calls. */
@@ -48,6 +54,11 @@ export interface PoolMintOperation {
      * mints, or the zapper's input token for zapper-routed mints.
      */
     tokenIn: Address;
+    /**
+     * Token minted to the receiver: the pool's diesel token for direct mints,
+     * or the zapper's output token for zapper-routed mints.
+     */
+    tokenOut: Address;
     /** Zapper contract the call is sent to; `undefined` for direct mints. */
     zapper?: Address;
     /** Referral code, present only for `mintWithReferral` calls. */
@@ -71,6 +82,12 @@ export interface PoolWithdrawOperation {
     assets: bigint;
     /** Underlying token of the source pool. */
     underlying: Address;
+    /**
+     * Token burned from `owner`: the pool's diesel token for direct
+     * withdrawals, or the zapper's share-side token for zapper-routed
+     * withdrawals.
+     */
+    tokenIn: Address;
     /**
      * Token actually returned to the receiver: the pool underlying for direct
      * withdrawals, or the zapper's output token for zapper-routed withdrawals.
@@ -95,10 +112,20 @@ export interface PoolRedeemOperation {
     receiver: Address;
     /** Address whose pool shares are burned. */
     owner: Address;
-    /** Pool shares (diesel) burned. */
+    /**
+     * Amount of {@link PoolRedeemOperation.tokenIn} burned: pool shares
+     * (diesel) for direct redeems, or the zapper's share-side token amount for
+     * zapper-routed redeems.
+     */
     shares: bigint;
     /** Underlying token of the source pool. */
     underlying: Address;
+    /**
+     * Token burned from `owner`: the pool's diesel token for direct redeems, or
+     * the zapper's share-side token (e.g. a farmed/staked diesel wrapper) for
+     * zapper-routed redeems.
+     */
+    tokenIn: Address;
     /**
      * Token actually returned to the receiver: the pool underlying for direct
      * redeems, or the zapper's output token for zapper-routed redeems.
@@ -113,3 +140,4 @@ export interface PoolRedeemOperation {
  * field).
  */
 export type PoolOperation = PoolDepositOperation | PoolMintOperation | PoolWithdrawOperation | PoolRedeemOperation;
+export type PoolOperationType = PoolOperation["operation"];

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

@@ -1,6 +1,6 @@
 import type { Address } from "viem";
 import type { SecuritizeRegisterMessage } from "../../sdk/index.js";
-import type { ExpectedBalanceChange, InnerOperation } from "./types-facades.js";
+import type { InnerOperation } from "./types-facades.js";
 /**
  * Metadata shared by all RWA factory operations. RWA credit accounts are
  * opened and managed through the market's RWA factory rather than the credit
@@ -16,12 +16,6 @@ export interface RWAOperationMetadata {
 export interface SecuritizeOpenCreditAccountOperation<Ext extends object = {}> extends RWAOperationMetadata {
     operation: "SecuritizeOpenCreditAccount";
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
     /**
      * DSToken addresses to register, decoded from calldata. Empty in the
      * template flow, where the real value comes from the factory's open-account
@@ -42,12 +36,6 @@ export interface SecuritizeMulticallOperation<Ext extends object = {}> extends R
     operation: "SecuritizeMulticall";
     creditAccount: Address;
     multicall: InnerOperation<Ext>[];
-    /**
-     * Potential balance changes declared by a router-generated
-     * `storeExpectedBalances`/`compareBalances` pair, or `undefined` when the
-     * multicall is not router-shaped. See {@link ExpectedBalanceChange}.
-     */
-    expectedBalanceChanges?: ExpectedBalanceChange[];
     /** DSToken addresses to register, decoded from calldata. */
     tokensToRegister: Address[];
     /** EIP-712 registration signatures to store on-chain, decoded from calldata. */

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

@@ -1,6 +1,6 @@
 import { type Address, type ContractFunctionParameters } from "viem";
 import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
-import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
 export interface BalancePrerequisiteProps {
     token: Address;
     owner: Address;
@@ -8,7 +8,12 @@ export interface BalancePrerequisiteProps {
     title?: string;
     id?: string;
 }
-/** Checks that `owner` holds an ERC-20 balance >= `required`. */
+/**
+ * Checks that `owner` holds a token balance >= `required`. The token is read
+ * as an ERC-20, except for the native pseudo-address ({@link NATIVE_ADDRESS},
+ * e.g. ETH-zapper deposits) whose balance is read via multicall3's
+ * `getEthBalance`.
+ */
 export declare class BalancePrerequisite extends Prerequisite<"balance"> {
     #private;
     constructor(props: BalancePrerequisiteProps);
@@ -16,6 +21,6 @@ export declare class BalancePrerequisite extends Prerequisite<"balance"> {
     get kind(): "balance";
     get title(): string;
     get detail(): PrerequisiteDetail<"balance">;
-    calls(): ContractFunctionParameters[];
+    calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
     resolve(slice: MulticallCallResult[]): PrerequisiteResult<"balance">;
 }

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

@@ -1,10 +1,19 @@
-import type { Operation } from "../parse/index.js";
+import { type PluginsMap } from "../../sdk/index.js";
+import { type ParseOperationCalldataInput } from "../parse/parseOperationCalldata.js";
 import type { AnyPrerequisite } from "./Prerequisite.js";
-import type { PrerequisiteContext } from "./types.js";
 /**
- * Derives the on-chain prerequisites for a parsed operation: the conditions
- * that must hold for the call not to revert and that we can verify with the
- * SDK (token approvals, wallet balances).
+ * Input of {@link buildPrerequisites}: the same raw-calldata input as the
+ * internal calldata parser, plus an optional block to read at.
+ */
+export type BuildPrerequisitesInput<P extends PluginsMap = PluginsMap> = ParseOperationCalldataInput<P> & {
+    /** Block to read at; defaults to latest. Only set for testnet forks. */
+    blockNumber?: bigint;
+};
+/**
+ * Derives the on-chain prerequisites for an operation given its raw calldata:
+ * the conditions that must hold for the call not to revert and that we can
+ * verify with the SDK (token approvals, wallet balances). The calldata is
+ * decoded internally via `parseOperationCalldata`.
  *
  * Only *sender-actionable* prerequisites belong here: conditions the LP
  * provider or borrower can fix themselves before retrying (e.g. approve a
@@ -13,4 +22,4 @@ import type { PrerequisiteContext } from "./types.js";
  * bot permissions) is intentionally out of scope, since the user cannot
  * resolve it. New {@link AnyPrerequisite} subclasses must follow the same rule.
  */
-export declare function buildPrerequisites(tx: Operation, ctx: PrerequisiteContext): Promise<AnyPrerequisite[]>;
+export declare function buildPrerequisites<P extends PluginsMap>(input: BuildPrerequisitesInput<P>): Promise<AnyPrerequisite[]>;

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/{parse → preview}/extractExpectedBalanceChanges.d.ts

@@ -1,5 +1,4 @@
-import type { ParsedCallV2 } from "../../sdk/index.js";
-import type { ExpectedBalanceChange } from "./types.js";
+import type { Asset, ParsedCallV2 } from "../../sdk/index.js";
 /**
  * Recovers the potential balance changes declared by a router-generated
  * `storeExpectedBalances`/`compareBalances` pair inside a credit-facade
@@ -13,10 +12,10 @@ import type { ExpectedBalanceChange } from "./types.js";
  *
  * When the multicall does not match this shape, `undefined` is returned. On a
  * match, the `BalanceDelta[]` argument of `storeExpectedBalances` is decoded
- * into {@link ExpectedBalanceChange}[] (the `amount` is the signed `int256`
- * delta and may be negative).
+ * into {@link Asset}[] (the `balance` is the signed `int256` delta and may be
+ * negative).
  *
  * @param innerCalls - Raw (already-decoded) inner multicall calls.
  * @returns The declared balance changes, or `undefined` when not router-shaped.
  */
-export declare function extractExpectedBalanceChanges(innerCalls: ParsedCallV2[]): ExpectedBalanceChange[] | undefined;
+export declare function extractExpectedBalanceChanges(innerCalls: ParsedCallV2[]): Asset[] | undefined;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { OperationSimulationOptions } from "../simulate/index.js";
+import type { OperationPreview, PreviewOperationInput } 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?: OperationSimulationOptions): Promise<OperationPreview>;

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

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

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

@@ -0,0 +1,103 @@
+import type { Address, Hex } from "viem";
+import type { Asset, PluginsMap } from "../../sdk/index.js";
+import type { PoolOperationType, SdkWithAdapters } from "../parse/index.js";
+/**
+ * Input of {@link previewOperation}: the raw operation calldata plus the
+ * already-attached SDK
+ */
+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`
+     **/
+    value?: bigint;
+}
+/**
+ * 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;
+    /**
+     * 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). In case of error only the token address is
+     * returned.
+     */
+    tokenIn: PreviewedAsset;
+    /**
+     * 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). In case of error only the token address is
+     * returned.
+     */
+    tokenOut: PreviewedAsset;
+}
+export interface OpenCreditAccountPreview {
+    operation: "OpenCreditAccount" | "SecuritizeOpenCreditAccount";
+    /**
+     * 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
+     */
+    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[];
+}
+/**
+ * Result of previewing a raw operation calldata: currently pool operations and
+ * credit account opening are supported.
+ */
+export type OperationPreview = PoolOperationPreview | OpenCreditAccountPreview;

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

@@ -7,4 +7,4 @@ 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 { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput, PoolOperationSimulationResult, } from "./types.js";

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

@@ -11,8 +11,6 @@ export interface SimulateFacadeOperationInput {
     to: Address;
     /** Raw credit-facade calldata to simulate. */
     calldata: Hex;
-    /** Wallet whose balance changes and transfers we track. */
-    wallet: Address;
 }
 /**
  * Simulates a credit-facade operation.

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

@@ -11,8 +11,6 @@ export interface SimulateOperationInput {
     to: Address;
     /** Raw operation calldata to simulate. */
     calldata: Hex;
-    /** Wallet whose balance changes and transfers we track. */
-    wallet: Address;
 }
 /**
  * Simulates a parsed pool or credit account operation {@link Operation}