@gearbox-protocol/sdk 9.11.0 → 9.12.0

package/dist/esm/plugins/adapters/abi/utils.js

@@ -0,0 +1,64 @@
+import {
+  decodeAbiParameters,
+  decodeFunctionData
+} from "viem";
+import { json_stringify } from "../../../sdk/index.js";
+import { AdapterType } from "../types";
+import {
+  adapterActionAbi,
+  adapterActionSelectors,
+  adapterConstructorAbi
+} from ".";
+function getAdapterType(value) {
+  const cleanValue = value.replace(/\0/g, "").trim();
+  return Object.values(AdapterType).includes(cleanValue) ? cleanValue : null;
+}
+function getAdapterDeployParamsAbi(adapterPostfix, version = 310) {
+  const adapterType = getAdapterType(adapterPostfix);
+  if (!adapterType) return null;
+  return adapterConstructorAbi[adapterType][version] ?? null;
+}
+function parseAdapterDeployParams(adapterPostfix, version, data) {
+  const abi = getAdapterDeployParamsAbi(adapterPostfix, version);
+  if (!abi) return null;
+  const decoded = decodeAbiParameters(abi, data);
+  const result = {};
+  abi.forEach((param, index) => {
+    if (param.name !== void 0 && param.name !== "") {
+      result[param.name] = String(decoded[index]);
+    }
+  });
+  return result;
+}
+function hasAdapterDeployParamsAbi(adapterType) {
+  return adapterType in adapterConstructorAbi;
+}
+function getAdapterActionAbi(adapterPostfix, version = 310) {
+  const adapterType = getAdapterType(adapterPostfix);
+  if (!adapterType) return null;
+  return adapterActionAbi[adapterType]?.[version] ?? null;
+}
+function parseAdapterAction(data) {
+  if (data.length < 10) return null;
+  const selector = data.slice(0, 10);
+  const adapterType = adapterActionSelectors[selector]?.adapterType;
+  if (!adapterType) return null;
+  const abi = getAdapterActionAbi(adapterType);
+  if (!abi) return null;
+  const decoded = decodeFunctionData({
+    abi,
+    data
+  });
+  return {
+    functionName: decoded.functionName,
+    args: json_stringify(decoded.args)
+  };
+}
+export {
+  getAdapterActionAbi,
+  getAdapterDeployParamsAbi,
+  getAdapterType,
+  hasAdapterDeployParamsAbi,
+  parseAdapterAction,
+  parseAdapterDeployParams
+};

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

@@ -0,0 +1,15 @@
+import { BaseContract } from "../../../sdk/index.js";
+class AbstractAdapterContract extends BaseContract {
+  targetContract;
+  constructor(sdk, args) {
+    const { baseParams, targetContract, ...rest } = args;
+    super(sdk, { ...rest, ...baseParams });
+    this.targetContract = targetContract;
+  }
+  get adapterType() {
+    return this.contractType;
+  }
+}
+export {
+  AbstractAdapterContract
+};

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

@@ -0,0 +1,27 @@
+import { iBalancerV2VaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iBalancerV2VaultAdapterAbi;
+class BalancerV2VaultAdapterContract extends AbstractAdapterContract {
+  supportedPoolIds;
+  poolStatuses;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi });
+    const decoded = decodeAbiParameters(
+      [
+        { type: "address", name: "creditManager" },
+        { type: "address", name: "targetContract" },
+        { type: "bytes32[]", name: "supportedPoolIds" },
+        { type: "uint8[]", name: "poolStatuses" }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.supportedPoolIds = [...decoded[2]];
+    this.poolStatuses = decoded[3].map(
+      (status) => status
+    );
+  }
+}
+export {
+  BalancerV2VaultAdapterContract
+};

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

@@ -0,0 +1,22 @@
+import { iBalancerV3RouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iBalancerV3RouterAdapterAbi;
+class BalancerV3RouterAdapterContract extends AbstractAdapterContract {
+  allowedPools;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi });
+    const decoded = decodeAbiParameters(
+      [
+        { type: "address", name: "creditManager" },
+        { type: "address", name: "targetContract" },
+        { type: "address[]", name: "allowedPools" }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.allowedPools = [...decoded[2]];
+  }
+}
+export {
+  BalancerV3RouterAdapterContract
+};

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

@@ -0,0 +1,32 @@
+import { iCamelotV3AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iCamelotV3AdapterAbi;
+class CamelotV3AdapterContract extends AbstractAdapterContract {
+  supportedPools;
+  constructor(sdk, args) {
+    super(sdk, { ...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" }
+          ]
+        }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.supportedPools = decoded[2].map((pool) => ({
+      token0: pool.token0,
+      token1: pool.token1
+    }));
+  }
+}
+export {
+  CamelotV3AdapterContract
+};

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

@@ -0,0 +1,36 @@
+import { iConvexV1BaseRewardPoolAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iConvexV1BaseRewardPoolAdapterAbi;
+class ConvexV1BaseRewardPoolAdapterContract extends AbstractAdapterContract {
+  curveLPtoken;
+  stakingToken;
+  stakedPhantomToken;
+  extraRewards;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi });
+    const decoded = decodeAbiParameters(
+      [
+        { type: "address", name: "creditManager" },
+        { type: "address", name: "targetContract" },
+        { type: "address", name: "curveLPtoken" },
+        { type: "address", name: "stakingToken" },
+        { type: "address", name: "stakedPhantomToken" },
+        { type: "address[4]", name: "extraRewards" }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.curveLPtoken = decoded[2];
+    this.stakingToken = decoded[3];
+    this.stakedPhantomToken = decoded[4];
+    this.extraRewards = [
+      decoded[5][0],
+      decoded[5][1],
+      decoded[5][2],
+      decoded[5][3]
+    ];
+  }
+}
+export {
+  ConvexV1BaseRewardPoolAdapterContract
+};

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

@@ -0,0 +1,36 @@
+import { iConvexV1BoosterAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iConvexV1BoosterAdapterAbi;
+class ConvexV1BoosterAdapterContract extends AbstractAdapterContract {
+  supportedPools;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi });
+    const decoded = decodeAbiParameters(
+      [
+        { type: "address", name: "creditManager" },
+        { type: "address", name: "targetContract" },
+        {
+          type: "tuple[]",
+          name: "supportedPools",
+          components: [
+            { type: "uint256", name: "pid" },
+            { type: "address", name: "curveToken" },
+            { type: "address", name: "convexToken" },
+            { type: "address", name: "phantomToken" }
+          ]
+        }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.supportedPools = decoded[2].map((pool) => ({
+      pid: Number(pool.pid),
+      curveToken: pool.curveToken,
+      convexToken: pool.convexToken,
+      phantomToken: pool.phantomToken
+    }));
+  }
+}
+export {
+  ConvexV1BoosterAdapterContract
+};

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

@@ -0,0 +1,42 @@
+import { iCurveV1_2AssetsAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iCurveV1_2AssetsAdapterAbi;
+class Curve2AssetsAdapterContract extends AbstractAdapterContract {
+  token;
+  lpToken;
+  metapoolBase;
+  use256;
+  tokens;
+  underlyings;
+  constructor(sdk, args) {
+    super(sdk, { ...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: "bool", name: "use256" },
+        { type: "address[2]", name: "tokens" },
+        { type: "address[4]", name: "underlyings" }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.token = decoded[2];
+    this.lpToken = decoded[3];
+    this.metapoolBase = decoded[4];
+    this.use256 = decoded[5];
+    this.tokens = [decoded[6][0], decoded[6][1]];
+    this.underlyings = [
+      decoded[7][0],
+      decoded[7][1],
+      decoded[7][2],
+      decoded[7][3]
+    ];
+  }
+}
+export {
+  Curve2AssetsAdapterContract
+};

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

@@ -0,0 +1,42 @@
+import { iCurveV1_3AssetsAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iCurveV1_3AssetsAdapterAbi;
+class Curve3AssetsAdapterContract extends AbstractAdapterContract {
+  token;
+  lpToken;
+  metapoolBase;
+  use256;
+  tokens;
+  underlyings;
+  constructor(sdk, args) {
+    super(sdk, { ...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: "bool", name: "use256" },
+        { type: "address[3]", name: "tokens" },
+        { type: "address[4]", name: "underlyings" }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.token = decoded[2];
+    this.lpToken = decoded[3];
+    this.metapoolBase = decoded[4];
+    this.use256 = decoded[5];
+    this.tokens = [decoded[6][0], decoded[6][1], decoded[6][2]];
+    this.underlyings = [
+      decoded[7][0],
+      decoded[7][1],
+      decoded[7][2],
+      decoded[7][3]
+    ];
+  }
+}
+export {
+  Curve3AssetsAdapterContract
+};

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

@@ -0,0 +1,42 @@
+import { iCurveV1_4AssetsAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iCurveV1_4AssetsAdapterAbi;
+class Curve4AssetsAdapterContract extends AbstractAdapterContract {
+  token;
+  lpToken;
+  metapoolBase;
+  use256;
+  tokens;
+  underlyings;
+  constructor(sdk, args) {
+    super(sdk, { ...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: "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.use256 = decoded[5];
+    this.tokens = [decoded[6][0], decoded[6][1], decoded[6][2], decoded[6][3]];
+    this.underlyings = [
+      decoded[7][0],
+      decoded[7][1],
+      decoded[7][2],
+      decoded[7][3]
+    ];
+  }
+}
+export {
+  Curve4AssetsAdapterContract
+};

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

@@ -0,0 +1,45 @@
+import { iCurveV1AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iCurveV1AdapterAbi;
+class CurveV1AdapterDeposit extends AbstractAdapterContract {
+  token;
+  lpToken;
+  metapoolBase;
+  nCoins;
+  use256;
+  tokens;
+  underlyings;
+  constructor(sdk, args) {
+    super(sdk, { ...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]
+    ];
+  }
+}
+export {
+  CurveV1AdapterDeposit
+};

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

@@ -0,0 +1,37 @@
+import { iCurveV1_2AssetsAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iCurveV1_2AssetsAdapterAbi;
+class CurveV1AdapterStETHContract extends AbstractAdapterContract {
+  token;
+  lpToken;
+  metapoolBase;
+  nCoins;
+  use256;
+  tokens;
+  constructor(sdk, args) {
+    super(sdk, { ...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[2]", name: "tokens" }
+      ],
+      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]];
+  }
+}
+export {
+  CurveV1AdapterStETHContract
+};

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

@@ -0,0 +1,45 @@
+import { iCurveV1StableNgAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iCurveV1StableNgAdapterAbi;
+class CurveV1StableNGAdapterContract extends AbstractAdapterContract {
+  token;
+  lpToken;
+  metapoolBase;
+  nCoins;
+  use256;
+  tokens;
+  underlyings;
+  constructor(sdk, args) {
+    super(sdk, { ...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]
+    ];
+  }
+}
+export {
+  CurveV1StableNGAdapterContract
+};

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

@@ -0,0 +1,25 @@
+import { iDaiUsdsAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iDaiUsdsAdapterAbi;
+class DaiUsdsAdapterContract extends AbstractAdapterContract {
+  dai;
+  usds;
+  constructor(sdk, args) {
+    super(sdk, { ...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];
+  }
+}
+export {
+  DaiUsdsAdapterContract
+};

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

@@ -0,0 +1,39 @@
+import { ierc4626AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters, zeroAddress } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = ierc4626AdapterAbi;
+class ERC4626AdapterContract extends AbstractAdapterContract {
+  vault;
+  asset;
+  constructor(sdk, args) {
+    super(sdk, { ...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];
+    }
+  }
+}
+export {
+  ERC4626AdapterContract
+};

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

@@ -0,0 +1,25 @@
+import { erc4626ReferralAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = erc4626ReferralAdapterAbi;
+class ERC4626ReferralAdapterContract extends AbstractAdapterContract {
+  asset;
+  referral;
+  constructor(sdk, args) {
+    super(sdk, { ...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];
+  }
+}
+export {
+  ERC4626ReferralAdapterContract
+};

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

@@ -0,0 +1,34 @@
+import { iEqualizerRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iEqualizerRouterAdapterAbi;
+class EqualizerRouterAdapterContract extends AbstractAdapterContract {
+  supportedPools;
+  constructor(sdk, args) {
+    super(sdk, { ...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" }
+          ]
+        }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.supportedPools = decoded[2].map((pool) => ({
+      token0: pool.token0,
+      token1: pool.token1,
+      stable: pool.stable
+    }));
+  }
+}
+export {
+  EqualizerRouterAdapterContract
+};

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

@@ -0,0 +1,25 @@
+import { iFluidDexAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iFluidDexAdapterAbi;
+class FluidDexAdapterContract extends AbstractAdapterContract {
+  token0;
+  token1;
+  constructor(sdk, args) {
+    super(sdk, { ...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];
+  }
+}
+export {
+  FluidDexAdapterContract
+};

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

@@ -0,0 +1,25 @@
+import { iInfraredVaultAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iInfraredVaultAdapterAbi;
+class InfraredVaultAdapterContract extends AbstractAdapterContract {
+  stakingToken;
+  stakedPhantomToken;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi });
+    const decoded = decodeAbiParameters(
+      [
+        { type: "address", name: "creditManager" },
+        { type: "address", name: "targetContract" },
+        { type: "address", name: "stakingToken" },
+        { type: "address", name: "stakedPhantomToken" }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.stakingToken = decoded[2];
+    this.stakedPhantomToken = decoded[3];
+  }
+}
+export {
+  InfraredVaultAdapterContract
+};