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

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

@@ -1,23 +1,47 @@
+import {
+  iKelpLrtWithdrawalManagerAdapterAbi,
+  iKelpLrtWithdrawalManagerGatewayAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-const abi = [];
+const abi = iKelpLrtWithdrawalManagerAdapterAbi;
+const protocolAbi = iKelpLrtWithdrawalManagerGatewayAbi;
 class KelpLRTWithdrawalManagerAdapterContract extends AbstractAdapterContract {
-  allowedTokensOut;
+  #allowedTokensOut;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address[]", name: "allowedTokensOut" },
-        { type: "address[]", name: "phantomTokensForAllowedTokensOut" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.allowedTokensOut = decoded[2].map((tokenOut, index) => ({
-      tokenOut,
-      phantomToken: decoded[3][index]
-    }));
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address[]", name: "allowedTokensOut" },
+          { type: "address[]", name: "phantomTokensForAllowedTokensOut" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#allowedTokensOut = decoded[2].map((tokenOut, index) => ({
+        tokenOut,
+        phantomToken: decoded[3][index]
+      }));
+    }
+  }
+  get allowedTokensOut() {
+    if (!this.#allowedTokensOut)
+      throw new MissingSerializedParamsError("allowedTokensOut");
+    return this.#allowedTokensOut;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedTokensOut: this.#allowedTokensOut?.map((t) => ({
+        tokenOut: this.labelAddress(t.tokenOut),
+        phantomToken: this.labelAddress(t.phantomToken)
+      }))
+    };
   }
 }
 export {

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

@@ -1,26 +1,58 @@
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      stETH: this.#stETH ? this.labelAddress(this.#stETH) : void 0,
+      weth: this.#weth ? this.labelAddress(this.#weth) : void 0,
+      treasury: this.#treasury ? this.labelAddress(this.#treasury) : void 0
+    };
+  }
+  /** @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,40 @@
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedMultiVaults: this.#allowedMultiVaults?.map(
+        (v) => this.labelAddress(v)
+      )
+    };
   }
 }
 export {

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

@@ -1,23 +1,56 @@
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      vault: this.#vault ? this.labelAddress(this.#vault) : void 0,
+      asset: this.#asset ? this.labelAddress(this.#asset) : void 0
+    };
+  }
+  /**
+   * @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/MellowDepositQueueAdapterContract.js

@@ -1,25 +1,52 @@
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = [];
+const protocolAbi = [];
 class MellowDepositQueueAdapterContract extends AbstractAdapterContract {
-  asset;
-  phantomToken;
-  referral;
+  #asset;
+  #phantomToken;
+  #referral;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "asset" },
-        { type: "address", name: "phantomToken" },
-        { type: "address", name: "referral" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.asset = decoded[2];
-    this.phantomToken = decoded[3];
-    this.referral = 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: "asset" },
+          { type: "address", name: "phantomToken" },
+          { type: "address", name: "referral" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#asset = decoded[2];
+      this.#phantomToken = decoded[3];
+      this.#referral = decoded[4];
+    }
+  }
+  get asset() {
+    if (!this.#asset) throw new MissingSerializedParamsError("asset");
+    return this.#asset;
+  }
+  get phantomToken() {
+    if (!this.#phantomToken)
+      throw new MissingSerializedParamsError("phantomToken");
+    return this.#phantomToken;
+  }
+  get referral() {
+    if (!this.#referral) throw new MissingSerializedParamsError("referral");
+    return this.#referral;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      asset: this.#asset ? this.labelAddress(this.#asset) : void 0,
+      phantomToken: this.#phantomToken ? this.labelAddress(this.#phantomToken) : void 0,
+      referral: this.#referral ? this.labelAddress(this.#referral) : void 0
+    };
   }
 }
 export {

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

@@ -1,53 +1,92 @@
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      vault: this.#vault ? this.labelAddress(this.#vault) : void 0,
+      asset: this.#asset ? this.labelAddress(this.#asset) : void 0,
+      stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0
+    };
+  }
+  /**
+   * 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/MellowRedeemQueueAdapterContract.js

@@ -1,22 +1,44 @@
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = [];
+const protocolAbi = [];
 class MellowRedeemQueueAdapterContract extends AbstractAdapterContract {
-  vaultToken;
-  phantomToken;
+  #vaultToken;
+  #phantomToken;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "vaultToken" },
-        { type: "address", name: "phantomToken" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.vaultToken = decoded[2];
-    this.phantomToken = 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: "vaultToken" },
+          { type: "address", name: "phantomToken" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#vaultToken = decoded[2];
+      this.#phantomToken = decoded[3];
+    }
+  }
+  get vaultToken() {
+    if (!this.#vaultToken) throw new MissingSerializedParamsError("vaultToken");
+    return this.#vaultToken;
+  }
+  get phantomToken() {
+    if (!this.#phantomToken)
+      throw new MissingSerializedParamsError("phantomToken");
+    return this.#phantomToken;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      vaultToken: this.#vaultToken ? this.labelAddress(this.#vaultToken) : void 0,
+      phantomToken: this.#phantomToken ? this.labelAddress(this.#phantomToken) : void 0
+    };
   }
 }
 export {

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

@@ -1,20 +1,38 @@
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedVaults: this.#allowedVaults?.map((v) => this.labelAddress(v))
+    };
   }
 }
 export {

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

@@ -1,26 +1,55 @@
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      mToken: this.#mToken ? this.labelAddress(this.#mToken) : void 0,
+      referrerId: this.#referrerId,
+      allowedTokens: this.#allowedTokens?.map((t) => this.labelAddress(t))
+    };
   }
 }
 export {