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

package/dist/types/abi/iZapper.d.ts

@@ -1,121 +1,189 @@
 export declare const iZapperAbi: readonly [{
     readonly type: "function";
+    readonly name: "contractType";
     readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
     readonly name: "pool";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
+    readonly name: "previewDeposit";
     readonly inputs: readonly [{
         readonly name: "tokenInAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
-    readonly name: "previewDeposit";
     readonly outputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
+    readonly name: "previewRedeem";
     readonly inputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
-    readonly name: "previewRedeem";
     readonly outputs: readonly [{
         readonly name: "tokenInAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
+    readonly name: "redeem";
     readonly inputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }, {
         readonly name: "receiver";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
-    readonly name: "redeem";
     readonly outputs: readonly [{
         readonly name: "tokenInAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
+    readonly name: "redeemWithPermit";
     readonly inputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }, {
         readonly name: "receiver";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }, {
         readonly name: "deadline";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }, {
         readonly name: "v";
-        readonly internalType: "uint8";
         readonly type: "uint8";
+        readonly internalType: "uint8";
     }, {
         readonly name: "r";
-        readonly internalType: "bytes32";
         readonly type: "bytes32";
+        readonly internalType: "bytes32";
     }, {
         readonly name: "s";
-        readonly internalType: "bytes32";
         readonly type: "bytes32";
+        readonly internalType: "bytes32";
     }];
-    readonly name: "redeemWithPermit";
     readonly outputs: readonly [{
         readonly name: "tokenInAmount";
+        readonly type: "uint256";
         readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "redeemWithPermitAllowed";
+    readonly inputs: readonly [{
+        readonly name: "tokenOutAmount";
         readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "expiry";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "v";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "r";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "s";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "tokenInAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
+    readonly name: "serialize";
     readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "serializedData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
     readonly name: "tokenIn";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly inputs: readonly [];
     readonly name: "tokenOut";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly inputs: readonly [];
     readonly name: "underlying";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "version";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
 }];

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

@@ -1,4 +1,5 @@
 import type { Address } from "viem";
+export { UnsupportedZapperFunctionError } from "../../sdk/index.js";
 /**
  * Thrown when the target of a transaction is neither a known Gearbox pool nor a
  * credit facade.

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

@@ -12,12 +12,12 @@ export interface ParseOperationCalldataInput<P extends PluginsMap = PluginsMap>
     calldata: Hex;
     /** Transaction sender, contextual only. */
     sender: Address;
+    /** Transaction `msg.value`, required for native-token zapper deposits. */
+    value?: bigint;
 }
 /**
  * Decodes raw operation calldata into an {@link Operation}.
  *
- * Routes by the resolved contract at `to`: a pool yields a deposit/redeem
- * operation, a credit facade yields one facade operation. Anything else throws
- * {@link UnsupportedTargetError}.
+ * Support parsing of pool operations (including via zappers) and credit facade operations.
  */
 export declare function parseOperationCalldata<P extends PluginsMap>(input: ParseOperationCalldataInput<P>): Operation;

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

@@ -1,14 +1,30 @@
 import type { Address } from "viem";
 /**
  * ERC4626 `deposit` into a Gearbox pool.
+ *
+ * A deposit can reach the pool directly (an ERC4626 call sent straight to the
+ * pool contract) or through a zapper (e.g. RWA-default pools and classic zapper
+ * pools). When routed through a zapper, `zapper` is the call target and
+ * `tokenIn` is the zapper's input token rather than the pool underlying.
  */
 export interface PoolDepositOperation {
+    /** ERC4626 operation kind. */
     operation: "Deposit";
+    /** Destination pool the assets are deposited into. */
     pool: Address;
+    /** Address credited with the minted pool shares. */
     receiver: Address;
-    /** Underlying assets supplied to the pool. */
+    /** Amount of underlying assets supplied to the pool. */
     assets: bigint;
+    /** Underlying token of the destination pool. */
     underlying: Address;
+    /**
+     * Token actually supplied by the caller: the pool underlying for direct
+     * deposits, or the zapper's input token for zapper-routed deposits.
+     */
+    tokenIn: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct deposits. */
+    zapper?: Address;
     /** Referral code, present only for `depositWithReferral` calls. */
     referralCode?: bigint;
 }
@@ -17,12 +33,23 @@ export interface PoolDepositOperation {
  * amount of shares to mint; the assets pulled are resolved by the pool.
  */
 export interface PoolMintOperation {
+    /** ERC4626 operation kind. */
     operation: "Mint";
+    /** Destination pool the shares are minted from. */
     pool: Address;
+    /** Address credited with the minted pool shares. */
     receiver: Address;
     /** Pool shares (diesel) minted to the receiver. */
     shares: bigint;
+    /** Underlying token of the destination pool. */
     underlying: Address;
+    /**
+     * Token actually supplied by the caller: the pool underlying for direct
+     * mints, or the zapper's input token for zapper-routed mints.
+     */
+    tokenIn: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct mints. */
+    zapper?: Address;
     /** Referral code, present only for `mintWithReferral` calls. */
     referralCode?: bigint;
 }
@@ -32,24 +59,57 @@ export interface PoolMintOperation {
  * the pool.
  */
 export interface PoolWithdrawOperation {
+    /** ERC4626 operation kind. */
     operation: "Withdraw";
+    /** Source pool the assets are withdrawn from. */
     pool: Address;
+    /** Address that receives the withdrawn tokens. */
     receiver: Address;
+    /** Address whose pool shares are burned. */
     owner: Address;
     /** Underlying assets withdrawn to the receiver. */
     assets: bigint;
+    /** Underlying token of the source pool. */
     underlying: Address;
+    /**
+     * Token actually returned to the receiver: the pool underlying for direct
+     * withdrawals, or the zapper's output token for zapper-routed withdrawals.
+     */
+    tokenOut: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct withdrawals. */
+    zapper?: Address;
 }
 /**
  * ERC4626 `redeem` from a Gearbox pool.
+ *
+ * A redeem can reach the pool directly or through a zapper. When routed through
+ * a zapper, `zapper` is the call target and `tokenOut` is the zapper's output
+ * token rather than the pool underlying.
  */
 export interface PoolRedeemOperation {
+    /** ERC4626 operation kind. */
     operation: "Redeem";
+    /** Source pool the shares are redeemed from. */
     pool: Address;
+    /** Address that receives the redeemed tokens. */
     receiver: Address;
+    /** Address whose pool shares are burned. */
     owner: Address;
     /** Pool shares (diesel) burned. */
     shares: bigint;
+    /** Underlying token of the source pool. */
     underlying: Address;
+    /**
+     * Token actually returned to the receiver: the pool underlying for direct
+     * redeems, or the zapper's output token for zapper-routed redeems.
+     */
+    tokenOut: Address;
+    /** Zapper contract the call is sent to; `undefined` for direct redeems. */
+    zapper?: Address;
 }
+/**
+ * ERC4626 pool operations. Each operation may be sent directly to the pool
+ * contract or routed through a zapper (indicated by the optional `zapper`
+ * field).
+ */
 export type PoolOperation = PoolDepositOperation | PoolMintOperation | PoolWithdrawOperation | PoolRedeemOperation;

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

@@ -1,17 +1,14 @@
 import { BaseError, type Hex } from "viem";
 /** Which simulation flow produced a failure. */
-export type SimulationFlowSource = "eth_simulateV1" | "multicall" | "unknown";
+export type SimulationFlowSource = "multicall" | "unknown";
 /** A single flow failure with its decoded revert detail. */
 export interface SimulationFlowFailure {
     source: SimulationFlowSource;
     detail: SimulationError;
 }
 /**
- * Error returned by the pool simulation when all attempted flows fail.
- *
- * On a single-flow failure it wraps that flow's decoded revert reason; when both
- * the `eth_simulateV1` and multicall flows fail, it carries the details of both
- * (see {@link failures}).
+ * Error returned by the pool simulation when it fails. It wraps the flow's
+ * decoded revert reason (see {@link failures}).
  */
 export declare class PreviewSimulationError extends BaseError {
     name: string;
@@ -24,8 +21,6 @@ export declare class PreviewSimulationError extends BaseError {
  * Pass-through when it already is one; otherwise decodes it under `source`.
  */
 export declare function asPreviewSimulationError(reason: unknown, source: SimulationFlowSource): PreviewSimulationError;
-/** Merges several {@link PreviewSimulationError}s into one carrying all failures. */
-export declare function combinePreviewSimulationErrors(...errors: (PreviewSimulationError | undefined)[]): PreviewSimulationError;
 /** Decoded revert of the simulated transaction. */
 export interface SimulationError {
     /** Human-readable revert reason / error name. */
@@ -33,17 +28,16 @@ export interface SimulationError {
     /** Original error, kept for debugging. */
     cause?: unknown;
 }
-/** Per-call slice of a `simulateCalls` failure we need to decode. */
+/** Per-call slice of a multicall failure we need to decode. */
 export interface SimulationRevert {
     error?: Error;
     /** Raw revert return data, when present. */
     data?: Hex;
 }
 /**
- * Decodes a simulated transaction revert into a {@link SimulationError}.
+ * Decodes a simulated call revert into a {@link SimulationError}.
  *
- * The simulated call is raw calldata (no ABI), so viem cannot decode the revert
- * itself. We first try to decode the raw return bytes against the SDK's
+ * We first try to decode any raw return bytes against the SDK's
  * {@link errorAbis} (Gearbox protocol exceptions plus standard ERC-20 custom
  * errors); failing that, we walk viem's error chain for a
  * {@link ContractFunctionRevertedError} (covers `Error(string)` / `Panic`).

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

@@ -1,4 +1,3 @@
-export { ETH_SIMULATE_V1_NETWORKS } from "./constants.js";
 export type { SimulationError, SimulationFlowFailure, SimulationFlowSource, } from "./errors.js";
 export { PreviewSimulationError } from "./errors.js";
 export type { SimulateFacadeOperationInput } from "./simulateFacadeOperation.js";

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

@@ -1,8 +1,26 @@
-import type { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput } from "./types.js";
+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;
 /**
- * Simulates a pool deposit/mint/withdraw/redeem and returns the resulting
- * balance changes (and, when available, ERC-20 transfers), or a decoded failure.
+ * Simulates a pool deposit/mint/withdraw/redeem (direct or zapper-routed) and
+ * returns the resulting balance changes, or a decoded failure.
  *
- * @throws {@link PreviewSimulationError} when the simulation 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.
+ *
+ * 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/types.d.ts

@@ -1,7 +1,7 @@
 import type { Address, Hex } from "viem";
 import type { OnchainSDK } from "../../sdk/index.js";
 import type { ILogger } from "../../sdk/types/logger.js";
-import type { PoolOperation, TokenTransfer } from "../parse/index.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.
@@ -37,12 +37,6 @@ export interface PoolOperationSimulationInput {
 export interface OperationSimulationOptions {
     /** Block to simulate at; defaults to latest. */
     blockNumber?: bigint;
-    /**
-     * Whether to run the `eth_simulateV1` flow (preferred, recovers transfers).
-     * When `undefined`, defaults to whether the SDK's network is in
-     * {@link ETH_SIMULATE_V1_NETWORKS}.
-     */
-    useSimulateV1?: boolean;
     /**
      * Optional logger.
      **/
@@ -50,21 +44,14 @@ export interface OperationSimulationOptions {
 }
 /**
  * Successful simulation of a pool operation: the balance changes grouped by
- * watched address and, when available, the wallet-filtered ERC-20 transfers.
- * This is the success payload of {@link PoolOperationSimulation} without the
- * `status` discriminant.
+ * watched address. This is the success payload of
+ * {@link PoolOperationSimulation} without the `status` discriminant.
  */
 export interface PoolOperationSimulationResult {
     /**
      * Balance changes grouped by watched address (wallet, recipient, owner).
      **/
     balanceChanges: AddressBalanceChanges[];
-    /**
-     * ERC-20 transfers involving the watched addresses.
-     *
-     * NOTE: transfers are **not guaranteed** to be returned.
-     */
-    transfers?: TokenTransfer[];
 }
 /**
  * Outcome of simulating a pool operation. On success it carries a

package/dist/types/sdk/MultichainSDK.d.ts

@@ -55,6 +55,11 @@ export interface MultichainAttachOptions {
      * Options for Pyth price-feed updates (shared cache across chains).
      **/
     pyth?: PythOptions;
+    /**
+     * When `true`, automatically load zappers after markets are loaded during
+     * attach on every chain.
+     **/
+    loadZappers?: boolean;
 }
 /**
  * Options for {@link MultichainSDK.hydrate}.

package/dist/types/sdk/OnchainSDK.d.ts

@@ -117,6 +117,10 @@ export interface AttachOptions {
      * Options for Pyth price-feed updates.
      **/
     pyth?: PythOptions;
+    /**
+     * When `true`, automatically call {@link MarketRegister.loadZappers} during attach.
+     **/
+    loadZappers?: boolean;
 }
 /**
  * Options accepted by {@link OnchainSDK.hydrate}.

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

@@ -1,7 +1,7 @@
 import type { Address } from "viem";
 import type { MarketData, MarketFilter } from "../base/index.js";
 import type { OnchainSDK } from "../OnchainSDK.js";
-import type { MarketStateHuman } from "../types/index.js";
+import type { MarketStateHuman, ZapperStateHuman } from "../types/index.js";
 import { AddressMap } from "../utils/index.js";
 import { type DelegatedMulticall } from "../utils/viem/index.js";
 import type { CreditSuite } from "./credit/index.js";
@@ -9,7 +9,18 @@ import { MarketConfiguratorContract } from "./MarketConfiguratorContract.js";
 import { MarketSuite } from "./MarketSuite.js";
 import type { IPriceOracleContract } from "./oracle/index.js";
 import type { PoolSuite } from "./pool/index.js";
+import type { ZapperData } from "./types.js";
 import { ZapperRegister } from "./ZapperRegister.js";
+/** @internal */
+export interface MarketRegistryState {
+    markets: MarketData[];
+    zappers?: ZapperData[];
+}
+/** @internal */
+export interface MarketRegistryStateHuman {
+    markets: MarketStateHuman[];
+    zappers?: ZapperStateHuman[];
+}
 /**
  * Central registry of all Gearbox markets on the current chain.
  *
@@ -29,7 +40,7 @@ export declare class MarketRegister extends ZapperRegister {
      * bypassing on-chain reads.
      * @param state - Array of market data snapshots.
      **/
-    hydrate(state: MarketData[]): void;
+    hydrate({ markets, zappers }: MarketRegistryState): void;
     /**
      * @internal
      * Returns delegated multicalls for loading all markets from the on-chain
@@ -57,14 +68,12 @@ export declare class MarketRegister extends ZapperRegister {
     /**
      * Serializable snapshot of all loaded markets, suitable for hydration.
      **/
-    get state(): MarketData[];
+    get state(): MarketRegistryState;
     /**
      * Returns a human-readable snapshot of all markets.
      * @param raw - When `true`, includes raw/unformatted values.
      **/
-    stateHuman(raw?: boolean): {
-        markets: MarketStateHuman[];
-    };
+    stateHuman(raw?: boolean): MarketRegistryStateHuman;
     /**
      * All pool suites across loaded markets.
      **/

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

@@ -1,17 +1,38 @@
 import type { Address } from "viem";
 import { SDKConstruct } from "../base/index.js";
+import type { ZapperStateHuman } from "../types/index.js";
 import { AddressMap } from "../utils/index.js";
-import { type Zapper } from "./zapper/index.js";
+import type { ZapperData } from "./types.js";
+import { type IZapperContract } from "./zapper/index.js";
 export declare class ZapperRegister extends SDKConstruct {
     #private;
     /**
      * Load zappers for all pools using periphery compressor, adds hardcoded zappers
      */
     loadZappers(force?: boolean): Promise<void>;
-    get zappers(): AddressMap<Zapper[]>;
-    poolZappers(pool: Address): Zapper[];
+    /**
+     * Serializable snapshot of all loaded zappers, suitable for hydration.
+     * Returns `undefined` when zappers were never loaded (i.e. `loadZappers` was
+     * not called), so the not-loaded state round-trips cleanly.
+     **/
+    protected get zappersState(): ZapperData[] | undefined;
+    /**
+     * Restores zapper state from a previously serialized snapshot,
+     * bypassing on-chain reads.
+     * @param state - Array of zapper data snapshots, or `undefined` when zappers
+     *   were not loaded in the snapshot (leaves the registry in the not-loaded state).
+     **/
+    protected hydrateZappers(state?: ZapperData[]): void;
+    /**
+     * Returns a human-readable snapshot of all loaded zappers.
+     * Returns `undefined` when zappers were never loaded.
+     * @param raw - When `true`, includes raw/unformatted values.
+     **/
+    protected zappersStateHuman(_?: boolean): ZapperStateHuman[] | undefined;
+    get zappers(): AddressMap<IZapperContract[]>;
+    poolZappers(pool: Address): IZapperContract[];
     /**
      * Can return multiple zappers if there are multiple zappers for the same tokenIn and tokenOut
      */
-    getZapper(pool: Address, tokenIn: Address, tokenOut: Address): Array<Zapper> | undefined;
+    getZapper(pool: Address, tokenIn: Address, tokenOut: Address): Array<IZapperContract> | undefined;
 }