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

package/dist/esm/history/extractTransfers.js

@@ -0,0 +1,146 @@
+import {
+  getAddress,
+  isAddressEqual,
+  parseEventLogs
+} from "viem";
+import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { ierc20Abi } from "../abi/iERC20.js";
+import { AddressMap } from "../sdk/index.js";
+import { UnexpectedFacadeEventOrderError } from "./errors.js";
+function extractTransfers(logs, creditAccount, pool, creditFacade) {
+  const ranges = buildOperationRanges(logs, creditFacade, creditAccount);
+  let currentEntries = [];
+  const executeResults = [];
+  const directTransfers = [];
+  const phantomTokens = new AddressMap();
+  let liquidationRemainingFunds;
+  for (const log of logs) {
+    const facadeEvent = tryDecodeFacadeEvent(log, creditFacade);
+    if (facadeEvent) {
+      if (isExecute(facadeEvent, creditAccount)) {
+        executeResults.push({
+          transfers: currentEntries,
+          targetContract: facadeEvent.args.targetContract
+        });
+      } else if (isLiquidation(facadeEvent, creditAccount)) {
+        liquidationRemainingFunds = facadeEvent.args.remainingFunds;
+      } else if (isWithdrawPhantomToken(facadeEvent, creditAccount)) {
+        const phantomExec = executeResults.pop();
+        if (!phantomExec) {
+          throw new Error(
+            `WithdrawPhantomToken without preceding Execute at logIndex ${facadeEvent.logIndex}`
+          );
+        }
+        const rawDeposit = phantomExec.transfers.find(
+          (t) => isAddressEqual(t.to, creditAccount)
+        );
+        if (!rawDeposit) {
+          throw new Error(
+            `phantom Execute has no transfer to credit account at logIndex ${facadeEvent.logIndex}`
+          );
+        }
+        phantomTokens.upsert(
+          facadeEvent.args.token,
+          getAddress(rawDeposit.token)
+        );
+      }
+      currentEntries = [];
+      continue;
+    }
+    const transfer = tryDecodeTransfer(log);
+    if (!transfer) {
+      continue;
+    }
+    const { from, to, value } = transfer.args;
+    const token = transfer.address;
+    if (isAddressEqual(from, pool) && isAddressEqual(to, creditAccount) || isAddressEqual(from, creditAccount) && isAddressEqual(to, pool)) {
+      continue;
+    }
+    currentEntries.push({ token, amount: value, from, to });
+    if (isAddressEqual(to, creditAccount) && !isInRange(log.logIndex, ranges)) {
+      directTransfers.push({ token, from, amount: value });
+    }
+  }
+  return {
+    executeResults,
+    directTransfers,
+    liquidationRemainingFunds,
+    phantomTokens
+  };
+}
+function buildOperationRanges(logs, facadeAddress, creditAccount) {
+  const breakpoints = [];
+  let inMulticall = false;
+  for (const l of logs) {
+    const e = tryDecodeFacadeEvent(l, facadeAddress);
+    switch (e?.eventName) {
+      case "StartMultiCall":
+        if (isAddressEqual(e.args.creditAccount, creditAccount)) {
+          breakpoints.push(e);
+          inMulticall = true;
+        }
+        break;
+      case "FinishMultiCall":
+        if (inMulticall) {
+          breakpoints.push(e);
+          inMulticall = false;
+        }
+        break;
+      case "PartiallyLiquidateCreditAccount":
+        if (isAddressEqual(e.args.creditAccount, creditAccount)) {
+          breakpoints.push(e);
+        }
+        break;
+      case "AddCollateral":
+        if (!inMulticall && isAddressEqual(e.args.creditAccount, creditAccount)) {
+          breakpoints.push(e);
+        }
+        break;
+    }
+  }
+  const ranges = [];
+  let i = 0;
+  while (i < breakpoints.length - 1) {
+    const a = breakpoints[i];
+    const b = breakpoints[i + 1];
+    if (a.eventName === "StartMultiCall" && b.eventName === "FinishMultiCall") {
+      ranges.push({ start: a.logIndex, end: b.logIndex });
+      i += 2;
+    } else if (a.eventName === "AddCollateral" && b.eventName === "PartiallyLiquidateCreditAccount") {
+      ranges.push({ start: a.logIndex - 1, end: b.logIndex });
+      i += 2;
+    } else {
+      throw new UnexpectedFacadeEventOrderError(a);
+    }
+  }
+  return ranges;
+}
+function tryDecodeFacadeEvent(log, facadeAddress) {
+  if (!isAddressEqual(log.address, facadeAddress)) return void 0;
+  return parseEventLogs({
+    abi: iCreditFacadeV310Abi,
+    logs: [log]
+  })[0];
+}
+function tryDecodeTransfer(log) {
+  return parseEventLogs({
+    abi: ierc20Abi,
+    logs: [log],
+    eventName: "Transfer"
+  })[0];
+}
+function isInRange(logIndex, ranges) {
+  return ranges.some((r) => logIndex >= r.start && logIndex <= r.end);
+}
+function isExecute(e, creditAccount) {
+  return e.eventName === "Execute" && isAddressEqual(e.args.creditAccount, creditAccount);
+}
+function isLiquidation(e, creditAccount) {
+  return e.eventName === "LiquidateCreditAccount" && isAddressEqual(e.args.creditAccount, creditAccount);
+}
+function isWithdrawPhantomToken(e, creditAccount) {
+  return e.eventName === "WithdrawPhantomToken" && isAddressEqual(e.args.creditAccount, creditAccount);
+}
+export {
+  extractTransfers
+};

package/dist/esm/history/findFacadeCalls.js

@@ -0,0 +1,63 @@
+import {
+  decodeFunctionResult,
+  isAddressEqual
+} from "viem";
+import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { UnknownFacadeCallError } from "./errors.js";
+import { collectTraces } from "./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 decodeFunctionResult({
+      abi: 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 = 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 UnknownFacadeCallError(creditFacade, parsed.functionName);
+      }
+      continue;
+    }
+    const ca = extractCreditAccount(operation, parsed.rawArgs, trace2.output);
+    if (!isAddressEqual(ca, creditAccount)) {
+      continue;
+    }
+    results.push({
+      operation,
+      creditAccount: ca,
+      parsed,
+      innerCalls: parsed.rawArgs.calls ?? [],
+      trace: trace2
+    });
+  }
+  return results;
+}
+export {
+  findFacadeCalls
+};

package/dist/esm/history/index.js

@@ -0,0 +1,9 @@
+export * from "./inner-operations.js";
+import { parseCreditAccountTransaction } from "./parseCreditAccountTransaction.js";
+export * from "./populateContractsRegister.js";
+import { toLegacyOperations } from "./toLegacyOperation.js";
+export * from "./types.js";
+export {
+  parseCreditAccountTransaction,
+  toLegacyOperations
+};

package/dist/esm/history/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}

package/dist/esm/history/parseCreditAccountTransaction.js

@@ -0,0 +1,59 @@
+import { assembleOperations } from "./assembleOperations.js";
+import { enrichOperations } from "./enrichTokens.js";
+import { extractTransfers } from "./extractTransfers.js";
+import { findFacadeCalls } from "./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 = findFacadeCalls(
+    trace,
+    creditFacade,
+    creditAccount,
+    register,
+    strict
+  );
+  const {
+    executeResults,
+    directTransfers,
+    liquidationRemainingFunds,
+    phantomTokens
+  } = extractTransfers(logs, creditAccount, pool, creditFacade);
+  const facadeOps = 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 enrichOperations(rawOps, resolve);
+}
+export {
+  parseCreditAccountTransaction
+};

package/dist/esm/history/populateContractsRegister.js

@@ -0,0 +1,52 @@
+import {
+  isHex
+} from "viem";
+import { createAdapter } from "../plugins/adapters/createAdapter.js";
+import {
+  bytes32ToString,
+  ChainContractsRegister,
+  CreditFacadeV310BaseContract,
+  isV310,
+  TokensMeta
+} from "../sdk/index.js";
+function populateContractsRegister(options) {
+  const { client, deployments, tokens, logger, strict } = options;
+  const register = ChainContractsRegister.for(client, logger);
+  for (const d of deployments) {
+    let contractType;
+    if ("contractType" in d) {
+      contractType = isHex(d.contractType) ? bytes32ToString(d.contractType) : d.contractType;
+    } else {
+      contractType = [d.contractTypePrefix, d.contractTypeSuffix].filter(Boolean).join("::");
+    }
+    if (contractType === "CREDIT_FACADE" && isV310(d.version)) {
+      new CreditFacadeV310BaseContract(
+        { client: register.client, logger },
+        { addr: d.address, version: d.version, contractType }
+      );
+    } else if (contractType.startsWith("ADAPTER::")) {
+      createAdapter(
+        {
+          client: register.client,
+          logger
+        },
+        {
+          baseParams: {
+            addr: d.address,
+            version: d.version,
+            contractType
+          }
+        },
+        strict
+      );
+    }
+  }
+  const tMetas = tokens instanceof TokensMeta ? tokens.values() : tokens;
+  for (const t of tMetas) {
+    register.tokensMeta.upsert(t.addr, t);
+  }
+  return register;
+}
+export {
+  populateContractsRegister
+};

package/dist/esm/history/toLegacyOperation.js

@@ -0,0 +1,96 @@
+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);
+  });
+}
+export {
+  toLegacyOperations
+};

package/dist/esm/history/trace-utils.js

@@ -0,0 +1,36 @@
+import { isAddressEqual } from "viem";
+function findCallTo(node, target) {
+  if (node.error) {
+    return void 0;
+  }
+  if (node.type === "CALL" && 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" && isAddressEqual(node.to, target)) {
+    results.push(node);
+  } else if (node.calls) {
+    for (const child of node.calls) {
+      results.push(...collectTraces(child, target));
+    }
+  }
+  return results;
+}
+export {
+  collectTraces,
+  findCallTo
+};

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

@@ -1,158 +1,21 @@
-import { BasePlugin, bytes32ToString } from "../../sdk/index.js";
-import { AccountMigratorAdapterContract } from "./contracts/AccountMigratorAdapterContract.js";
-import { InfinifiGatewayAdapterContract } from "./contracts/InfinifiGatewayAdapterContract.js";
-import { InfinifiUnwindingGatewayAdapterContract } from "./contracts/InfinifiUnwindingGatewayAdapterContract.js";
-import {
-  BalancerV2VaultAdapterContract,
-  BalancerV3RouterAdapterContract,
-  BalancerV3WrapperAdapterContract,
-  CamelotV3AdapterContract,
-  ConvexV1BaseRewardPoolAdapterContract,
-  ConvexV1BoosterAdapterContract,
-  Curve2AssetsAdapterContract,
-  Curve3AssetsAdapterContract,
-  Curve4AssetsAdapterContract,
-  CurveV1AdapterDeposit,
-  CurveV1AdapterStETHContract,
-  CurveV1StableNGAdapterContract,
-  DaiUsdsAdapterContract,
-  EqualizerRouterAdapterContract,
-  ERC4626AdapterContract,
-  ERC4626ReferralAdapterContract,
-  FluidDexAdapterContract,
-  InfraredVaultAdapterContract,
-  KelpLRTDepositPoolAdapterContract,
-  KelpLRTWithdrawalManagerAdapterContract,
-  KodiakIslandGatewayAdapterContract,
-  LidoV1AdapterContract,
-  MellowClaimerAdapterContract,
-  MellowDepositQueueAdapterContract,
-  MellowDVVAdapterContract,
-  MellowERC4626VaultAdapterContract,
-  MellowRedeemQueueAdapterContract,
-  MellowVaultAdapterContract,
-  MellowWrapperAdapterContract,
-  MidasIssuanceVaultAdapterContract,
-  MidasRedemptionVaultAdapterContract,
-  PendleRouterAdapterContract,
-  StakingRewardsAdapterContract,
-  TraderJoeRouterAdapterContract,
-  UniswapV2AdapterContract,
-  UniswapV3AdapterContract,
-  UpshiftVaultAdapterContract,
-  VelodromeV2RouterAdapterContract,
-  WstETHV1AdapterContract,
-  YearnV2RouterAdapterContract
-} from "./contracts/index.js";
-import { UniswapV4AdapterContract } from "./contracts/UniswapV4AdapterContract.js";
+import { BasePlugin } from "../../sdk/index.js";
+import { AbstractAdapterContract } from "./contracts/AbstractAdapter.js";
+import { createAdapter } from "./createAdapter.js";
 class AdaptersPlugin extends BasePlugin {
   name = "Adapters";
   version = 1;
   loaded = true;
   createContract(data) {
-    const args = data;
-    const adapterType = bytes32ToString(
-      args.baseParams.contractType
-    );
-    switch (adapterType) {
-      case "ADAPTER::ACCOUNT_MIGRATOR":
-        return new AccountMigratorAdapterContract(this.sdk, args);
-      case "ADAPTER::BALANCER_V3_ROUTER":
-        return new BalancerV3RouterAdapterContract(this.sdk, args);
-      case "ADAPTER::BALANCER_V3_WRAPPER":
-        return new BalancerV3WrapperAdapterContract(this.sdk, args);
-      case "ADAPTER::BALANCER_VAULT":
-        return new BalancerV2VaultAdapterContract(this.sdk, args);
-      case "ADAPTER::CAMELOT_V3_ROUTER":
-        return new CamelotV3AdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_STABLE_NG":
-        return new CurveV1StableNGAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_2ASSETS":
-        return new Curve2AssetsAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_3ASSETS":
-        return new Curve3AssetsAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_4ASSETS":
-        return new Curve4AssetsAdapterContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_STECRV_POOL":
-        return new CurveV1AdapterStETHContract(this.sdk, args);
-      case "ADAPTER::CURVE_V1_WRAPPER":
-        return new CurveV1AdapterDeposit(this.sdk, args);
-      case "ADAPTER::CVX_V1_BASE_REWARD_POOL":
-        return new ConvexV1BaseRewardPoolAdapterContract(this.sdk, args);
-      case "ADAPTER::CVX_V1_BOOSTER":
-        return new ConvexV1BoosterAdapterContract(this.sdk, args);
-      case "ADAPTER::DAI_USDS_EXCHANGE":
-        return new DaiUsdsAdapterContract(this.sdk, args);
-      case "ADAPTER::EQUALIZER_ROUTER":
-        return new EqualizerRouterAdapterContract(this.sdk, args);
-      case "ADAPTER::ERC4626_VAULT":
-        return new ERC4626AdapterContract(this.sdk, args);
-      case "ADAPTER::ERC4626_VAULT_REFERRAL":
-        return new ERC4626ReferralAdapterContract(this.sdk, args);
-      case "ADAPTER::FLUID_DEX":
-        return new FluidDexAdapterContract(this.sdk, args);
-      case "ADAPTER::INFINIFI_GATEWAY":
-        return new InfinifiGatewayAdapterContract(this.sdk, args);
-      case "ADAPTER::INFINIFI_UNWINDING":
-        return new InfinifiUnwindingGatewayAdapterContract(this.sdk, args);
-      case "ADAPTER::INFRARED_VAULT":
-        return new InfraredVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::KELP_DEPOSIT_POOL":
-        return new KelpLRTDepositPoolAdapterContract(this.sdk, args);
-      case "ADAPTER::KELP_WITHDRAWAL":
-        return new KelpLRTWithdrawalManagerAdapterContract(this.sdk, args);
-      case "ADAPTER::KODIAK_ISLAND_GATEWAY":
-        return new KodiakIslandGatewayAdapterContract(this.sdk, args);
-      case "ADAPTER::LIDO_V1":
-        return new LidoV1AdapterContract(this.sdk, args);
-      case "ADAPTER::LIDO_WSTETH_V1":
-        return new WstETHV1AdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_CLAIMER":
-        return new MellowClaimerAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_DVV":
-        return new MellowDVVAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_ERC4626_VAULT":
-        return new MellowERC4626VaultAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_LRT_VAULT":
-        return new MellowVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_WRAPPER":
-        return new MellowWrapperAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_DEPOSIT_QUEUE_QUEUE":
-        return new MellowDepositQueueAdapterContract(this.sdk, args);
-      case "ADAPTER::MELLOW_REDEEM_QUEUE_QUEUE":
-        return new MellowRedeemQueueAdapterContract(this.sdk, args);
-      case "ADAPTER::MIDAS_ISSUANCE_VAULT":
-        return new MidasIssuanceVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::MIDAS_REDEMPTION_VAULT":
-        return new MidasRedemptionVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::PENDLE_ROUTER":
-        return new PendleRouterAdapterContract(this.sdk, args);
-      case "ADAPTER::STAKING_REWARDS":
-        return new StakingRewardsAdapterContract(this.sdk, args);
-      case "ADAPTER::TRADERJOE_ROUTER":
-        return new TraderJoeRouterAdapterContract(this.sdk, args);
-      case "ADAPTER::UNISWAP_V2_ROUTER":
-        return new UniswapV2AdapterContract(this.sdk, args);
-      case "ADAPTER::UNISWAP_V3_ROUTER":
-        return new UniswapV3AdapterContract(this.sdk, args);
-      case "ADAPTER::UNISWAP_V4_GATEWAY":
-        return new UniswapV4AdapterContract(this.sdk, args);
-      case "ADAPTER::UPSHIFT_VAULT":
-        return new UpshiftVaultAdapterContract(this.sdk, args);
-      case "ADAPTER::VELODROME_V2_ROUTER":
-        return new VelodromeV2RouterAdapterContract(this.sdk, args);
-      case "ADAPTER::YEARN_V2":
-        return new YearnV2RouterAdapterContract(this.sdk, args);
-      default: {
-        const err = new Error(
-          `Adapter type ${adapterType} not supported for adapter at ${args.baseParams.addr}`
+    const adapter = 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) {
@@ -165,6 +28,9 @@ class AdaptersPlugin extends BasePlugin {
     return {};
   }
 }
+function isAbstract(adapter) {
+  return Object.getPrototypeOf(adapter) === AbstractAdapterContract.prototype;
+}
 export {
   AdaptersPlugin
 };

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

@@ -1,3 +1,4 @@
 export * from "./actionAbi.js";
 export * from "./conctructorAbi.js";
+export * from "./targetContractAbi.js";
 export * from "./utils.js";