@gearbox-protocol/sdk 14.12.0-next.6 → 14.12.0-next.8

package/dist/esm/preview/preview/errors.js

@@ -1,3 +1,17 @@
+class InvalidTransactionValueError extends Error {
+  /** Transaction `msg.value`. */
+  value;
+  /** Amount of wrapped native token added as collateral. */
+  wethCollateral;
+  constructor(value, wethCollateral) {
+    super(
+      `transaction value ${value} exceeds WETH collateral ${wethCollateral}`
+    );
+    this.name = "InvalidTransactionValueError";
+    this.value = value;
+    this.wethCollateral = wethCollateral;
+  }
+}
 class UnsupportedOperationError extends Error {
   /** The parsed operation kind (the `operation` discriminant). */
   operation;
@@ -8,5 +22,6 @@ class UnsupportedOperationError extends Error {
   }
 }
 export {
+  InvalidTransactionValueError,
   UnsupportedOperationError
 };

package/dist/esm/preview/preview/extractExpectedBalanceChanges.js

@@ -1,20 +1,42 @@
 function extractExpectedBalanceChanges(innerCalls) {
-  const calls = innerCalls.filter(
-    (call) => functionName(call) !== "onDemandPriceUpdates"
-  );
-  if (calls.length === 0) {
-    return void 0;
+  const storeIndices = [];
+  const compareIndices = [];
+  for (let i = 0; i < innerCalls.length; i++) {
+    const name = functionName(innerCalls[i]);
+    if (name === "storeExpectedBalances") {
+      storeIndices.push(i);
+    } else if (name === "compareBalances") {
+      compareIndices.push(i);
+    }
   }
-  const first = calls[0];
-  const last = calls[calls.length - 1];
-  if (functionName(first) !== "storeExpectedBalances" || functionName(last) !== "compareBalances") {
+  if (storeIndices.length === 0 && compareIndices.length === 0) {
     return void 0;
   }
-  const balanceDeltas = first.rawArgs.balanceDeltas;
+  if (storeIndices.length !== 1 || compareIndices.length !== 1) {
+    throw new Error(
+      `malformed multicall: expected exactly one storeExpectedBalances/compareBalances pair, got ${storeIndices.length} storeExpectedBalances and ${compareIndices.length} compareBalances calls`
+    );
+  }
+  if (compareIndices[0] < storeIndices[0]) {
+    throw new Error(
+      "malformed multicall: compareBalances appears before storeExpectedBalances"
+    );
+  }
+  const store = innerCalls[storeIndices[0]];
+  const balanceDeltas = store.rawArgs.balanceDeltas;
   if (!balanceDeltas) {
-    return void 0;
+    throw new Error(
+      "malformed multicall: storeExpectedBalances has no balanceDeltas argument"
+    );
   }
-  return balanceDeltas.map(({ token, amount }) => ({ token, balance: amount }));
+  return {
+    deltas: balanceDeltas.map(({ token, amount }) => ({
+      token,
+      balance: amount
+    })),
+    startIndex: storeIndices[0],
+    endIndex: compareIndices[0]
+  };
 }
 function functionName(call) {
   return call.functionName.split("(")[0];

package/dist/esm/preview/preview/previewOpenCreditAccount.js

@@ -1,9 +1,18 @@
 import {
-  AddressMap
+  AbstractAdapterContract,
+  copyBalances
+} from "../../plugins/adapters/index.js";
+import {
+  AddressMap,
+  AP_WETH_TOKEN,
+  CreditFacadeV310BaseContract,
+  NO_VERSION,
+  SecuritizeRWAFactory
 } from "../../sdk/index.js";
 import { extractExpectedBalanceChanges } from "./extractExpectedBalanceChanges.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
 function previewOpenCreditAccount(input, operation) {
-  const { sdk, to, calldata } = input;
+  const { sdk, to, calldata, value = 0n } = input;
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
@@ -41,21 +50,49 @@ function previewOpenCreditAccount(input, operation) {
         break;
     }
   }
-  const collateral = collateralByToken.values();
+  let collateral = collateralByToken.values();
   const collateralValue = collateral.reduce(
     (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
     0n
   );
+  collateral = unwrapNativeCollateral(
+    collateral,
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
   const parsed = sdk.parseFunctionDataV2(to, calldata);
   const innerCalls = parsed.rawArgs.calls ?? [];
-  const deltas = extractExpectedBalanceChanges(innerCalls) ?? [];
-  for (const { token, balance } of deltas) {
-    addBalance(token, balance);
+  const expected = extractExpectedBalanceChanges(innerCalls);
+  let finalBalances = balances;
+  if (expected) {
+    const rawCalls = extractRawInnerCalls(sdk, to, calldata);
+    if (rawCalls.length !== innerCalls.length) {
+      throw new Error(
+        `raw and parsed inner calls of ${to} are misaligned: ${rawCalls.length} raw vs ${innerCalls.length} parsed`
+      );
+    }
+    const snapshot = copyBalances(balances);
+    for (let i = expected.startIndex + 1; i < expected.endIndex; i++) {
+      const call = rawCalls[i];
+      const adapter = sdk.getContract(call.target);
+      if (!(adapter instanceof AbstractAdapterContract)) {
+        throw new Error(
+          `call to ${call.target} between storeExpectedBalances and compareBalances is not an adapter call`
+        );
+      }
+      finalBalances = adapter.previewBalanceChanges(
+        finalBalances,
+        call.callData
+      );
+    }
+    for (const { token, balance } of expected.deltas) {
+      finalBalances.upsert(token, (snapshot.get(token) ?? 0n) + balance);
+    }
   }
-  const assets = balances.entries().filter(([, balance]) => balance > 1n).map(([token, balance]) => ({ token, balance }));
+  const assets = finalBalances.entries().filter(([, balance]) => balance > 1n).map(([token, balance]) => ({ token, balance }));
   return {
     operation: operation.operation,
-    target: inferTargetAsset(operation.multicall, balances),
+    target: inferTargetAsset(operation.multicall, finalBalances),
     collateral,
     collateralValue,
     debt,
@@ -63,6 +100,15 @@ function previewOpenCreditAccount(input, operation) {
     assets
   };
 }
+function extractRawInnerCalls(sdk, to, calldata) {
+  const entry = sdk.getContract(to);
+  if (entry instanceof CreditFacadeV310BaseContract || entry instanceof SecuritizeRWAFactory) {
+    return entry.extractRawInnerCalls(calldata);
+  }
+  throw new Error(
+    `cannot extract raw inner calls from ${to}: neither a credit facade nor a supported RWA factory`
+  );
+}
 function inferTargetAsset(multicall, balances) {
   for (const op of multicall) {
     if (op.operation === "UpdateQuota" && op.change > 0n) {

package/dist/esm/preview/preview/unwrapNativeCollateral.js

@@ -0,0 +1,35 @@
+import { isAddressEqual } from "viem";
+import { NATIVE_ADDRESS } from "../../sdk/index.js";
+import { InvalidTransactionValueError } from "./errors.js";
+function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
+  if (nativeAmount === 0n) {
+    return collateral;
+  }
+  let unwrapped = false;
+  const result = [];
+  for (const asset of collateral) {
+    const isWeth = !unwrapped && isAddressEqual(asset.token, wethToken);
+    if (!isWeth) {
+      result.push(asset);
+      continue;
+    }
+    if (asset.balance < nativeAmount) {
+      throw new InvalidTransactionValueError(nativeAmount, asset.balance);
+    }
+    result.push({ token: NATIVE_ADDRESS, balance: nativeAmount });
+    if (asset.balance > nativeAmount) {
+      result.push({
+        token: asset.token,
+        balance: asset.balance - nativeAmount
+      });
+    }
+    unwrapped = true;
+  }
+  if (!unwrapped) {
+    throw new InvalidTransactionValueError(nativeAmount, 0n);
+  }
+  return result;
+}
+export {
+  unwrapNativeCollateral
+};

package/dist/esm/sdk/market/credit/CreditFacadeV310BaseContract.js

@@ -1,3 +1,6 @@
+import {
+  decodeFunctionData
+} from "viem";
 import {
   iCreditFacadeMulticallV310Abi,
   iCreditFacadeV310Abi
@@ -13,6 +16,36 @@ class CreditFacadeV310BaseContract extends BaseContract {
   constructor(options, args) {
     super(options, { ...args, abi });
   }
+  /**
+   * Decodes entry-point calldata with the facade ABI and returns the untouched
+   * inner multicall structs (targets with still-ABI-encoded `callData`).
+   *
+   * Unlike {@link ChainContractsRegister.parseMultiCallV2}, the inner calls are
+   * not decoded, so callers can re-decode them with a specific contract's ABI.
+   *
+   * @throws When the calldata cannot be decoded or the function has no inner
+   * multicall argument.
+   */
+  extractRawInnerCalls(calldata) {
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    switch (decoded.functionName) {
+      case "openCreditAccount":
+      case "closeCreditAccount":
+      case "botMulticall":
+      case "multicall": {
+        const [, calls] = decoded.args;
+        return [...calls];
+      }
+      case "liquidateCreditAccount": {
+        const [, , calls] = decoded.args;
+        return [...calls];
+      }
+      default:
+        throw new Error(
+          `function ${decoded.functionName} on ${this.name} has no inner multicall`
+        );
+    }
+  }
   parseFunctionParamsV2(params, strict) {
     switch (params.functionName) {
       case "openCreditAccount": {

package/dist/esm/sdk/market/rwa/securitize/SecuritizeRWAFactory.js

@@ -1,5 +1,6 @@
 import {
-  decodeAbiParameters
+  decodeAbiParameters,
+  decodeFunctionData
 } from "viem";
 import { iSecuritizeRWAFactoryAbi } from "../../../../abi/rwa/iSecuritizeRWAFactory.js";
 import { BaseContract } from "../../../base/index.js";
@@ -51,6 +52,31 @@ class SecuritizeRWAFactory extends BaseContract {
       operators: [...t.operators]
     }));
   }
+  /**
+   * Decodes entry-point calldata with the factory ABI and returns the
+   * untouched inner multicall structs (targets with still-ABI-encoded
+   * `callData`).
+   *
+   * Unlike {@link ChainContractsRegister.parseMultiCallV2}, the inner calls are
+   * not decoded, so callers can re-decode them with a specific contract's ABI.
+   *
+   * @throws When the calldata cannot be decoded or the function has no inner
+   * multicall argument.
+   */
+  extractRawInnerCalls(calldata) {
+    const decoded = decodeFunctionData({ abi: this.abi, data: calldata });
+    switch (decoded.functionName) {
+      case "openCreditAccount":
+      case "multicall": {
+        const [, calls] = decoded.args;
+        return [...calls];
+      }
+      default:
+        throw new Error(
+          `function ${decoded.functionName} on ${this.name} has no inner multicall`
+        );
+    }
+  }
   parseFunctionParamsV2(params, strict) {
     switch (params.functionName) {
       case "openCreditAccount": {

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

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import { AddressMap } from "../../sdk/index.js";
+/**
+ * Returns a copy of the balances map, leaving the original untouched.
+ */
+export declare function copyBalances(balances: AddressMap<bigint>): AddressMap<bigint>;
+/**
+ * Applies diff-call semantics to a balances map: a diff-style adapter call
+ * spends the consumed token down to the exact `leftoverAmount` encoded in its
+ * calldata, so the post-call balance of `tokenIn` is `leftoverAmount`
+ * regardless of the actual amount spent.
+ *
+ * Returns a new map; the input map is not mutated.
+ */
+export declare function clampToLeftover(balances: AddressMap<bigint>, tokenIn: Address, leftoverAmount: bigint): AddressMap<bigint>;
+/**
+ * Resolves a Curve pool coin index to its token address.
+ *
+ * @throws When the index is out of range for the pool.
+ */
+export declare function curveCoin(tokens: readonly Address[], i: bigint | number): Address;

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

@@ -1,6 +1,6 @@
-import { type Abi, type Address } from "viem";
+import { type Abi, type Address, type DecodeFunctionDataReturnType, type Hex } from "viem";
 import { type CallTrace } from "../../../common-utils/utils/trace.js";
-import type { ConstructOptions, ParsedCallV2, RelaxedBaseParams } from "../../../sdk/index.js";
+import type { AddressMap, ConstructOptions, ParsedCallV2, RelaxedBaseParams } from "../../../sdk/index.js";
 import { BaseContract } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
 import type { AdapterContractStateHuman, AdapterContractType, AdapterProtocolOperation } from "../types.js";
@@ -36,6 +36,26 @@ export declare class AbstractAdapterContract<const abi extends Abi | readonly un
      * @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. Not mutated.
+     * @param calldata - Raw ABI-encoded adapter calldata.
+     * @returns A new balances map with the call's changes applied.
+     * @throws When the calldata cannot be decoded or the adapter (or the
+     * specific function) has no balance-changes support.
+     */
+    previewBalanceChanges(balances: AddressMap<bigint>, calldata: Hex): AddressMap<bigint>;
+    /**
+     * Typed hook for {@link previewBalanceChanges}: receives the viem-decoded
+     * adapter call, so overrides can switch on `decoded.functionName` and get
+     * fully-typed `decoded.args` without casts.
+     *
+     * @throws When the adapter (or the specific function) has no balance-changes
+     * support; protocol-specific subclasses override this method.
+     */
+    protected previewDecodedBalanceChanges(_balances: AddressMap<bigint>, decoded: DecodeFunctionDataReturnType<abi>): AddressMap<bigint>;
     /**
      * Classifies an adapter call into a {@link LegacyAdapterOperation} using the
      * parsed call and credit-account transfer deltas.

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

@@ -1,5 +1,5 @@
-import { type Address } from "viem";
-import type { ConstructOptions } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import type { AddressMap, ConstructOptions } from "../../../sdk/index.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 export declare enum BalancerV3PoolStatus {
@@ -451,5 +451,6 @@ export declare class BalancerV3RouterAdapterContract extends AbstractAdapterCont
         version: number;
         contractType?: string;
     };
+    protected previewDecodedBalanceChanges(balances: AddressMap<bigint>, decoded: DecodeFunctionDataReturnType<abi>): AddressMap<bigint>;
 }
 export {};

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

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

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

@@ -1,5 +1,5 @@
-import { type Address } from "viem";
-import type { ConstructOptions } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import type { AddressMap, ConstructOptions } from "../../../sdk/index.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 export interface CamelotPool {
@@ -655,5 +655,6 @@ export declare class CamelotV3AdapterContract extends AbstractAdapterContract<ab
         version: number;
         contractType?: string;
     };
+    protected previewDecodedBalanceChanges(balances: AddressMap<bigint>, decoded: DecodeFunctionDataReturnType<abi>): AddressMap<bigint>;
 }
 export {};

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

@@ -1,5 +1,5 @@
-import { type Address } from "viem";
-import { type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type AddressMap, type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -690,5 +690,6 @@ export declare class ConvexV1BaseRewardPoolAdapterContract extends AbstractAdapt
      * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L76-L83
      */
     classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    protected previewDecodedBalanceChanges(balances: AddressMap<bigint>, decoded: DecodeFunctionDataReturnType<abi>): AddressMap<bigint>;
 }
 export {};

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

@@ -1,5 +1,5 @@
-import { type Address } from "viem";
-import { type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
+import { type Address, type DecodeFunctionDataReturnType } from "viem";
+import { type AddressMap, type ConstructOptions, type ParsedCallV2 } from "../../../sdk/index.js";
 import type { LegacyAdapterOperation, Transfers } from "../legacyAdapterOperations.js";
 import type { ConcreteAdapterContractOptions } from "./AbstractAdapter.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -54,11 +54,11 @@ declare const abi: readonly [{
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
-        readonly name: "leftoverAmount";
+        readonly name: "_pid";
         readonly internalType: "uint256";
         readonly type: "uint256";
     }, {
-        readonly name: "_pid";
+        readonly name: "leftoverAmount";
         readonly internalType: "uint256";
         readonly type: "uint256";
     }, {
@@ -172,11 +172,11 @@ declare const abi: readonly [{
 }, {
     readonly type: "function";
     readonly inputs: readonly [{
-        readonly name: "leftoverAmount";
+        readonly name: "_pid";
         readonly internalType: "uint256";
         readonly type: "uint256";
     }, {
-        readonly name: "_pid";
+        readonly name: "leftoverAmount";
         readonly internalType: "uint256";
         readonly type: "uint256";
     }];
@@ -421,5 +421,6 @@ export declare class ConvexV1BoosterAdapterContract extends AbstractAdapterContr
      * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L84-L91
      */
     classifyLegacyOperation(parsed: ParsedCallV2, transfers: Transfers): LegacyAdapterOperation;
+    protected previewDecodedBalanceChanges(balances: AddressMap<bigint>, decoded: DecodeFunctionDataReturnType<abi>): AddressMap<bigint>;
 }
 export {};