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

package/dist/cjs/sdk/market/credit/CreditFacadeV310BaseContract.js

@@ -0,0 +1,108 @@
+"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 CreditFacadeV310BaseContract_exports = {};
+__export(CreditFacadeV310BaseContract_exports, {
+  CreditFacadeV310BaseContract: () => CreditFacadeV310BaseContract,
+  creditFacadeV310Abi: () => abi
+});
+module.exports = __toCommonJS(CreditFacadeV310BaseContract_exports);
+var import_generated = require("../../../abi/310/generated.js");
+var import_iPausable = require("../../../abi/iPausable.js");
+var import_base = require("../../base/index.js");
+const abi = [
+  ...import_generated.iCreditFacadeV310Abi,
+  ...import_generated.iCreditFacadeMulticallV310Abi,
+  ...import_iPausable.iPausableAbi
+];
+class CreditFacadeV310BaseContract extends import_base.BaseContract {
+  constructor(options, args) {
+    super(options, { ...args, abi });
+  }
+  parseFunctionParamsV2(params, strict) {
+    switch (params.functionName) {
+      case "openCreditAccount": {
+        const [onBehalfOf, calls, referralCode] = params.args;
+        return {
+          onBehalfOf,
+          calls: this.register.parseMultiCallV2([...calls], strict),
+          referralCode
+        };
+      }
+      case "closeCreditAccount": {
+        const [creditAccount, calls] = params.args;
+        return {
+          creditAccount,
+          calls: this.register.parseMultiCallV2([...calls], strict)
+        };
+      }
+      case "botMulticall":
+      case "multicall": {
+        const [creditAccount, calls] = params.args;
+        return {
+          creditAccount,
+          calls: this.register.parseMultiCallV2([...calls], strict)
+        };
+      }
+      case "liquidateCreditAccount": {
+        const [creditAccount, to, calls] = params.args;
+        return {
+          creditAccount,
+          to,
+          calls: this.register.parseMultiCallV2([...calls], strict)
+        };
+      }
+      default:
+        return super.parseFunctionParamsV2(params, strict);
+    }
+  }
+  stringifyFunctionParams(params) {
+    switch (params.functionName) {
+      case "openCreditAccount": {
+        const [onBehalfOf, calls, referralCode] = params.args;
+        return [
+          this.labelAddress(onBehalfOf),
+          this.register.parseMultiCall([...calls]).join(","),
+          `${referralCode}`
+        ];
+      }
+      case "closeCreditAccount": {
+        const [creditAccount, calls] = params.args;
+        return [
+          this.labelAddress(creditAccount),
+          this.register.parseMultiCall([...calls]).join(",")
+        ];
+      }
+      case "liquidateCreditAccount": {
+        const [creditAccount, to, calls] = params.args;
+        return [
+          this.labelAddress(creditAccount),
+          this.labelAddress(to),
+          this.register.parseMultiCall([...calls]).join(",")
+        ];
+      }
+      default:
+        return super.stringifyFunctionParams(params);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreditFacadeV310BaseContract,
+  creditFacadeV310Abi
+});

package/dist/cjs/sdk/market/credit/CreditFacadeV310Contract.js

@@ -21,24 +21,16 @@ __export(CreditFacadeV310Contract_exports, {
   CreditFacadeV310Contract: () => CreditFacadeV310Contract
 });
 module.exports = __toCommonJS(CreditFacadeV310Contract_exports);
-var import_generated = require("../../../abi/310/generated.js");
-var import_iPausable = require("../../../abi/iPausable.js");
-var import_base = require("../../base/index.js");
 var import_constants = require("../../constants/index.js");
 var import_utils = require("../../utils/index.js");
-const abi = [
-  ...import_generated.iCreditFacadeV310Abi,
-  ...import_generated.iCreditFacadeMulticallV310Abi,
-  ...import_iPausable.iPausableAbi
-];
-class CreditFacadeV310Contract extends import_base.BaseContract {
+var import_CreditFacadeV310BaseContract = require("./CreditFacadeV310BaseContract.js");
+class CreditFacadeV310Contract extends import_CreditFacadeV310BaseContract.CreditFacadeV310BaseContract {
   underlying;
   constructor(options, { creditFacade, creditManager }) {
     const { baseParams, ...rest } = creditFacade;
     super(options, {
       ...baseParams,
-      name: `CreditFacadeV310(${creditManager.name})`,
-      abi
+      name: `CreditFacadeV310(${creditManager.name})`
     });
     Object.assign(this, rest);
     this.underlying = creditManager.underlying;
@@ -105,35 +97,6 @@ class CreditFacadeV310Contract extends import_base.BaseContract {
       args: [to, calls, referralCode]
     });
   }
-  stringifyFunctionParams(params) {
-    switch (params.functionName) {
-      case "openCreditAccount": {
-        const [onBehalfOf, calls, referralCode] = params.args;
-        return [
-          this.labelAddress(onBehalfOf),
-          this.register.parseMultiCall([...calls]).join(","),
-          `${referralCode}`
-        ];
-      }
-      case "closeCreditAccount": {
-        const [creditAccount, calls] = params.args;
-        return [
-          this.labelAddress(creditAccount),
-          this.register.parseMultiCall([...calls]).join(",")
-        ];
-      }
-      case "liquidateCreditAccount": {
-        const [creditAccount, to, calls] = params.args;
-        return [
-          this.labelAddress(creditAccount),
-          this.labelAddress(to),
-          this.register.parseMultiCall([...calls]).join(",")
-        ];
-      }
-      default:
-        return super.stringifyFunctionParams(params);
-    }
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/market/credit/index.js

@@ -18,6 +18,7 @@ module.exports = __toCommonJS(credit_exports);
 __reExport(credit_exports, require("./CreditConfiguratorV300Contract.js"), module.exports);
 __reExport(credit_exports, require("./CreditConfiguratorV310Contract.js"), module.exports);
 __reExport(credit_exports, require("./CreditFacadeV300Contract.js"), module.exports);
+__reExport(credit_exports, require("./CreditFacadeV310BaseContract.js"), module.exports);
 __reExport(credit_exports, require("./CreditFacadeV310Contract.js"), module.exports);
 __reExport(credit_exports, require("./CreditManagerV300Contract.js"), module.exports);
 __reExport(credit_exports, require("./CreditManagerV310Contract.js"), module.exports);
@@ -28,6 +29,7 @@ __reExport(credit_exports, require("./types.js"), module.exports);
   ...require("./CreditConfiguratorV300Contract.js"),
   ...require("./CreditConfiguratorV310Contract.js"),
   ...require("./CreditFacadeV300Contract.js"),
+  ...require("./CreditFacadeV310BaseContract.js"),
   ...require("./CreditFacadeV310Contract.js"),
   ...require("./CreditManagerV300Contract.js"),
   ...require("./CreditManagerV310Contract.js"),

package/dist/cjs/sdk/utils/abi-decode.js

@@ -18,11 +18,22 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var abi_decode_exports = {};
 __export(abi_decode_exports, {
-  functionArgsToMap: () => functionArgsToMap
+  functionArgsToMap: () => functionArgsToMap,
+  functionArgsToRecord: () => functionArgsToRecord,
+  getFunctionSignature: () => getFunctionSignature
 });
 module.exports = __toCommonJS(abi_decode_exports);
 var import_viem = require("viem");
 var import_utils = require("../../sdk/utils/index.js");
+function getFunctionSignature(abi, calldataOrSelector) {
+  const selector = calldataOrSelector.slice(0, 10);
+  for (const item of abi) {
+    if (item.type === "function" && (0, import_viem.toFunctionSelector)(item) === selector) {
+      return (0, import_viem.toFunctionSignature)(item);
+    }
+  }
+  throw new Error(`Function with selector ${selector} not found in ABI`);
+}
 function functionArgsToMap(abi, functionName, args) {
   const abiItem = (0, import_viem.getAbiItem)({
     abi,
@@ -52,7 +63,37 @@ function functionArgsToMap(abi, functionName, args) {
   }
   return namedArgs;
 }
+function functionArgsToRecord(abi, functionName, args) {
+  const abiItem = (0, import_viem.getAbiItem)({
+    abi,
+    name: functionName,
+    args
+  });
+  if (!abiItem || abiItem.type !== "function") {
+    throw new import_viem.AbiFunctionNotFoundError(functionName);
+  }
+  const namedArgs = {};
+  if (Array.isArray(args)) {
+    args.forEach((value, i) => {
+      const input = abiItem.inputs?.[i];
+      const key = input?.name || `${i}`;
+      namedArgs[key] = value;
+    });
+  } else {
+    Object.entries(args || {}).forEach(([key, value]) => {
+      const index = parseInt(key, 10);
+      if (!Number.isNaN(index) && abiItem.inputs?.[index]?.name) {
+        namedArgs[abiItem.inputs[index].name] = value;
+      } else {
+        namedArgs[key] = value;
+      }
+    });
+  }
+  return namedArgs;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  functionArgsToMap
+  functionArgsToMap,
+  functionArgsToRecord,
+  getFunctionSignature
 });

package/dist/esm/dev/providers.js

@@ -22,9 +22,6 @@ function getRpcProviderUrl(provider, network, apiKey, protocol = "http") {
   }
 }
 function getAlchemyUrl(network, apiKey, protocol = "http") {
-  if (!apiKey) {
-    return void 0;
-  }
   const alchemyDomain = ALCHEMY_DOMAINS[network];
   if (!alchemyDomain) {
     return void 0;
@@ -68,9 +65,6 @@ const ALCHEMY_DOMAINS = {
   Somnia: null
 };
 function getDrpcUrl(network, apiKey, protocol = "http") {
-  if (!apiKey) {
-    return void 0;
-  }
   const net = DRPC_NETS[network];
   return net ? `${protocol}s://lb.drpc.live/${net}/${apiKey}` : void 0;
 }
@@ -93,9 +87,6 @@ const ANKR_DOMAINS = {
   Somnia: "somnia_mainnet"
 };
 function getAnkrUrl(network, apiKey, protocol = "http") {
-  if (!apiKey) {
-    return void 0;
-  }
   const net = ANKR_DOMAINS[network];
   const sep = protocol === "ws" ? "/ws/" : "/";
   return net ? `${protocol}s://rpc.ankr.com/${net}${sep}${apiKey}` : void 0;
@@ -119,9 +110,6 @@ const THIRDWEB_DOMAINS = {
   Somnia: chains.Somnia.id.toString()
 };
 function getThirdWebUrl(network, apiKey, protocol = "http") {
-  if (!apiKey) {
-    return void 0;
-  }
   if (protocol === "ws") {
     return void 0;
   }

package/dist/esm/history/assembleOperations.js

@@ -0,0 +1,86 @@
+import { AbstractAdapterContract } from "../plugins/adapters/index.js";
+import { classifyMulticallOperations } from "./classifyMulticallOperations.js";
+import { extractProtocolCalls } from "./extractProtocolCalls.js";
+function assembleOperations(input) {
+  const {
+    facadeCalls,
+    executeResults,
+    register,
+    underlying,
+    txHash,
+    blockNumber,
+    liquidationRemainingFunds,
+    phantomTokens,
+    strict
+  } = input;
+  let offset = 0;
+  const meta = { txHash, blockNumber };
+  return facadeCalls.map((fc) => {
+    if (fc.operation === "PartiallyLiquidateCreditAccount") {
+      return assemblePartialLiquidation(fc, meta);
+    }
+    const count = countAdapterCalls(fc.innerCalls, register);
+    const sliced = executeResults.slice(offset, offset + count);
+    offset += count;
+    const protocolCalldatas = extractProtocolCalls(fc.trace, sliced);
+    const multicall = classifyMulticallOperations({
+      innerCalls: fc.innerCalls,
+      executeResults: sliced,
+      protocolCalldatas,
+      register,
+      creditAccount: fc.creditAccount,
+      underlying,
+      strict,
+      phantomTokens
+    });
+    switch (fc.operation) {
+      case "OpenCreditAccount":
+        return {
+          ...meta,
+          operation: fc.operation,
+          creditAccount: fc.creditAccount,
+          onBehalfOf: fc.parsed.rawArgs.onBehalfOf,
+          referralCode: fc.parsed.rawArgs.referralCode,
+          multicall
+        };
+      case "LiquidateCreditAccount":
+        return {
+          ...meta,
+          operation: fc.operation,
+          creditAccount: fc.creditAccount,
+          to: fc.parsed.rawArgs.to,
+          token: underlying,
+          remainingFunds: liquidationRemainingFunds ?? 0n,
+          multicall
+        };
+      default:
+        return {
+          ...meta,
+          operation: fc.operation,
+          creditAccount: fc.creditAccount,
+          multicall
+        };
+    }
+  });
+}
+function countAdapterCalls(innerCalls, register) {
+  return innerCalls.filter((call) => {
+    const contract = register.getContract(call.target);
+    return !contract || contract instanceof AbstractAdapterContract;
+  }).length;
+}
+function assemblePartialLiquidation(fc, meta) {
+  const { rawArgs } = fc.parsed;
+  return {
+    ...meta,
+    operation: "PartiallyLiquidateCreditAccount",
+    creditAccount: fc.creditAccount,
+    token: rawArgs.token,
+    repaidAmount: rawArgs.repaidAmount,
+    minSeizedAmount: rawArgs.minSeizedAmount,
+    to: rawArgs.to
+  };
+}
+export {
+  assembleOperations
+};

package/dist/esm/history/classifyMulticallOperations.js

@@ -0,0 +1,137 @@
+import { isAddressEqual } from "viem";
+import {
+  AbstractAdapterContract,
+  swapFromTransfers,
+  toNetTransfers
+} from "../plugins/adapters/index.js";
+import { TransferAlignmentError, UnknownAdapterError } from "./errors.js";
+function classifyMulticallOperations(input) {
+  const {
+    innerCalls,
+    executeResults,
+    protocolCalldatas,
+    register,
+    creditAccount,
+    underlying,
+    strict,
+    phantomTokens
+  } = input;
+  let transferIdx = 0;
+  const result = [];
+  for (const call of innerCalls) {
+    const contract = register.getContract(call.target);
+    if (contract instanceof AbstractAdapterContract) {
+      const idx = transferIdx++;
+      const executeResult = executeResults[idx];
+      if (!executeResult) {
+        throw new TransferAlignmentError(executeResults.length, transferIdx);
+      }
+      const { transfers: transfers2, targetContract: targetContract2 } = executeResult;
+      const protocolCalldata = protocolCalldatas[idx];
+      const partial = contract.parseAdapterOperation(
+        call,
+        transfers2,
+        creditAccount,
+        protocolCalldata,
+        strict
+      );
+      if (partial) result.push({ ...partial, protocol: targetContract2 });
+      continue;
+    }
+    if (contract !== void 0) {
+      const op = classifyFacadeInnerCall(call, underlying, phantomTokens);
+      if (op) result.push(op);
+      continue;
+    }
+    if (strict) {
+      throw new UnknownAdapterError(call.target);
+    }
+    const unknownIdx = transferIdx++;
+    const unknownResult = executeResults[unknownIdx];
+    if (!unknownResult) {
+      throw new TransferAlignmentError(executeResults.length, transferIdx);
+    }
+    const { transfers, targetContract } = unknownResult;
+    const netTransfers = toNetTransfers(transfers, creditAccount);
+    result.push({
+      operation: "Execute",
+      adapter: call.target,
+      protocol: targetContract,
+      adapterType: call.contractType,
+      version: call.version,
+      label: call.label,
+      adapterFunctionName: call.functionName,
+      adapterArgs: call.rawArgs,
+      protocolFunctionName: call.functionName,
+      protocolArgs: call.rawArgs,
+      transfers,
+      legacy: {
+        operation: "Swap",
+        ...swapFromTransfers(netTransfers)
+      }
+    });
+  }
+  if (transferIdx !== executeResults.length) {
+    throw new TransferAlignmentError(executeResults.length, transferIdx);
+  }
+  return result;
+}
+function classifyFacadeInnerCall(call, underlying, phantomTokens) {
+  const { functionName: sig, rawArgs } = call;
+  const functionName = sig.split("(")[0];
+  switch (functionName) {
+    case "increaseDebt":
+      return {
+        operation: "IncreaseBorrowedAmount",
+        token: underlying,
+        amount: rawArgs.amount
+      };
+    case "decreaseDebt":
+      return {
+        operation: "DecreaseBorrowedAmount",
+        token: underlying,
+        amount: rawArgs.amount
+      };
+    case "addCollateral":
+    case "addCollateralWithPermit":
+      return {
+        operation: "AddCollateral",
+        token: rawArgs.token,
+        amount: rawArgs.amount
+      };
+    case "withdrawCollateral": {
+      const calldataToken = rawArgs.token;
+      const depositedToken = findPhantomDepositedToken(
+        calldataToken,
+        phantomTokens
+      );
+      return {
+        operation: "WithdrawCollateral",
+        token: depositedToken ?? calldataToken,
+        amount: rawArgs.amount,
+        to: rawArgs.to,
+        ...depositedToken ? { phantomToken: calldataToken } : {}
+      };
+    }
+    case "updateQuota":
+      return {
+        operation: "UpdateQuota",
+        token: rawArgs.token,
+        change: rawArgs.quotaChange
+      };
+    // other unclassified facade calls, for example onDemandPriceUpdates
+    // https://github.com/Gearbox-protocol/core-v3/blob/b038597d9070d9fd18593a6ae9c3d28ca931bb73/contracts/credit/CreditFacadeV3.sol#L534
+    default:
+      return null;
+  }
+}
+function findPhantomDepositedToken(calldataToken, phantomTokens) {
+  if (!phantomTokens) return void 0;
+  for (const [phantom, deposited] of phantomTokens.entries()) {
+    if (isAddressEqual(phantom, calldataToken)) return deposited;
+  }
+  return void 0;
+}
+export {
+  classifyMulticallOperations
+};

package/dist/esm/history/enrichTokens.js

@@ -0,0 +1,56 @@
+function enrichOperations(ops, resolve) {
+  return ops.map((op) => enrichOperation(op, resolve));
+}
+function enrichOperation(op, resolve) {
+  switch (op.operation) {
+    case "DirectTokenTransfer":
+      return { ...op, token: resolve(op.token) };
+    case "PartiallyLiquidateCreditAccount":
+      return { ...op, token: resolve(op.token) };
+    case "LiquidateCreditAccount":
+      return {
+        ...op,
+        token: resolve(op.token),
+        multicall: enrichMulticall(op.multicall, resolve)
+      };
+    case "OpenCreditAccount":
+    case "CloseCreditAccount":
+    case "MultiCall":
+    case "BotMulticall":
+      return { ...op, multicall: enrichMulticall(op.multicall, resolve) };
+  }
+}
+function enrichMulticall(ops, resolve) {
+  return ops.map((op) => enrichInnerOp(op, resolve));
+}
+function enrichInnerOp(op, resolve) {
+  switch (op.operation) {
+    case "Execute":
+      return {
+        ...op,
+        transfers: op.transfers.map((t) => ({ ...t, token: resolve(t.token) }))
+      };
+    case "IncreaseBorrowedAmount":
+    case "DecreaseBorrowedAmount":
+      return { ...op, token: resolve(op.token) };
+    case "AddCollateral":
+      return { ...op, token: resolve(op.token) };
+    case "WithdrawCollateral": {
+      const enriched = {
+        operation: op.operation,
+        token: resolve(op.token),
+        amount: op.amount,
+        to: op.to
+      };
+      if (op.phantomToken) {
+        enriched.phantomToken = resolve(op.phantomToken);
+      }
+      return enriched;
+    }
+    case "UpdateQuota":
+      return { ...op, token: resolve(op.token) };
+  }
+}
+export {
+  enrichOperations
+};

package/dist/esm/history/errors.js

@@ -0,0 +1,62 @@
+class UnknownAdapterError extends Error {
+  address;
+  constructor(address) {
+    super(`unknown adapter contract ${address}`);
+    this.name = "UnknownAdapterError";
+    this.address = address;
+  }
+}
+class TransferAlignmentError extends Error {
+  constructor(expected, actual) {
+    super(
+      `transfer alignment mismatch: expected ${expected} Execute transfers, consumed ${actual}`
+    );
+    this.name = "TransferAlignmentError";
+  }
+}
+class ProtocolCallNotFoundError extends Error {
+  targetContract;
+  executeIndex;
+  constructor(targetContract, executeIndex) {
+    super(
+      `protocol call to ${targetContract} not found in trace for Execute #${executeIndex}`
+    );
+    this.name = "ProtocolCallNotFoundError";
+    this.targetContract = targetContract;
+    this.executeIndex = executeIndex;
+  }
+}
+class AdapterTraceAlignmentError extends Error {
+  constructor(expected, actual) {
+    super(`found ${actual} adapter traces for ${expected} execute events`);
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "AdapterTracesAlignmentError";
+  }
+}
+class UnexpectedFacadeEventOrderError extends Error {
+  constructor(e) {
+    super(
+      `unexpected facade event order: ${e.eventName} at ${e.logIndex} in ${e.transactionHash}`
+    );
+    this.name = "UnexpectedFacadeEventOrderError";
+  }
+}
+class UnknownFacadeCallError extends Error {
+  address;
+  functionName;
+  constructor(address, functionName) {
+    super(`unknown facade call "${functionName}" at ${address}`);
+    this.name = "UnknownFacadeCallError";
+    this.address = address;
+    this.functionName = functionName;
+  }
+}
+export {
+  AdapterTraceAlignmentError,
+  ProtocolCallNotFoundError,
+  TransferAlignmentError,
+  UnexpectedFacadeEventOrderError,
+  UnknownAdapterError,
+  UnknownFacadeCallError
+};

package/dist/esm/history/extractProtocolCalls.js

@@ -0,0 +1,32 @@
+import {
+  AdapterTraceAlignmentError,
+  ProtocolCallNotFoundError
+} from "./errors.js";
+import { findCallTo } from "./trace-utils.js";
+function extractProtocolCalls(facadeTrace, executeResults) {
+  if (executeResults.length === 0) {
+    return [];
+  }
+  const subtraces = facadeTrace.calls ?? [];
+  const result = [];
+  let subtraceIdx = 0;
+  for (let i = 0; i < executeResults.length; i++) {
+    const { targetContract } = executeResults[i];
+    let found;
+    while (subtraceIdx < subtraces.length && !found) {
+      found = findCallTo(subtraces[subtraceIdx], targetContract);
+      subtraceIdx++;
+    }
+    if (!found) {
+      throw new ProtocolCallNotFoundError(targetContract, i);
+    }
+    result.push(found.input);
+  }
+  if (result.length !== executeResults.length) {
+    throw new AdapterTraceAlignmentError(executeResults.length, result.length);
+  }
+  return result;
+}
+export {
+  extractProtocolCalls
+};