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

package/dist/cjs/history/mapOperations.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mapOperations_exports = {};
+__export(mapOperations_exports, {
+  mapOperations: () => mapOperations
+});
+module.exports = __toCommonJS(mapOperations_exports);
+function mapInnerOperation(op, visitor, ctx) {
+  switch (op.operation) {
+    case "Execute":
+      return visitor.Execute(op, ctx);
+    case "IncreaseBorrowedAmount":
+      return visitor.IncreaseBorrowedAmount(op, ctx);
+    case "DecreaseBorrowedAmount":
+      return visitor.DecreaseBorrowedAmount(op, ctx);
+    case "AddCollateral":
+      return visitor.AddCollateral(op, ctx);
+    case "WithdrawCollateral":
+      return visitor.WithdrawCollateral(op, ctx);
+    case "UpdateQuota":
+      return visitor.UpdateQuota(op, ctx);
+  }
+}
+function mapOuterOperation(op, visitor) {
+  switch (op.operation) {
+    case "DirectTokenTransfer":
+      return visitor.DirectTokenTransfer(op);
+    case "PartiallyLiquidateCreditAccount":
+      return visitor.PartiallyLiquidateCreditAccount(op);
+    case "MultiCall":
+    case "BotMulticall": {
+      const multicall = op.multicall.map(
+        (inner) => mapInnerOperation(inner, visitor, op)
+      );
+      return visitor.MultiCall(op, multicall);
+    }
+    case "OpenCreditAccount": {
+      const multicall = op.multicall.map(
+        (inner) => mapInnerOperation(inner, visitor, op)
+      );
+      return visitor.OpenCreditAccount(op, multicall);
+    }
+    case "CloseCreditAccount": {
+      const multicall = op.multicall.map(
+        (inner) => mapInnerOperation(inner, visitor, op)
+      );
+      return visitor.CloseCreditAccount(op, multicall);
+    }
+    case "LiquidateCreditAccount": {
+      const multicall = op.multicall.map(
+        (inner) => mapInnerOperation(inner, visitor, op)
+      );
+      return visitor.LiquidateCreditAccount(op, multicall);
+    }
+  }
+}
+function mapOperations(ops, visitor) {
+  return ops.map((op) => mapOuterOperation(op, visitor));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapOperations
+});

package/dist/cjs/history/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/cjs/history/parseCreditAccountTransaction.js

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parseCreditAccountTransaction_exports = {};
+__export(parseCreditAccountTransaction_exports, {
+  parseCreditAccountTransaction: () => parseCreditAccountTransaction
+});
+module.exports = __toCommonJS(parseCreditAccountTransaction_exports);
+var import_assembleOperations = require("./assembleOperations.js");
+var import_extractTransfers = require("./extractTransfers.js");
+var import_findFacadeCalls = require("./findFacadeCalls.js");
+function parseCreditAccountTransaction(input) {
+  const {
+    trace,
+    receipt,
+    pool,
+    creditFacade,
+    creditManager,
+    creditAccount,
+    underlying,
+    register,
+    strict
+  } = input;
+  const logs = receipt.logs;
+  const txHash = receipt.transactionHash;
+  const blockNumber = Number(receipt.blockNumber);
+  const timestamp = Number(receipt.blockTimestamp ?? 0);
+  const facadeCalls = (0, import_findFacadeCalls.findFacadeCalls)(
+    trace,
+    creditFacade,
+    creditAccount,
+    register,
+    strict
+  );
+  const {
+    executeResults,
+    directTransfers,
+    liquidationRemainingFunds,
+    phantomTokens
+  } = (0, import_extractTransfers.extractTransfers)(logs, creditAccount, pool, creditFacade);
+  const meta = {
+    creditManager,
+    creditFacade,
+    timestamp,
+    blockNumber,
+    txHash
+  };
+  const facadeOps = (0, import_assembleOperations.assembleOperations)({
+    facadeCalls,
+    executeResults,
+    register,
+    underlying,
+    liquidationRemainingFunds,
+    phantomTokens,
+    strict
+  }).map((o) => ({ ...o, ...meta }));
+  const directOps = directTransfers.map((dt) => ({
+    operation: "DirectTokenTransfer",
+    txHash,
+    blockNumber,
+    timestamp,
+    protocol: dt.token,
+    creditAccount,
+    ...dt
+  }));
+  return [...facadeOps, ...directOps];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCreditAccountTransaction
+});

package/dist/cjs/history/populateContractsRegister.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var populateContractsRegister_exports = {};
+__export(populateContractsRegister_exports, {
+  populateContractsRegister: () => populateContractsRegister
+});
+module.exports = __toCommonJS(populateContractsRegister_exports);
+var import_viem = require("viem");
+var import_createAdapter = require("../plugins/adapters/createAdapter.js");
+var import_sdk = require("../sdk/index.js");
+function populateContractsRegister(options) {
+  const { client, deployments, tokens, logger, strict } = options;
+  const register = new import_sdk.ChainContractsRegister(client, logger);
+  for (const d of deployments) {
+    let contractType;
+    if ("contractType" in d) {
+      contractType = (0, import_viem.isHex)(d.contractType) ? (0, import_sdk.bytes32ToString)(d.contractType) : d.contractType;
+    } else {
+      contractType = [d.contractTypePrefix, d.contractTypeSuffix].filter(Boolean).join("::");
+    }
+    if (contractType === "CREDIT_FACADE" && (0, import_sdk.isV310)(d.version)) {
+      new import_sdk.CreditFacadeV310BaseContract(
+        { register, logger },
+        { addr: d.address, version: d.version, contractType }
+      );
+    } else if (contractType.startsWith("ADAPTER::")) {
+      (0, import_createAdapter.createAdapter)(
+        {
+          register,
+          logger
+        },
+        {
+          baseParams: {
+            addr: d.address,
+            version: d.version,
+            contractType
+          }
+        },
+        strict
+      );
+    }
+  }
+  const tMetas = tokens instanceof import_sdk.TokensMeta ? tokens.values() : tokens;
+  for (const t of tMetas) {
+    register.tokensMeta.upsert(t.addr, t);
+  }
+  return register;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  populateContractsRegister
+});

package/dist/cjs/history/toLegacyOperation.js

@@ -0,0 +1,182 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toLegacyOperation_exports = {};
+__export(toLegacyOperation_exports, {
+  createLegacyVisitor: () => createLegacyVisitor,
+  toLegacyOperations: () => toLegacyOperations
+});
+module.exports = __toCommonJS(toLegacyOperation_exports);
+var import_mapOperations = require("./mapOperations.js");
+function commonFields(op, params) {
+  return {
+    timestamp: op.timestamp,
+    sessionId: params.sessionId,
+    protocol: op.creditFacade
+  };
+}
+function innerCommonFields(ctx, params) {
+  return {
+    txHash: ctx.txHash,
+    blockNum: ctx.blockNumber,
+    timestamp: ctx.timestamp,
+    sessionId: params.sessionId,
+    protocol: ctx.creditFacade
+  };
+}
+function createLegacyVisitor(params) {
+  return {
+    Execute(op, ctx) {
+      return {
+        ...op.legacy,
+        txHash: ctx.txHash,
+        blockNum: ctx.blockNumber,
+        timestamp: ctx.timestamp,
+        sessionId: params.sessionId,
+        protocol: op.protocol
+      };
+    },
+    IncreaseBorrowedAmount(op, ctx) {
+      return {
+        operation: op.operation,
+        amount: op.amount.toString(),
+        ...innerCommonFields(ctx, params),
+        protocol: ctx.creditManager
+      };
+    },
+    DecreaseBorrowedAmount(op, ctx) {
+      return {
+        operation: op.operation,
+        amount: op.amount.toString(),
+        ...innerCommonFields(ctx, params),
+        protocol: ctx.creditManager
+      };
+    },
+    AddCollateral(op, ctx) {
+      return {
+        operation: op.operation,
+        token: op.token,
+        amount: op.amount.toString(),
+        ...innerCommonFields(ctx, params)
+      };
+    },
+    WithdrawCollateral(op, ctx) {
+      return {
+        operation: op.operation,
+        token: op.token,
+        amount: op.amount.toString(),
+        to: op.to,
+        ...op.phantomToken ? { phantomToken: op.phantomToken } : {},
+        ...innerCommonFields(ctx, params)
+      };
+    },
+    UpdateQuota(op, ctx) {
+      return {
+        operation: op.operation,
+        token: op.token,
+        change: op.change.toString(),
+        ...innerCommonFields(ctx, params)
+      };
+    },
+    DirectTokenTransfer(op) {
+      return {
+        operation: op.operation,
+        txHash: op.txHash,
+        blockNum: op.blockNumber,
+        timestamp: op.timestamp,
+        sessionId: params.sessionId,
+        protocol: op.protocol,
+        token: op.token,
+        amount: op.amount.toString(),
+        from: op.from,
+        to: op.creditAccount
+      };
+    },
+    MultiCall(op, multicall) {
+      return {
+        operation: op.operation,
+        txHash: op.txHash,
+        blockNum: op.blockNumber,
+        ...commonFields(op, params),
+        multicall
+      };
+    },
+    OpenCreditAccount(op, multicall) {
+      return {
+        operation: op.operation,
+        txHash: op.txHash,
+        blockNum: op.blockNumber,
+        ...commonFields(op, params),
+        multicall,
+        // TODO: missing legacy fields:
+        // userFunds: require prices to compute as
+        // sum of AddCollateral/WithdrawCollateral amounts denominated in underlying token.
+        // initialFunds: === userFunds
+        //
+        // leverage: (userFunds + borrowAmount) / userFunds
+        // where borrowAmount = sum of IncreaseDebt amounts in multicall (computable from data)
+        userFunds: "0",
+        initialFunds: "0",
+        leverage: "0"
+      };
+    },
+    CloseCreditAccount(op, multicall) {
+      return {
+        operation: op.operation,
+        txHash: op.txHash,
+        blockNum: op.blockNumber,
+        ...commonFields(op, params),
+        multicall,
+        // TODO: missing legacy fields:
+        // remainingFunds:
+        remainingFunds: "0"
+      };
+    },
+    LiquidateCreditAccount(op, multicall) {
+      return {
+        operation: op.operation,
+        txHash: op.txHash,
+        blockNum: op.blockNumber,
+        ...commonFields(op, params),
+        to: op.to,
+        remainingFunds: op.remainingFunds.toString(),
+        multicall
+      };
+    },
+    PartiallyLiquidateCreditAccount(op) {
+      return {
+        operation: op.operation,
+        txHash: op.txHash,
+        blockNum: op.blockNumber,
+        ...commonFields(op, params),
+        token: op.token,
+        repaidAmount: op.repaidAmount.toString(),
+        minSeizedAmount: op.minSeizedAmount.toString(),
+        to: op.to
+      };
+    }
+  };
+}
+function toLegacyOperations(ops, params) {
+  return (0, import_mapOperations.mapOperations)(ops, createLegacyVisitor(params));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLegacyVisitor,
+  toLegacyOperations
+});

package/dist/cjs/{plugins/adapters/contracts/YearnV2AdapterContract.js → history/trace-utils.js}

@@ -16,31 +16,46 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var YearnV2AdapterContract_exports = {};
-__export(YearnV2AdapterContract_exports, {
-  YearnV2RouterAdapterContract: () => YearnV2RouterAdapterContract
+var trace_utils_exports = {};
+__export(trace_utils_exports, {
+  collectTraces: () => collectTraces,
+  findCallTo: () => findCallTo
 });
-module.exports = __toCommonJS(YearnV2AdapterContract_exports);
-var import_integrations_v3 = require("@gearbox-protocol/integrations-v3");
+module.exports = __toCommonJS(trace_utils_exports);
 var import_viem = require("viem");
-var import_AbstractAdapter = require("./AbstractAdapter.js");
-const abi = import_integrations_v3.iYearnV2AdapterAbi;
-class YearnV2RouterAdapterContract extends import_AbstractAdapter.AbstractAdapterContract {
-  token;
-  constructor(options, args) {
-    super(options, { ...args, abi });
-    const decoded = (0, import_viem.decodeAbiParameters)(
-      [
-        { type: "address", name: "creditManager" },
-        { type: "address", name: "targetContract" },
-        { type: "address", name: "token" }
-      ],
-      args.baseParams.serializedParams
-    );
-    this.token = decoded[2];
+function findCallTo(node, target) {
+  if (node.error) {
+    return void 0;
   }
+  if (node.type === "CALL" && (0, import_viem.isAddressEqual)(node.to, target)) {
+    return node;
+  }
+  if (node.calls) {
+    for (const child of node.calls) {
+      const found = findCallTo(child, target);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+function collectTraces(node, target) {
+  const results = [];
+  if (node.error) {
+    return results;
+  }
+  if (node.type === "CALL" && (0, import_viem.isAddressEqual)(node.to, target)) {
+    results.push(node);
+  } else if (node.calls) {
+    for (const child of node.calls) {
+      results.push(...collectTraces(child, target));
+    }
+  }
+  return results;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  YearnV2RouterAdapterContract
+  collectTraces,
+  findCallTo
 });

package/dist/cjs/permissionless/bindings/cross-chain-multisig.js

@@ -31,8 +31,8 @@ var import_instance_manager = require("./instance-manager.js");
 var import_market_configurator_factory = require("./market-configurator-factory.js");
 const abi = import_crossChainMultisig.crossChainMultisigAbi;
 class CrossChainMultisigContract extends import_sdk.BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "CrossChainMultisig" });
+  constructor(addr, register) {
+    super({ register }, { abi, addr, name: "CrossChainMultisig" });
   }
   async getExecutedBatches(fromBlock, toBlock) {
     const events = await this.getEvents("ExecuteBatch", fromBlock, toBlock);
@@ -185,7 +185,7 @@ class CrossChainMultisigContract extends import_sdk.BaseContract {
       case import_addresses.Addresses.INSTANCE_MANAGER.toLowerCase(): {
         const instanceManager = new import_instance_manager.InstanceManagerContract(
           target,
-          this.client
+          this.register
         );
         return instanceManager.parseFunctionData(calldata);
       }

package/dist/cjs/permissionless/bindings/instance-manager.js

@@ -38,8 +38,8 @@ var import_router = require("./router/index.js");
 var import_treasury_splitter = require("./treasury-splitter.js");
 const abi = import_instanceManager.instanceManagerAbi;
 class InstanceManagerContract extends import_sdk.BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "InstanceManager" });
+  constructor(addr, register) {
+    super({ register }, { abi, addr, name: "InstanceManager" });
   }
   // TODO:
   #decodeFunctionData(target, calldata) {
@@ -154,7 +154,7 @@ class InstanceManagerContract extends import_sdk.BaseContract {
       );
       return {
         ...result,
-        label: `${this.register.labelAddress(target, true)} via ${result.label}`
+        label: `${this.labelAddress(target, true)} via ${result.label}`
       };
     }
     return super.mustParseFunctionData(calldata);

package/dist/cjs/permissionless/utils/price-update/get-prices.js

@@ -105,12 +105,8 @@ async function getPrices({
     client,
     gasLimit,
     marketConfigurators: [],
-    redstone: {
-      ignoreMissingFeeds: true
-    },
-    pyth: {
-      ignoreMissingFeeds: true
-    }
+    redstone: {},
+    pyth: {}
   });
   const chunks = [];
   for (let i = 0; i < priceFeeds.length; i += chunkSize) {

package/dist/cjs/plugins/adapters/AdaptersPlugin.js

@@ -22,119 +22,23 @@ __export(AdaptersPlugin_exports, {
 });
 module.exports = __toCommonJS(AdaptersPlugin_exports);
 var import_sdk = require("../../sdk/index.js");
-var import_AccountMigratorAdapterContract = require("./contracts/AccountMigratorAdapterContract.js");
-var import_InfinifiGatewayAdapterContract = require("./contracts/InfinifiGatewayAdapterContract.js");
-var import_InfinifiUnwindingGatewayAdapterContract = require("./contracts/InfinifiUnwindingGatewayAdapterContract.js");
-var import_contracts = require("./contracts/index.js");
-var import_UniswapV4AdapterContract = require("./contracts/UniswapV4AdapterContract.js");
+var import_AbstractAdapter = require("./contracts/AbstractAdapter.js");
+var import_createAdapter = require("./createAdapter.js");
 class AdaptersPlugin extends import_sdk.BasePlugin {
   name = "Adapters";
   version = 1;
   loaded = true;
   createContract(data) {
-    const args = data;
-    const adapterType = (0, import_sdk.bytes32ToString)(
-      args.baseParams.contractType
-    );
-    switch (adapterType) {
-      case "ADAPTER::ACCOUNT_MIGRATOR":
-        return new import_AccountMigratorAdapterContract.AccountMigratorAdapterContract(this.sdk, args);
-      case "ADAPTER::BALANCER_V3_ROUTER":
-        return new import_contracts.BalancerV3RouterAdapterContract(this.sdk, args);
-      case "ADAPTER::BALANCER_V3_WRAPPER":
-        return new import_contracts.BalancerV3WrapperAdapterContract(this.sdk, args);
-      case "ADAPTER::BALANCER_VAULT":
-        return new import_contracts.BalancerV2VaultAdapterContract(this.sdk, args);
-      case "ADAPTER::CAMELOT_V3_ROUTER":
-        return new import_contracts.CamelotV3AdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_STABLE_NG":
-        return new import_contracts.CurveV1StableNGAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_2ASSETS":
-        return new import_contracts.Curve2AssetsAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_3ASSETS":
-        return new import_contracts.Curve3AssetsAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_4ASSETS":
-        return new import_contracts.Curve4AssetsAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_STECRV_POOL":
-        return new import_contracts.CurveV1AdapterStETHContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_WRAPPER":
-        return new import_contracts.CurveV1AdapterDeposit(this.sdk, args);
-      case "ADAPTER::CVX_V1_BASE_REWARD_POOL":
-        return new import_contracts.ConvexV1BaseRewardPoolAdapterContract(this.sdk, args);
-      case "ADAPTER::CVX_V1_BOOSTER":
-        return new import_contracts.ConvexV1BoosterAdapterContract(this.sdk, args);
-      case "ADAPTER::DAI_USDS_EXCHANGE":
-        return new import_contracts.DaiUsdsAdapterContract(this.sdk, args);
-      case "ADAPTER::EQUALIZER_ROUTER":
-        return new import_contracts.EqualizerRouterAdapterContract(this.sdk, args);
-      case "ADAPTER::ERC4626_VAULT":
-        return new import_contracts.ERC4626AdapterContract(this.sdk, args);
-      case "ADAPTER::ERC4626_VAULT_REFERRAL":
-        return new import_contracts.ERC4626ReferralAdapterContract(this.sdk, args);
-      case "ADAPTER::FLUID_DEX":
-        return new import_contracts.FluidDexAdapterContract(this.sdk, args);
-      case "ADAPTER::INFINIFI_GATEWAY":
-        return new import_InfinifiGatewayAdapterContract.InfinifiGatewayAdapterContract(this.sdk, args);
-      case "ADAPTER::INFINIFI_UNWINDING":
-        return new import_InfinifiUnwindingGatewayAdapterContract.InfinifiUnwindingGatewayAdapterContract(this.sdk, args);
-      case "ADAPTER::INFRARED_VAULT":
-        return new import_contracts.InfraredVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::KELP_DEPOSIT_POOL":
-        return new import_contracts.KelpLRTDepositPoolAdapterContract(this.sdk, args);
-      case "ADAPTER::KELP_WITHDRAWAL":
-        return new import_contracts.KelpLRTWithdrawalManagerAdapterContract(this.sdk, args);
-      case "ADAPTER::KODIAK_ISLAND_GATEWAY":
-        return new import_contracts.KodiakIslandGatewayAdapterContract(this.sdk, args);
-      case "ADAPTER::LIDO_V1":
-        return new import_contracts.LidoV1AdapterContract(this.sdk, args);
-      case "ADAPTER::LIDO_WSTETH_V1":
-        return new import_contracts.WstETHV1AdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_CLAIMER":
-        return new import_contracts.MellowClaimerAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_DVV":
-        return new import_contracts.MellowDVVAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_ERC4626_VAULT":
-        return new import_contracts.MellowERC4626VaultAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_LRT_VAULT":
-        return new import_contracts.MellowVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_WRAPPER":
-        return new import_contracts.MellowWrapperAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_DEPOSIT_QUEUE_QUEUE":
-        return new import_contracts.MellowDepositQueueAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_REDEEM_QUEUE_QUEUE":
-        return new import_contracts.MellowRedeemQueueAdapterContract(this.sdk, args);
-      case "ADAPTER::MIDAS_ISSUANCE_VAULT":
-        return new import_contracts.MidasIssuanceVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::MIDAS_REDEMPTION_VAULT":
-        return new import_contracts.MidasRedemptionVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::PENDLE_ROUTER":
-        return new import_contracts.PendleRouterAdapterContract(this.sdk, args);
-      case "ADAPTER::STAKING_REWARDS":
-        return new import_contracts.StakingRewardsAdapterContract(this.sdk, args);
-      case "ADAPTER::TRADERJOE_ROUTER":
-        return new import_contracts.TraderJoeRouterAdapterContract(this.sdk, args);
-      case "ADAPTER::UNISWAP_V2_ROUTER":
-        return new import_contracts.UniswapV2AdapterContract(this.sdk, args);
-      case "ADAPTER::UNISWAP_V3_ROUTER":
-        return new import_contracts.UniswapV3AdapterContract(this.sdk, args);
-      case "ADAPTER::UNISWAP_V4_GATEWAY":
-        return new import_UniswapV4AdapterContract.UniswapV4AdapterContract(this.sdk, args);
-      case "ADAPTER::UPSHIFT_VAULT":
-        return new import_contracts.UpshiftVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::VELODROME_V2_ROUTER":
-        return new import_contracts.VelodromeV2RouterAdapterContract(this.sdk, args);
-      case "ADAPTER::YEARN_V2":
-        return new import_contracts.YearnV2RouterAdapterContract(this.sdk, args);
-      default: {
-        const err = new Error(
-          `Adapter type ${adapterType} not supported for adapter at ${args.baseParams.addr}`
+    const adapter = (0, import_createAdapter.createAdapter)(this.sdk, data, false);
+    if (this.sdk.strictContractTypes) {
+      if (isAbstract(adapter)) {
+        throw new Error(
+          `Adapter type ${adapter.contractType} not supported for adapter at ${data.baseParams.addr}`
         );
-        if (this.sdk.strictContractTypes) {
-          throw err;
-        }
-        this.sdk.logger?.error(err);
-        return void 0;
       }
+      return adapter;
+    } else {
+      return isAbstract(adapter) ? void 0 : adapter;
     }
   }
   async load(_force) {
@@ -147,6 +51,9 @@ class AdaptersPlugin extends import_sdk.BasePlugin {
     return {};
   }
 }
+function isAbstract(adapter) {
+  return Object.getPrototypeOf(adapter) === import_AbstractAdapter.AbstractAdapterContract.prototype;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdaptersPlugin