@gearbox-protocol/sdk 12.8.1 → 12.9.0-txparser.2

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

@@ -0,0 +1,29 @@
+import type { Address, TransactionReceipt } from "viem";
+import type { TokenInfo } from "../plugins/adapters/types.js";
+import type { ChainContractsRegister } from "../sdk/index.js";
+import type { CreditAccountOperation } from "./types.js";
+export interface ParseTransactionInput {
+    /**
+     * Output of `debug_traceTransaction`
+     */
+    trace: unknown;
+    receipt: Pick<TransactionReceipt<bigint | number>, "logs" | "transactionHash" | "blockNumber">;
+    pool: Address;
+    /**
+     * Underlying token of the pool.
+     */
+    underlying: Address;
+    creditFacade: Address;
+    creditAccount: Address;
+    register: ChainContractsRegister;
+    /**
+     * Whether to throw an error if an unknown adapter/protocol is encountered.
+     */
+    strict?: boolean;
+}
+/**
+ * Parses a single transaction into classified credit account operations.
+ * Token address fields are enriched with metadata (symbol, decimals) from
+ * `register.tokensMeta`.
+ */
+export declare function parseCreditAccountTransaction(input: ParseTransactionInput): CreditAccountOperation<TokenInfo>[];

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

@@ -0,0 +1,19 @@
+import { type Address, type Chain, type PublicClient, type Transport } from "viem";
+import { ChainContractsRegister, type ILogger, type TokenMetaData, TokensMeta } from "../sdk/index.js";
+export type Deployment = {
+    address: Address;
+    version: number;
+} & ({
+    contractTypePrefix: string;
+    contractTypeSuffix: string;
+} | {
+    contractType: string;
+});
+export interface PopulateContractsRegisterOptions {
+    client: PublicClient<Transport, Chain>;
+    deployments: Deployment[];
+    tokens: TokensMeta | Iterable<TokenMetaData>;
+    logger?: ILogger;
+    strict?: boolean;
+}
+export declare function populateContractsRegister(options: PopulateContractsRegisterOptions): ChainContractsRegister;

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

@@ -0,0 +1,35 @@
+import type { Hex } from "viem";
+import type { TokenInfo } from "../plugins/adapters/types.js";
+import type { CreditAccountOperation } from "./types.js";
+/**
+ * JSON-serializable representation of a top-level legacy API operation.
+ * Mirrors the shape returned by charts-server's `/operations` endpoint,
+ * but omits fields the new parser cannot produce (sessionId, timestamp,
+ * protocol on inner ops, initialFunds/userFunds/leverage).
+ */
+export interface LegacyApiOperation {
+    operation: string;
+    txHash: Hex;
+    blockNum: number;
+    [key: string]: unknown;
+}
+/**
+ * JSON-serializable representation of an inner multicall operation
+ * from the legacy API.
+ */
+export interface LegacyMulticallOp {
+    operation: string;
+    [key: string]: unknown;
+}
+/**
+ * Converts new parser output to the legacy API format for comparison.
+ *
+ * The returned objects use string amounts (not bigint) and `blockNum`
+ * (not `blockNumber`), matching the charts-server JSON shape.
+ *
+ * Fields that only exist in the old API and cannot be derived from the
+ * new parser output are omitted: `sessionId`, `timestamp`, `protocol`
+ * on all operations, and `initialFunds`/`userFunds`/`leverage` on
+ * OpenCreditAccount.
+ */
+export declare function toLegacyOperations(ops: CreditAccountOperation<TokenInfo>[]): LegacyApiOperation[];

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

@@ -0,0 +1,65 @@
+import type { Address, Hex } from "viem";
+import type { InnerOperation } from "./inner-operations.js";
+/**
+ * An ERC-20 Transfer to the credit account that was not part of any
+ * facade operation (multicall, liquidation, etc.).
+ */
+export interface DirectTransferInfo<TToken = Address> {
+    token: TToken;
+    from: Address;
+    amount: bigint;
+}
+export interface OperationMetadata {
+    txHash: Hex;
+    blockNumber: number;
+}
+export interface MulticallOperation<TToken = Address> extends OperationMetadata {
+    operation: "MultiCall" | "BotMulticall";
+    creditAccount: Address;
+    multicall: InnerOperation<TToken>[];
+}
+export interface OpenCreditAccountOperation<TToken = Address> extends OperationMetadata {
+    operation: "OpenCreditAccount";
+    creditAccount: Address;
+    onBehalfOf: Address;
+    referralCode: bigint;
+    multicall: InnerOperation<TToken>[];
+}
+export interface CloseCreditAccountOperation<TToken = Address> extends OperationMetadata {
+    operation: "CloseCreditAccount";
+    creditAccount: Address;
+    multicall: InnerOperation<TToken>[];
+}
+export interface LiquidateCreditAccountOperation<TToken = Address> extends OperationMetadata {
+    operation: "LiquidateCreditAccount";
+    creditAccount: Address;
+    to: Address;
+    token: TToken;
+    remainingFunds: bigint;
+    multicall: InnerOperation<TToken>[];
+}
+export interface PartialLiquidationOperation<TToken = Address> extends OperationMetadata {
+    operation: "PartiallyLiquidateCreditAccount";
+    creditAccount: Address;
+    token: TToken;
+    repaidAmount: bigint;
+    minSeizedAmount: bigint;
+    to: Address;
+}
+export interface DirectTokenTransferOperation<TToken = Address> extends OperationMetadata {
+    operation: "DirectTokenTransfer";
+    token: TToken;
+    from: 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<TToken = Address> = MulticallOperation<TToken> | OpenCreditAccountOperation<TToken> | CloseCreditAccountOperation<TToken> | LiquidateCreditAccountOperation<TToken> | PartialLiquidationOperation<TToken>;
+/**
+ * Discriminated union of all credit account operation types
+ * (facade operations + direct token transfers).
+ */
+export type CreditAccountOperation<TToken = Address> = OuterFacadeOperation<TToken> | DirectTokenTransferOperation<TToken>;

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

@@ -1,3 +1,4 @@
 export * from "./actionAbi.js";
 export * from "./conctructorAbi.js";
+export * from "./targetContractAbi.js";
 export * from "./utils.js";