@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.10

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,5 @@
+export * from "./applyInnerOperations.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewOperation.js";
+export * from "./types.js";

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

@@ -0,0 +1,11 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { MulticallOperation, SecuritizeMulticallOperation } from "../parse/index.js";
+import type { AdjustCreditAccountPreview, PreviewOperationInput, PreviewOperationOptions } 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 | SecuritizeMulticallOperation, options?: PreviewOperationOptions): Promise<AdjustCreditAccountPreview>;

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,7 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { OperationPreview, PreviewOperationInput, PreviewOperationOptions } 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 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,177 @@
+import type { Address, Hex } from "viem";
+import type { Asset, CreditAccountData, PluginsMap } from "../../sdk/index.js";
+import type { PoolOperationType, SdkWithAdapters } from "../parse/index.js";
+import type { OperationSimulationOptions } from "../simulate/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;
+}
+/**
+ * Options of {@link previewOperation}, extending the simulation options with
+ * preview-specific inputs.
+ */
+export interface PreviewOperationOptions extends OperationSimulationOptions {
+    /**
+     * Pre-fetched state of the credit account being adjusted. When omitted,
+     * multicall/botMulticall previews fetch it via
+     * `sdk.accounts.getCreditAccountData` (one compressor read). Ignored by
+     * other operation kinds.
+     */
+    creditAccount?: CreditAccountData;
+}
+/**
+ * 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";
+    /**
+     * 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[];
+}
+/**
+ * Result of previewing a raw operation calldata: currently pool operations and
+ * credit account opening are supported.
+ */
+export type OperationPreview = PoolOperationPreview | OpenCreditAccountPreview | AdjustCreditAccountPreview;

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

@@ -0,0 +1,45 @@
+import { BaseError, type Hex } from "viem";
+/** Which simulation flow produced a failure. */
+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 it fails. It wraps the flow's
+ * decoded revert reason (see {@link failures}).
+ */
+export declare class PreviewSimulationError extends BaseError {
+    name: string;
+    /** Per-flow decoded failures behind this error. */
+    readonly failures: SimulationFlowFailure[];
+    constructor(failures: SimulationFlowFailure[]);
+}
+/**
+ * Normalises an unknown rejection reason into a {@link PreviewSimulationError}.
+ * Pass-through when it already is one; otherwise decodes it under `source`.
+ */
+export declare function asPreviewSimulationError(reason: unknown, source: SimulationFlowSource): PreviewSimulationError;
+/** Decoded revert of the simulated transaction. */
+export interface SimulationError {
+    /** Human-readable revert reason / error name. */
+    reason: string;
+    /** Original error, kept for debugging. */
+    cause?: unknown;
+}
+/** 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 call revert into a {@link SimulationError}.
+ *
+ * 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`).
+ */
+export declare function decodeSimulationError(revert: SimulationRevert): SimulationError;

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

@@ -0,0 +1,10 @@
+export type { SimulationError, SimulationFlowFailure, SimulationFlowSource, } from "./errors.js";
+export { PreviewSimulationError } from "./errors.js";
+export type { SimulateFacadeOperationInput } from "./simulateFacadeOperation.js";
+export { simulateFacadeOperation } from "./simulateFacadeOperation.js";
+export type { SimulateOperationInput } from "./simulateOperation.js";
+export { simulateOperation } from "./simulateOperation.js";
+export { simulatePoolOperation } from "./simulatePoolOperation.js";
+export type { SimulateRWAOperationInput } from "./simulateRWAOperation.js";
+export { simulateRWAOperation } from "./simulateRWAOperation.js";
+export type { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput, PoolOperationSimulationResult, } from "./types.js";

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

@@ -0,0 +1,23 @@
+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;
+}
+/**
+ * Simulates a credit-facade operation.
+ *
+ * Not yet implemented: credit-facade simulation 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 simulateFacadeOperation(_input: SimulateFacadeOperationInput, _options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;

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

@@ -0,0 +1,18 @@
+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;
+}
+/**
+ * Simulates a parsed pool or credit account operation {@link Operation}
+ */
+export declare function simulateOperation(input: SimulateOperationInput, options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;

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

@@ -0,0 +1,14 @@
+import type { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput } from "./types.js";
+/**
+ * Simulates a pool deposit/mint/withdraw/redeem (direct or zapper-routed) and
+ * returns the resulting token amounts going in and out, or a decoded failure.
+ *
+ * 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>;

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

@@ -0,0 +1,52 @@
+import type { Address, Hex } from "viem";
+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";
+export interface PoolOperationSimulationInput {
+    /** Only `client`/`networkType` are used, so any OnchainSDK works. */
+    sdk: OnchainSDK;
+    /** Parsed operation, used to resolve the underlying and pool tokens. */
+    operation: PoolOperation;
+    /** Target contract the calldata is sent to (the pool). */
+    to: Address;
+    /** Raw deposit/mint/withdraw/redeem calldata to simulate. */
+    calldata: Hex;
+}
+export interface OperationSimulationOptions {
+    /** Block to simulate at; defaults to latest. */
+    blockNumber?: bigint;
+    /**
+     * Optional logger.
+     **/
+    logger?: ILogger;
+}
+/**
+ * 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 {
+    /**
+     * 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).
+     **/
+    amountOut: bigint;
+}
+/**
+ * Outcome of simulating a pool operation. On success it carries a
+ * {@link PoolOperationSimulationResult}; on failure it carries a
+ * {@link PreviewSimulationError}.
+ */
+export type PoolOperationSimulation = ({
+    status: "success";
+} & PoolOperationSimulationResult) | {
+    status: "failure";
+    error: PreviewSimulationError;
+};

package/dist/types/{history → preview/trace}/errors.d.ts

@@ -9,16 +9,6 @@ export declare class TransferAlignmentError extends Error {
 export declare class WithdrawCollateralAlignmentError extends Error {
     constructor(expected: number, actual: number);
 }
-export declare class ProtocolCallNotFoundError extends Error {
-    readonly targetContract: Address;
-    readonly executeIndex: number;
-    constructor(targetContract: Address, executeIndex: number);
-}
-export declare class AdapterTraceAlignmentError extends Error {
-    readonly expected: number;
-    readonly actual: number;
-    constructor(expected: number, actual: number);
-}
 export declare class UnexpectedFacadeEventOrderError extends Error {
     constructor(e: {
         eventName: string;

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

@@ -0,0 +1,23 @@
+import { type CallTrace } from "../../common-utils/utils/trace.js";
+/**
+ * Extracts the user multicall's adapter-level call traces from a single facade
+ * call trace.
+ *
+ * Returns the direct children of the facade trace that perform an external
+ * protocol call (their subtree resolves to a `CreditManager.execute(bytes)`
+ * that reaches a leaf CALL to a target contract), in trace order.
+ *
+ * Scoping to direct children of the facade trace (rather than flattening the
+ * whole subtree) avoids over-counting in nested credit-manager scenarios such
+ * as account migration, where a single migrate-adapter subtree nests another
+ * account's `execute(bytes)` calls.
+ *
+ * Facade-synthesized phantom-token withdrawals are excluded: while processing
+ * `withdrawCollateral` on a phantom token the facade issues its own
+ * `withdrawPhantomToken` adapter call, which also reaches an external target
+ * but does not correspond to a user multicall inner call. These are detected
+ * via the preceding `getPhantomTokenInfo()` probe (see
+ * {@link isSynthesizedPhantomWithdrawal}), so the returned traces line up 1:1,
+ * in order, with the multicall's adapter inner calls.
+ */
+export declare function extractAdapterCallTraces(facadeTrace: CallTrace): CallTrace[];

package/dist/types/{history → preview/trace}/extractTransfers.d.ts

@@ -1,7 +1,6 @@
 import { type Address, type Log } from "viem";
-import { AddressMap } from "../sdk/index.js";
-import type { ExecuteResult } from "./internal-types.js";
-import type { DirectTransferInfo } from "./types.js";
+import { AddressMap } from "../../sdk/index.js";
+import type { TokenTransfer } from "../parse/index.js";
 type RawLog = Log<bigint | number, number, false>;
 /**
  * Effective `withdrawCollateral` outcome decoded from the facade's
@@ -26,8 +25,18 @@ export interface WithdrawCollateralEventInfo {
  * @param creditAccount - the credit account address to track
  */
 export interface ExtractTransfersResult {
-    executeResults: ExecuteResult[];
-    directTransfers: DirectTransferInfo[];
+    /**
+     * ERC-20 transfers grouped per facade `Execute` event, one inner array per
+     * Execute event across the whole transaction, in emission order. Each inner
+     * array holds the transfers to/from the credit account that occurred between
+     * that Execute boundary and the previous one.
+     */
+    executeTransfers: TokenTransfer[][];
+    /**
+     * ERC-20 transfers that are not part of a facade `Execute` event and are
+     * direct incoming transfers to the credit account.
+     */
+    directTransfers: TokenTransfer[];
     liquidationRemainingFunds?: bigint;
     /** Maps phantom token address to its deposited (underlying) token address. */
     phantomTokens: AddressMap<Address>;

package/dist/types/{history → preview/trace}/findFacadeCalls.d.ts

@@ -1,6 +1,7 @@
 import { type Address } from "viem";
-import type { ChainContractsRegister } from "../sdk/index.js";
-import type { CallTrace, FacadeParsedCall } from "./internal-types.js";
+import { type CallTrace } from "../../common-utils/utils/trace.js";
+import type { ChainContractsRegister } from "../../sdk/index.js";
+import type { FacadeParsedCall } from "./types.js";
 /**
  * Walks a `debug_traceTransaction` callTracer tree, finds all non-reverted
  * calls to the credit facade, parses them via the register, and returns

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

@@ -0,0 +1,5 @@
+export * from "./errors.js";
+export * from "./extractAdapterCallTraces.js";
+export * from "./extractTransfers.js";
+export * from "./findFacadeCalls.js";
+export * from "./types.js";

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

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import type { CallTrace } from "../../common-utils/utils/trace.js";
+import type { ParsedCallV2 } from "../../sdk/index.js";
+/**
+ * The set of credit facade entry-point functions that produce history operations.
+ */
+export type FacadeCallType = "MultiCall" | "BotMulticall" | "OpenCreditAccount" | "CloseCreditAccount" | "LiquidateCreditAccount" | "PartiallyLiquidateCreditAccount";
+/**
+ * A parsed credit facade call extracted from a call trace,
+ * with inner multicall calls already decoded.
+ */
+export interface FacadeParsedCall {
+    operation: FacadeCallType;
+    creditAccount: Address;
+    /** The full ParsedCallV2 from facade calldata parsing. */
+    parsed: ParsedCallV2;
+    /** Inner multicall entries from rawArgs.calls (empty for partiallyLiquidateCreditAccount). */
+    innerCalls: ParsedCallV2[];
+    /** The full call trace node for this facade call (used to extract protocol-level calldata). */
+    trace: CallTrace;
+}

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/accounts/CreditAccountsServiceV310.d.ts

@@ -4,9 +4,9 @@ import { SDKConstruct } from "../base/index.js";
 import { type PriceUpdate } from "../market/index.js";
 import type { RWAOpenAccountRequirements } from "../market/rwa/index.js";
 import type { OnchainSDK } from "../OnchainSDK.js";
-import { type RouterCASlice } from "../router/index.js";
+import type { RouterCASlice } from "../router/index.js";
 import type { MultiCall, RawTx } from "../types/index.js";
-import type { AccountToCheck, AddCollateralProps, ChangeDeptProps, ClaimDelayedProps, ClaimFarmRewardsProps, CloseCreditAccountProps, CloseCreditAccountResult, CreditAccountOperationResult, CreditAccountTokensSlice, CreditManagerOperationResult, DefaultPartialLiquidationParams, ExecuteSwapProps, FullyLiquidateProps, FullyLiquidateResult, GetApprovalAddressProps, GetConnectedBotsResult, GetConnectedMigrationBotsResult, GetCreditAccountsOptions, GetOpenAccountRequirementsProps, GetPendingWithdrawalsProps, GetPendingWithdrawalsResult, ICreditAccountsService, OpenCAProps, PartiallyLiquidateProps, PreviewDelayedWithdrawalProps, PreviewDelayedWithdrawalResult, RepayAndLiquidateCreditAccountProps, RepayCreditAccountProps, Rewards, SetBotProps, StartDelayedWithdrawalProps, UpdateQuotasProps, WithdrawCollateralProps } from "./types.js";
+import type { AccountToCheck, AddCollateralProps, AssembleCaUpdateCallsProps, ChangeDeptProps, ClaimDelayedProps, ClaimFarmRewardsProps, CloseCreditAccountProps, CloseCreditAccountResult, CreditAccountOperationResult, CreditAccountTokensSlice, CreditManagerOperationResult, DefaultPartialLiquidationParams, ExecuteSwapProps, FullyLiquidateProps, FullyLiquidateResult, GetApprovalAddressProps, GetConnectedBotsResult, GetConnectedMigrationBotsResult, GetCreditAccountsOptions, GetOpenAccountRequirementsProps, GetPendingWithdrawalsProps, GetPendingWithdrawalsResult, ICreditAccountsService, OpenCAProps, PartiallyLiquidateProps, PreviewDelayedWithdrawalProps, PreviewDelayedWithdrawalResult, RepayAndLiquidateCreditAccountProps, RepayCreditAccountProps, Rewards, SetBotProps, StartDelayedWithdrawalProps, UpdateQuotasProps, WithdrawCollateralProps } from "./types.js";
 /**
  * Options for configuring the credit account service.
  **/
@@ -204,6 +204,26 @@ export declare class CreditAccountsServiceV310 extends SDKConstruct implements I
     botMulticall(creditAccount: RouterCASlice, calls: MultiCall[], options?: {
         ignoreReservePrices?: boolean;
     }): Promise<RawTx>;
+    /**
+     * {@inheritDoc ICreditAccountsService.prependPriceUpdates}
+     */
+    prependPriceUpdates(creditManager: Address, calls: MultiCall[], creditAccount?: RouterCASlice, options?: {
+        ignoreReservePrices?: boolean;
+    }): Promise<MultiCall[]>;
+    /**
+     * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
+     */
+    assembleCaUpdateCalls({ operations, routerCallGroups, creditFacade, withdrawTo, creditAccount, underlyingToken, }: AssembleCaUpdateCallsProps): MultiCall[];
+    /**
+     * {@inheritDoc ICreditAccountsService.executeCaUpdate}
+     */
+    executeCaUpdate(creditAccount: RouterCASlice, calls: MultiCall[], options?: {
+        ignoreReservePrices?: boolean;
+        ethAmount?: bigint;
+    }): Promise<{
+        tx: RawTx;
+        calls: MultiCall[];
+    }>;
     /**
      * Returns addresses of market configurators
      */