@gearbox-protocol/sdk 13.0.0-next.9 → 13.0.1

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
+};

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/permissionless/bindings/cross-chain-multisig.js

@@ -16,8 +16,8 @@ import { InstanceManagerContract } from "./instance-manager.js";
 import { MarketConfiguratorFactoryContract } from "./market-configurator-factory.js";
 const abi = crossChainMultisigAbi;
 class CrossChainMultisigContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "CrossChainMultisig" });
+  constructor(addr, register) {
+    super({ register }, { abi, addr, name: "CrossChainMultisig" });
   }
   async getExecutedBatches(fromBlock, toBlock) {
     const events = await this.getEvents("ExecuteBatch", fromBlock, toBlock);
@@ -170,7 +170,7 @@ class CrossChainMultisigContract extends BaseContract {
       case Addresses.INSTANCE_MANAGER.toLowerCase(): {
         const instanceManager = new InstanceManagerContract(
           target,
-          this.client
+          this.register
         );
         return instanceManager.parseFunctionData(calldata);
       }

package/dist/esm/permissionless/bindings/instance-manager.js

@@ -22,8 +22,8 @@ import { RoutingManagerContract } from "./router/index.js";
 import { TreasurySplitterContract } from "./treasury-splitter.js";
 const abi = instanceManagerAbi;
 class InstanceManagerContract extends BaseContract {
-  constructor(addr, client) {
-    super({ client }, { abi, addr, name: "InstanceManager" });
+  constructor(addr, register) {
+    super({ register }, { abi, addr, name: "InstanceManager" });
   }
   // TODO:
   #decodeFunctionData(target, calldata) {
@@ -138,7 +138,7 @@ class InstanceManagerContract extends BaseContract {
       );
       return {
         ...result,
-        label: `${this.register.labelAddress(target, true)} via ${result.label}`
+        label: `${this.labelAddress(target, true)} via ${result.label}`
       };
     }
     return super.mustParseFunctionData(calldata);

package/dist/esm/permissionless/utils/price-update/get-prices.js

@@ -84,12 +84,8 @@ async function getPrices({
     client,
     gasLimit,
     marketConfigurators: [],
-    redstone: {
-      ignoreMissingFeeds: true
-    },
-    pyth: {
-      ignoreMissingFeeds: true
-    }
+    redstone: {},
+    pyth: {}
   });
   const chunks = [];
   for (let i = 0; i < priceFeeds.length; i += chunkSize) {