@gearbox-protocol/sdk 13.0.0-next.29 → 13.0.0-next.30

package/dist/esm/history/mapOperations.js

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

package/dist/esm/history/package.json

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

package/dist/esm/history/parseCreditAccountTransaction.js

@@ -0,0 +1,62 @@
+import { assembleOperations } from "./assembleOperations.js";
+import { extractTransfers } from "./extractTransfers.js";
+import { findFacadeCalls } from "./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 = findFacadeCalls(
+    trace,
+    creditFacade,
+    creditAccount,
+    register,
+    strict
+  );
+  const {
+    executeResults,
+    directTransfers,
+    liquidationRemainingFunds,
+    phantomTokens
+  } = extractTransfers(logs, creditAccount, pool, creditFacade);
+  const meta = {
+    creditManager,
+    creditFacade,
+    timestamp,
+    blockNumber,
+    txHash
+  };
+  const facadeOps = 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];
+}
+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 = new ChainContractsRegister(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(
+        { register, logger },
+        { addr: d.address, version: d.version, contractType }
+      );
+    } else if (contractType.startsWith("ADAPTER::")) {
+      createAdapter(
+        {
+          register,
+          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,157 @@
+import { mapOperations } from "./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 mapOperations(ops, createLegacyVisitor(params));
+}
+export {
+  createLegacyVisitor,
+  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";