@gearbox-protocol/sdk 12.8.1 → 12.9.0-txparser.2

package/dist/cjs/history/findFacadeCalls.js

@@ -0,0 +1,84 @@
+"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 findFacadeCalls_exports = {};
+__export(findFacadeCalls_exports, {
+  findFacadeCalls: () => findFacadeCalls
+});
+module.exports = __toCommonJS(findFacadeCalls_exports);
+var import_viem = require("viem");
+var import_generated = require("../abi/310/generated.js");
+var import_errors = require("./errors.js");
+var import_trace_utils = require("./trace-utils.js");
+const FACADE_CALL_TYPES = {
+  multicall: "MultiCall",
+  botMulticall: "BotMulticall",
+  openCreditAccount: "OpenCreditAccount",
+  closeCreditAccount: "CloseCreditAccount",
+  liquidateCreditAccount: "LiquidateCreditAccount",
+  partiallyLiquidateCreditAccount: "PartiallyLiquidateCreditAccount"
+};
+function extractCreditAccount(operation, rawArgs, traceOutput) {
+  if (operation === "OpenCreditAccount") {
+    return (0, import_viem.decodeFunctionResult)({
+      abi: import_generated.iCreditFacadeV310Abi,
+      functionName: "openCreditAccount",
+      data: traceOutput
+    });
+  }
+  const ca = rawArgs.creditAccount;
+  if (!ca) {
+    throw new Error(`missing creditAccount arg in ${operation} call`);
+  }
+  return ca;
+}
+function findFacadeCalls(trace, creditFacade, creditAccount, register, strict) {
+  const facadeTraces = (0, import_trace_utils.collectTraces)(trace, creditFacade);
+  const results = [];
+  for (const trace2 of facadeTraces) {
+    const parsed = register.parseFunctionDataV2(
+      creditFacade,
+      trace2.input,
+      strict
+    );
+    const name = parsed.functionName.split("(")[0];
+    const operation = FACADE_CALL_TYPES[name];
+    if (!operation) {
+      if (strict) {
+        throw new import_errors.UnknownFacadeCallError(creditFacade, parsed.functionName);
+      }
+      continue;
+    }
+    const ca = extractCreditAccount(operation, parsed.rawArgs, trace2.output);
+    if (!(0, import_viem.isAddressEqual)(ca, creditAccount)) {
+      continue;
+    }
+    results.push({
+      operation,
+      creditAccount: ca,
+      parsed,
+      innerCalls: parsed.rawArgs.calls ?? [],
+      trace: trace2
+    });
+  }
+  return results;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findFacadeCalls
+});

package/dist/cjs/history/index.js

@@ -0,0 +1,38 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var history_exports = {};
+__export(history_exports, {
+  parseCreditAccountTransaction: () => import_parseCreditAccountTransaction.parseCreditAccountTransaction,
+  toLegacyOperations: () => import_toLegacyOperation.toLegacyOperations
+});
+module.exports = __toCommonJS(history_exports);
+__reExport(history_exports, require("./inner-operations.js"), module.exports);
+var import_parseCreditAccountTransaction = require("./parseCreditAccountTransaction.js");
+__reExport(history_exports, require("./populateContractsRegister.js"), module.exports);
+var import_toLegacyOperation = require("./toLegacyOperation.js");
+__reExport(history_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCreditAccountTransaction,
+  toLegacyOperations,
+  ...require("./inner-operations.js"),
+  ...require("./populateContractsRegister.js"),
+  ...require("./types.js")
+});

package/dist/cjs/history/inner-operations.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 inner_operations_exports = {};
+module.exports = __toCommonJS(inner_operations_exports);

package/dist/cjs/history/internal-types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 internal_types_exports = {};
+module.exports = __toCommonJS(internal_types_exports);

package/dist/cjs/history/package.json

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

package/dist/cjs/history/parseCreditAccountTransaction.js

@@ -0,0 +1,83 @@
+"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_enrichTokens = require("./enrichTokens.js");
+var import_extractTransfers = require("./extractTransfers.js");
+var import_findFacadeCalls = require("./findFacadeCalls.js");
+function parseCreditAccountTransaction(input) {
+  const {
+    trace,
+    receipt,
+    pool,
+    creditFacade,
+    creditAccount,
+    underlying,
+    register,
+    strict
+  } = input;
+  const logs = receipt.logs;
+  const txHash = receipt.transactionHash;
+  const blockNumber = Number(receipt.blockNumber);
+  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 facadeOps = (0, import_assembleOperations.assembleOperations)({
+    facadeCalls,
+    executeResults,
+    register,
+    underlying,
+    txHash,
+    blockNumber,
+    liquidationRemainingFunds,
+    phantomTokens,
+    strict
+  });
+  const directOps = directTransfers.map((dt) => ({
+    operation: "DirectTokenTransfer",
+    txHash,
+    blockNumber,
+    creditAccount,
+    ...dt
+  }));
+  const rawOps = [...facadeOps, ...directOps];
+  const resolve = (addr) => {
+    const meta = register.tokensMeta.mustGet(addr);
+    return { address: addr, symbol: meta.symbol, decimals: meta.decimals };
+  };
+  return (0, import_enrichTokens.enrichOperations)(rawOps, resolve);
+}
+// 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 = import_sdk.ChainContractsRegister.for(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(
+        { client: register.client, logger },
+        { addr: d.address, version: d.version, contractType }
+      );
+    } else if (contractType.startsWith("ADAPTER::")) {
+      (0, import_createAdapter.createAdapter)(
+        {
+          client: register.client,
+          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,120 @@
+"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, {
+  toLegacyOperations: () => toLegacyOperations
+});
+module.exports = __toCommonJS(toLegacyOperation_exports);
+function convertMulticallOp(op) {
+  if ("legacy" in op) {
+    return { ...op.legacy };
+  }
+  switch (op.operation) {
+    case "IncreaseBorrowedAmount":
+      return {
+        operation: op.operation,
+        amount: op.amount.toString()
+      };
+    case "DecreaseBorrowedAmount":
+      return {
+        operation: op.operation,
+        amount: op.amount.toString()
+      };
+    case "AddCollateral":
+      return {
+        operation: op.operation,
+        token: op.token.address,
+        amount: op.amount.toString()
+      };
+    case "WithdrawCollateral":
+      return {
+        operation: op.operation,
+        token: op.token.address,
+        amount: op.amount.toString(),
+        to: op.to,
+        ...op.phantomToken ? { phantomToken: op.phantomToken.address } : {}
+      };
+    case "UpdateQuota":
+      return {
+        operation: op.operation,
+        token: op.token.address,
+        change: op.change.toString()
+      };
+  }
+}
+function convertFacadeOp(op) {
+  const base = {
+    operation: op.operation,
+    txHash: op.txHash,
+    blockNum: op.blockNumber
+  };
+  switch (op.operation) {
+    case "MultiCall":
+    case "BotMulticall":
+      return {
+        ...base,
+        multicall: op.multicall.map(convertMulticallOp)
+      };
+    case "OpenCreditAccount":
+      return {
+        ...base,
+        multicall: op.multicall.map(convertMulticallOp)
+      };
+    case "CloseCreditAccount":
+      return {
+        ...base,
+        multicall: op.multicall.map(convertMulticallOp)
+      };
+    case "LiquidateCreditAccount":
+      return {
+        ...base,
+        to: op.to,
+        remainingFunds: op.remainingFunds.toString(),
+        multicall: op.multicall.map(convertMulticallOp)
+      };
+    case "PartiallyLiquidateCreditAccount":
+      return {
+        ...base,
+        token: op.token.address,
+        repaidAmount: op.repaidAmount.toString(),
+        minSeizedAmount: op.minSeizedAmount.toString(),
+        to: op.to
+      };
+  }
+}
+function toLegacyOperations(ops) {
+  return ops.map((op) => {
+    if (op.operation === "DirectTokenTransfer") {
+      return {
+        operation: op.operation,
+        txHash: op.txHash,
+        blockNum: op.blockNumber,
+        token: op.token.address,
+        amount: op.amount.toString(),
+        from: op.from,
+        to: op.creditAccount
+      };
+    }
+    return convertFacadeOp(op);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/history/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

package/dist/cjs/plugins/adapters/abi/index.js

@@ -17,10 +17,12 @@ var abi_exports = {};
 module.exports = __toCommonJS(abi_exports);
 __reExport(abi_exports, require("./actionAbi.js"), module.exports);
 __reExport(abi_exports, require("./conctructorAbi.js"), module.exports);
+__reExport(abi_exports, require("./targetContractAbi.js"), module.exports);
 __reExport(abi_exports, require("./utils.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./actionAbi.js"),
   ...require("./conctructorAbi.js"),
+  ...require("./targetContractAbi.js"),
   ...require("./utils.js")
 });