@gearbox-protocol/sdk 14.11.0-next.1 → 14.11.0-next.10

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

@@ -1,7 +1,10 @@
-import type { Address } from "viem";
-import type { OuterFacadeOperation } from "../../history/index.js";
-import type { AdaptersPlugin, TokenTransfer } from "../../plugins/adapters/index.js";
+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";
+export * from "./types-adapters.js";
+export * from "./types-facades.js";
+export * from "./types-pools.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),
@@ -26,53 +29,16 @@ export type RequireAdaptersPlugin<P extends PluginsMap> = HasAdaptersPlugin<P> e
  */
 export type SdkWithAdapters<P extends PluginsMap = PluginsMap> = OnchainSDK<P> & RequireAdaptersPlugin<P>;
 /**
- * ERC4626 `deposit` into a Gearbox pool.
- * Token metadata (symbol/decimals) is intentionally omitted: consumers resolve
- * it from `sdk.tokensMeta` using the token addresses below.
- */
-export interface PoolDepositOperation {
-    operation: "Deposit";
-    pool: Address;
-    receiver: Address;
-    /** Underlying assets supplied to the pool. */
-    assets: bigint;
-    underlying: Address;
-    /** Referral code, present only for `depositWithReferral` calls. */
-    referralCode?: bigint;
-    /**
-     * ERC-20 transfers involving the wallet, recovered by simulating the call.
-     * Empty for the calldata-only parse; populated by the simulation stage.
-     */
-    transfers: TokenTransfer[];
-}
-/**
- * ERC4626 `redeem` from a Gearbox pool.
- * Token metadata (symbol/decimals) is intentionally omitted: consumers resolve
- * it from `sdk.tokensMeta` using the token addresses below.
- */
-export interface PoolRedeemOperation {
-    operation: "Redeem";
-    pool: Address;
-    receiver: Address;
-    owner: Address;
-    /** Pool shares (diesel) burned. */
-    shares: bigint;
-    underlying: Address;
-    /**
-     * ERC-20 transfers involving the wallet, recovered by simulating the call.
-     * Empty for the calldata-only parse; populated by the simulation stage.
-     */
-    transfers: TokenTransfer[];
-}
-export type PoolOperation = PoolDepositOperation | PoolRedeemOperation;
-/**
- * Narrows a {@link ParsedTransaction} to a {@link PoolOperation} (deposit 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.
+ * 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 = {}`.
  */
-export declare function isPoolOperation(tx: ParsedTransaction): tx is PoolOperation;
+export type Operation = PoolOperation | OuterFacadeOperation;
 /**
- * Result of decoding a single raw transaction calldata: either a pool
- * deposit/redeem or one of the credit-facade operations from `sdk/history`.
+ * 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 type ParsedTransaction = PoolOperation | OuterFacadeOperation;
+export declare function isPoolOperation(tx: Operation): tx is PoolOperation;

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

@@ -1,8 +1,8 @@
-import type { ParsedTransaction } from "../parse/index.js";
+import type { Operation } from "../parse/index.js";
 import type { AnyPrerequisite } from "./Prerequisite.js";
 import type { PrerequisiteContext } from "./types.js";
 /**
- * Derives the on-chain prerequisites for a parsed transaction: the conditions
+ * 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).
  *
@@ -13,4 +13,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: ParsedTransaction, ctx: PrerequisiteContext): AnyPrerequisite[];
+export declare function buildPrerequisites(tx: Operation, ctx: PrerequisiteContext): AnyPrerequisite[];

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

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

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

@@ -0,0 +1,52 @@
+import { type Address, type Hex } from "viem";
+import type { AnyPrerequisiteResult } from "./types.js";
+/**
+ * A single transaction that satisfies a sender-actionable prerequisite.
+ *
+ * The shape is intentionally minimal (`to`/`data`/optional `value`) so it maps
+ * directly onto wallet send primitives (e.g. viem `sendTransaction`, wagmi
+ * `useSendTransaction`/`useWriteContract`). It is deliberately *not* the heavier
+ * {@link import("../../sdk/types/transactions.js").RawTx} used for Safe batches.
+ *
+ * The `kind` mirrors the prerequisite kind it remediates, so consumers can label
+ * the action (e.g. "Approve") without re-deriving it.
+ */
+export interface PrerequisiteAction {
+    /** Prerequisite kind this action remediates. */
+    kind: "allowance";
+    /** Contract the transaction is sent to (the ERC-20 token for allowances). */
+    to: Address;
+    /** Encoded calldata (e.g. `approve(spender, required)`). */
+    data: Hex;
+    /** Native value to send; omitted (treated as 0) for ERC-20 approvals. */
+    value?: bigint;
+}
+/**
+ * Builds the transaction that resolves an unsatisfied, sender-actionable
+ * prerequisite, or returns `null` when the prerequisite cannot be fixed with a
+ * single wallet transaction.
+ *
+ * Currently only `allowance` is actionable: it returns an ERC-20
+ * `approve(spender, required)` for the exact required amount. `balance`
+ * shortfalls (the user must acquire/free up funds) and errored reads are not
+ * actionable and return `null`. New actionable kinds (permits, native unwrap,
+ * approve-reset-to-zero for non-standard tokens, ...) should be encoded here so
+ * consumers do not have to special-case them.
+ *
+ * Operates on the serializable {@link AnyPrerequisiteResult} produced by
+ * `verifyPrerequisites` (not on {@link import("./Prerequisite.js").Prerequisite}
+ * instances), so it works against cached/persisted results.
+ *
+ * @param result - A verified prerequisite result.
+ * @returns The remediation transaction, or `null` if not auto-actionable.
+ */
+export declare function preparePrerequisiteAction(result: AnyPrerequisiteResult): PrerequisiteAction | null;
+/**
+ * Whether a prerequisite result represents something the sender can fix with a
+ * single wallet transaction (i.e. {@link preparePrerequisiteAction} returns a
+ * transaction for it).
+ *
+ * Useful for UIs that distinguish "approve to continue" (actionable) from hard
+ * blocks like an insufficient balance (not actionable).
+ */
+export declare function isActionablePrerequisite(result: AnyPrerequisiteResult): boolean;

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

@@ -0,0 +1,6 @@
+import type { NetworkType } from "../../sdk/chain/index.js";
+/**
+ * Networks where the `eth_simulateV1` JSON-RPC method is available and usable
+ * for pool or credit account operation simulation.
+ **/
+export declare const ETH_SIMULATE_V1_NETWORKS: ReadonlySet<NetworkType>;

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

@@ -0,0 +1,51 @@
+import { BaseError, type Hex } from "viem";
+/** Which simulation flow produced a failure. */
+export type SimulationFlowSource = "eth_simulateV1" | "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}).
+ */
+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;
+/** 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. */
+    reason: string;
+    /** Original error, kept for debugging. */
+    cause?: unknown;
+}
+/** Per-call slice of a `simulateCalls` 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}.
+ *
+ * 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
+ * {@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/extractERC20Transfers.d.ts

@@ -1,5 +1,5 @@
 import { type Address, type Log } from "viem";
-import type { TokenTransfer } from "../../plugins/adapters/index.js";
+import type { TokenTransfer } from "../parse/index.js";
 /**
  * Parses ERC-20 `Transfer` logs and keeps only those involving one of the
  * watched addresses (as sender or receiver). A log that touches several watched

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

@@ -0,0 +1,7 @@
+import type { Address } from "viem";
+import type { PoolOperation } from "../parse/index.js";
+/**
+ * Distinct addresses whose balances change during the operation: the funds
+ * source (payer or share owner) and the receiver.
+ */
+export declare function watchedHolders(operation: PoolOperation, wallet: Address): Address[];

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

@@ -1,4 +1,9 @@
-export * from "./decodeSimulationError.js";
-export * from "./extractERC20Transfers.js";
-export * from "./simulatePoolOperation.js";
-export * from "./types.js";
+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";
+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";

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

@@ -0,0 +1,25 @@
+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;
+    /** Wallet whose balance changes and transfers we track. */
+    wallet: Address;
+}
+/**
+ * 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,20 @@
+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;
+    /** Wallet whose balance changes and transfers we track. */
+    wallet: Address;
+}
+/**
+ * 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/simulatePoolOpMulticall.d.ts

@@ -0,0 +1,28 @@
+import type { Address } from "viem";
+import type { PoolOperation } from "../parse/index.js";
+import type { AddressBalanceChanges, OperationSimulationOptions, PoolOperationSimulationInput, PoolOperationSimulationResult } from "./types.js";
+/** Reads a watched holder's "before" balance of a token. */
+export type BalanceLookup = (token: Address, holder: Address) => bigint;
+/**
+ * Multicall pool-operation flow, used where `eth_simulateV1` is unavailable or
+ * as a fallback alongside it.
+ *
+ * Reads the watched holders' "before" balances together with the matching
+ * ERC4626 preview (`previewDeposit`/`previewMint`/`previewWithdraw`/
+ * `previewRedeem`) in a single multicall, then computes the theoretical balance
+ * changes via {@link computePoolOpBalanceChanges}.
+ *
+ * Unlike the `eth_simulateV1` flow it does not execute the calldata, so it
+ * cannot recover ERC-20 transfers (`transfers` is always `undefined`) and it
+ * ignores balance/allowance prerequisites (preview reads succeed regardless).
+ *
+ * @throws {@link PreviewSimulationError} when the multicall round-trip throws or
+ * any call (a balance read or the preview read) reverts.
+ */
+export declare function simulatePoolOpMulticall(input: PoolOperationSimulationInput, options?: OperationSimulationOptions): Promise<PoolOperationSimulationResult>;
+/**
+ * Pure computation of {@link AddressBalanceChanges} for a pool operation from
+ * its ERC4626 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/simulatePoolOpV1.d.ts

@@ -0,0 +1,14 @@
+import type { OperationSimulationOptions, PoolOperationSimulationInput, PoolOperationSimulationResult } from "./types.js";
+/**
+ * `eth_simulateV1` pool-operation flow.
+ *
+ * Sandwiches the raw calldata between `balanceOf` reads of the underlying and
+ * pool (share) tokens for every watched holder, then derives the balance changes
+ * from the before/after diff and the wallet-relevant ERC-20 transfers from the
+ * emitted logs. Simulation runs against real chain state (no overrides), so an
+ * unmet prerequisite surfaces here as a revert.
+ *
+ * @throws {@link PreviewSimulationError} when the round-trip throws or the
+ * simulated transaction reverts.
+ */
+export declare function simulatePoolOpV1(input: PoolOperationSimulationInput, options?: OperationSimulationOptions): Promise<PoolOperationSimulationResult>;

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

@@ -1,30 +1,8 @@
-import { type Address, type Hex } from "viem";
-import type { OnchainSDK } from "../../sdk/index.js";
-import type { PoolOperation } from "../parse/index.js";
-import type { PoolSimulationResult } from "./types.js";
-export interface SimulatePoolOperationInput {
-    /** Only `client` is 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/redeem calldata to simulate. */
-    calldata: Hex;
-    /** Wallet whose balance changes and transfers we track. */
-    wallet: Address;
-    /** Block to simulate at; defaults to latest. Only set for testnet forks. */
-    blockNumber?: bigint;
-}
+import type { OperationSimulationOptions, PoolOperationSimulation, PoolOperationSimulationInput } from "./types.js";
 /**
- * Simulates a pool deposit/redeem by sandwiching the raw calldata between
- * `balanceOf(wallet)` reads of the underlying and pool (share) tokens.
+ * Simulates a pool deposit/mint/withdraw/redeem and returns the resulting
+ * balance changes (and, when available, ERC-20 transfers), or a decoded failure.
  *
- * On success, returns the ERC-20 transfers emitted by the call that involve the
- * wallet or the operation recipient (for merging into the parsed operation) and
- * the balance changes grouped by watched address (wallet, plus the recipient
- * when distinct); on revert, returns the decoded reason. Simulation runs against
- * real chain state (no overrides), so an unmet prerequisite surfaces here as a
- * failure.
+ * @throws {@link PreviewSimulationError} when the simulation fails.
  */
-export declare function simulatePoolOperation(input: SimulatePoolOperationInput): Promise<PoolSimulationResult>;
+export declare function simulatePoolOperation(input: PoolOperationSimulationInput, options?: OperationSimulationOptions): Promise<PoolOperationSimulation>;

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

@@ -1,5 +1,8 @@
-import type { Address } from "viem";
-import type { TokenTransfer } from "../../plugins/adapters/index.js";
+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 { 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).
@@ -19,25 +22,58 @@ export interface AddressBalanceChanges {
     address: Address;
     changes: TokenBalanceChange[];
 }
-/** Decoded revert of the simulated transaction. */
-export interface SimulationError {
-    /** Human-readable revert reason / error name. */
-    reason: string;
-    /** Original error, kept for debugging. */
-    cause?: unknown;
+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;
+    /** Wallet whose balance changes and transfers we track. */
+    wallet: Address;
+}
+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.
+     **/
+    logger?: ILogger;
 }
 /**
- * Outcome of simulating a pool operation. On success it carries the
- * wallet-filtered ERC-20 transfers (to merge into the parsed operation) and the
- * balance changes grouped by watched address; on failure it carries the decoded
- * revert reason.
+ * 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.
  */
-export type PoolSimulationResult = {
-    status: "success";
-    transfers: TokenTransfer[];
+export interface PoolOperationSimulationResult {
+    /**
+     * Balance changes grouped by watched address (wallet, recipient, owner).
+     **/
     balanceChanges: AddressBalanceChanges[];
-    gasUsed: bigint;
-} | {
+    /**
+     * 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
+ * {@link PoolOperationSimulationResult}; on failure it carries a
+ * {@link PreviewSimulationError}.
+ */
+export type PoolOperationSimulation = ({
+    status: "success";
+} & PoolOperationSimulationResult) | {
     status: "failure";
-    error: SimulationError;
+    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
@@ -25,8 +24,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/rewards/rewards/api.d.ts

@@ -26,10 +26,11 @@ export interface GetLmRewardsMerkleProps {
     account: Address;
     network: NetworkType;
     reportError?: ReportHandler;
+    apiKey?: string;
 }
 export declare class RewardAmountAPI {
     private constructor();
-    static getLmRewardsMerkle({ pools, account, network, reportError, }: GetLmRewardsMerkleProps): Promise<GearboxExtraMerkleLmReward[]>;
+    static getLmRewardsMerkle({ pools, account, network, reportError, apiKey, }: GetLmRewardsMerkleProps): Promise<GearboxExtraMerkleLmReward[]>;
     private static extractFulfilled;
 }
 export {};

package/dist/types/rewards/rewards/merkl-api.d.ts

@@ -39,7 +39,8 @@ export declare class MerkleXYZApi {
     private constructor();
     static defaultDomain: string;
     static angleDomain: string;
-    static fetchWithFallback: <T>(getUrl: (domain: string) => string) => Promise<import("axios").AxiosResponse<T, any, {}>>;
+    static apiKeyHeader: string;
+    static fetchWithFallback: <T>(getUrl: (domain: string) => string, apiKey?: string) => Promise<import("axios").AxiosResponse<T, any, {}>>;
     static getUserRewardsUrl: (options: UserOptions) => (domain: string) => string;
 }
 export {};