@gearbox-protocol/sdk 13.0.0-next.9 → 13.1.0-next.1

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

@@ -1,14 +1,143 @@
-import { BaseContract } from "../../../sdk/index.js";
+import {
+  decodeAbiParameters,
+  decodeFunctionData,
+  zeroAddress
+} from "viem";
+import {
+  BaseContract,
+  functionArgsToRecord,
+  getFunctionSignature,
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { swapFromTransfers, toNetTransfers } from "../transferHelpers.js";
 class AbstractAdapterContract extends BaseContract {
-  targetContract;
+  #targetContract;
+  #creditManager;
+  protocolAbi;
   constructor(options, args) {
-    const { baseParams, targetContract, ...rest } = args;
+    const { baseParams, protocolAbi, ...rest } = args;
     super(options, { ...rest, ...baseParams });
-    this.targetContract = targetContract;
+    this.protocolAbi = protocolAbi;
+    if (baseParams.serializedParams) {
+      const [cm, tc] = decodeAbiParameters(
+        [{ type: "address" }, { type: "address" }],
+        baseParams.serializedParams
+      );
+      this.#creditManager = cm;
+      this.#targetContract = tc;
+    }
+  }
+  get targetContract() {
+    if (this.#targetContract === void 0) {
+      throw new MissingSerializedParamsError("targetContract");
+    }
+    return this.#targetContract;
+  }
+  get creditManager() {
+    if (this.#creditManager === void 0) {
+      throw new MissingSerializedParamsError("creditManager");
+    }
+    return this.#creditManager;
   }
   get adapterType() {
     return this.contractType;
   }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      creditManager: this.#creditManager ? this.labelAddress(this.#creditManager) : void 0,
+      targetContract: this.#targetContract ? this.labelAddress(this.#targetContract) : void 0
+    };
+  }
+  /**
+   * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
+   *
+   * Returns `PartialBy<AdapterOperation, "targetContract">` because the adapter
+   * may not have `targetContract` (adapters created without SDK do not have serializedParams)
+   *
+   * @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
+   */
+  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 {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
+    }
+    try {
+      const decoded = decodeFunctionData({
+        abi: this.protocolAbi,
+        data: calldata
+      });
+      const functionName = getFunctionSignature(this.protocolAbi, calldata);
+      const protocolArgs = functionArgsToRecord(
+        this.protocolAbi,
+        decoded.functionName,
+        decoded.args
+      );
+      return { protocolFunctionName: functionName, protocolArgs };
+    } catch (e) {
+      if (strict) {
+        throw new Error(
+          `Failed to decode protocol calldata for selector ${selector}`,
+          { cause: e }
+        );
+      }
+      return {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
+    }
+  }
+  /**
+   * Classifies an adapter call into a {@link LegacyAdapterOperation} using the
+   * parsed call and credit-account transfer deltas.
+   *
+   * Default: replicates charts_server fallback —
+   * - no positive transfers (swap.to is zero) → {@link MakerDeposit}
+   * - otherwise → generic {@link Swap}
+   *
+   * Override in protocol-specific subclasses for richer classification.
+   *
+   * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/account_operation.go#L238-L264
+   */
+  classifyLegacyOperation(_parsed, transfers) {
+    const swap = swapFromTransfers(transfers);
+    if (swap.to === zeroAddress) {
+      return {
+        operation: "MakerDeposit",
+        token: swap.from,
+        amount: swap.fromAmount
+      };
+    }
+    return { operation: "Swap", ...swap };
+  }
 }
 export {
   AbstractAdapterContract

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

@@ -1,9 +1,16 @@
 import { accountMigratorAbi } from "../../../abi/AccountMigrator.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = accountMigratorAbi;
+const protocolAbi = accountMigratorAbi;
 class AccountMigratorAdapterContract extends AbstractAdapterContract {
   constructor(options, args) {
-    super(options, { ...args, abi });
+    super(options, { ...args, abi, protocolAbi });
+  }
+  /** Legacy adapter not present in integrations-v3. */
+  classifyLegacyOperation(_parsed, _transfers) {
+    throw new Error(
+      `classifyLegacyOperation is not supported for legacy adapter: ${this.contractType}`
+    );
   }
 }
 export {

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

@@ -1,42 +1,76 @@
 import { iBalancerV3RouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iBalancerV3RouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
+var BalancerV3PoolStatus = /* @__PURE__ */ ((BalancerV3PoolStatus2) => {
+  BalancerV3PoolStatus2[BalancerV3PoolStatus2["NOT_ALLOWED"] = 0] = "NOT_ALLOWED";
+  BalancerV3PoolStatus2[BalancerV3PoolStatus2["ALLOWED"] = 1] = "ALLOWED";
+  BalancerV3PoolStatus2[BalancerV3PoolStatus2["EXIT_AND_SWAP"] = 2] = "EXIT_AND_SWAP";
+  BalancerV3PoolStatus2[BalancerV3PoolStatus2["SWAP_ONLY"] = 3] = "SWAP_ONLY";
+  BalancerV3PoolStatus2[BalancerV3PoolStatus2["EXIT_ONLY"] = 4] = "EXIT_ONLY";
+  return BalancerV3PoolStatus2;
+})(BalancerV3PoolStatus || {});
 const abi = iBalancerV3RouterAdapterAbi;
+const protocolAbi = iBalancerV3RouterAbi;
 class BalancerV3RouterAdapterContract extends AbstractAdapterContract {
-  allowedPools;
+  #allowedPools;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const version = Number(args.baseParams.version);
-    if (version === 310) {
-      const decoded = decodeAbiParameters(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          { type: "address[]", name: "allowedPools" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.allowedPools = [...decoded[2]];
-    } else {
-      const decoded = decodeAbiParameters(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          {
-            type: "tuple[]",
-            name: "allowedPairs",
-            components: [
-              { type: "address", name: "pool" },
-              { type: "uint8", name: "status" }
-            ]
-          }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.allowedPools = [...decoded[2]];
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const version = Number(args.baseParams.version);
+      if (version <= 310) {
+        const decoded = decodeAbiParameters(
+          [
+            { type: "address", name: "creditManager" },
+            { type: "address", name: "targetContract" },
+            { type: "address[]", name: "allowedPools" }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#allowedPools = decoded[2].map((p) => ({
+          pool: p,
+          status: 1 /* ALLOWED */
+        }));
+      } else {
+        const decoded = decodeAbiParameters(
+          [
+            { type: "address", name: "creditManager" },
+            { type: "address", name: "targetContract" },
+            {
+              type: "tuple[]",
+              name: "allowedPools",
+              components: [
+                { type: "address", name: "pool" },
+                { type: "uint8", name: "status" }
+              ]
+            }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#allowedPools = decoded[2].map((p) => ({
+          pool: p.pool,
+          status: p.status
+        }));
+      }
     }
   }
+  get allowedPools() {
+    if (!this.#allowedPools)
+      throw new MissingSerializedParamsError("allowedPools");
+    return this.#allowedPools;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedPools: this.#allowedPools?.map((p) => ({
+        pool: this.labelAddress(p.pool),
+        status: p.status
+      }))
+    };
+  }
 }
 export {
+  BalancerV3PoolStatus,
   BalancerV3RouterAdapterContract
 };

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

@@ -1,20 +1,36 @@
 import { iBalancerV3WrapperAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iBalancerV3WrapperAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iBalancerV3WrapperAdapterAbi;
+const protocolAbi = iBalancerV3WrapperAbi;
 class BalancerV3WrapperAdapterContract extends AbstractAdapterContract {
-  balancerPoolToken;
+  #balancerPoolToken;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "balancerPoolToken" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.balancerPoolToken = decoded[2];
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "balancerPoolToken" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#balancerPoolToken = decoded[2];
+    }
+  }
+  get balancerPoolToken() {
+    if (!this.#balancerPoolToken)
+      throw new MissingSerializedParamsError("balancerPoolToken");
+    return this.#balancerPoolToken;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      balancerPoolToken: this.#balancerPoolToken ? this.labelAddress(this.#balancerPoolToken) : void 0
+    };
   }
 }
 export {

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

@@ -1,30 +1,49 @@
 import { iCamelotV3AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iCamelotV3RouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iCamelotV3AdapterAbi;
+const protocolAbi = iCamelotV3RouterAbi;
 class CamelotV3AdapterContract extends AbstractAdapterContract {
-  supportedPools;
+  #supportedPools;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        {
-          type: "tuple[]",
-          name: "supportedPools",
-          components: [
-            { type: "address", name: "token0" },
-            { type: "address", name: "token1" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPools = decoded[2].map((pool) => ({
-      token0: pool.token0,
-      token1: pool.token1
-    }));
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          {
+            type: "tuple[]",
+            name: "supportedPools",
+            components: [
+              { type: "address", name: "token0" },
+              { type: "address", name: "token1" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPools = decoded[2].map((pool) => ({
+        token0: pool.token0,
+        token1: pool.token1
+      }));
+    }
+  }
+  get supportedPools() {
+    if (!this.#supportedPools)
+      throw new MissingSerializedParamsError("supportedPools");
+    return this.#supportedPools;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      supportedPools: this.#supportedPools?.map((p) => ({
+        token0: this.labelAddress(p.token0),
+        token1: this.labelAddress(p.token1)
+      }))
+    };
   }
 }
 export {

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

@@ -1,34 +1,117 @@
 import { iConvexV1BaseRewardPoolAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import { decodeAbiParameters, zeroAddress } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iBaseRewardPoolAbi } from "../abi/targetContractAbi.js";
+import {
+  allTransfersAsTokenAmounts,
+  fnSigToName,
+  parsePosNegAmount,
+  rewardsFromTransfers,
+  swapFromTransfers
+} from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iConvexV1BaseRewardPoolAdapterAbi;
+const protocolAbi = iBaseRewardPoolAbi;
 class ConvexV1BaseRewardPoolAdapterContract extends AbstractAdapterContract {
-  curveLPtoken;
-  stakingToken;
-  stakedPhantomToken;
-  extraRewards;
+  #curveLPtoken;
+  #stakingToken;
+  #stakedPhantomToken;
+  #extraRewards;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "curveLPtoken" },
-        { type: "address", name: "stakingToken" },
-        { type: "address", name: "stakedPhantomToken" },
-        { type: "address[4]", name: "extraRewards" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.curveLPtoken = decoded[2];
-    this.stakingToken = decoded[3];
-    this.stakedPhantomToken = decoded[4];
-    this.extraRewards = [
-      decoded[5][0],
-      decoded[5][1],
-      decoded[5][2],
-      decoded[5][3]
-    ];
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "curveLPtoken" },
+          { type: "address", name: "stakingToken" },
+          { type: "address", name: "stakedPhantomToken" },
+          { type: "address[4]", name: "extraRewards" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#curveLPtoken = decoded[2];
+      this.#stakingToken = decoded[3];
+      this.#stakedPhantomToken = decoded[4];
+      this.#extraRewards = [
+        decoded[5][0],
+        decoded[5][1],
+        decoded[5][2],
+        decoded[5][3]
+      ];
+    }
+  }
+  get curveLPtoken() {
+    if (!this.#curveLPtoken)
+      throw new MissingSerializedParamsError("curveLPtoken");
+    return this.#curveLPtoken;
+  }
+  get stakingToken() {
+    if (!this.#stakingToken)
+      throw new MissingSerializedParamsError("stakingToken");
+    return this.#stakingToken;
+  }
+  get stakedPhantomToken() {
+    if (!this.#stakedPhantomToken)
+      throw new MissingSerializedParamsError("stakedPhantomToken");
+    return this.#stakedPhantomToken;
+  }
+  get extraRewards() {
+    if (!this.#extraRewards)
+      throw new MissingSerializedParamsError("extraRewards");
+    return this.#extraRewards;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      curveLPtoken: this.#curveLPtoken ? this.labelAddress(this.#curveLPtoken) : void 0,
+      stakingToken: this.#stakingToken ? this.labelAddress(this.#stakingToken) : void 0,
+      stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0,
+      extraRewards: this.#extraRewards?.map((r) => this.labelAddress(r))
+    };
+  }
+  /**
+   * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L200-L262
+   * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L76-L83
+   */
+  classifyLegacyOperation(parsed, transfers) {
+    const fn = fnSigToName(parsed.functionName);
+    const { rawArgs: args } = parsed;
+    if (fn === "getReward") {
+      return {
+        operation: "GetReward",
+        rewards: rewardsFromTransfers(transfers)
+      };
+    }
+    if (fn === "stake" || fn === "stakeDiff" || fn === "depositPhantomToken") {
+      const neg = parsePosNegAmount(transfers).neg;
+      return {
+        operation: "ConvexStake",
+        stakedToken: neg[0] ?? { token: zeroAddress, amount: "0" }
+      };
+    }
+    if (fn === "withdrawAll") {
+      return {
+        operation: "CurveClaims",
+        claims: parsePosNegAmount(transfers).pos
+      };
+    }
+    const claim = args.claim;
+    if (claim) {
+      return {
+        operation: "ConvexWithdrawAndClaim",
+        rewards: allTransfersAsTokenAmounts(transfers)
+      };
+    }
+    const swap = swapFromTransfers(transfers);
+    return {
+      operation: "ConvexWithdraw",
+      withdrawToken: swap.to,
+      withdrawAmount: swap.toAmount
+    };
   }
 }
 export {

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

@@ -1,34 +1,85 @@
 import { iConvexV1BoosterAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iBoosterAbi } from "../abi/targetContractAbi.js";
+import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iConvexV1BoosterAdapterAbi;
+const protocolAbi = iBoosterAbi;
 class ConvexV1BoosterAdapterContract extends AbstractAdapterContract {
-  supportedPools;
+  #supportedPools;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        {
-          type: "tuple[]",
-          name: "supportedPools",
-          components: [
-            { type: "uint256", name: "pid" },
-            { type: "address", name: "curveToken" },
-            { type: "address", name: "convexToken" },
-            { type: "address", name: "phantomToken" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPools = decoded[2].map((pool) => ({
-      pid: Number(pool.pid),
-      curveToken: pool.curveToken,
-      convexToken: pool.convexToken,
-      phantomToken: pool.phantomToken
-    }));
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          {
+            type: "tuple[]",
+            name: "supportedPools",
+            components: [
+              { type: "uint256", name: "pid" },
+              { type: "address", name: "curveToken" },
+              { type: "address", name: "convexToken" },
+              { type: "address", name: "phantomToken" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPools = decoded[2].map((pool) => ({
+        pid: Number(pool.pid),
+        curveToken: pool.curveToken,
+        convexToken: pool.convexToken,
+        phantomToken: pool.phantomToken
+      }));
+    }
+  }
+  get supportedPools() {
+    if (!this.#supportedPools)
+      throw new MissingSerializedParamsError("supportedPools");
+    return this.#supportedPools;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      supportedPools: this.#supportedPools?.map((p) => ({
+        pid: p.pid,
+        curveToken: this.labelAddress(p.curveToken),
+        convexToken: this.labelAddress(p.convexToken),
+        phantomToken: this.labelAddress(p.phantomToken)
+      }))
+    };
+  }
+  /**
+   * Charts_server only maps `withdrawAll(uint256)` → CurveWithdrawal.
+   * `withdrawDiff` and other withdraw variants fall to the base class fallback → Swap.
+   *
+   * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L166-L199
+   * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L84-L91
+   */
+  classifyLegacyOperation(parsed, transfers) {
+    const fn = fnSigToName(parsed.functionName);
+    const { rawArgs: args } = parsed;
+    if (fn === "withdrawAll") {
+      return { operation: "CurveWithdrawal", ...swapFromTransfers(transfers) };
+    }
+    const staked = args._stake ?? args.stake;
+    const swap = swapFromTransfers(transfers);
+    if (staked === true) {
+      return {
+        operation: "ConvexDepositAndStake",
+        depositToken: swap.from,
+        depositAmount: swap.fromAmount
+      };
+    }
+    if (fn === "depositAll" || fn === "deposit") {
+      return { operation: "ConvexDeposit", ...swap };
+    }
+    return super.classifyLegacyOperation(parsed, transfers);
   }
 }
 export {