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

package/dist/types/plugins/adapters/contracts/StakingRewardsAdapterContract.d.ts

@@ -1,5 +1,6 @@
-import { type Address } from "viem";
-import { type ConstructOptions } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type AddressMap, type ConstructOptions } from "../../../sdk/index.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -280,5 +281,6 @@ export declare class StakingRewardsAdapterContract extends AbstractAdapterContra
         version: number;
         contractType?: string;
     };
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
 }
 export {};

package/dist/types/plugins/adapters/contracts/TraderJoeRouterAdapterContract.d.ts

@@ -1,5 +1,6 @@
-import { type Address } from "viem";
-import type { ConstructOptions } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import type { AddressMap, ConstructOptions } from "../../../sdk/index.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 export declare enum TraderJoePoolVersion {
@@ -483,5 +484,6 @@ export declare class TraderJoeRouterAdapterContract extends AbstractAdapterContr
         version: number;
         contractType?: string;
     };
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
 }
 export {};

package/dist/types/plugins/adapters/contracts/UniswapV2AdapterContract.d.ts

@@ -1,6 +1,7 @@
 import { type Address, type DecodeFunctionDataReturnType } from "viem";
-import type { ConstructOptions, ParsedCallV2 } from "../../../sdk/index.js";
+import type { AddressMap, ConstructOptions, ParsedCallV2 } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -964,6 +965,7 @@ export declare class UniswapV2AdapterContract extends AbstractAdapterContract<ab
     };
     protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L81-L91 */
-    protected classifyLegacyOperation(_parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    classifyLegacyOperation(_parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
 }
 export {};

package/dist/types/plugins/adapters/contracts/UniswapV3AdapterContract.d.ts

@@ -1,5 +1,6 @@
 import { type Address, type DecodeFunctionDataReturnType } from "viem";
-import type { ConstructOptions } from "../../../sdk/index.js";
+import type { AddressMap, ConstructOptions } from "../../../sdk/index.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -556,6 +557,7 @@ export declare class UniswapV3AdapterContract extends AbstractAdapterContract<ab
         version: number;
         contractType?: string;
     };
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
     protected stringifyFunctionParams(params: DecodeFunctionDataReturnType<abi>): string[];
     private trackInputPath;
     private trackOutputPath;

package/dist/types/plugins/adapters/contracts/UniswapV4AdapterContract.d.ts

@@ -1,6 +1,7 @@
-import { type Address } from "viem";
-import type { ConstructOptions, ParsedCallV2 } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import type { AddressMap, ConstructOptions, ParsedCallV2 } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -420,6 +421,7 @@ export declare class UniswapV4AdapterContract extends AbstractAdapterContract<ab
         contractType?: string;
     };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L81-L91 */
-    protected classifyLegacyOperation(_parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    classifyLegacyOperation(_parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
 }
 export {};

package/dist/types/plugins/adapters/contracts/UpshiftVaultAdapterContract.d.ts

@@ -1,5 +1,6 @@
-import { type Address } from "viem";
-import { type ConstructOptions } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type AddressMap, type ConstructOptions } from "../../../sdk/index.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -356,5 +357,6 @@ export declare class UpshiftVaultAdapterContract extends AbstractAdapterContract
         version: number;
         contractType?: string;
     };
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
 }
 export {};

package/dist/types/plugins/adapters/contracts/VelodromeV2AdapterContract.d.ts

@@ -1,5 +1,6 @@
-import { type Address } from "viem";
-import type { ConstructOptions } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import type { AddressMap, ConstructOptions } from "../../../sdk/index.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -361,5 +362,6 @@ export declare class VelodromeV2RouterAdapterContract extends AbstractAdapterCon
         version: number;
         contractType?: string;
     };
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
 }
 export {};

package/dist/types/plugins/adapters/contracts/WstETHV1AdapterContract.d.ts

@@ -1,6 +1,7 @@
-import { type Address } from "viem";
-import { type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type AddressMap, type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
+import type { DiffLeftover } from "../types.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 declare const abi: readonly [{
@@ -392,6 +393,7 @@ export declare class WstETHV1AdapterContract extends AbstractAdapterContract<abi
         contractType?: string;
     };
     /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L264-L275 */
-    protected classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, balances: AddressMap<bigint>): DiffLeftover[];
 }
 export {};

package/dist/types/plugins/adapters/transferHelpers.d.ts

@@ -1,6 +1,6 @@
 import { type Address } from "viem";
 import type { BasicSwapCall, CurveAddLiquidity, CurveRemoveLiquidity, LegacyAdapterOperation, TokenAmount, Transfers } from "./legacyAdapterOperations.js";
-import type { TokenTransfer } from "./types.js";
+import type { TokenTransfer } from "./transfers.js";
 /**
  * Converts an ordered array of {@link TokenTransfer} into net signed balance
  * changes ({@link Transfers}) for the given credit account.

package/dist/types/plugins/adapters/transfers.d.ts

@@ -0,0 +1,17 @@
+import type { Address } from "viem";
+/**
+ * A single ERC-20 Transfer event captured between Execute boundaries.
+ *
+ * Internal to `plugins/adapters` (kept here so {@link toNetTransfers} stays
+ * typed) and intentionally **not** re-exported from the package barrel: the
+ * canonical, public `TokenTransfer` lives in the `preview` module. The two are
+ * structurally identical, so values flow between the modules without casts.
+ *
+ * @deprecated Will be deprecated when we get rid of classifyLegacyOperation
+ */
+export interface TokenTransfer {
+    token: Address;
+    amount: bigint;
+    from: Address;
+    to: Address;
+}

package/dist/types/plugins/adapters/types.d.ts

@@ -1,6 +1,5 @@
 import type { AbiParameter, Address } from "viem";
 import type { BaseContractStateHuman } from "../../sdk/types/state-human.js";
-import type { LegacyAdapterOperation } from "./legacyAdapterOperations.js";
 export type VersionedAbi = Record<number, readonly AbiParameter[]>;
 export type AdapterContractType = "ADAPTER::ACCOUNT_MIGRATOR" | "ADAPTER::BALANCER_V3_ROUTER" | "ADAPTER::BALANCER_V3_WRAPPER" | "ADAPTER::BALANCER_VAULT" | "ADAPTER::CAMELOT_V3_ROUTER" | "ADAPTER::CURVE_STABLE_NG" | "ADAPTER::CURVE_V1_2ASSETS" | "ADAPTER::CURVE_V1_3ASSETS" | "ADAPTER::CURVE_V1_4ASSETS" | "ADAPTER::CURVE_V1_STECRV_POOL" | "ADAPTER::CURVE_V1_WRAPPER" | "ADAPTER::CVX_V1_BASE_REWARD_POOL" | "ADAPTER::CVX_V1_BOOSTER" | "ADAPTER::DAI_USDS_EXCHANGE" | "ADAPTER::EQUALIZER_ROUTER" | "ADAPTER::ERC4626_VAULT" | "ADAPTER::ERC4626_VAULT_REFERRAL" | "ADAPTER::FLUID_DEX" | "ADAPTER::INFINIFI_GATEWAY" | "ADAPTER::INFINIFI_UNWINDING" | "ADAPTER::INFRARED_VAULT" | "ADAPTER::KELP_DEPOSIT_POOL" | "ADAPTER::KELP_WITHDRAWAL" | "ADAPTER::KODIAK_ISLAND_GATEWAY" | "ADAPTER::LIDO_V1" | "ADAPTER::LIDO_WSTETH_V1" | "ADAPTER::MELLOW_CLAIMER" | "ADAPTER::MELLOW_DVV" | "ADAPTER::MELLOW_ERC4626_VAULT" | "ADAPTER::MELLOW_LRT_VAULT" | "ADAPTER::MELLOW_WRAPPER" | "ADAPTER::MELLOW_DEPOSIT_QUEUE_QUEUE" | "ADAPTER::MELLOW_REDEEM_QUEUE_QUEUE" | "ADAPTER::MIDAS_ISSUANCE_VAULT" | "ADAPTER::MIDAS_REDEMPTION_VAULT" | "ADAPTER::PENDLE_ROUTER" | "ADAPTER::SECURITIZE_ONRAMP" | "ADAPTER::SECURITIZE_REDEMPTION" | "ADAPTER::SECURITIZE_SWAP" | "ADAPTER::STAKING_REWARDS" | "ADAPTER::TRADER_JOE_ROUTER" | "ADAPTER::UNISWAP_V2_ROUTER" | "ADAPTER::UNISWAP_V3_ROUTER" | "ADAPTER::UNISWAP_V4_GATEWAY" | "ADAPTER::UPSHIFT_VAULT" | "ADAPTER::VELODROME_V2_ROUTER" | "ADAPTER::YEARN_V2";
 export declare enum AdapterType {
@@ -52,64 +51,37 @@ export declare enum AdapterType {
     VELODROME_V2_ROUTER = "VELODROME_V2_ROUTER",
     YEARN_V2 = "YEARN_V2"
 }
+/**
+ * Diff-call semantics of a diff-style adapter call: the call spends the
+ * consumed token down to the exact `leftoverAmount` encoded in its calldata,
+ * so the post-call balance of `tokenIn` is `leftoverAmount` regardless of the
+ * actual amount spent.
+ */
+export interface DiffLeftover {
+    tokenIn: Address;
+    leftoverAmount: bigint;
+}
 export interface AdapterContractStateHuman extends BaseContractStateHuman {
     creditManager?: string;
     targetContract?: string;
 }
 /**
- * A single ERC-20 Transfer event captured between Execute boundaries.
- */
-export interface TokenTransfer {
-    token: Address;
-    amount: bigint;
-    from: Address;
-    to: Address;
-}
-/**
- * Parsed adapter operation to display in credit account transactions history
+ * Protocol-level call performed by an adapter: the target (protocol) contract
+ * together with the decoded function name and arguments of the actual CALL the
+ * adapter made to it. Recovered from an execution trace, so it is only present
+ * when a trace is available (history, facade simulation).
  */
-export interface AdapterOperation {
-    operation: "Execute";
-    /**
-     * Address of Gearbox Adapter contract
-     */
-    adapter: Address;
+export interface AdapterProtocolOperation {
     /**
      * Address of protocol contract (targetContract of adapter contract)
      */
-    protocol: Address;
-    /**
-     * Namespaced adapter type
-     * E.g. "ADAPTER::FLUID_DEX"
-     */
-    adapterType: string;
-    /**
-     * Adapter contract version
-     */
-    version: number;
-    /**
-     * Label of protocol contract (NOT adapter contract)
-     */
-    label?: string;
-    /**
-     * Function name of adapter contract
-     */
-    adapterFunctionName: string;
-    /**
-     * Arguments of adapter contract
-     */
-    adapterArgs: Record<string, unknown>;
+    contract: Address;
     /**
      * Function name protocol called by adapter
      */
-    protocolFunctionName: string;
+    functionName: string;
     /**
      * Arguments of protocol called by adapter
      */
-    protocolArgs: Record<string, unknown>;
-    /**
-     * ERC20 transfer to and from credit account made during adapter call
-     */
-    transfers: TokenTransfer[];
-    legacy: LegacyAdapterOperation;
+    functionArgs: Record<string, unknown>;
 }

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

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

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

@@ -0,0 +1,19 @@
+import type { Address } from "viem";
+import type { OnchainSDK, ParsedCallV2 } from "../../sdk/index.js";
+import type { InnerOperation } from "./types.js";
+export interface ClassifyInnerOperationsProps {
+    sdk: OnchainSDK;
+    /** Underlying token of the credit manager, used for debt operations. */
+    underlying: Address;
+}
+/**
+ * Maps each inner multicall entry to an {@link InnerOperation}:
+ * - adapter and unknown targets become a pure-descriptor `Execute`
+ *   {@link AdapterOperation};
+ * - credit-facade self-calls map to the matching inner facade operation.
+ *
+ * Raw calldata has no execution trace, so the trace-derived adapter data
+ * (`protocol`, `transfers`) and `legacy` are intentionally absent; they are only
+ * recovered by trace-based flows (history, facade simulation).
+ */
+export declare function classifyInnerOperations(calls: ParsedCallV2[], props: ClassifyInnerOperationsProps): InnerOperation[];

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

@@ -0,0 +1,18 @@
+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.
+ */
+export declare class UnsupportedTargetError extends Error {
+    readonly target: Address;
+    constructor(target: Address);
+}
+/**
+ * Thrown when a pool call uses a function other than ERC4626 `deposit`/`redeem`.
+ */
+export declare class UnsupportedPoolFunctionError extends Error {
+    readonly pool: Address;
+    readonly functionName: string;
+    constructor(pool: Address, functionName: string);
+}

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

@@ -0,0 +1,7 @@
+export * from "./classifyInnerOperations.js";
+export * from "./errors.js";
+export * from "./parseFacadeOperationCalldata.js";
+export * from "./parseOperationCalldata.js";
+export * from "./parsePoolOperationCalldata.js";
+export * from "./parseRWAFactoryOperationCalldata.js";
+export * from "./types.js";

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

@@ -0,0 +1,19 @@
+import { type Hex } from "viem";
+import type { CreditFacadeV310Contract, OnchainSDK } from "../../sdk/index.js";
+import type { OuterFacadeOperation } from "./types.js";
+export interface ParseFacadeOperationCalldataProps {
+    sdk: OnchainSDK;
+    /** Resolved credit facade contract for the transaction target. */
+    facade: CreditFacadeV310Contract;
+    calldata: Hex;
+}
+/**
+ * Decodes a credit-facade entry-point call into the matching
+ * {@link OuterFacadeOperation}.
+ *
+ * Transaction-level metadata (`txHash`, `blockNumber`, `timestamp`) is not part
+ * of the base `preview` operation: those values are only known once the
+ * transaction is mined and are added in `history` mode. `creditAccount` is
+ * `zeroAddress` for `openCreditAccount` (the address is assigned on-chain).
+ */
+export declare function parseFacadeOperationCalldata(props: ParseFacadeOperationCalldataProps): OuterFacadeOperation;

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

@@ -0,0 +1,23 @@
+import type { Address, Hex } from "viem";
+import { type PluginsMap } from "../../sdk/index.js";
+import type { Operation, SdkWithAdapters } from "./types.js";
+export interface ParseOperationCalldataInput<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>;
+    to: Address;
+    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}.
+ *
+ * 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/parsePoolOperationCalldata.d.ts

@@ -0,0 +1,17 @@
+import type { Hex } from "viem";
+import type { OnchainSDK, PoolV310Contract } from "../../sdk/index.js";
+import type { PoolOperation } from "./types.js";
+export interface ParsePoolOperationCalldataProps {
+    sdk: OnchainSDK;
+    /** Resolved pool contract for the transaction target. */
+    pool: PoolV310Contract;
+    calldata: Hex;
+}
+/**
+ * Decodes ERC4626 pool calldata into a {@link PoolOperation}. Supports every
+ * deposit/mint/withdraw/redeem variant of `IPoolV3` (and the `IERC4626` base it
+ * extends): `deposit`/`depositWithReferral`, `mint`/`mintWithReferral`,
+ * `withdraw` and `redeem`. Any other selector throws
+ * {@link UnsupportedPoolFunctionError}.
+ */
+export declare function parsePoolOperationCalldata(props: ParsePoolOperationCalldataProps): PoolOperation;

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

@@ -0,0 +1,22 @@
+import type { Hex } from "viem";
+import { type IRWAFactory, type OnchainSDK } from "../../sdk/index.js";
+import type { RWAOperation } from "./types-rwa.js";
+export interface ParseRWAFactoryOperationCalldataProps {
+    sdk: OnchainSDK;
+    /** Resolved RWA factory contract for the transaction target. */
+    factory: IRWAFactory;
+    calldata: Hex;
+}
+/**
+ * Decodes a RWA-factory entry-point call into the matching
+ * {@link RWAOperation}.
+ *
+ * RWA credit accounts are opened and managed through the market's RWA factory
+ * (see `CreditAccountsServiceV310`) rather than the credit facade, but the
+ * inner `calls` share the credit-facade multicall shape, so classification is
+ * identical to {@link parseFacadeOperationCalldata}.
+ *
+ * Dispatches on the factory's contract type; supporting a new factory type
+ * requires a new branch here plus new operation types in `types-rwa.ts`.
+ */
+export declare function parseRWAFactoryOperationCalldata(props: ParseRWAFactoryOperationCalldataProps): RWAOperation;

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

@@ -0,0 +1,73 @@
+import type { Address, Hex } from "viem";
+import type { AdapterProtocolOperation } from "../../plugins/adapters/index.js";
+/**
+ * A single ERC-20 Transfer event captured between Execute boundaries.
+ *
+ * Canonical, public definition owned by the `preview` module; `plugins/adapters`
+ * keeps a structurally identical internal copy for its legacy helpers.
+ */
+export interface TokenTransfer {
+    token: Address;
+    amount: bigint;
+    from: Address;
+    to: Address;
+}
+/**
+ * Pure adapter-call descriptor: everything that can be recovered without an
+ * execution trace (from raw calldata alone).
+ */
+export interface AdapterOperationBase {
+    operation: "Execute";
+    /**
+     * Address of Gearbox Adapter contract
+     */
+    adapter: Address;
+    /**
+     * Namespaced adapter type
+     * E.g. "ADAPTER::FLUID_DEX"
+     */
+    adapterType: string;
+    /**
+     * Adapter contract version
+     */
+    version: number;
+    /**
+     * Label of protocol contract (NOT adapter contract)
+     */
+    label?: string;
+    /**
+     * Function name of adapter contract
+     */
+    adapterFunctionName: string;
+    /**
+     * Arguments of adapter contract
+     */
+    adapterArgs: Record<string, unknown>;
+    /**
+     * Raw ABI-encoded adapter calldata
+     */
+    calldata: Hex;
+}
+/**
+ * Adapter `Execute` operation, generic over the extra data added by consumers.
+ *
+ * - calldata-only parse uses `Ext = {}` (pure descriptor);
+ * - trace-based flows (history, facade simulation) use {@link TraceAdapterExt};
+ * - history additionally intersects `{ legacy: LegacyAdapterOperation }`.
+ */
+export type AdapterOperation<Ext extends object = {}> = AdapterOperationBase & Ext;
+/**
+ * Trace-derived adapter data: the protocol-level call and the ERC-20 transfers
+ * made during the adapter call. Both are only available from an execution
+ * trace, so they always travel together.
+ *
+ * `protocol` is optional: it is absent when no external protocol call was
+ * recovered for the adapter `Execute`. This happens for the account-migrator
+ * adapter (its `execute` targets the migrator bot, not an external protocol),
+ * for unknown adapters in non-strict mode (no ABI to decode against), and when
+ * the protocol calldata cannot be decoded.
+ */
+export interface TraceAdapterExt {
+    protocol?: AdapterProtocolOperation;
+    transfers: TokenTransfer[];
+}

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

@@ -0,0 +1,147 @@
+import type { Address, Hex } from "viem";
+import type { Asset } from "../../sdk/index.js";
+import type { AdapterOperation } from "./types-adapters.js";
+/**
+ * Increase debt (borrow more).
+ * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L149-L154
+ */
+export interface IncreaseDebtOp {
+    operation: "IncreaseBorrowedAmount";
+    token: Address;
+    amount: bigint;
+}
+/**
+ * Decrease debt (repay).
+ * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L155-L161
+ */
+export interface DecreaseDebtOp {
+    operation: "DecreaseBorrowedAmount";
+    token: Address;
+    amount: bigint;
+}
+/**
+ * Add collateral to credit account.
+ */
+export interface AddCollateralOp {
+    operation: "AddCollateral";
+    token: Address;
+    amount: bigint;
+}
+/**
+ * Withdraw collateral from credit account.
+ * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L162-L171
+ */
+export interface WithdrawCollateralOp {
+    operation: "WithdrawCollateral";
+    token: Address;
+    amount: bigint;
+    to: Address;
+    phantomToken?: Address;
+}
+/**
+ * Update token quota on credit account.
+ * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L172-L178
+ */
+export interface UpdateQuotaOp {
+    operation: "UpdateQuota";
+    token: Address;
+    change: bigint;
+}
+/**
+ * Router-generated slippage-control call that declares expected minimal
+ * balance changes for the adapter calls that follow, up to the matching
+ * {@link CompareBalancesOp}.
+ */
+export interface StoreExpectedBalancesOp {
+    operation: "StoreExpectedBalances";
+    /**
+     * Declared minimal balance changes (relative to balances at
+     * `storeExpectedBalances` time).
+     */
+    deltas: Asset[];
+}
+/**
+ * Router-generated slippage-control call that validates the balance changes
+ * declared by the preceding {@link StoreExpectedBalancesOp}. Pure validation
+ * marker, carries no data.
+ */
+export interface CompareBalancesOp {
+    operation: "CompareBalances";
+}
+/**
+ * Union of facade inner-call operation types (non-adapter credit account operations).
+ * Discriminated on the `operation` field.
+ */
+export type InnerFacadeOperation = IncreaseDebtOp | DecreaseDebtOp | AddCollateralOp | WithdrawCollateralOp | UpdateQuotaOp | StoreExpectedBalancesOp | CompareBalancesOp;
+/**
+ * All operations that can happen within a CreditFacade's multicall and that we're interested in.
+ *
+ * Generic over the adapter-operation extension `Ext` (see {@link AdapterOperation}).
+ */
+export type InnerOperation<Ext extends object = {}> = AdapterOperation<Ext> | InnerFacadeOperation;
+/**
+ * Transaction-level metadata available only when parsing a mined transaction
+ * (the `history` mode). It is intentionally absent from base `preview`
+ * operations, which describe not-yet-mined calls where these values are unknown.
+ */
+export interface OperationMetadata {
+    txHash: Hex;
+    blockNumber: number;
+    timestamp: number;
+}
+export interface FacadeOperationMetadata {
+    creditManager: Address;
+    creditFacade: Address;
+}
+export interface MulticallOperation<Ext extends object = {}> extends FacadeOperationMetadata {
+    operation: "MultiCall" | "BotMulticall";
+    creditAccount: Address;
+    multicall: InnerOperation<Ext>[];
+}
+export interface OpenCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
+    operation: "OpenCreditAccount";
+    creditAccount: Address;
+    onBehalfOf: Address;
+    referralCode: bigint;
+    multicall: InnerOperation<Ext>[];
+}
+export interface CloseCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
+    operation: "CloseCreditAccount";
+    creditAccount: Address;
+    multicall: InnerOperation<Ext>[];
+}
+export interface LiquidateCreditAccountOperation<Ext extends object = {}> extends FacadeOperationMetadata {
+    operation: "LiquidateCreditAccount";
+    creditAccount: Address;
+    to: Address;
+    token: Address;
+    remainingFunds: bigint;
+    multicall: InnerOperation<Ext>[];
+}
+export interface PartialLiquidationOperation extends FacadeOperationMetadata {
+    operation: "PartiallyLiquidateCreditAccount";
+    creditAccount: Address;
+    token: Address;
+    repaidAmount: bigint;
+    minSeizedAmount: bigint;
+    to: Address;
+}
+export interface DirectTokenTransferOperation {
+    operation: "DirectTokenTransfer";
+    protocol: Address;
+    token: Address;
+    from: Address;
+    to: Address;
+    creditAccount: Address;
+    amount: bigint;
+}
+/**
+ * Discriminated union of all facade-level operation types.
+ * One per facade entry-point call within a transaction.
+ */
+export type OuterFacadeOperation<Ext extends object = {}> = MulticallOperation<Ext> | OpenCreditAccountOperation<Ext> | CloseCreditAccountOperation<Ext> | LiquidateCreditAccountOperation<Ext> | PartialLiquidationOperation;
+/**
+ * Discriminated union of all credit account operation types
+ * (facade operations + direct token transfers).
+ */
+export type CreditAccountOperation<Ext extends object = {}> = OuterFacadeOperation<Ext> | DirectTokenTransferOperation;