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

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

@@ -1,48 +1,75 @@
 import { iStakingRewardsAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iStakingRewardsAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iStakingRewardsAdapterAbi;
+const protocolAbi = iStakingRewardsAbi;
 class StakingRewardsAdapterContract extends 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 = 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 = 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 = 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 = 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 MissingSerializedParamsError("stakingToken");
+    return this.#stakingToken;
+  }
+  get rewardsToken() {
+    if (!this.#rewardsToken)
+      throw new MissingSerializedParamsError("rewardsToken");
+    return this.#rewardsToken;
+  }
+  get stakedPhantomToken() {
+    if (!this.#stakedPhantomToken)
+      throw new MissingSerializedParamsError("stakedPhantomToken");
+    return this.#stakedPhantomToken;
+  }
+  get referral() {
+    if (this.#referral === void 0)
+      throw new MissingSerializedParamsError("referral");
+    return this.#referral;
+  }
 }
 export {
   StakingRewardsAdapterContract

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

@@ -1,34 +1,44 @@
 import { iTraderJoeRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iTraderJoeRouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iTraderJoeRouterAdapterAbi;
+const protocolAbi = iTraderJoeRouterAbi;
 class TraderJoeRouterAdapterContract 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" },
-            { 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 = 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 MissingSerializedParamsError("supportedPools");
+    return this.#supportedPools;
   }
 }
 export {

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

@@ -2,32 +2,42 @@ import { iUniswapV2AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
-import { formatBN } from "../../../sdk/index.js";
+import { formatBN, MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iUniswapV2Router02Abi } from "../abi/targetContractAbi.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iUniswapV2AdapterAbi;
+const protocolAbi = iUniswapV2Router02Abi;
 class UniswapV2AdapterContract extends AbstractAdapterContract {
-  supportedPairs;
+  #supportedPairs;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = 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 = 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 MissingSerializedParamsError("supportedPairs");
+    return this.#supportedPairs;
   }
   stringifyFunctionParams(params) {
     switch (params.functionName) {
@@ -49,6 +59,10 @@ class UniswapV2AdapterContract extends AbstractAdapterContract {
         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", ...swapFromTransfers(transfers) };
+  }
 }
 export {
   UniswapV2AdapterContract

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

@@ -2,34 +2,43 @@ import { iUniswapV3AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import {
   decodeAbiParameters
 } from "viem";
-import { formatBN } from "../../../sdk/index.js";
+import { formatBN, MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iUniswapV3Abi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iUniswapV3AdapterAbi;
+const protocolAbi = iUniswapV3Abi;
 class UniswapV3AdapterContract 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" },
-            { 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 = 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 MissingSerializedParamsError("supportedPools");
+    return this.#supportedPools;
   }
   stringifyFunctionParams(params) {
     switch (params.functionName) {

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

@@ -1,36 +1,53 @@
-import { iUniswapV4AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  iUniswapV4AdapterAbi,
+  iUniswapV4GatewayAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iUniswapV4AdapterAbi;
+const protocolAbi = iUniswapV4GatewayAbi;
 class UniswapV4AdapterContract extends AbstractAdapterContract {
-  supportedPoolKeys;
+  #supportedPoolKeys;
   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" },
-            { 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 = 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 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", ...swapFromTransfers(transfers) };
   }
 }
 export {

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

@@ -1,26 +1,48 @@
-import { iUpshiftVaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  iUpshiftVaultAdapterAbi,
+  iUpshiftVaultGatewayAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iUpshiftVaultAdapterAbi;
+const protocolAbi = iUpshiftVaultGatewayAbi;
 class UpshiftVaultAdapterContract extends AbstractAdapterContract {
-  vault;
-  asset;
-  stakedPhantomToken;
+  #vault;
+  #asset;
+  #stakedPhantomToken;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = 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 = 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 MissingSerializedParamsError("vault");
+    return this.#vault;
+  }
+  get asset() {
+    if (!this.#asset) throw new MissingSerializedParamsError("asset");
+    return this.#asset;
+  }
+  get stakedPhantomToken() {
+    if (!this.#stakedPhantomToken)
+      throw new MissingSerializedParamsError("stakedPhantomToken");
+    return this.#stakedPhantomToken;
   }
 }
 export {

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

@@ -1,34 +1,44 @@
 import { iVelodromeV2RouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import { MissingSerializedParamsError } from "../../../sdk/index.js";
+import { iVelodromeV2RouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iVelodromeV2RouterAdapterAbi;
+const protocolAbi = iVelodromeV2RouterAbi;
 class VelodromeV2RouterAdapterContract 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" },
-            { 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 = 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 MissingSerializedParamsError("supportedPools");
+    return this.#supportedPools;
   }
 }
 export {

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

@@ -1,20 +1,42 @@
 import { iwstEthv1AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iwstETHAbi } from "../abi/targetContractAbi.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iwstEthv1AdapterAbi;
+const protocolAbi = iwstETHAbi;
 class WstETHV1AdapterContract extends AbstractAdapterContract {
-  stETH;
+  #stETH;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = 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 = 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 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", ...swapFromTransfers(transfers) };
+    }
+    if (parsed.functionName.startsWith("unwrap")) {
+      return { operation: "WstETHUnwrap", ...swapFromTransfers(transfers) };
+    }
+    return super.classifyLegacyOperation(parsed, transfers);
   }
 }
 export {