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

package/dist/cjs/history/extractTransfers.js

@@ -0,0 +1,166 @@
+"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 extractTransfers_exports = {};
+__export(extractTransfers_exports, {
+  extractTransfers: () => extractTransfers
+});
+module.exports = __toCommonJS(extractTransfers_exports);
+var import_viem = require("viem");
+var import_generated = require("../abi/310/generated.js");
+var import_iERC20 = require("../abi/iERC20.js");
+var import_sdk = require("../sdk/index.js");
+var import_errors = require("./errors.js");
+function extractTransfers(logs, creditAccount, pool, creditFacade) {
+  const ranges = buildOperationRanges(logs, creditFacade, creditAccount);
+  let currentEntries = [];
+  const executeResults = [];
+  const directTransfers = [];
+  const phantomTokens = new import_sdk.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) => (0, import_viem.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,
+          (0, import_viem.getAddress)(rawDeposit.token)
+        );
+      }
+      currentEntries = [];
+      continue;
+    }
+    const transfer = tryDecodeTransfer(log);
+    if (!transfer) {
+      continue;
+    }
+    const { from, to, value } = transfer.args;
+    const token = transfer.address;
+    if ((0, import_viem.isAddressEqual)(from, pool) && (0, import_viem.isAddressEqual)(to, creditAccount) || (0, import_viem.isAddressEqual)(from, creditAccount) && (0, import_viem.isAddressEqual)(to, pool)) {
+      continue;
+    }
+    currentEntries.push({ token, amount: value, from, to });
+    if ((0, import_viem.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 ((0, import_viem.isAddressEqual)(e.args.creditAccount, creditAccount)) {
+          breakpoints.push(e);
+          inMulticall = true;
+        }
+        break;
+      case "FinishMultiCall":
+        if (inMulticall) {
+          breakpoints.push(e);
+          inMulticall = false;
+        }
+        break;
+      case "PartiallyLiquidateCreditAccount":
+        if ((0, import_viem.isAddressEqual)(e.args.creditAccount, creditAccount)) {
+          breakpoints.push(e);
+        }
+        break;
+      case "AddCollateral":
+        if (!inMulticall && (0, import_viem.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 import_errors.UnexpectedFacadeEventOrderError(a);
+    }
+  }
+  return ranges;
+}
+function tryDecodeFacadeEvent(log, facadeAddress) {
+  if (!(0, import_viem.isAddressEqual)(log.address, facadeAddress)) return void 0;
+  return (0, import_viem.parseEventLogs)({
+    abi: import_generated.iCreditFacadeV310Abi,
+    logs: [log]
+  })[0];
+}
+function tryDecodeTransfer(log) {
+  return (0, import_viem.parseEventLogs)({
+    abi: import_iERC20.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" && (0, import_viem.isAddressEqual)(e.args.creditAccount, creditAccount);
+}
+function isLiquidation(e, creditAccount) {
+  return e.eventName === "LiquidateCreditAccount" && (0, import_viem.isAddressEqual)(e.args.creditAccount, creditAccount);
+}
+function isWithdrawPhantomToken(e, creditAccount) {
+  return e.eventName === "WithdrawPhantomToken" && (0, import_viem.isAddressEqual)(e.args.creditAccount, creditAccount);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractTransfers
+});

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("./ContractRegister.js"), module.exports);
+__reExport(history_exports, require("./inner-operations.js"), module.exports);
+var import_parseCreditAccountTransaction = require("./parseCreditAccountTransaction.js");
+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("./ContractRegister.js"),
+  ...require("./inner-operations.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/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);