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

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

@@ -0,0 +1,48 @@
+import type { Address } from "viem";
+import type { SecuritizeRegisterMessage } from "../../sdk/index.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
+ * facade, but the inner `calls` still target the facade/adapters, so the
+ * credit suite is known.
+ */
+export interface RWAOperationMetadata {
+    /** RWA factory contract the transaction is sent to. */
+    factory: Address;
+    creditManager: Address;
+    creditFacade: Address;
+}
+export interface SecuritizeOpenCreditAccountOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "SecuritizeOpenCreditAccount";
+    multicall: InnerOperation<Ext>[];
+    /**
+     * DSToken addresses to register, decoded from calldata. Empty in the
+     * template flow, where the real value comes from the factory's open-account
+     * requirements.
+     */
+    tokensToRegister: Address[];
+    /**
+     * EIP-712 registration signatures to store on-chain, decoded from calldata.
+     * Empty in the template flow.
+     */
+    signaturesToCache: SecuritizeRegisterMessage[];
+}
+/**
+ * `SecuritizeRWAFactory.multicall` call: like the facade's `multicall`, plus
+ * the factory-specific registration args.
+ */
+export interface SecuritizeMulticallOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "SecuritizeMulticall";
+    creditAccount: Address;
+    multicall: InnerOperation<Ext>[];
+    /** DSToken addresses to register, decoded from calldata. */
+    tokensToRegister: Address[];
+    /** EIP-712 registration signatures to store on-chain, decoded from calldata. */
+    signaturesToCache: SecuritizeRegisterMessage[];
+}
+/**
+ * Discriminated union of all RWA factory operation types. Extend it when
+ * adding support for a new RWA factory type.
+ */
+export type RWAOperation<Ext extends object = {}> = SecuritizeOpenCreditAccountOperation<Ext> | SecuritizeMulticallOperation<Ext>;

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

@@ -2,9 +2,11 @@ import type { AdaptersPlugin } from "../../plugins/adapters/index.js";
 import type { OnchainSDK, PluginsMap } from "../../sdk/index.js";
 import type { OuterFacadeOperation } from "./types-facades.js";
 import type { PoolOperation } from "./types-pools.js";
+import type { RWAOperation } from "./types-rwa.js";
 export * from "./types-adapters.js";
 export * from "./types-facades.js";
 export * from "./types-pools.js";
+export * from "./types-rwa.js";
 /**
  * True when the plugin map `P` contains the {@link AdaptersPlugin} under any
  * key. Matched nominally (the plugin's private fields make it non-structural),
@@ -29,16 +31,19 @@ export type RequireAdaptersPlugin<P extends PluginsMap> = HasAdaptersPlugin<P> e
  */
 export type SdkWithAdapters<P extends PluginsMap = PluginsMap> = OnchainSDK<P> & RequireAdaptersPlugin<P>;
 /**
- * Result of decoding a single raw operation calldata: either a pool
- * deposit/redeem or one of the credit-facade operations.
- *
- * Calldata-only parse produces base (descriptor) adapter operations, so the
- * facade operations are used with the default `Ext = {}`.
+ * Result of decoding a single raw operation calldata: a pool deposit/redeem,
+ * one of the credit-facade operations, or an RWA-factory operation.
  */
-export type Operation = PoolOperation | OuterFacadeOperation;
+export type Operation = PoolOperation | OuterFacadeOperation | RWAOperation;
 /**
  * Narrows an {@link Operation} to a {@link PoolOperation} (deposit, mint,
  * withdraw or redeem). Used by the UI to decide whether a custom view exists for
  * the parsed result; everything else falls back to the raw JSON view.
  */
 export declare function isPoolOperation(tx: Operation): tx is PoolOperation;
+/**
+ * Narrows an {@link Operation} to an {@link RWAOperation} (an RWA-factory
+ * open-account or multicall). Used to route parsed operations to the
+ * RWA-specific simulation path.
+ */
+export declare function isRWAOperation(tx: Operation): tx is RWAOperation;

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

@@ -11,9 +11,7 @@ export interface AllowancePrerequisiteProps {
 }
 /** Checks that `owner` granted `spender` an ERC-20 allowance >= `required`. */
 export declare class AllowancePrerequisite extends Prerequisite<"allowance"> {
-    private readonly _id;
-    private readonly _title;
-    private readonly _detail;
+    #private;
     constructor(props: AllowancePrerequisiteProps);
     get id(): string;
     get kind(): "allowance";

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,16 +8,19 @@ 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 readonly _id;
-    private readonly _title;
-    private readonly _detail;
+    #private;
     constructor(props: BalancePrerequisiteProps);
     get id(): string;
     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/RWAOpenRequirementsPrerequisite.d.ts

@@ -0,0 +1,36 @@
+import type { Address, ContractFunctionParameters } from "viem";
+import type { RWAOpenAccountRequirements } from "../../sdk/index.js";
+import { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+export interface RWAOpenRequirementsPrerequisiteProps {
+    /** Requirements already resolved via `sdk.accounts.getOpenAccountRequirements`. */
+    requirements: RWAOpenAccountRequirements;
+    /** RWA token (e.g. Securitize DSToken) the requirements were computed for. */
+    token: Address;
+    /** RWA factory that produced the requirements. */
+    factory: Address;
+    title?: string;
+    id?: string;
+}
+/**
+ * Checks that the borrower has fulfilled the RWA factory's open-account
+ * requirements (issuer-side token registration, EIP-712 signatures).
+ *
+ * Unlike `allowance`/`balance`, the requirements cannot be derived from plain
+ * ERC-20 multicall reads: they come from an async compressor read performed by
+ * `sdk.accounts.getOpenAccountRequirements`. The prerequisite is therefore
+ * *pre-resolved*: it is constructed with the requirements already computed,
+ * contributes no calls to the verification multicall, and `resolve` only
+ * interprets the stored payload.
+ */
+export declare class RWAOpenRequirementsPrerequisite extends Prerequisite<"rwaOpenRequirements"> {
+    #private;
+    constructor(props: RWAOpenRequirementsPrerequisiteProps);
+    get id(): string;
+    get kind(): "rwaOpenRequirements";
+    get title(): string;
+    get detail(): PrerequisiteDetail<"rwaOpenRequirements">;
+    /** Pre-resolved: no on-chain reads to contribute. */
+    calls(): ContractFunctionParameters[];
+    resolve(): PrerequisiteResult<"rwaOpenRequirements">;
+}

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/prerequisites/index.d.ts

@@ -3,5 +3,6 @@ export * from "./BalancePrerequisite.js";
 export * from "./buildPrerequisites.js";
 export * from "./Prerequisite.js";
 export * from "./prepareAction.js";
+export * from "./RWAOpenRequirementsPrerequisite.js";
 export * from "./runPrerequisites.js";
 export * from "./types.js";

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

@@ -1,18 +1,14 @@
 import type { Address } from "viem";
-import type { OnchainSDK } from "../../sdk/index.js";
+import type { OnchainSDK, RWAOpenAccountRequirements } 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.
+ * or perform offchain KYC verification.
+ *
+ * Do NOT add protocol- or admin-level state the user cannot change.
  */
 export interface PrerequisiteDetailMap {
     /** ERC-20 allowance from `owner` to `spender` must cover `required`. */
@@ -32,6 +28,12 @@ export interface PrerequisiteDetailMap {
         /** On-chain balance read; only present when the read succeeded. */
         actual?: bigint;
     };
+    /**
+     * RWA (e.g. Securitize) open-account requirements: off-chain token
+     * registration and/or EIP-712 signatures the borrower must provide before
+     * opening a credit account in an RWA market.
+     */
+    rwaOpenRequirements: RWAOpenAccountRequirements;
 }
 export type PrerequisiteKind = keyof PrerequisiteDetailMap;
 export type PrerequisiteDetail<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteDetailMap[K];

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

@@ -5,4 +5,6 @@ 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 type { SimulateRWAOperationInput } from "./simulateRWAOperation.js";
+export { simulateRWAOperation } from "./simulateRWAOperation.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}

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

@@ -1,26 +1,14 @@
-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 { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput } 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, or a decoded failure.
  *
- * 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[];

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

@@ -0,0 +1,23 @@
+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;
+}
+/**
+ * Simulates an RWA-factory operation.
+ *
+ * Not yet implemented: like credit-facade simulation, it requires
+ * multicall-aware balance/transfer accounting that the pool simulation does
+ * not cover. The signature mirrors {@link simulatePoolOperation} so the
+ * {@link simulateOperation} wrapper can delegate uniformly once implemented.
+ */
+export declare function simulateRWAOperation(_input: SimulateRWAOperationInput, _options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;

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

@@ -3,25 +3,6 @@ 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";
-/**
- * Change in an address's balance of a single token over the simulated call.
- * `delta` is `after - before` (negative when the address spent the token).
- */
-export interface TokenBalanceChange {
-    token: Address;
-    before: bigint;
-    after: bigint;
-    delta: bigint;
-}
-/**
- * Balance changes for a single watched address (e.g. the wallet or the
- * operation recipient). Keyed purely by address; UI labeling is resolved
- * separately by the presentation layer.
- */
-export interface AddressBalanceChanges {
-    address: Address;
-    changes: TokenBalanceChange[];
-}
 export interface PoolOperationSimulationInput {
     /** Only `client`/`networkType` are used, so any OnchainSDK works. */
     sdk: OnchainSDK;
@@ -31,8 +12,6 @@ export interface PoolOperationSimulationInput {
     to: Address;
     /** Raw deposit/mint/withdraw/redeem calldata to simulate. */
     calldata: Hex;
-    /** Wallet whose balance changes and transfers we track. */
-    wallet: Address;
 }
 export interface OperationSimulationOptions {
     /** Block to simulate at; defaults to latest. */
@@ -43,15 +22,22 @@ export interface OperationSimulationOptions {
     logger?: ILogger;
 }
 /**
- * Successful simulation of a pool operation: the balance changes grouped by
- * watched address. This is the success payload of
- * {@link PoolOperationSimulation} without the `status` discriminant.
+ * Successful simulation of 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.
  */
 export interface PoolOperationSimulationResult {
     /**
-     * Balance changes grouped by watched address (wallet, recipient, owner).
+     * Amount of tokens going from the user to the pool (underlying or zapper
+     * input token for deposit/mint, pool shares for withdraw/redeem).
+     **/
+    amountIn: bigint;
+    /**
+     * Amount of tokens going from the pool to the user (pool shares or zapper
+     * output token for deposit/mint, underlying for withdraw/redeem).
      **/
-    balanceChanges: AddressBalanceChanges[];
+    amountOut: bigint;
 }
 /**
  * Outcome of simulating a pool operation. On success it carries a

package/dist/types/sdk/market/rwa/securitize/SecuritizeRWAFactory.d.ts

@@ -468,6 +468,10 @@ export declare class SecuritizeRWAFactory extends BaseContract<abi> implements I
      * {@inheritDoc IRWAFactory.decodeInvestorData}
      */
     decodeInvestorData(data: RWACompressorInvestorData): SecuritizeInvestorData;
+    /**
+     * {@inheritDoc IRWAFactory.getTokens}
+     */
+    getTokens(): Address[];
     /**
      * {@inheritDoc IRWAFactory.getInvestor}
      */

package/dist/types/sdk/market/rwa/types.d.ts

@@ -102,6 +102,12 @@ export interface IRWAFactory<T extends RWAFactoryType = RWAFactoryType> extends
      * @param data - raw RWACompressor InvestorData
      **/
     decodeInvestorData(data: RWACompressorInvestorData): RWAInvestorData<T>;
+    /**
+     * Returns the RWA token addresses this factory can register/gate
+     * (e.g. Securitize DSTokens). Named for parity with the Solidity
+     * `IRWAFactory` contract.
+     **/
+    getTokens(): Address[];
     /**
      * Returns the investor address for a credit account.
      * @param creditAccount - credit account address
@@ -161,11 +167,13 @@ export interface IRWAFactory<T extends RWAFactoryType = RWAFactoryType> extends
     openCreditAccount(creditManager: Address, calls: MultiCall[], options?: RWAOperationParams<T>): RawTx;
 }
 /**
- * Narrows an {@link IRWAFactory} to a specific factory type.
+ * Narrows any contract to an {@link IRWAFactory}.
  *
- * @param factory - factory instance to check
- * @param type - expected factory type literal
- * @returns `true` if `factory.factoryType === type`
+ * @param contract - contract instance to check
+ * @param type - optional expected factory type literal. When provided, narrows
+ *   to the concrete `IRWAFactory<T>`; when omitted, narrows to the
+ *   generalized {@link IRWAFactory}
+ * @returns `true` if the contract is an RWA factory (of the given type, if provided)
  **/
-export declare function isRWAFactory<T extends RWAFactoryType>(factory: IRWAFactory, type: T): factory is IRWAFactory<T>;
+export declare function isRWAFactory<T extends RWAFactoryType = RWAFactoryType>(contract: IBaseContract, type?: T): contract is IRWAFactory<T>;
 export {};

package/dist/types/sdk/market/zapper/types.d.ts

@@ -12,10 +12,8 @@ export interface ParsedZapperDeposit {
     /** Zapper contract the call is sent to. */
     zapper: Address;
     receiver: Address;
-    /** Amount of `token` supplied to the zapper. */
+    /** Amount of `tokenIn` supplied to the zapper. */
     assets: bigint;
-    /** Token actually deposited into the zapper (the zapper's `tokenIn`). */
-    token: Address;
     /** Underlying token of the destination pool. */
     underlying: Address;
     /** Referral code, present only for `depositWithReferral(...)` calls. */
@@ -32,10 +30,12 @@ export interface ParsedZapperRedeem {
     /** Zapper contract the call is sent to. */
     zapper: Address;
     receiver: Address;
-    /** Pool shares (diesel) burned. */
+    /**
+     * Amount of the zapper's `tokenOut` burned. This is the pool's diesel token
+     * only when the zapper's `tokenOut` is the pool itself; for farmed/staked
+     * wrappers it's denominated in the wrapper token.
+     */
     shares: bigint;
-    /** Token returned to the receiver (the zapper's `tokenIn`). */
-    token: Address;
     /** Underlying token of the source pool. */
     underlying: Address;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "14.12.0-next.3",
+  "version": "14.12.0-next.5",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {