@gearbox-protocol/sdk 13.0.0-next.9 → 13.0.1

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

@@ -21,17 +21,137 @@ __export(AbstractAdapter_exports, {
   AbstractAdapterContract: () => AbstractAdapterContract
 });
 module.exports = __toCommonJS(AbstractAdapter_exports);
+var import_viem = require("viem");
 var import_sdk = require("../../../sdk/index.js");
+var import_transferHelpers = require("../transferHelpers.js");
 class AbstractAdapterContract extends import_sdk.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] = (0, import_viem.decodeAbiParameters)(
+        [{ type: "address" }, { type: "address" }],
+        baseParams.serializedParams
+      );
+      this.#creditManager = cm;
+      this.#targetContract = tc;
+    }
+  }
+  get targetContract() {
+    if (this.#targetContract === void 0) {
+      throw new import_sdk.MissingSerializedParamsError("targetContract");
+    }
+    return this.#targetContract;
+  }
+  get creditManager() {
+    if (this.#creditManager === void 0) {
+      throw new import_sdk.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 = (0, import_transferHelpers.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 = (0, import_viem.decodeFunctionData)({
+        abi: this.protocolAbi,
+        data: calldata
+      });
+      const functionName = (0, import_sdk.getFunctionSignature)(this.protocolAbi, calldata);
+      const protocolArgs = (0, import_sdk.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 = (0, import_transferHelpers.swapFromTransfers)(transfers);
+    if (swap.to === import_viem.zeroAddress) {
+      return {
+        operation: "MakerDeposit",
+        token: swap.from,
+        amount: swap.fromAmount
+      };
+    }
+    return { operation: "Swap", ...swap };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -24,9 +24,16 @@ module.exports = __toCommonJS(AccountMigratorAdapterContract_exports);
 var import_AccountMigrator = require("../../../abi/AccountMigrator.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
 const abi = import_AccountMigrator.accountMigratorAbi;
+const protocolAbi = import_AccountMigrator.accountMigratorAbi;
 class AccountMigratorAdapterContract extends import_AbstractAdapter.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}`
+    );
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -18,49 +18,84 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var BalancerV3RouterAdapterContract_exports = {};
 __export(BalancerV3RouterAdapterContract_exports, {
+  BalancerV3PoolStatus: () => BalancerV3PoolStatus,
   BalancerV3RouterAdapterContract: () => BalancerV3RouterAdapterContract
 });
 module.exports = __toCommonJS(BalancerV3RouterAdapterContract_exports);
 var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_AbstractAdapter = require("./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 = import_integrations_v3.iBalancerV3RouterAdapterAbi;
+const protocolAbi = import_targetContractAbi.iBalancerV3RouterAbi;
 class BalancerV3RouterAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  allowedPools;
+  #allowedPools;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const version = Number(args.baseParams.version);
-    if (version === 310) {
-      const decoded = (0, import_viem.decodeAbiParameters)(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          { type: "address[]", name: "allowedPools" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.allowedPools = [...decoded[2]];
-    } else {
-      const decoded = (0, import_viem.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 = (0, import_viem.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 = (0, import_viem.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 import_sdk.MissingSerializedParamsError("allowedPools");
+    return this.#allowedPools;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedPools: this.#allowedPools?.map((p) => ({
+        pool: this.labelAddress(p.pool),
+        status: p.status
+      }))
+    };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BalancerV3PoolStatus,
   BalancerV3RouterAdapterContract
 });

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

@@ -23,21 +23,37 @@ __export(BalancerV3WrapperAdapterContract_exports, {
 module.exports = __toCommonJS(BalancerV3WrapperAdapterContract_exports);
 var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
 const abi = import_integrations_v3.iBalancerV3WrapperAdapterAbi;
+const protocolAbi = import_targetContractAbi.iBalancerV3WrapperAbi;
 class BalancerV3WrapperAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  balancerPoolToken;
+  #balancerPoolToken;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.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 = (0, import_viem.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 import_sdk.MissingSerializedParamsError("balancerPoolToken");
+    return this.#balancerPoolToken;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      balancerPoolToken: this.#balancerPoolToken ? this.labelAddress(this.#balancerPoolToken) : void 0
+    };
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -23,31 +23,50 @@ __export(CamelotV3AdapterContract_exports, {
 module.exports = __toCommonJS(CamelotV3AdapterContract_exports);
 var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_targetContractAbi = require("../abi/targetContractAbi.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
 const abi = import_integrations_v3.iCamelotV3AdapterAbi;
+const protocolAbi = import_targetContractAbi.iCamelotV3RouterAbi;
 class CamelotV3AdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  supportedPools;
+  #supportedPools;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.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 = (0, import_viem.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 import_sdk.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)
+      }))
+    };
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -23,35 +23,110 @@ __export(ConvexV1BaseRewardPoolAdapterContract_exports, {
 module.exports = __toCommonJS(ConvexV1BaseRewardPoolAdapterContract_exports);
 var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_targetContractAbi = require("../abi/targetContractAbi.js");
+var import_transferHelpers = require("../transferHelpers.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
 const abi = import_integrations_v3.iConvexV1BaseRewardPoolAdapterAbi;
+const protocolAbi = import_targetContractAbi.iBaseRewardPoolAbi;
 class ConvexV1BaseRewardPoolAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  curveLPtoken;
-  stakingToken;
-  stakedPhantomToken;
-  extraRewards;
+  #curveLPtoken;
+  #stakingToken;
+  #stakedPhantomToken;
+  #extraRewards;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.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 = (0, import_viem.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 import_sdk.MissingSerializedParamsError("curveLPtoken");
+    return this.#curveLPtoken;
+  }
+  get stakingToken() {
+    if (!this.#stakingToken)
+      throw new import_sdk.MissingSerializedParamsError("stakingToken");
+    return this.#stakingToken;
+  }
+  get stakedPhantomToken() {
+    if (!this.#stakedPhantomToken)
+      throw new import_sdk.MissingSerializedParamsError("stakedPhantomToken");
+    return this.#stakedPhantomToken;
+  }
+  get extraRewards() {
+    if (!this.#extraRewards)
+      throw new import_sdk.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 = (0, import_transferHelpers.fnSigToName)(parsed.functionName);
+    const { rawArgs: args } = parsed;
+    if (fn === "getReward") {
+      return {
+        operation: "GetReward",
+        rewards: (0, import_transferHelpers.rewardsFromTransfers)(transfers)
+      };
+    }
+    if (fn === "stake" || fn === "stakeDiff" || fn === "depositPhantomToken") {
+      const neg = (0, import_transferHelpers.parsePosNegAmount)(transfers).neg;
+      return {
+        operation: "ConvexStake",
+        stakedToken: neg[0] ?? { token: import_viem.zeroAddress, amount: "0" }
+      };
+    }
+    if (fn === "withdrawAll") {
+      return {
+        operation: "CurveClaims",
+        claims: (0, import_transferHelpers.parsePosNegAmount)(transfers).pos
+      };
+    }
+    const claim = args.claim;
+    if (claim) {
+      return {
+        operation: "ConvexWithdrawAndClaim",
+        rewards: (0, import_transferHelpers.allTransfersAsTokenAmounts)(transfers)
+      };
+    }
+    const swap = (0, import_transferHelpers.swapFromTransfers)(transfers);
+    return {
+      operation: "ConvexWithdraw",
+      withdrawToken: swap.to,
+      withdrawAmount: swap.toAmount
+    };
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -23,35 +23,84 @@ __export(ConvexV1BoosterAdapterContract_exports, {
 module.exports = __toCommonJS(ConvexV1BoosterAdapterContract_exports);
 var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_targetContractAbi = require("../abi/targetContractAbi.js");
+var import_transferHelpers = require("../transferHelpers.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
 const abi = import_integrations_v3.iConvexV1BoosterAdapterAbi;
+const protocolAbi = import_targetContractAbi.iBoosterAbi;
 class ConvexV1BoosterAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  supportedPools;
+  #supportedPools;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.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 = (0, import_viem.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 import_sdk.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 = (0, import_transferHelpers.fnSigToName)(parsed.functionName);
+    const { rawArgs: args } = parsed;
+    if (fn === "withdrawAll") {
+      return { operation: "CurveWithdrawal", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
+    }
+    const staked = args._stake ?? args.stake;
+    const swap = (0, import_transferHelpers.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);
   }
 }
 // Annotate the CommonJS export names for ESM import in node: