@gearbox-protocol/sdk 9.11.1 → 9.12.1

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

@@ -0,0 +1,32 @@
+import { iKodiakIslandGatewayAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iKodiakIslandGatewayAdapterAbi;
+class KodiakIslandGatewayAdapterContract extends AbstractAdapterContract {
+  allowedIslands;
+  constructor(sdk, args) {
+    super(sdk, { ...args, abi });
+    const decoded = decodeAbiParameters(
+      [
+        { type: "address", name: "creditManager" },
+        { type: "address", name: "targetContract" },
+        {
+          type: "tuple[]",
+          name: "allowedIslands",
+          components: [
+            { type: "address", name: "island" },
+            { type: "uint8", name: "status" }
+          ]
+        }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.allowedIslands = decoded[2].map(({ island, status }) => ({
+      island,
+      status
+    }));
+  }
+}
+export {
+  KodiakIslandGatewayAdapterContract
+};

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

@@ -0,0 +1,28 @@
+import { iLidoV1AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iLidoV1AdapterAbi;
+class LidoV1AdapterContract extends AbstractAdapterContract {
+  stETH;
+  weth;
+  treasury;
+  constructor(sdk, args) {
+    super(sdk, { ...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];
+  }
+}
+export {
+  LidoV1AdapterContract
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+import { iTraderJoeRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iTraderJoeRouterAdapterAbi;
+class TraderJoeRouterAdapterContract 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: "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
+    }));
+  }
+}
+export {
+  TraderJoeRouterAdapterContract
+};

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

@@ -0,0 +1,55 @@
+import { iUniswapV2AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  decodeAbiParameters
+} from "viem";
+import { formatBN } from "../../../sdk/index.js";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iUniswapV2AdapterAbi;
+class UniswapV2AdapterContract extends AbstractAdapterContract {
+  supportedPairs;
+  constructor(sdk, args) {
+    super(sdk, { ...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
+    }));
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "swapDiffTokensForTokens": {
+        const [leftoverAmount, rateMinRAY, path, _deadline] = params.args;
+        const leftoverAmountStr = this.sdk.tokensMeta.formatBN(
+          path[0],
+          leftoverAmount
+        );
+        const pathStr = path.map((t) => this.labelAddress(t)).join(" => ");
+        return [
+          `(leftoverAmount: ${leftoverAmountStr}, rate: ${formatBN(
+            rateMinRAY,
+            27
+          )},  path: ${pathStr}`
+        ];
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+export {
+  UniswapV2AdapterContract
+};

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

@@ -0,0 +1,155 @@
+import { iUniswapV3AdapterAbi } from "@gearbox-protocol/integrations-v3";
+import {
+  decodeAbiParameters
+} from "viem";
+import { formatBN } from "../../../sdk/index.js";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iUniswapV3AdapterAbi;
+class UniswapV3AdapterContract 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: "uint24", name: "fee" }
+          ]
+        }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.supportedPools = decoded[2].map((pool) => ({
+      token0: pool.token0,
+      token1: pool.token1,
+      fee: pool.fee
+    }));
+  }
+  parseFunctionParams(params) {
+    switch (params.functionName) {
+      case "exactInputSingle": {
+        const [{ tokenIn, tokenOut, fee, amountIn, amountOutMinimum }] = params.args;
+        const tokenInSym = this.sdk.tokensMeta.symbol(tokenIn);
+        const tokenOutSym = this.sdk.tokensMeta.symbol(tokenOut);
+        const amountInStr = this.sdk.tokensMeta.formatBN(tokenIn, amountIn);
+        const amountOutMinimumStr = this.sdk.tokensMeta.formatBN(
+          tokenOut,
+          amountOutMinimum
+        );
+        return [
+          `(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`
+        ];
+      }
+      case "exactDiffInputSingle": {
+        const [{ tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }] = params.args;
+        const tokenInSym = this.sdk.tokensMeta.symbol(tokenIn);
+        const tokenOutSym = this.sdk.tokensMeta.symbol(tokenOut);
+        const leftoverAmountStr = this.sdk.tokensMeta.formatBN(
+          tokenIn,
+          leftoverAmount
+        );
+        const rateStr = formatBN(rateMinRAY, 27);
+        return [
+          `(leftoverAmount: ${leftoverAmountStr}, rate: ${rateStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`
+        ];
+      }
+      case "exactInput": {
+        const [{ amountIn, amountOutMinimum, path }] = params.args;
+        const pathStr = this.trackInputPath(path);
+        const token = `0x${path.replace("0x", "").slice(0, 40)}`;
+        const amountInStr = this.sdk.tokensMeta.formatBN(token, amountIn);
+        const amountOutMinimumStr = this.sdk.tokensMeta.formatBN(
+          `0x${path.slice(-40, path.length)}`,
+          amountOutMinimum
+        );
+        return [
+          `(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${pathStr}`
+        ];
+      }
+      case "exactDiffInput": {
+        const [{ leftoverAmount, rateMinRAY, path }] = params.args;
+        const leftoverAmountStr = this.sdk.tokensMeta.formatBN(
+          `0x${path.replace("0x", "").slice(0, 40)}`,
+          leftoverAmount
+        );
+        const pathStr = this.trackInputPath(path);
+        return [
+          `(leftoverAmount: ${leftoverAmountStr}, rate: ${formatBN(
+            rateMinRAY,
+            27
+          )},  path: ${pathStr}`
+        ];
+      }
+      case "exactOutput": {
+        const [{ amountInMaximum, amountOut, path }] = params.args;
+        const pathStr = this.trackOutputPath(path);
+        const amountInMaximumStr = this.sdk.tokensMeta.formatBN(
+          `0x${path.slice(-40, path.length)}`,
+          amountInMaximum
+        );
+        const amountOutStr = this.sdk.tokensMeta.formatBN(
+          `0x${path.replace("0x", "").slice(0, 40)}`,
+          amountOut
+        );
+        return [
+          `(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${pathStr}`
+        ];
+      }
+      case "exactOutputSingle": {
+        const [{ tokenIn, tokenOut, fee, amountOut, amountInMaximum }] = params.args;
+        const tokenInSym = this.sdk.tokensMeta.symbol(tokenIn);
+        const tokenOutSym = this.sdk.tokensMeta.symbol(tokenOut);
+        const amountInMaximumStr = this.sdk.tokensMeta.formatBN(
+          tokenIn,
+          amountInMaximum
+        );
+        const amountOutStr = this.sdk.tokensMeta.formatBN(tokenOut, amountOut);
+        return [
+          `(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`
+        ];
+      }
+      default:
+        return void 0;
+    }
+  }
+  trackInputPath(path) {
+    let result = "";
+    let pointer = path.startsWith("0x") ? 2 : 0;
+    while (pointer <= path.length - 40) {
+      const from = `0x${path.slice(
+        pointer,
+        pointer + 40
+      )}`.toLowerCase();
+      result += this.sdk.tokensMeta.symbol(from) || from;
+      pointer += 40;
+      if (pointer > path.length - 6) return result;
+      const fee = parseInt(path.slice(pointer, pointer + 6), 16);
+      pointer += 6;
+      result += ` ==(fee: ${fee})==> `;
+    }
+    return result;
+  }
+  trackOutputPath(path) {
+    let result = "";
+    let pointer = path.length;
+    while (pointer >= 40) {
+      pointer -= 40;
+      const from = `0x${path.slice(pointer, pointer + 40)}`;
+      result += this.sdk.tokensMeta.symbol(from) || from;
+      if (pointer < 6) return result;
+      pointer -= 6;
+      const fee = parseInt(path.slice(pointer, pointer + 6), 16);
+      result += ` ==(fee: ${fee})==> `;
+    }
+    return result;
+  }
+}
+export {
+  UniswapV3AdapterContract
+};

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

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

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

@@ -0,0 +1,36 @@
+import { iVelodromeV2RouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
+import { decodeAbiParameters } from "viem";
+import { AbstractAdapterContract } from "./AbstractAdapter.js";
+const abi = iVelodromeV2RouterAdapterAbi;
+class VelodromeV2RouterAdapterContract 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" },
+            { type: "address", name: "factory" }
+          ]
+        }
+      ],
+      args.baseParams.serializedParams
+    );
+    this.supportedPools = decoded[2].map((pool) => ({
+      token0: pool.token0,
+      token1: pool.token1,
+      stable: pool.stable,
+      factory: pool.factory
+    }));
+  }
+}
+export {
+  VelodromeV2RouterAdapterContract
+};

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

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

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

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