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

package/dist/types/common-utils/utils/strategies/tokens/get-list-with-amount-in-target.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { Asset } from "../../../../sdk/router/types.js";
+import type { Asset } from "../../../../sdk/index.js";
 import type { TokenSlice } from "../strategy-info/types.js";
 export interface AddAmountInTargetProps<T> {
     assets: Array<T>;

package/dist/types/common-utils/utils/strategies/types/strategy-earnings.d.ts

@@ -1,4 +1,4 @@
-import type { Asset } from "../../../../sdk/router/types.js";
+import type { Asset } from "../../../../sdk/index.js";
 import type { calculateEarnings } from "../../apy/calculate-earnings.js";
 import type { Strategy } from "../../strategies/types/strategy.js";
 import type { calculateTotalAPY } from "../strategy-info/calculate-total-apy.js";

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

@@ -0,0 +1,73 @@
+import { type Address, type Hex } from "viem";
+/**
+ * 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[];
+}
+/**
+ * Selector of `CreditManagerV3.execute(bytes)` (`0x09c5eabe`).
+ *
+ * This is the authoritative marker of an adapter performing an external
+ * protocol call: the adapter calls the credit manager's `execute(bytes)`, which
+ * forwards the calldata to the credit account, which in turn CALLs the target
+ * (protocol) contract. Adapter approvals use a different selector
+ * (`execute(address,bytes)` on the credit account), so matching on this
+ * selector isolates the real protocol call.
+ */
+export declare const EXECUTE_BYTES_SELECTOR: "0x09c5eabe";
+/**
+ * Finds the shallowest non-reverted `CreditManager.execute(bytes)` call in a
+ * trace subtree (breadth-first), or `undefined` if none exists.
+ *
+ * "Shallowest" matters for account migration: a migrate adapter nests the
+ * entire target `openCreditAccount` multicall - including that account's own
+ * `execute(bytes)` calls - inside its subtree. The shallowest match is the
+ * adapter's own protocol call, not a nested one.
+ */
+export declare function findExecuteBytes(node: CallTrace): CallTrace | undefined;
+/**
+ * Finds the first non-reverted CALL in a subtree whose `input` exactly matches
+ * `input` (case-insensitive). Used to locate the leaf CALL to the target
+ * contract: `execute(bytes)` forwards the calldata unchanged through the credit
+ * account proxy DELEGATECALL down to the final CALL to the protocol contract.
+ */
+export declare function findCallWithInput(node: CallTrace, input: Hex): CallTrace | undefined;
+/**
+ * Resolves the external protocol call performed by an adapter-level call trace.
+ *
+ * Locates the shallowest `CreditManager.execute(bytes)`, decodes the forwarded
+ * calldata, then finds the leaf CALL whose input matches that calldata to
+ * recover the target (protocol) contract address. Returns `undefined` when the
+ * subtree does not actually reach an external protocol CALL (e.g. the
+ * facade-internal `depositPhantomToken` / `withdrawPhantomToken` accounting
+ * calls, which forward calldata but make no external CALL).
+ *
+ * @param node - direct child node of the upper-level facade call trace
+ */
+export declare function resolveProtocolCall(node: CallTrace): {
+    contract: Address;
+    calldata: Hex;
+} | undefined;
+/**
+ * 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/common-utils/utils/validation/validate-balances.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { Asset } from "../../../sdk/router/types.js";
+import type { Asset } from "../../../sdk/index.js";
 import type { ValidateBalanceResult } from "./validate-balance.js";
 export interface ValidateBalancesProps {
     balances: Record<Address, bigint>;

package/dist/types/common-utils/utils/validation/validate-open-account.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { Asset } from "../../../sdk/router/types.js";
+import type { Asset } from "../../../sdk/index.js";
 import type { CreditManagerSlice } from "../strategies/strategy-info/types.js";
 import type { ValidateQuotaResult } from "./validate-quota.js";
 export interface ValidateOpenAccountProps {

package/dist/types/common-utils/utils/validation/validate-quota.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { Asset } from "../../../sdk/router/types.js";
+import type { Asset } from "../../../sdk/index.js";
 import type { CreditManagerSlice } from "../strategies/strategy-info/types.js";
 export interface ValidateQuotaProps {
     desiredQuota: Record<Address, Asset>;

package/dist/types/common-utils/utils/validation/validate-token-to-obtain.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { Asset } from "../../../sdk/router/types.js";
+import type { Asset } from "../../../sdk/index.js";
 export interface ValidateTokenToObtainProps {
     targetToken: Address | Array<Asset> | null;
     creditManager: {

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

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

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

@@ -0,0 +1,24 @@
+import type { Address, PublicClient } from "viem";
+/**
+ * Address is stable, contract deployed via create2
+ */
+export declare const ONCHAIN_EXECUTION_ID_ADDRESS: Address;
+export type VerifyTestnetParams = {
+    executionId: string;
+} | {
+    alias: string;
+} | {
+    executionId: string;
+    alias: string;
+};
+/**
+ * Tries to read the contract that is deployed on every Gearbox testnet
+ * and verify that we're on expected testnet.
+ *
+ * Used to check that wallet is using correct RPC for the testnet.
+ *
+ * @param client - Public client
+ * @param expected - Expected tesnet alias or execution id
+ * @returns True if we're on expected testnet
+ */
+export declare function verifyTestnet(client: PublicClient, expected: VerifyTestnetParams): Promise<boolean>;

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

@@ -1,11 +1,16 @@
 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 { WithdrawCollateralEventInfo } from "./extractTransfers.js";
-import type { ExecuteResult, FacadeParsedCall } from "./internal-types.js";
-import type { FacadeOperationMetadata, OuterFacadeOperation } from "./types.js";
+import type { HistoryFacadeMetadata, OuterFacadeOperation } from "./types.js";
 export interface AssembleOperationsInput {
     facadeCalls: FacadeParsedCall[];
-    executeResults: ExecuteResult[];
+    /**
+     * 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[][];
     register: ChainContractsRegister;
     underlying: Address;
     liquidationRemainingFunds?: bigint;
@@ -17,8 +22,8 @@ export interface AssembleOperationsInput {
  * Combines parsed facade calls with per-Execute transfer data into
  * fully classified {@link OuterFacadeOperation} entries.
  *
- * The flat `executeResults` array (one entry per Execute event across
+ * The flat `executeTransfers` array (one inner array 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 FacadeOperationMetadata>[];
+export declare function assembleOperations(input: AssembleOperationsInput): Omit<OuterFacadeOperation, keyof HistoryFacadeMetadata>[];

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

@@ -1,12 +1,23 @@
-import { type Address, type Hex } from "viem";
+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 { AddressMap, ChainContractsRegister, ParsedCallV2 } from "../sdk/index.js";
-import type { WithdrawCollateralEventInfo } from "./extractTransfers.js";
-import type { InnerOperation } from "./inner-operations.js";
-import type { ExecuteResult } from "./internal-types.js";
+import type { InnerOperation } from "./types.js";
 export interface ClassifyMulticallOperationsInput {
     innerCalls: ParsedCallV2[];
-    executeResults: ExecuteResult[];
-    protocolCalldatas: Hex[];
+    /**
+     * 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[];
     register: ChainContractsRegister;
     creditAccount: Address;
     underlying: Address;
@@ -17,9 +28,10 @@ export interface ClassifyMulticallOperationsInput {
 /**
  * Classifies each multicall inner call into a {@link InnerOperation}:
  *
- * - **Adapter calls** (target registered as an adapter): delegates to
- *   `adapter.parseAdapterOperation()` and consumes the next entry from
- *   `executeTransfers` (one Execute event per adapter call).
+ * - **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).
  *
  * - **Facade self-calls** (`increaseDebt`, `updateQuota`, etc.): mapped
  *   directly from `functionName` / `rawArgs`. No transfer consumed.

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

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

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

@@ -1,18 +1,16 @@
-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";
+import type { AdapterOperation, AddCollateralOp, CloseCreditAccountOperation, CreditAccountOperation, DecreaseDebtOp, DirectTokenTransferOperation, HistoryFacadeMetadata, IncreaseDebtOp, LiquidateCreditAccountOperation, MulticallOperation, OpenCreditAccountOperation, PartialLiquidationOperation, UpdateQuotaOp, WithdrawCollateralOp } 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: 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;
+    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;
     DirectTokenTransfer(op: DirectTokenTransferOperation): TOuter;
     MultiCall(op: MulticallOperation, multicall: TInner[]): TOuter;
     OpenCreditAccount(op: OpenCreditAccountOperation, multicall: TInner[]): TOuter;

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

@@ -1,77 +1,28 @@
-import type { Address, Hex } from "viem";
-import type { InnerOperation } from "./inner-operations.js";
+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";
 /**
- * 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.
+ * 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`.
  */
-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;
-}
+export type HistoryAdapterExt = TraceAdapterExt & {
+    legacy: LegacyAdapterOperation;
+};
 /**
- * Discriminated union of all facade-level operation types.
- * One per facade entry-point call within a transaction.
+ * 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.
  */
+export type HistoryFacadeMetadata = FacadeOperationMetadata & OperationMetadata;
+export type AdapterOperation = BaseAdapterOperation<HistoryAdapterExt>;
+export type InnerOperation = BaseInnerOperation<HistoryAdapterExt>;
+export type MulticallOperation = BaseMulticallOperation<HistoryAdapterExt> & OperationMetadata;
+export type OpenCreditAccountOperation = BaseOpenCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
+export type CloseCreditAccountOperation = BaseCloseCreditAccountOperation<HistoryAdapterExt> & OperationMetadata;
+export type LiquidateCreditAccountOperation = BaseLiquidateCreditAccountOperation<HistoryAdapterExt> & 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;

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

@@ -0,0 +1,204 @@
+/**
+ * Local copy of the Convex V1 Booster adapter ABI.
+ *
+ * The ABI published by `@gearbox-protocol/integrations-v3` is generated from
+ * `IConvexV1BoosterAdapter.sol`, which declares `depositDiff`/`withdrawDiff`
+ * args as `(leftoverAmount, _pid, ...)`, while the deployed implementation
+ * (`ConvexV1_Booster.sol`) — and the calldata encoded by the router — uses
+ * `(_pid, leftoverAmount, ...)`. Selectors only depend on types, so encoding
+ * works on-chain, but decoding with the interface ABI yields swapped argument
+ * names. This copy fixes the argument order to match the implementation.
+ */
+export declare const iConvexV1BoosterAdapterAbi: readonly [{
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "contractType";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "creditManager";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_pid";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_stake";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "deposit";
+    readonly outputs: readonly [{
+        readonly name: "useSafePrices";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_pid";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "leftoverAmount";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "_stake";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly name: "depositDiff";
+    readonly outputs: readonly [{
+        readonly name: "useSafePrices";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "pidToConvexToken";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "pidToCurveToken";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "pidToPhantomToken";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "serialize";
+    readonly outputs: readonly [{
+        readonly name: "serializedData";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "targetContract";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "updateSupportedPids";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "version";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_pid";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "withdraw";
+    readonly outputs: readonly [{
+        readonly name: "useSafePrices";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_pid";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "leftoverAmount";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "withdrawDiff";
+    readonly outputs: readonly [{
+        readonly name: "useSafePrices";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "pid";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }];
+    readonly name: "AddSupportedPid";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "UnsupportedPidException";
+}];

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

@@ -1,5 +1,6 @@
 export * from "./actionAbi.js";
 export * from "./conctructorAbi.js";
+export * from "./iConvexV1BoosterAdapter.js";
 export * from "./securitize/index.js";
 export * from "./targetContractAbi.js";
 export * from "./utils.js";

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

@@ -1,8 +1,9 @@
-import { type Abi, type Address, type Hex, type PartialBy } from "viem";
-import type { ConstructOptions, ParsedCallV2, RelaxedBaseParams } from "../../../sdk/index.js";
+import { type Abi, type Address, type DecodeFunctionDataReturnType, type Hex } from "viem";
+import { type CallTrace } from "../../../common-utils/utils/trace.js";
+import type { AddressMap, AssetsMap, ConstructOptions, ParsedCallV2, RelaxedBaseParams } from "../../../sdk/index.js";
 import { BaseContract } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
-import type { AdapterContractStateHuman, AdapterContractType, AdapterOperation, TokenTransfer } from "../types.js";
+import type { AdapterContractStateHuman, AdapterContractType, AdapterProtocolOperation, DiffLeftover } from "../types.js";
 export interface ConcreteAdapterContractOptions {
     baseParams: RelaxedBaseParams;
 }
@@ -22,23 +23,37 @@ export declare class AbstractAdapterContract<const abi extends Abi | readonly un
     get adapterType(): AdapterContractType;
     stateHuman(raw?: boolean): AdapterContractStateHuman;
     /**
-     * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
+     * Decodes the protocol-level call (target contract + function name + args)
+     * performed by this adapter, recovered from its adapter-level call trace.
      *
-     * Returns `PartialBy<AdapterOperation, "targetContract">` because the adapter
-     * may not have `targetContract` (adapters created without SDK do not have serializedParams)
+     * Both the `targetContract` and the protocol calldata are taken from the
+     * execution trace.
      *
-     * @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
+     * Returns `undefined` (in non-strict mode) when no external protocol call can
+     * be recovered, in strict mode throws instead.
+     *
+     * @param trace Adapter-level call trace (a direct child of the facade trace)
+     * @param strict When true, throws instead of returning `undefined`
+     */
+    parseProtocolCall(trace: CallTrace, strict?: boolean): AdapterProtocolOperation | undefined;
+    /**
+     * Applies the balance changes implied by a router-generated diff-style
+     * adapter call to a map of credit-account token balances.
+     *
+     * @param balances - Token balances before the call. Mutated in place.
+     * @param calldata - Raw ABI-encoded adapter calldata.
+     * @throws When the calldata cannot be decoded or the adapter (or the
+     * specific function) has no balance-changes support.
      */
-    parseAdapterOperation(parsed: ParsedCallV2, transfers: TokenTransfer[], creditAccount: Address, protocolCalldata: Hex, strict?: boolean): PartialBy<AdapterOperation, "protocol">;
+    previewBalanceChanges(balances: AssetsMap, calldata: Hex): void;
     /**
-     * Decodes protocol-level function name and args from the raw calldata
-     * sent to targetContract.
+     * Resolves which tokens the diff-style call spends down to which leftovers.
+     *
+     * @param decoded - The viem-decoded adapter call
+     * @param _balances - Token balances before the call
+     * @throws When the adapter (or the specific function) has no balance-changes support
      */
-    protected parseProtocolCall(calldata: Hex, strict?: boolean): {
-        protocolFunctionName: string;
-        protocolArgs: Record<string, unknown>;
-    };
+    protected decodeDiffLeftovers(decoded: DecodeFunctionDataReturnType<abi>, _balances: AddressMap<bigint>): DiffLeftover[];
     /**
      * Classifies an adapter call into a {@link LegacyAdapterOperation} using the
      * parsed call and credit-account transfer deltas.
@@ -50,6 +65,8 @@ export declare class AbstractAdapterContract<const abi extends Abi | readonly un
      * 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
      */
-    protected classifyLegacyOperation(_parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    classifyLegacyOperation(_parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
 }