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

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

@@ -23,49 +23,74 @@ __export(StakingRewardsAdapterContract_exports, {
 module.exports = __toCommonJS(StakingRewardsAdapterContract_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.iStakingRewardsAdapterAbi;
+const protocolAbi = import_targetContractAbi.iStakingRewardsAbi;
 class StakingRewardsAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  stakingToken;
-  rewardsToken;
-  stakedPhantomToken;
-  referral;
+  #stakingToken;
+  #rewardsToken;
+  #stakedPhantomToken;
+  #referral;
   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: "stakingToken" },
-          { type: "address", name: "rewardsToken" },
-          { type: "address", name: "stakedPhantomToken" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.stakingToken = decoded[2];
-      this.rewardsToken = decoded[3];
-      this.stakedPhantomToken = decoded[4];
-      this.referral = 0;
-    } else {
-      const decoded = (0, import_viem.decodeAbiParameters)(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          { type: "address", name: "stakingToken" },
-          { type: "address", name: "rewardsToken" },
-          { type: "address", name: "stakedPhantomToken" },
-          { type: "uint16", name: "referral" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.stakingToken = decoded[2];
-      this.rewardsToken = decoded[3];
-      this.stakedPhantomToken = decoded[4];
-      this.referral = decoded[5];
+    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: "stakingToken" },
+            { type: "address", name: "rewardsToken" },
+            { type: "address", name: "stakedPhantomToken" }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#stakingToken = decoded[2];
+        this.#rewardsToken = decoded[3];
+        this.#stakedPhantomToken = decoded[4];
+        this.#referral = 0;
+      } else {
+        const decoded = (0, import_viem.decodeAbiParameters)(
+          [
+            { type: "address", name: "creditManager" },
+            { type: "address", name: "targetContract" },
+            { type: "address", name: "stakingToken" },
+            { type: "address", name: "rewardsToken" },
+            { type: "address", name: "stakedPhantomToken" },
+            { type: "uint16", name: "referral" }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#stakingToken = decoded[2];
+        this.#rewardsToken = decoded[3];
+        this.#stakedPhantomToken = decoded[4];
+        this.#referral = decoded[5];
+      }
     }
   }
+  get stakingToken() {
+    if (!this.#stakingToken)
+      throw new import_sdk.MissingSerializedParamsError("stakingToken");
+    return this.#stakingToken;
+  }
+  get rewardsToken() {
+    if (!this.#rewardsToken)
+      throw new import_sdk.MissingSerializedParamsError("rewardsToken");
+    return this.#rewardsToken;
+  }
+  get stakedPhantomToken() {
+    if (!this.#stakedPhantomToken)
+      throw new import_sdk.MissingSerializedParamsError("stakedPhantomToken");
+    return this.#stakedPhantomToken;
+  }
+  get referral() {
+    if (this.#referral === void 0)
+      throw new import_sdk.MissingSerializedParamsError("referral");
+    return this.#referral;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -23,35 +23,45 @@ __export(TraderJoeRouterAdapterContract_exports, {
 module.exports = __toCommonJS(TraderJoeRouterAdapterContract_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.iTraderJoeRouterAdapterAbi;
+const protocolAbi = import_targetContractAbi.iTraderJoeRouterAbi;
 class TraderJoeRouterAdapterContract 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" },
-            { type: "uint256", name: "binStep" },
-            { type: "uint8", name: "poolVersion" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPools = decoded[2].map((pool) => ({
-      token0: pool.token0,
-      token1: pool.token1,
-      binStep: Number(pool.binStep),
-      poolVersion: pool.poolVersion
-    }));
+    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" },
+              { type: "uint256", name: "binStep" },
+              { type: "uint8", name: "poolVersion" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPools = decoded[2].map((pool) => ({
+        token0: pool.token0,
+        token1: pool.token1,
+        binStep: Number(pool.binStep),
+        poolVersion: pool.poolVersion
+      }));
+    }
+  }
+  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/UniswapV2AdapterContract.js

@@ -24,31 +24,41 @@ module.exports = __toCommonJS(UniswapV2AdapterContract_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.iUniswapV2AdapterAbi;
+const protocolAbi = import_targetContractAbi.iUniswapV2Router02Abi;
 class UniswapV2AdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  supportedPairs;
+  #supportedPairs;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.decodeAbiParameters)(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        {
-          type: "tuple[]",
-          name: "supportedPairs",
-          components: [
-            { type: "address", name: "token0" },
-            { type: "address", name: "token1" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPairs = decoded[2].map((pair) => ({
-      token0: pair.token0,
-      token1: pair.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: "supportedPairs",
+            components: [
+              { type: "address", name: "token0" },
+              { type: "address", name: "token1" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPairs = decoded[2].map((pair) => ({
+        token0: pair.token0,
+        token1: pair.token1
+      }));
+    }
+  }
+  get supportedPairs() {
+    if (!this.#supportedPairs)
+      throw new import_sdk.MissingSerializedParamsError("supportedPairs");
+    return this.#supportedPairs;
   }
   stringifyFunctionParams(params) {
     switch (params.functionName) {
@@ -70,6 +80,10 @@ class UniswapV2AdapterContract extends import_AbstractAdapter.AbstractAdapterCon
         return super.stringifyFunctionParams(params);
     }
   }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L81-L91 */
+  classifyLegacyOperation(_parsed, transfers) {
+    return { operation: "UniswapSwap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -24,33 +24,42 @@ module.exports = __toCommonJS(UniswapV3AdapterContract_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.iUniswapV3AdapterAbi;
+const protocolAbi = import_targetContractAbi.iUniswapV3Abi;
 class UniswapV3AdapterContract 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" },
-            { type: "uint24", name: "fee" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPools = decoded[2].map((pool) => ({
-      token0: pool.token0,
-      token1: pool.token1,
-      fee: pool.fee
-    }));
+    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" },
+              { type: "uint24", name: "fee" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPools = decoded[2].map((pool) => ({
+        token0: pool.token0,
+        token1: pool.token1,
+        fee: pool.fee
+      }));
+    }
+  }
+  get supportedPools() {
+    if (!this.#supportedPools)
+      throw new import_sdk.MissingSerializedParamsError("supportedPools");
+    return this.#supportedPools;
   }
   stringifyFunctionParams(params) {
     switch (params.functionName) {

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

@@ -23,37 +23,51 @@ __export(UniswapV4AdapterContract_exports, {
 module.exports = __toCommonJS(UniswapV4AdapterContract_exports);
 var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
+var import_transferHelpers = require("../transferHelpers.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
 const abi = import_integrations_v3.iUniswapV4AdapterAbi;
+const protocolAbi = import_integrations_v3.iUniswapV4GatewayAbi;
 class UniswapV4AdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  supportedPoolKeys;
+  #supportedPoolKeys;
   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" },
-            { type: "uint24", name: "fee" },
-            { type: "int24", name: "tickSpacing" },
-            { type: "address", name: "hooks" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPoolKeys = decoded[2].map((pool) => ({
-      token0: pool.token0,
-      token1: pool.token1,
-      fee: pool.fee,
-      tickSpacing: pool.tickSpacing,
-      hooks: pool.hooks
-    }));
+    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" },
+              { type: "uint24", name: "fee" },
+              { type: "int24", name: "tickSpacing" },
+              { type: "address", name: "hooks" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPoolKeys = decoded[2].map((pool) => ({
+        token0: pool.token0,
+        token1: pool.token1,
+        fee: pool.fee,
+        tickSpacing: pool.tickSpacing,
+        hooks: pool.hooks
+      }));
+    }
+  }
+  get supportedPoolKeys() {
+    if (!this.#supportedPoolKeys)
+      throw new import_sdk.MissingSerializedParamsError("supportedPoolKeys");
+    return this.#supportedPoolKeys;
+  }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L81-L91 */
+  classifyLegacyOperation(_parsed, transfers) {
+    return { operation: "UniswapSwap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -23,27 +23,44 @@ __export(UpshiftVaultAdapterContract_exports, {
 module.exports = __toCommonJS(UpshiftVaultAdapterContract_exports);
 var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
 var import_viem = require("viem");
+var import_sdk = require("../../../sdk/index.js");
 var import_AbstractAdapter = require("./AbstractAdapter.js");
 const abi = import_integrations_v3.iUpshiftVaultAdapterAbi;
+const protocolAbi = import_integrations_v3.iUpshiftVaultGatewayAbi;
 class UpshiftVaultAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  vault;
-  asset;
-  stakedPhantomToken;
+  #vault;
+  #asset;
+  #stakedPhantomToken;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.decodeAbiParameters)(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "vault" },
-        { type: "address", name: "asset" },
-        { type: "address", name: "stakedPhantomToken" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.vault = decoded[2];
-    this.asset = decoded[3];
-    this.stakedPhantomToken = decoded[4];
+    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: "vault" },
+          { type: "address", name: "asset" },
+          { type: "address", name: "stakedPhantomToken" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#vault = decoded[2];
+      this.#asset = decoded[3];
+      this.#stakedPhantomToken = decoded[4];
+    }
+  }
+  get vault() {
+    if (!this.#vault) throw new import_sdk.MissingSerializedParamsError("vault");
+    return this.#vault;
+  }
+  get asset() {
+    if (!this.#asset) throw new import_sdk.MissingSerializedParamsError("asset");
+    return this.#asset;
+  }
+  get stakedPhantomToken() {
+    if (!this.#stakedPhantomToken)
+      throw new import_sdk.MissingSerializedParamsError("stakedPhantomToken");
+    return this.#stakedPhantomToken;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -23,35 +23,45 @@ __export(VelodromeV2AdapterContract_exports, {
 module.exports = __toCommonJS(VelodromeV2AdapterContract_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.iVelodromeV2RouterAdapterAbi;
+const protocolAbi = import_targetContractAbi.iVelodromeV2RouterAbi;
 class VelodromeV2RouterAdapterContract 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" },
-            { type: "bool", name: "stable" },
-            { type: "address", name: "factory" }
-          ]
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.supportedPools = decoded[2].map((pool) => ({
-      token0: pool.token0,
-      token1: pool.token1,
-      stable: pool.stable,
-      factory: pool.factory
-    }));
+    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" },
+              { type: "bool", name: "stable" },
+              { type: "address", name: "factory" }
+            ]
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#supportedPools = decoded[2].map((pool) => ({
+        token0: pool.token0,
+        token1: pool.token1,
+        stable: pool.stable,
+        factory: pool.factory
+      }));
+    }
+  }
+  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/WstETHV1AdapterContract.js

@@ -23,21 +23,41 @@ __export(WstETHV1AdapterContract_exports, {
 module.exports = __toCommonJS(WstETHV1AdapterContract_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.iwstEthv1AdapterAbi;
+const protocolAbi = import_targetContractAbi.iwstETHAbi;
 class WstETHV1AdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  stETH;
+  #stETH;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.decodeAbiParameters)(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "stETH" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.stETH = 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: "stETH" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#stETH = decoded[2];
+    }
+  }
+  get stETH() {
+    if (!this.#stETH) throw new import_sdk.MissingSerializedParamsError("stETH");
+    return this.#stETH;
+  }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L264-L275 */
+  classifyLegacyOperation(parsed, transfers) {
+    if (parsed.functionName.startsWith("wrap")) {
+      return { operation: "WstETHWrap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
+    }
+    if (parsed.functionName.startsWith("unwrap")) {
+      return { operation: "WstETHUnwrap", ...(0, import_transferHelpers.swapFromTransfers)(transfers) };
+    }
+    return super.classifyLegacyOperation(parsed, transfers);
   }
 }
 // Annotate the CommonJS export names for ESM import in node: