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

package/dist/esm/abi/310/iSecuritizeKYCFactory.js

@@ -1,11 +1,4 @@
 const iSecuritizeKYCFactoryAbi = [
-  {
-    type: "function",
-    name: "addRegistrar",
-    inputs: [{ name: "registrar", type: "address", internalType: "address" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
   {
     type: "function",
     name: "contractType",
@@ -13,13 +6,6 @@ const iSecuritizeKYCFactoryAbi = [
     outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
     stateMutability: "view"
   },
-  {
-    type: "function",
-    name: "degenNFT",
-    inputs: [],
-    outputs: [{ name: "", type: "address", internalType: "address" }],
-    stateMutability: "view"
-  },
   {
     type: "function",
     name: "getCreditAccounts",
@@ -29,33 +15,17 @@ const iSecuritizeKYCFactoryAbi = [
   },
   {
     type: "function",
-    name: "getDSTokens",
+    name: "getDegenNFT",
     inputs: [],
-    outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getInvestor",
-    inputs: [
-      { name: "creditAccount", type: "address", internalType: "address" }
-    ],
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "getRegisteredTokens",
+    name: "getInvestor",
     inputs: [
       { name: "creditAccount", type: "address", internalType: "address" }
     ],
-    outputs: [{ name: "", type: "address[]", internalType: "address[]" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getRegistrar",
-    inputs: [{ name: "token", type: "address", internalType: "address" }],
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
@@ -68,15 +38,6 @@ const iSecuritizeKYCFactoryAbi = [
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
-  {
-    type: "function",
-    name: "isActiveCreditAccount",
-    inputs: [
-      { name: "creditAccount", type: "address", internalType: "address" }
-    ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "view"
-  },
   {
     type: "function",
     name: "isCreditAccount",
@@ -95,15 +56,6 @@ const iSecuritizeKYCFactoryAbi = [
     outputs: [{ name: "", type: "bool", internalType: "bool" }],
     stateMutability: "view"
   },
-  {
-    type: "function",
-    name: "isInactiveCreditAccount",
-    inputs: [
-      { name: "creditAccount", type: "address", internalType: "address" }
-    ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "view"
-  },
   {
     type: "function",
     name: "multicall",
@@ -163,6 +115,13 @@ const iSecuritizeKYCFactoryAbi = [
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "serialize",
+    inputs: [],
+    outputs: [{ name: "serializedData", type: "bytes", internalType: "bytes" }],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "setFrozenStatus",
@@ -254,30 +213,6 @@ const iSecuritizeKYCFactoryAbi = [
     ],
     anonymous: false
   },
-  {
-    type: "event",
-    name: "SetRegistrar",
-    inputs: [
-      {
-        name: "token",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      },
-      {
-        name: "registrar",
-        type: "address",
-        indexed: true,
-        internalType: "address"
-      }
-    ],
-    anonymous: false
-  },
-  {
-    type: "error",
-    name: "CallerIsNotInstanceOwnerException",
-    inputs: [{ name: "caller", type: "address", internalType: "address" }]
-  },
   {
     type: "error",
     name: "CallerIsNotInvestorException",
@@ -305,11 +240,6 @@ const iSecuritizeKYCFactoryAbi = [
     name: "InvalidUnderlyingTokenException",
     inputs: [{ name: "underlying", type: "address", internalType: "address" }]
   },
-  {
-    type: "error",
-    name: "RegistrarNotSetForTokenException",
-    inputs: [{ name: "token", type: "address", internalType: "address" }]
-  },
   {
     type: "error",
     name: "UnknownCreditAccountException",
@@ -317,14 +247,6 @@ const iSecuritizeKYCFactoryAbi = [
       { name: "creditAccount", type: "address", internalType: "address" }
     ]
   },
-  {
-    type: "error",
-    name: "WalletCallExecutionFailedException",
-    inputs: [
-      { name: "index", type: "uint256", internalType: "uint256" },
-      { name: "reason", type: "bytes", internalType: "bytes" }
-    ]
-  },
   { type: "error", name: "ZeroAddressException", inputs: [] }
 ];
 export {

package/dist/esm/history/assembleOperations.js

@@ -0,0 +1,79 @@
+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,
+    liquidationRemainingFunds,
+    phantomTokens,
+    strict
+  } = input;
+  let offset = 0;
+  return facadeCalls.map((fc) => {
+    if (fc.operation === "PartiallyLiquidateCreditAccount") {
+      return assemblePartialLiquidation(fc);
+    }
+    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 {
+          operation: fc.operation,
+          creditAccount: fc.creditAccount,
+          onBehalfOf: fc.parsed.rawArgs.onBehalfOf,
+          referralCode: fc.parsed.rawArgs.referralCode,
+          multicall
+        };
+      case "LiquidateCreditAccount":
+        return {
+          operation: fc.operation,
+          creditAccount: fc.creditAccount,
+          to: fc.parsed.rawArgs.to,
+          token: underlying,
+          remainingFunds: liquidationRemainingFunds ?? 0n,
+          multicall
+        };
+      default:
+        return {
+          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) {
+  const { rawArgs } = fc.parsed;
+  return {
+    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/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
+};

package/dist/esm/history/extractTransfers.js

@@ -0,0 +1,148 @@
+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;
+    }
+    if (isAddressEqual(from, creditAccount) || isAddressEqual(to, creditAccount)) {
+      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";
+export * from "./mapOperations.js";
+import { parseCreditAccountTransaction } from "./parseCreditAccountTransaction.js";
+export * from "./populateContractsRegister.js";
+export * from "./toLegacyOperation.js";
+export * from "./types.js";
+export {
+  parseCreditAccountTransaction
+};