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

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

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

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

@@ -1,65 +1,102 @@
 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";
+var PendleTokenType = /* @__PURE__ */ ((PendleTokenType2) => {
+  PendleTokenType2[PendleTokenType2["PT"] = 0] = "PT";
+  PendleTokenType2[PendleTokenType2["LP"] = 1] = "LP";
+  return PendleTokenType2;
+})(PendleTokenType || {});
+var PendlePairStatus = /* @__PURE__ */ ((PendlePairStatus2) => {
+  PendlePairStatus2[PendlePairStatus2["NOT_ALLOWED"] = 0] = "NOT_ALLOWED";
+  PendlePairStatus2[PendlePairStatus2["ALLOWED"] = 1] = "ALLOWED";
+  PendlePairStatus2[PendlePairStatus2["EXIT_ONLY"] = 2] = "EXIT_ONLY";
+  return PendlePairStatus2;
+})(PendlePairStatus || {});
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedPairs: this.#allowedPairs?.map((p) => ({
+        market: this.labelAddress(p.market),
+        inputToken: this.labelAddress(p.inputToken),
+        pendleToken: this.labelAddress(p.pendleToken),
+        pendleTokenType: p.pendleTokenType,
+        status: p.status
+      }))
+    };
+  }
 }
 export {
-  PendleRouterAdapterContract
+  PendlePairStatus,
+  PendleRouterAdapterContract,
+  PendleTokenType
 };

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

@@ -1,48 +1,84 @@
 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 <= 311) {
+        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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      stakingToken: this.#stakingToken ? this.labelAddress(this.#stakingToken) : void 0,
+      rewardsToken: this.#rewardsToken ? this.labelAddress(this.#rewardsToken) : void 0,
+      stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0,
+      referral: this.#referral
+    };
+  }
 }
 export {
   StakingRewardsAdapterContract

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

@@ -1,36 +1,65 @@
 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";
+var TraderJoePoolVersion = /* @__PURE__ */ ((TraderJoePoolVersion2) => {
+  TraderJoePoolVersion2[TraderJoePoolVersion2["V1"] = 0] = "V1";
+  TraderJoePoolVersion2[TraderJoePoolVersion2["V2"] = 1] = "V2";
+  TraderJoePoolVersion2[TraderJoePoolVersion2["V2_1"] = 2] = "V2_1";
+  TraderJoePoolVersion2[TraderJoePoolVersion2["V2_2"] = 3] = "V2_2";
+  return TraderJoePoolVersion2;
+})(TraderJoePoolVersion || {});
 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      supportedPools: this.#supportedPools?.map((p) => ({
+        token0: this.labelAddress(p.token0),
+        token1: this.labelAddress(p.token1),
+        binStep: p.binStep,
+        poolVersion: p.poolVersion
+      }))
+    };
   }
 }
 export {
+  TraderJoePoolVersion,
   TraderJoeRouterAdapterContract
 };

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

@@ -2,32 +2,51 @@ 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      supportedPairs: this.#supportedPairs?.map((p) => ({
+        token0: this.labelAddress(p.token0),
+        token1: this.labelAddress(p.token1)
+      }))
+    };
   }
   stringifyFunctionParams(params) {
     switch (params.functionName) {
@@ -49,6 +68,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,53 @@ 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      supportedPools: this.#supportedPools?.map((p) => ({
+        token0: this.labelAddress(p.token0),
+        token1: this.labelAddress(p.token1),
+        fee: p.fee
+      }))
+    };
   }
   stringifyFunctionParams(params) {
     switch (params.functionName) {