@gearbox-protocol/sdk 14.11.0-next.8 → 14.11.0

package/dist/esm/plugins/adapters/contracts/AbstractAdapter.js

@@ -3,16 +3,13 @@ import {
   decodeFunctionData,
   zeroAddress
 } from "viem";
-import {
-  resolveProtocolCall
-} from "../../../common-utils/utils/trace.js";
 import {
   BaseContract,
   functionArgsToRecord,
   getFunctionSignature,
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
-import { swapFromTransfers } from "../transferHelpers.js";
+import { swapFromTransfers, toNetTransfers } from "../transferHelpers.js";
 class AbstractAdapterContract extends BaseContract {
   #targetContract;
   #creditManager;
@@ -53,33 +50,45 @@ class AbstractAdapterContract extends BaseContract {
     };
   }
   /**
-   * Decodes the protocol-level call (target contract + function name + args)
-   * performed by this adapter, recovered from its adapter-level call trace.
-   *
-   * Both the `targetContract` and the protocol calldata are taken from the
-   * execution trace.
+   * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
    *
-   * Returns `undefined` (in non-strict mode) when no external protocol call can
-   * be recovered, in strict mode throws instead.
+   * Returns `PartialBy<AdapterOperation, "targetContract">` because the adapter
+   * may not have `targetContract` (adapters created without SDK do not have serializedParams)
    *
-   * @param trace Adapter-level call trace (a direct child of the facade trace)
-   * @param strict When true, throws instead of returning `undefined`
+   * @param protocolCalldata Raw calldata of the actual CALL to targetContract, extracted from trace
+   * @param strict When true, throws if protocol ABI is missing or decode fails
    */
-  parseProtocolCall(trace, strict) {
-    const resolved = resolveProtocolCall(trace);
-    if (!resolved) {
-      if (strict) {
-        throw new Error("no external protocol call found in adapter trace");
-      }
-      return void 0;
-    }
-    const { contract, calldata } = resolved;
+  parseAdapterOperation(parsed, transfers, creditAccount, protocolCalldata, strict) {
+    const netTransfers = toNetTransfers(transfers, creditAccount);
+    const protocol = this.parseProtocolCall(protocolCalldata, strict);
+    return {
+      operation: "Execute",
+      adapter: this.address,
+      protocol: this.#targetContract,
+      adapterType: this.adapterType,
+      version: this.version,
+      label: parsed.label,
+      adapterFunctionName: parsed.functionName,
+      adapterArgs: parsed.rawArgs,
+      ...protocol,
+      transfers,
+      legacy: this.classifyLegacyOperation(parsed, netTransfers)
+    };
+  }
+  /**
+   * Decodes protocol-level function name and args from the raw calldata
+   * sent to targetContract.
+   */
+  parseProtocolCall(calldata, strict) {
     const selector = calldata.slice(0, 10);
     if (this.protocolAbi.length === 0) {
       if (strict) {
         throw new Error(`Protocol ABI is missing for selector ${selector}`);
       }
-      return void 0;
+      return {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
     }
     try {
       const decoded = decodeFunctionData({
@@ -87,12 +96,12 @@ class AbstractAdapterContract extends BaseContract {
         data: calldata
       });
       const functionName = getFunctionSignature(this.protocolAbi, calldata);
-      const functionArgs = functionArgsToRecord(
+      const protocolArgs = functionArgsToRecord(
         this.protocolAbi,
         decoded.functionName,
         decoded.args
       );
-      return { contract, functionName, functionArgs };
+      return { protocolFunctionName: functionName, protocolArgs };
     } catch (e) {
       if (strict) {
         throw new Error(
@@ -100,7 +109,10 @@ class AbstractAdapterContract extends BaseContract {
           { cause: e }
         );
       }
-      return void 0;
+      return {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
     }
   }
   /**
@@ -114,8 +126,6 @@ class AbstractAdapterContract extends BaseContract {
    * Override in protocol-specific subclasses for richer classification.
    *
    * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/account_operation.go#L238-L264
-   *
-   * @deprecated Eventually will be gone, exists to produce output that legacy UI can display
    */
   classifyLegacyOperation(_parsed, transfers) {
     const swap = swapFromTransfers(transfers);

package/dist/esm/plugins/adapters/contracts/AccountMigratorAdapterContract.js

@@ -12,15 +12,6 @@ class AccountMigratorAdapterContract extends AbstractAdapterContract {
       `classifyLegacyOperation is not supported for legacy adapter: ${this.contractType}`
     );
   }
-  /**
-   * The account-migrator adapter's `execute` targets the migrator bot, not an
-   * external protocol, so there is no protocol-level call to recover. Returning
-   * `undefined` keeps the `protocol` field aligned with its external-protocol
-   * semantics (see {@link TraceAdapterExt}).
-   */
-  parseProtocolCall(_trace, _strict) {
-    return void 0;
-  }
 }
 export {
   AccountMigratorAdapterContract

package/dist/esm/rewards/rewards/api.js

@@ -11,7 +11,8 @@ class RewardAmountAPI {
     pools,
     account,
     network,
-    reportError
+    reportError,
+    apiKey
   }) {
     const [merkleXYZLMResponse] = await Promise.allSettled([
       MerkleXYZApi.fetchWithFallback(
@@ -20,7 +21,8 @@ class RewardAmountAPI {
             chainId: chains[network].id,
             user: getAddress(account)
           }
-        })
+        }),
+        apiKey
       )
     ]);
     const merkleXYZLm = RewardAmountAPI.extractFulfilled(

package/dist/esm/rewards/rewards/merkl-api.js

@@ -4,11 +4,17 @@ class MerkleXYZApi {
   }
   static defaultDomain = "https://api.merkl.xyz";
   static angleDomain = "https://api-merkl.angle.money";
-  static fetchWithFallback = async (getUrl) => {
+  static apiKeyHeader = "X-API-Key";
+  static fetchWithFallback = async (getUrl, apiKey) => {
+    const headers = apiKey ? { [MerkleXYZApi.apiKeyHeader]: apiKey } : void 0;
     try {
-      return await axios.get(getUrl(MerkleXYZApi.defaultDomain));
+      return await axios.get(getUrl(MerkleXYZApi.defaultDomain), {
+        headers
+      });
     } catch {
-      return await axios.get(getUrl(MerkleXYZApi.angleDomain));
+      return await axios.get(getUrl(MerkleXYZApi.angleDomain), {
+        headers
+      });
     }
   };
   static getUserRewardsUrl = (options) => (domain) => `${domain}/v4/users/${options.params.user}/rewards?chainId=${options.params.chainId}`;

package/dist/types/common-utils/utils/index.d.ts

@@ -5,5 +5,4 @@ export * from "./constants.js";
 export * from "./creditAccount/index.js";
 export * from "./price-math.js";
 export * from "./strategies/index.js";
-export * from "./trace.js";
 export * from "./validation/index.js";

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

@@ -19,4 +19,3 @@ export * from "./replaceStorage.js";
 export * from "./resilientTransport.js";
 export * from "./transports.js";
 export * from "./types.js";
-export * from "./verifyTestnet.js";

package/dist/types/history/assembleOperations.d.ts

@@ -1,16 +1,11 @@
 import type { Address } from "viem";
-import type { TokenTransfer } from "../preview/parse/index.js";
-import { type FacadeParsedCall, type WithdrawCollateralEventInfo } from "../preview/trace/index.js";
 import type { AddressMap, ChainContractsRegister } from "../sdk/index.js";
-import type { HistoryFacadeMetadata, OuterFacadeOperation } from "./types.js";
+import type { WithdrawCollateralEventInfo } from "./extractTransfers.js";
+import type { ExecuteResult, FacadeParsedCall } from "./internal-types.js";
+import type { FacadeOperationMetadata, OuterFacadeOperation } from "./types.js";
 export interface AssembleOperationsInput {
     facadeCalls: FacadeParsedCall[];
-    /**
-     * ERC-20 transfers grouped per facade `Execute` event, one inner array per
-     * Execute event across the whole transaction, in emission order. Sliced per
-     * facade call and consumed one inner array per adapter/unknown inner call.
-     */
-    executeTransfers: TokenTransfer[][];
+    executeResults: ExecuteResult[];
     register: ChainContractsRegister;
     underlying: Address;
     liquidationRemainingFunds?: bigint;
@@ -22,8 +17,8 @@ export interface AssembleOperationsInput {
  * Combines parsed facade calls with per-Execute transfer data into
  * fully classified {@link OuterFacadeOperation} entries.
  *
- * The flat `executeTransfers` array (one inner array per Execute event across
+ * The flat `executeResults` array (one entry per Execute event across
  * the entire transaction) is sliced per facade call based on how many
  * adapter/unknown inner calls each one contains.
  */
-export declare function assembleOperations(input: AssembleOperationsInput): Omit<OuterFacadeOperation, keyof HistoryFacadeMetadata>[];
+export declare function assembleOperations(input: AssembleOperationsInput): Omit<OuterFacadeOperation, keyof FacadeOperationMetadata>[];

package/dist/types/history/classifyMulticallOperations.d.ts

@@ -1,23 +1,12 @@
-import { type Address } from "viem";
-import type { CallTrace } from "../common-utils/utils/trace.js";
-import type { TokenTransfer } from "../preview/parse/index.js";
-import { type WithdrawCollateralEventInfo } from "../preview/trace/index.js";
+import { type Address, type Hex } from "viem";
 import type { AddressMap, ChainContractsRegister, ParsedCallV2 } from "../sdk/index.js";
-import type { InnerOperation } from "./types.js";
+import type { WithdrawCollateralEventInfo } from "./extractTransfers.js";
+import type { InnerOperation } from "./inner-operations.js";
+import type { ExecuteResult } from "./internal-types.js";
 export interface ClassifyMulticallOperationsInput {
     innerCalls: ParsedCallV2[];
-    /**
-     * ERC-20 transfers grouped per facade `Execute` event for this facade call,
-     * one inner array per Execute event, in order. One inner array is consumed
-     * per adapter/unknown inner call.
-     */
-    executeTransfers: TokenTransfer[][];
-    /**
-     * Adapter-level call traces (one per Execute event, in order) used to recover
-     * the protocol-level call for adapter inner calls. See
-     * `extractAdapterCallTraces`.
-     */
-    adapterTraces: CallTrace[];
+    executeResults: ExecuteResult[];
+    protocolCalldatas: Hex[];
     register: ChainContractsRegister;
     creditAccount: Address;
     underlying: Address;
@@ -28,10 +17,9 @@ export interface ClassifyMulticallOperationsInput {
 /**
  * Classifies each multicall inner call into a {@link InnerOperation}:
  *
- * - **Adapter calls** (target registered as an adapter): decodes the
- *   protocol-level call via `adapter.parseProtocolCall()`, classifies the
- *   legacy operation via `adapter.classifyLegacyOperation()`, and consumes the
- *   next entry from `executeTransfers` (one Execute event per adapter call).
+ * - **Adapter calls** (target registered as an adapter): delegates to
+ *   `adapter.parseAdapterOperation()` and consumes the next entry from
+ *   `executeTransfers` (one Execute event per adapter call).
  *
  * - **Facade self-calls** (`increaseDebt`, `updateQuota`, etc.): mapped
  *   directly from `functionName` / `rawArgs`. No transfer consumed.

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

@@ -9,6 +9,16 @@ 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/history/extractProtocolCalls.d.ts

@@ -0,0 +1,8 @@
+import type { Hex } from "viem";
+import type { CallTrace, ExecuteResult } from "./internal-types.js";
+/**
+ * Extracts calldata sent to target contract for each Execute event.
+ *
+ * @returns
+ */
+export declare function extractProtocolCalls(facadeTrace: CallTrace, executeResults: ExecuteResult[]): Hex[];

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

@@ -1,6 +1,7 @@
 import { type Address, type Log } from "viem";
-import { AddressMap } from "../../sdk/index.js";
-import type { TokenTransfer } from "../parse/index.js";
+import { AddressMap } from "../sdk/index.js";
+import type { ExecuteResult } from "./internal-types.js";
+import type { DirectTransferInfo } from "./types.js";
 type RawLog = Log<bigint | number, number, false>;
 /**
  * Effective `withdrawCollateral` outcome decoded from the facade's
@@ -17,25 +18,16 @@ export interface WithdrawCollateralEventInfo {
 }
 /**
  * Extracts per-adapter-call token balance changes and detects direct
- * incoming transfers to the credit account.
+ * transfers into and out of the credit account (deposits and withdrawals
+ * performed independently of the facade).
  *
  * @param logs - raw viem Log[] from transaction receipt, sorted by logIndex
  * @param facadeAddress - the credit facade address (sole boundary event source)
  * @param creditAccount - the credit account address to track
  */
 export interface ExtractTransfersResult {
-    /**
-     * 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[];
+    executeResults: ExecuteResult[];
+    directTransfers: DirectTransferInfo[];
     liquidationRemainingFunds?: bigint;
     /** Maps phantom token address to its deposited (underlying) token address. */
     phantomTokens: AddressMap<Address>;

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

@@ -1,7 +1,6 @@
 import { type Address } from "viem";
-import { type CallTrace } from "../../common-utils/utils/trace.js";
-import type { ChainContractsRegister } from "../../sdk/index.js";
-import type { FacadeParsedCall } from "./types.js";
+import type { ChainContractsRegister } from "../sdk/index.js";
+import type { CallTrace, FacadeParsedCall } from "./internal-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/history/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./inner-operations.js";
 export * from "./mapOperations.js";
 export { parseCreditAccountTransaction } from "./parseCreditAccountTransaction.js";
 export * from "./populateContractsRegister.js";

package/dist/types/history/inner-operations.d.ts

@@ -0,0 +1,57 @@
+import type { Address } from "viem";
+import type { AdapterOperation } from "../plugins/adapters/index.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;
+}
+/**
+ * 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;
+/**
+ * All operations that can happen within a CreditFacade's multicall and that we're interested in.
+ */
+export type InnerOperation = AdapterOperation | InnerFacadeOperation;

package/dist/types/history/internal-types.d.ts

@@ -0,0 +1,47 @@
+import type { Address, Hex } from "viem";
+import type { TokenTransfer } from "../plugins/adapters/index.js";
+import type { ParsedCallV2 } from "../sdk/index.js";
+/**
+ * A single frame from Ethereum's `debug_traceTransaction` callTracer output.
+ * Recursive: each frame may contain nested sub-calls.
+ */
+export interface CallTrace {
+    from: Address;
+    to: Address;
+    input: Hex;
+    output: Hex;
+    value: Hex;
+    /** "CALL", "DELEGATECALL", "STATICCALL", "CREATE", etc. */
+    type: string;
+    /** Present when the call reverted (e.g. "execution reverted"). */
+    error?: string;
+    /** ABI-encoded revert data, if available. */
+    revertReason?: Hex;
+    calls?: CallTrace[];
+}
+/**
+ * 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;
+}
+/**
+ * Data extracted from a single Execute event: the ERC-20 transfers that
+ * occurred between Execute boundaries and the target contract address.
+ */
+export interface ExecuteResult {
+    transfers: TokenTransfer[];
+    targetContract: Address;
+}

package/dist/types/history/mapOperations.d.ts

@@ -1,16 +1,18 @@
-import type { AdapterOperation, AddCollateralOp, CloseCreditAccountOperation, CreditAccountOperation, DecreaseDebtOp, DirectTokenTransferOperation, HistoryFacadeMetadata, IncreaseDebtOp, LiquidateCreditAccountOperation, MulticallOperation, OpenCreditAccountOperation, PartialLiquidationOperation, UpdateQuotaOp, WithdrawCollateralOp } from "./types.js";
+import type { AdapterOperation } from "../plugins/adapters/index.js";
+import type { AddCollateralOp, DecreaseDebtOp, IncreaseDebtOp, UpdateQuotaOp, WithdrawCollateralOp } from "./inner-operations.js";
+import type { CloseCreditAccountOperation, CreditAccountOperation, DirectTokenTransferOperation, FacadeOperationMetadata, LiquidateCreditAccountOperation, MulticallOperation, OpenCreditAccountOperation, PartialLiquidationOperation } from "./types.js";
 /**
  * Visitor that maps each operation node in a {@link CreditAccountOperation}
  * tree to a new representation.
  *
  */
 export interface OperationVisitor<TInner, TOuter> {
-    Execute(op: AdapterOperation, ctx: HistoryFacadeMetadata): TInner;
-    IncreaseBorrowedAmount(op: IncreaseDebtOp, ctx: HistoryFacadeMetadata): TInner;
-    DecreaseBorrowedAmount(op: DecreaseDebtOp, ctx: HistoryFacadeMetadata): TInner;
-    AddCollateral(op: AddCollateralOp, ctx: HistoryFacadeMetadata): TInner;
-    WithdrawCollateral(op: WithdrawCollateralOp, ctx: HistoryFacadeMetadata): TInner;
-    UpdateQuota(op: UpdateQuotaOp, ctx: HistoryFacadeMetadata): TInner;
+    Execute(op: AdapterOperation, ctx: FacadeOperationMetadata): TInner;
+    IncreaseBorrowedAmount(op: IncreaseDebtOp, ctx: FacadeOperationMetadata): TInner;
+    DecreaseBorrowedAmount(op: DecreaseDebtOp, ctx: FacadeOperationMetadata): TInner;
+    AddCollateral(op: AddCollateralOp, ctx: FacadeOperationMetadata): TInner;
+    WithdrawCollateral(op: WithdrawCollateralOp, ctx: FacadeOperationMetadata): TInner;
+    UpdateQuota(op: UpdateQuotaOp, ctx: FacadeOperationMetadata): TInner;
     DirectTokenTransfer(op: DirectTokenTransferOperation): TOuter;
     MultiCall(op: MulticallOperation, multicall: TInner[]): TOuter;
     OpenCreditAccount(op: OpenCreditAccountOperation, multicall: TInner[]): TOuter;

package/dist/types/history/trace-utils.d.ts

@@ -0,0 +1,12 @@
+import { type Address } from "viem";
+import type { CallTrace } from "./internal-types.js";
+/**
+ * Finds the first non-reverted CALL to `target` anywhere in a trace subtree.
+ */
+export declare function findCallTo(node: CallTrace, target: Address): CallTrace | undefined;
+/**
+ * DFS walk of the call trace tree, collecting non-reverted CALL entries
+ * to the given address.
+ * Does not recurse into children of matched nodes
+ */
+export declare function collectTraces(node: CallTrace, target: Address): CallTrace[];

package/dist/types/history/types.d.ts

@@ -1,28 +1,77 @@
-import type { LegacyAdapterOperation } from "../plugins/adapters/index.js";
-import type { AdapterOperation as BaseAdapterOperation, CloseCreditAccountOperation as BaseCloseCreditAccountOperation, DirectTokenTransferOperation as BaseDirectTokenTransferOperation, InnerOperation as BaseInnerOperation, LiquidateCreditAccountOperation as BaseLiquidateCreditAccountOperation, MulticallOperation as BaseMulticallOperation, OpenCreditAccountOperation as BaseOpenCreditAccountOperation, PartialLiquidationOperation as BasePartialLiquidationOperation, FacadeOperationMetadata, OperationMetadata, TraceAdapterExt } from "../preview/parse/index.js";
-export type { AddCollateralOp, DecreaseDebtOp, FacadeOperationMetadata, IncreaseDebtOp, InnerFacadeOperation, OperationMetadata, UpdateQuotaOp, WithdrawCollateralOp, } from "../preview/parse/index.js";
+import type { Address, Hex } from "viem";
+import type { InnerOperation } from "./inner-operations.js";
 /**
- * History-specific adapter-operation extension: trace-derived data
- * ({@link TraceAdapterExt}) plus the backward-compatible `legacy` classification
- * used by charts_server serialization. The `legacy` field lives only in
- * `history`; the base `preview` operations carry no `legacy`.
+ * An ERC-20 Transfer into or out of the credit account that was not part of
+ * any facade operation (multicall, liquidation, etc.).
+ *
+ * `from`/`to` are the raw transfer endpoints: an inbound transfer (manual
+ * top-up / deposit) has `to` == the credit account, an outbound transfer
+ * (direct withdrawal) has `from` == the credit account.
  */
-export type HistoryAdapterExt = TraceAdapterExt & {
-    legacy: LegacyAdapterOperation;
-};
+export interface DirectTransferInfo {
+    token: Address;
+    from: Address;
+    to: Address;
+    amount: bigint;
+}
+export interface OperationMetadata {
+    txHash: Hex;
+    blockNumber: number;
+    timestamp: number;
+}
+export interface FacadeOperationMetadata extends OperationMetadata {
+    creditManager: Address;
+    creditFacade: Address;
+}
+export interface MulticallOperation extends FacadeOperationMetadata {
+    operation: "MultiCall" | "BotMulticall";
+    creditAccount: Address;
+    multicall: InnerOperation[];
+}
+export interface OpenCreditAccountOperation extends FacadeOperationMetadata {
+    operation: "OpenCreditAccount";
+    creditAccount: Address;
+    onBehalfOf: Address;
+    referralCode: bigint;
+    multicall: InnerOperation[];
+}
+export interface CloseCreditAccountOperation extends FacadeOperationMetadata {
+    operation: "CloseCreditAccount";
+    creditAccount: Address;
+    multicall: InnerOperation[];
+}
+export interface LiquidateCreditAccountOperation extends FacadeOperationMetadata {
+    operation: "LiquidateCreditAccount";
+    creditAccount: Address;
+    to: Address;
+    token: Address;
+    remainingFunds: bigint;
+    multicall: InnerOperation[];
+}
+export interface PartialLiquidationOperation extends FacadeOperationMetadata {
+    operation: "PartiallyLiquidateCreditAccount";
+    creditAccount: Address;
+    token: Address;
+    repaidAmount: bigint;
+    minSeizedAmount: bigint;
+    to: Address;
+}
+export interface DirectTokenTransferOperation extends OperationMetadata {
+    operation: "DirectTokenTransfer";
+    protocol: Address;
+    token: Address;
+    from: Address;
+    to: Address;
+    creditAccount: Address;
+    amount: bigint;
+}
 /**
- * Facade context available in `history` mode: the base facade metadata
- * (`creditManager`/`creditFacade`) plus the transaction-level
- * {@link OperationMetadata} that is only known once the transaction is mined.
+ * Discriminated union of all facade-level operation types.
+ * One per facade entry-point call within a transaction.
  */
-export type HistoryFacadeMetadata = FacadeOperationMetadata & OperationMetadata;
-export type AdapterOperation = BaseAdapterOperation<HistoryAdapterExt>;
-export type InnerOperation = BaseInnerOperation<HistoryAdapterExt>;
-export type MulticallOperation = Omit<BaseMulticallOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type OpenCreditAccountOperation = Omit<BaseOpenCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type CloseCreditAccountOperation = Omit<BaseCloseCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type LiquidateCreditAccountOperation = Omit<BaseLiquidateCreditAccountOperation<HistoryAdapterExt>, "expectedBalanceChanges"> & OperationMetadata;
-export type PartialLiquidationOperation = BasePartialLiquidationOperation & OperationMetadata;
-export type DirectTokenTransferOperation = BaseDirectTokenTransferOperation & OperationMetadata;
 export type OuterFacadeOperation = MulticallOperation | OpenCreditAccountOperation | CloseCreditAccountOperation | LiquidateCreditAccountOperation | PartialLiquidationOperation;
+/**
+ * Discriminated union of all credit account operation types
+ * (facade operations + direct token transfers).
+ */
 export type CreditAccountOperation = OuterFacadeOperation | DirectTokenTransferOperation;