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

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

@@ -1,26 +1,50 @@
 import { iLidoV1AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { lidoV1_WETHGatewayAbi } from "../abi/targetContractAbi.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iLidoV1AdapterAbi;
+const protocolAbi = lidoV1_WETHGatewayAbi;
 class LidoV1AdapterContract extends AbstractAdapterContract {
-  stETH;
-  weth;
-  treasury;
+  #stETH;
+  #weth;
+  #treasury;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "stETH" },
-        { type: "address", name: "weth" },
-        { type: "address", name: "treasury" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.stETH = decoded[2];
-    this.weth = decoded[3];
-    this.treasury = 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: "stETH" },
+          { type: "address", name: "weth" },
+          { type: "address", name: "treasury" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#stETH = decoded[2];
+      this.#weth = decoded[3];
+      this.#treasury = decoded[4];
+    }
+  }
+  get stETH() {
+    if (!this.#stETH) throw new MissingSerializedParamsError("stETH");
+    return this.#stETH;
+  }
+  get weth() {
+    if (!this.#weth) throw new MissingSerializedParamsError("weth");
+    return this.#weth;
+  }
+  get treasury() {
+    if (!this.#treasury) throw new MissingSerializedParamsError("treasury");
+    return this.#treasury;
+  }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L277-L282 */
+  classifyLegacyOperation(_parsed, transfers) {
+    return { operation: "LidoSubmit", ...swapFromTransfers(transfers) };
   }
 }
 export {

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

@@ -1,20 +1,32 @@
 import { iMellowClaimerAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iMellowClaimerAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMellowClaimerAdapterAbi;
+const protocolAbi = iMellowClaimerAbi;
 class MellowClaimerAdapterContract extends AbstractAdapterContract {
-  allowedMultiVaults;
+  #allowedMultiVaults;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address[]", name: "allowedMultiVaults" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.allowedMultiVaults = [...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: "allowedMultiVaults" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#allowedMultiVaults = [...decoded[2]];
+    }
+  }
+  get allowedMultiVaults() {
+    if (!this.#allowedMultiVaults)
+      throw new MissingSerializedParamsError("allowedMultiVaults");
+    return this.#allowedMultiVaults;
   }
 }
 export {

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

@@ -1,23 +1,49 @@
 import { mellowDvvAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iERC4626Abi } from "../abi/targetContractAbi.js";
+import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = mellowDvvAdapterAbi;
+const protocolAbi = iERC4626Abi;
 class MellowDVVAdapterContract extends AbstractAdapterContract {
-  vault;
-  asset;
+  #vault;
+  #asset;
   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" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.vault = decoded[2];
-    this.asset = decoded[3];
+    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" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#vault = decoded[2];
+      this.#asset = decoded[3];
+    }
+  }
+  get vault() {
+    if (!this.#vault) throw new MissingSerializedParamsError("vault");
+    return this.#vault;
+  }
+  get asset() {
+    if (!this.#asset) throw new MissingSerializedParamsError("asset");
+    return this.#asset;
+  }
+  /**
+   * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L32-L38
+   */
+  classifyLegacyOperation(parsed, transfers) {
+    const fn = fnSigToName(parsed.functionName);
+    if (fn === "redeem" || fn === "redeemDiff") {
+      return { operation: "MakerRedeem", ...swapFromTransfers(transfers) };
+    }
+    return super.classifyLegacyOperation(parsed, transfers);
   }
 }
 export {

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

@@ -1,53 +1,84 @@
 import { iMellow4626VaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters, zeroAddress } from "viem";
+import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iERC4626Abi } from "../abi/targetContractAbi.js";
+import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMellow4626VaultAdapterAbi;
+const protocolAbi = iERC4626Abi;
 class MellowERC4626VaultAdapterContract extends AbstractAdapterContract {
-  vault;
-  asset;
-  stakedPhantomToken;
+  #vault;
+  #asset;
+  #stakedPhantomToken;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    this.asset = zeroAddress;
-    this.vault = zeroAddress;
-    this.stakedPhantomToken = zeroAddress;
-    const version = Number(args.baseParams.version);
-    if (version === 310) {
-      const decoded = decodeAbiParameters(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          { type: "address", name: "asset" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.asset = decoded[2];
-    } else if (version === 311) {
-      const decoded = decodeAbiParameters(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          { type: "address", name: "asset" },
-          { type: "address", name: "stakedPhantomToken" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.asset = decoded[2];
-      this.stakedPhantomToken = decoded[3];
-    } else {
-      const decoded = decodeAbiParameters(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          { type: "address", name: "vault" },
-          { type: "address", name: "asset" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.vault = decoded[2];
-      this.asset = decoded[3];
+    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: "asset" }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#asset = decoded[2];
+      } else if (version === 311) {
+        const decoded = decodeAbiParameters(
+          [
+            { type: "address", name: "creditManager" },
+            { type: "address", name: "targetContract" },
+            { type: "address", name: "asset" },
+            { type: "address", name: "stakedPhantomToken" }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#asset = decoded[2];
+        this.#stakedPhantomToken = decoded[3];
+      } else {
+        const decoded = decodeAbiParameters(
+          [
+            { type: "address", name: "creditManager" },
+            { type: "address", name: "targetContract" },
+            { type: "address", name: "vault" },
+            { type: "address", name: "asset" }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#vault = decoded[2];
+        this.#asset = decoded[3];
+      }
     }
   }
+  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;
+  }
+  /**
+   * Charts_server maps `redeem(uint256,address,address)` → MakerRedeem.
+   * Diff variants (`redeemDiff`) should also map to MakerRedeem.
+   *
+   * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L32-L38
+   */
+  classifyLegacyOperation(parsed, transfers) {
+    const fn = fnSigToName(parsed.functionName);
+    if (fn === "redeem" || fn === "redeemDiff") {
+      return { operation: "MakerRedeem", ...swapFromTransfers(transfers) };
+    }
+    return super.classifyLegacyOperation(parsed, transfers);
+  }
 }
 export {
   MellowERC4626VaultAdapterContract

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

@@ -1,20 +1,32 @@
 import { iMellowWrapperAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iMellowWrapperAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMellowWrapperAdapterAbi;
+const protocolAbi = iMellowWrapperAbi;
 class MellowWrapperAdapterContract extends AbstractAdapterContract {
-  allowedVaults;
+  #allowedVaults;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address[]", name: "allowedVaults" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.allowedVaults = [...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: "allowedVaults" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#allowedVaults = [...decoded[2]];
+    }
+  }
+  get allowedVaults() {
+    if (!this.#allowedVaults)
+      throw new MissingSerializedParamsError("allowedVaults");
+    return this.#allowedVaults;
   }
 }
 export {

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

@@ -1,26 +1,47 @@
 import { iMidasIssuanceVaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iMidasIssuanceVaultAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMidasIssuanceVaultAdapterAbi;
+const protocolAbi = iMidasIssuanceVaultAbi;
 class MidasIssuanceVaultAdapterContract extends AbstractAdapterContract {
-  mToken;
-  referrerId;
-  allowedTokens;
+  #mToken;
+  #referrerId;
+  #allowedTokens;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "mToken" },
-        { type: "bytes32", name: "referrerId" },
-        { type: "address[]", name: "allowedTokens" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.mToken = decoded[2];
-    this.referrerId = decoded[3];
-    this.allowedTokens = [...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: "mToken" },
+          { type: "bytes32", name: "referrerId" },
+          { type: "address[]", name: "allowedTokens" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#mToken = decoded[2];
+      this.#referrerId = decoded[3];
+      this.#allowedTokens = [...decoded[4]];
+    }
+  }
+  get mToken() {
+    if (!this.#mToken) throw new MissingSerializedParamsError("mToken");
+    return this.#mToken;
+  }
+  get referrerId() {
+    if (this.#referrerId === void 0)
+      throw new MissingSerializedParamsError("referrerId");
+    return this.#referrerId;
+  }
+  get allowedTokens() {
+    if (!this.#allowedTokens)
+      throw new MissingSerializedParamsError("allowedTokens");
+    return this.#allowedTokens;
   }
 }
 export {

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

@@ -1,30 +1,52 @@
-import { iMidasRedemptionVaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  iMidasRedemptionVaultAdapterAbi,
+  iMidasRedemptionVaultGatewayAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iMidasRedemptionVaultAdapterAbi;
+const protocolAbi = iMidasRedemptionVaultGatewayAbi;
 class MidasRedemptionVaultAdapterContract extends AbstractAdapterContract {
-  gateway;
-  mToken;
-  allowedTokens;
+  #gateway;
+  #mToken;
+  #allowedTokens;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "gateway" },
-        { type: "address", name: "mToken" },
-        { type: "address[]", name: "allowedTokens" },
-        { type: "address[]", name: "allowedPhantomTokens" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.gateway = decoded[2];
-    this.mToken = decoded[3];
-    this.allowedTokens = decoded[4].map((token, index) => ({
-      token,
-      phantomToken: decoded[5][index]
-    }));
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "gateway" },
+          { type: "address", name: "mToken" },
+          { type: "address[]", name: "allowedTokens" },
+          { type: "address[]", name: "allowedPhantomTokens" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#gateway = decoded[2];
+      this.#mToken = decoded[3];
+      this.#allowedTokens = decoded[4].map((token, index) => ({
+        token,
+        phantomToken: decoded[5][index]
+      }));
+    }
+  }
+  get gateway() {
+    if (!this.#gateway) throw new MissingSerializedParamsError("gateway");
+    return this.#gateway;
+  }
+  get mToken() {
+    if (!this.#mToken) throw new MissingSerializedParamsError("mToken");
+    return this.#mToken;
+  }
+  get allowedTokens() {
+    if (!this.#allowedTokens)
+      throw new MissingSerializedParamsError("allowedTokens");
+    return this.#allowedTokens;
   }
 }
 export {

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

@@ -1,64 +1,76 @@
 import { iPendleRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iPendleRouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iPendleRouterAdapterAbi;
+const protocolAbi = iPendleRouterAbi;
 class PendleRouterAdapterContract extends AbstractAdapterContract {
-  allowedPairs;
+  #allowedPairs;
   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: "tuple[]",
-            name: "allowedPairs",
-            components: [
-              { type: "address", name: "market" },
-              { type: "address", name: "inputToken" },
-              { type: "address", name: "pendleToken" },
-              { type: "uint8", name: "status" }
-            ]
-          }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.allowedPairs = decoded[2].map((pair) => ({
-        market: pair.market,
-        inputToken: pair.inputToken,
-        pendleToken: pair.pendleToken,
-        status: pair.status
-      }));
-    } else {
-      const decoded = decodeAbiParameters(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          {
-            type: "tuple[]",
-            name: "allowedPairs",
-            components: [
-              { type: "address", name: "market" },
-              { type: "address", name: "inputToken" },
-              { type: "address", name: "pendleToken" },
-              { type: "uint8", name: "pendleTokenType" },
-              { type: "uint8", name: "status" }
-            ]
-          }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.allowedPairs = decoded[2].map((pair) => ({
-        market: pair.market,
-        inputToken: pair.inputToken,
-        pendleToken: pair.pendleToken,
-        pendleTokenType: pair.pendleTokenType,
-        status: pair.status
-      }));
+    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: "tuple[]",
+              name: "allowedPairs",
+              components: [
+                { type: "address", name: "market" },
+                { type: "address", name: "inputToken" },
+                { type: "address", name: "pendleToken" },
+                { type: "uint8", name: "status" }
+              ]
+            }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#allowedPairs = decoded[2].map((pair) => ({
+          market: pair.market,
+          inputToken: pair.inputToken,
+          pendleToken: pair.pendleToken,
+          status: pair.status
+        }));
+      } else {
+        const decoded = decodeAbiParameters(
+          [
+            { type: "address", name: "creditManager" },
+            { type: "address", name: "targetContract" },
+            {
+              type: "tuple[]",
+              name: "allowedPairs",
+              components: [
+                { type: "address", name: "market" },
+                { type: "address", name: "inputToken" },
+                { type: "address", name: "pendleToken" },
+                { type: "uint8", name: "pendleTokenType" },
+                { type: "uint8", name: "status" }
+              ]
+            }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#allowedPairs = decoded[2].map((pair) => ({
+          market: pair.market,
+          inputToken: pair.inputToken,
+          pendleToken: pair.pendleToken,
+          pendleTokenType: pair.pendleTokenType,
+          status: pair.status
+        }));
+      }
     }
   }
+  get allowedPairs() {
+    if (!this.#allowedPairs)
+      throw new MissingSerializedParamsError("allowedPairs");
+    return this.#allowedPairs;
+  }
 }
 export {
   PendleRouterAdapterContract