@gearbox-protocol/sdk 13.0.0-next.8 → 13.0.0

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

@@ -1,43 +1,106 @@
 import { iCurveV1StableNgAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import {
+  iCurvePoolAbi,
+  iCurvePoolStableNGAbi
+} from "../abi/targetContractAbi.js";
+import { classifyCurveOperation } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iCurveV1StableNgAdapterAbi;
+const protocolAbi = [...iCurvePoolAbi, ...iCurvePoolStableNGAbi];
 class CurveV1StableNGAdapterContract extends AbstractAdapterContract {
-  token;
-  lpToken;
-  metapoolBase;
-  nCoins;
-  use256;
-  tokens;
-  underlyings;
+  #token;
+  #lpToken;
+  #metapoolBase;
+  #nCoins;
+  #use256;
+  #tokens;
+  #underlyings;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "token" },
-        { type: "address", name: "lpToken" },
-        { type: "address", name: "metapoolBase" },
-        { type: "uint256", name: "nCoins" },
-        { type: "bool", name: "use256" },
-        { type: "address[4]", name: "tokens" },
-        { type: "address[4]", name: "underlyings" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.token = decoded[2];
-    this.lpToken = decoded[3];
-    this.metapoolBase = decoded[4];
-    this.nCoins = Number(decoded[5]);
-    this.use256 = decoded[6];
-    this.tokens = [decoded[7][0], decoded[7][1], decoded[7][2], decoded[7][3]];
-    this.underlyings = [
-      decoded[8][0],
-      decoded[8][1],
-      decoded[8][2],
-      decoded[8][3]
-    ];
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "token" },
+          { type: "address", name: "lpToken" },
+          { type: "address", name: "metapoolBase" },
+          { type: "uint256", name: "nCoins" },
+          { type: "bool", name: "use256" },
+          { type: "address[4]", name: "tokens" },
+          { type: "address[4]", name: "underlyings" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#token = decoded[2];
+      this.#lpToken = decoded[3];
+      this.#metapoolBase = decoded[4];
+      this.#nCoins = Number(decoded[5]);
+      this.#use256 = decoded[6];
+      this.#tokens = [
+        decoded[7][0],
+        decoded[7][1],
+        decoded[7][2],
+        decoded[7][3]
+      ];
+      this.#underlyings = [
+        decoded[8][0],
+        decoded[8][1],
+        decoded[8][2],
+        decoded[8][3]
+      ];
+    }
+  }
+  get token() {
+    if (!this.#token) throw new MissingSerializedParamsError("token");
+    return this.#token;
+  }
+  get lpToken() {
+    if (!this.#lpToken) throw new MissingSerializedParamsError("lpToken");
+    return this.#lpToken;
+  }
+  get metapoolBase() {
+    if (!this.#metapoolBase)
+      throw new MissingSerializedParamsError("metapoolBase");
+    return this.#metapoolBase;
+  }
+  get nCoins() {
+    if (!this.#nCoins) throw new MissingSerializedParamsError("nCoins");
+    return this.#nCoins;
+  }
+  get use256() {
+    if (this.#use256 === void 0)
+      throw new MissingSerializedParamsError("use256");
+    return this.#use256;
+  }
+  get tokens() {
+    if (!this.#tokens) throw new MissingSerializedParamsError("tokens");
+    return this.#tokens;
+  }
+  get underlyings() {
+    if (!this.#underlyings)
+      throw new MissingSerializedParamsError("underlyings");
+    return this.#underlyings;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      token: this.#token ? this.labelAddress(this.#token) : void 0,
+      lpToken: this.#lpToken ? this.labelAddress(this.#lpToken) : void 0,
+      metapoolBase: this.#metapoolBase ? this.labelAddress(this.#metapoolBase) : void 0,
+      nCoins: this.#nCoins,
+      use256: this.#use256,
+      tokens: this.#tokens?.map((t) => this.labelAddress(t)),
+      underlyings: this.#underlyings?.map((t) => this.labelAddress(t))
+    };
+  }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type.go#L132-L164 */
+  classifyLegacyOperation(parsed, transfers) {
+    return classifyCurveOperation(parsed.functionName, transfers) ?? super.classifyLegacyOperation(parsed, transfers);
   }
 }
 export {

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

@@ -1,23 +1,57 @@
 import { iDaiUsdsAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iDaiUsdsAbi } from "../abi/targetContractAbi.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iDaiUsdsAdapterAbi;
+const protocolAbi = iDaiUsdsAbi;
 class DaiUsdsAdapterContract extends AbstractAdapterContract {
-  dai;
-  usds;
+  #dai;
+  #usds;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "dai" },
-        { type: "address", name: "usds" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.dai = decoded[2];
-    this.usds = 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: "dai" },
+          { type: "address", name: "usds" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#dai = decoded[2];
+      this.#usds = decoded[3];
+    }
+  }
+  get dai() {
+    if (!this.#dai) throw new MissingSerializedParamsError("dai");
+    return this.#dai;
+  }
+  get usds() {
+    if (!this.#usds) throw new MissingSerializedParamsError("usds");
+    return this.#usds;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      dai: this.#dai ? this.labelAddress(this.#dai) : void 0,
+      usds: this.#usds ? this.labelAddress(this.#usds) : void 0
+    };
+  }
+  /** @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/operation_type_v3.go#L51-L68 */
+  classifyLegacyOperation(parsed, transfers) {
+    const { functionName: fn } = parsed;
+    if (fn === "daiToUsds") {
+      return { operation: "VaultDeposit", ...swapFromTransfers(transfers) };
+    }
+    if (fn === "usdsToDai") {
+      return { operation: "MakerRedeem", ...swapFromTransfers(transfers) };
+    }
+    return super.classifyLegacyOperation(parsed, transfers);
   }
 }
 export {

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

@@ -1,38 +1,75 @@
 import { ierc4626AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters, zeroAddress } 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 = ierc4626AdapterAbi;
+const protocolAbi = iERC4626Abi;
 class ERC4626AdapterContract extends AbstractAdapterContract {
-  vault;
-  asset;
+  #vault;
+  #asset;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const version = Number(args.baseParams.version);
-    if (version <= 311) {
-      const decoded = decodeAbiParameters(
-        [
-          { type: "address", name: "creditManager" },
-          { type: "address", name: "targetContract" },
-          { type: "address", name: "asset" }
-        ],
-        args.baseParams.serializedParams
-      );
-      this.asset = decoded[2];
-      this.vault = zeroAddress;
-    } 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 <= 311) {
+        const decoded = decodeAbiParameters(
+          [
+            { type: "address", name: "creditManager" },
+            { type: "address", name: "targetContract" },
+            { type: "address", name: "asset" }
+          ],
+          args.baseParams.serializedParams
+        );
+        this.#asset = decoded[2];
+        this.#vault = zeroAddress;
+      } 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;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      vault: this.#vault ? this.labelAddress(this.#vault) : void 0,
+      asset: this.#asset ? this.labelAddress(this.#asset) : void 0
+    };
+  }
+  /**
+   * Charts_server maps `redeem(uint256,address,address)` → MakerRedeem.
+   * Diff variants (`redeemDiff`) should also map to MakerRedeem.
+   * Everything else (deposit, depositDiff, withdraw) falls to base class fallback → Swap.
+   *
+   * @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 {
   ERC4626AdapterContract

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

@@ -1,23 +1,57 @@
 import { erc4626ReferralAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iERC4626ReferralAbi } from "../abi/targetContractAbi.js";
+import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = erc4626ReferralAdapterAbi;
+const protocolAbi = iERC4626ReferralAbi;
 class ERC4626ReferralAdapterContract extends AbstractAdapterContract {
-  asset;
-  referral;
+  #asset;
+  #referral;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "asset" },
-        { type: "uint16", name: "referral" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.asset = decoded[2];
-    this.referral = 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: "asset" },
+          { type: "uint16", name: "referral" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#asset = decoded[2];
+      this.#referral = decoded[3];
+    }
+  }
+  get asset() {
+    if (!this.#asset) throw new MissingSerializedParamsError("asset");
+    return this.#asset;
+  }
+  get referral() {
+    if (this.#referral === void 0)
+      throw new MissingSerializedParamsError("referral");
+    return this.#referral;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      asset: this.#asset ? this.labelAddress(this.#asset) : void 0,
+      referral: this.#referral
+    };
+  }
+  /**
+   * @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/FluidDexAdapterContract.js

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

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

@@ -1,32 +1,67 @@
 import { iInfinifiGatewayAdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
+import { iInfinifiGatewayAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iInfinifiGatewayAdapterAbi;
+const protocolAbi = iInfinifiGatewayAbi;
 class InfinifiGatewayAdapterContract extends AbstractAdapterContract {
-  usdc;
-  iusd;
-  siusd;
-  allowedLockedTokens;
+  #usdc;
+  #iusd;
+  #siusd;
+  #allowedLockedTokens;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "usdc" },
-        { type: "address", name: "iusd" },
-        { type: "address", name: "siusd" },
-        {
-          type: "address[]",
-          name: "allowedLockedTokens"
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.usdc = decoded[2];
-    this.iusd = decoded[3];
-    this.siusd = decoded[4];
-    this.allowedLockedTokens = [...decoded[5]];
+    super(options, { ...args, abi, protocolAbi });
+    if (args.baseParams.serializedParams) {
+      const decoded = decodeAbiParameters(
+        [
+          { type: "address", name: "creditManager" },
+          { type: "address", name: "targetContract" },
+          { type: "address", name: "usdc" },
+          { type: "address", name: "iusd" },
+          { type: "address", name: "siusd" },
+          {
+            type: "address[]",
+            name: "allowedLockedTokens"
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#usdc = decoded[2];
+      this.#iusd = decoded[3];
+      this.#siusd = decoded[4];
+      this.#allowedLockedTokens = [...decoded[5]];
+    }
+  }
+  get usdc() {
+    if (!this.#usdc) throw new MissingSerializedParamsError("usdc");
+    return this.#usdc;
+  }
+  get iusd() {
+    if (!this.#iusd) throw new MissingSerializedParamsError("iusd");
+    return this.#iusd;
+  }
+  get siusd() {
+    if (!this.#siusd) throw new MissingSerializedParamsError("siusd");
+    return this.#siusd;
+  }
+  get allowedLockedTokens() {
+    if (!this.#allowedLockedTokens)
+      throw new MissingSerializedParamsError("allowedLockedTokens");
+    return this.#allowedLockedTokens;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      usdc: this.#usdc ? this.labelAddress(this.#usdc) : void 0,
+      iusd: this.#iusd ? this.labelAddress(this.#iusd) : void 0,
+      siusd: this.#siusd ? this.labelAddress(this.#siusd) : void 0,
+      allowedLockedTokens: this.#allowedLockedTokens?.map(
+        (t) => this.labelAddress(t)
+      )
+    };
   }
 }
 export {

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

@@ -1,23 +1,45 @@
-import { iInfinifiUnwindingGatewayAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  iInfinifiUnwindingGatewayAbi,
+  iInfinifiUnwindingGatewayAdapterAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
 const abi = iInfinifiUnwindingGatewayAdapterAbi;
+const protocolAbi = iInfinifiUnwindingGatewayAbi;
 class InfinifiUnwindingGatewayAdapterContract extends AbstractAdapterContract {
-  allowedLockedTokens;
+  #allowedLockedTokens;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        {
-          type: "address[]",
-          name: "allowedLockedTokens"
-        }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.allowedLockedTokens = [...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: "allowedLockedTokens"
+          }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#allowedLockedTokens = [...decoded[2]];
+    }
+  }
+  get allowedLockedTokens() {
+    if (!this.#allowedLockedTokens)
+      throw new MissingSerializedParamsError("allowedLockedTokens");
+    return this.#allowedLockedTokens;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedLockedTokens: this.#allowedLockedTokens?.map(
+        (t) => this.labelAddress(t)
+      )
+    };
   }
 }
 export {

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

@@ -1,19 +1,40 @@
+import {
+  iKelpLrtDepositPoolAdapterAbi,
+  iKelpLrtDepositPoolGatewayAbi
+} from "@gearbox-protocol/integrations-v3";
 import { decodeAbiParameters } from "viem";
+import {
+  MissingSerializedParamsError
+} from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-const abi = [];
+const abi = iKelpLrtDepositPoolAdapterAbi;
+const protocolAbi = iKelpLrtDepositPoolGatewayAbi;
 class KelpLRTDepositPoolAdapterContract extends AbstractAdapterContract {
-  allowedAssets;
+  #allowedAssets;
   constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = decodeAbiParameters(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address[]", name: "allowedAssets" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.allowedAssets = [...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: "allowedAssets" }
+        ],
+        args.baseParams.serializedParams
+      );
+      this.#allowedAssets = [...decoded[2]];
+    }
+  }
+  get allowedAssets() {
+    if (!this.#allowedAssets)
+      throw new MissingSerializedParamsError("allowedAssets");
+    return this.#allowedAssets;
+  }
+  stateHuman(raw) {
+    return {
+      ...super.stateHuman(raw),
+      allowedAssets: this.#allowedAssets?.map((a) => this.labelAddress(a))
+    };
   }
 }
 export {