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

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

@@ -21,17 +21,116 @@ __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;
+  protocolAbi;
   constructor(options, args) {
-    const { baseParams, targetContract, ...rest } = args;
+    const { baseParams, targetContract, protocolAbi, ...rest } = args;
     super(options, { ...rest, ...baseParams });
-    this.targetContract = targetContract;
+    this.#targetContract = targetContract;
+    this.protocolAbi = protocolAbi;
+  }
+  get targetContract() {
+    if (this.#targetContract === void 0) {
+      throw new import_sdk.MissingSerializedParamsError("targetContract");
+    }
+    return this.#targetContract;
   }
   get adapterType() {
     return this.contractType;
   }
+  /**
+   * 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

@@ -23,42 +23,52 @@ __export(BalancerV3RouterAdapterContract_exports, {
 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");
 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]];
+      } 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]];
+      }
     }
   }
+  get allowedPools() {
+    if (!this.#allowedPools)
+      throw new import_sdk.MissingSerializedParamsError("allowedPools");
+    return this.#allowedPools;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -23,21 +23,31 @@ __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;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -23,31 +23,41 @@ __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;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -23,35 +23,101 @@ __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;
+  }
+  /**
+   * @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,73 @@ __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;
+  }
+  /**
+   * 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: