@gearbox-protocol/sdk 14.10.10 → 14.11.0-next.10

package/dist/cjs/{history → preview/trace}/extractTransfers.js

@@ -22,14 +22,14 @@ __export(extractTransfers_exports, {
 });
 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_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 executeTransfers = [];
   const directTransfers = [];
   const phantomTokens = new import_sdk.AddressMap();
   const withdrawCollateralEvents = [];
@@ -38,20 +38,17 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     const facadeEvent = tryDecodeFacadeEvent(log, creditFacade);
     if (facadeEvent) {
       if (isExecute(facadeEvent, creditAccount)) {
-        executeResults.push({
-          transfers: currentEntries,
-          targetContract: facadeEvent.args.targetContract
-        });
+        executeTransfers.push(currentEntries);
       } else if (isLiquidation(facadeEvent, creditAccount)) {
         liquidationRemainingFunds = facadeEvent.args.remainingFunds;
       } else if (isWithdrawPhantomToken(facadeEvent, creditAccount)) {
-        const phantomExec = executeResults.pop();
-        if (!phantomExec) {
+        const phantomTransfers = executeTransfers.pop();
+        if (!phantomTransfers) {
           throw new Error(
             `WithdrawPhantomToken without preceding Execute at logIndex ${facadeEvent.logIndex}`
           );
         }
-        const rawDeposit = phantomExec.transfers.find(
+        const rawDeposit = phantomTransfers.find(
           (t) => (0, import_viem.isAddressEqual)(t.to, creditAccount)
         );
         if (!rawDeposit) {
@@ -86,11 +83,11 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
       currentEntries.push({ token, amount: value, from, to });
     }
     if ((0, import_viem.isAddressEqual)(to, creditAccount) && !isInRange(log.logIndex, ranges)) {
-      directTransfers.push({ token, from, amount: value });
+      directTransfers.push({ token, amount: value, from, to });
     }
   }
   return {
-    executeResults,
+    executeTransfers,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,

package/dist/cjs/{history → preview/trace}/findFacadeCalls.js

@@ -22,9 +22,9 @@ __export(findFacadeCalls_exports, {
 });
 module.exports = __toCommonJS(findFacadeCalls_exports);
 var import_viem = require("viem");
-var import_generated = require("../abi/310/generated.js");
+var import_generated = require("../../abi/310/generated.js");
+var import_trace = require("../../common-utils/utils/trace.js");
 var import_errors = require("./errors.js");
-var import_trace_utils = require("./trace-utils.js");
 const FACADE_CALL_TYPES = {
   multicall: "MultiCall",
   botMulticall: "BotMulticall",
@@ -48,7 +48,7 @@ function extractCreditAccount(operation, rawArgs, traceOutput) {
   return ca;
 }
 function findFacadeCalls(trace, creditFacade, creditAccount, register, strict) {
-  const facadeTraces = (0, import_trace_utils.collectTraces)(trace, creditFacade);
+  const facadeTraces = (0, import_trace.collectTraces)(trace, creditFacade);
   const results = [];
   for (const trace2 of facadeTraces) {
     const parsed = register.parseFunctionDataV2(

package/dist/cjs/preview/trace/index.js

@@ -0,0 +1,30 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trace_exports = {};
+module.exports = __toCommonJS(trace_exports);
+__reExport(trace_exports, require("./errors.js"), module.exports);
+__reExport(trace_exports, require("./extractAdapterCallTraces.js"), module.exports);
+__reExport(trace_exports, require("./extractTransfers.js"), module.exports);
+__reExport(trace_exports, require("./findFacadeCalls.js"), module.exports);
+__reExport(trace_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./errors.js"),
+  ...require("./extractAdapterCallTraces.js"),
+  ...require("./extractTransfers.js"),
+  ...require("./findFacadeCalls.js"),
+  ...require("./types.js")
+});

package/dist/cjs/preview/trace/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);

package/dist/cjs/sdk/accounts/CreditAccountsServiceV310.js

@@ -1552,6 +1552,160 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
       callsWithPrices
     );
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.prependPriceUpdates}
+   */
+  async prependPriceUpdates(creditManager, calls, creditAccount, options) {
+    return this.#prependPriceUpdates(
+      creditManager,
+      calls,
+      creditAccount,
+      options
+    );
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
+   */
+  assembleCaUpdateCalls({
+    operations,
+    routerCallGroups,
+    creditFacade,
+    withdrawTo,
+    creditAccount,
+    underlyingToken
+  }) {
+    const calls = [];
+    let swapGroupIndex = 0;
+    let routerGroupsConsumed = 0;
+    for (const op of operations) {
+      switch (op.type) {
+        case "increaseDebt":
+          calls.push(this.#prepareIncreaseDebt(creditFacade, op.amount));
+          break;
+        case "decreaseDebt":
+          calls.push(this.#prepareChangeDebt(creditFacade, op.amount, true));
+          break;
+        case "addCollateral":
+          calls.push(
+            ...this.#prepareAddCollateral(
+              creditFacade,
+              [{ token: op.token, balance: op.amount }],
+              {}
+            )
+          );
+          break;
+        case "withdrawCollateral":
+          calls.push(
+            this.#prepareWithdrawToken(
+              creditFacade,
+              op.token,
+              op.amount,
+              withdrawTo
+            )
+          );
+          break;
+        case "swap": {
+          const routerCalls = routerCallGroups[swapGroupIndex];
+          if (!routerCalls) {
+            throw new Error(
+              `assembleCaUpdateCalls: missing router calls for swap leg ${swapGroupIndex}`
+            );
+          }
+          calls.push(...routerCalls);
+          swapGroupIndex += 1;
+          routerGroupsConsumed += 1;
+          break;
+        }
+        case "changeQuota": {
+          const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
+          if (quotaAssets.length === 0) {
+            break;
+          }
+          calls.push(
+            ...this.#prepareUpdateQuotas(creditFacade, {
+              averageQuota: quotaAssets,
+              minQuota: quotaAssets
+            })
+          );
+          break;
+        }
+        case "closeCreditAccount": {
+          for (const group of routerCallGroups) {
+            calls.push(...group);
+            routerGroupsConsumed += 1;
+          }
+          calls.push(
+            ...this.#prepareDisableQuotas({
+              creditFacade,
+              tokens: Object.entries(creditAccount.initialQuotas).map(
+                ([token, { quota }]) => ({
+                  token,
+                  quota
+                })
+              )
+            })
+          );
+          if (creditAccount.debt > 0n) {
+            calls.push(
+              ...this.#prepareDecreaseDebt({
+                creditFacade,
+                debt: creditAccount.debt
+              })
+            );
+          }
+          const hasAssets = creditAccount.assets.some(
+            (asset) => asset.balance > 0n
+          );
+          if (hasAssets) {
+            calls.push(
+              this.#prepareWithdrawToken(
+                creditFacade,
+                underlyingToken,
+                import_constants.MAX_UINT256,
+                withdrawTo
+              )
+            );
+          }
+          break;
+        }
+        default: {
+          const _exhaustive = op;
+          throw new Error(
+            `assembleCaUpdateCalls: unsupported operation ${_exhaustive}`
+          );
+        }
+      }
+    }
+    if (routerGroupsConsumed !== routerCallGroups.length) {
+      throw new Error(
+        `assembleCaUpdateCalls: router call group mismatch (consumed ${routerGroupsConsumed}, got ${routerCallGroups.length})`
+      );
+    }
+    return calls;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.executeCaUpdate}
+   */
+  async executeCaUpdate(creditAccount, calls, options) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const callsWithPrices = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      calls,
+      creditAccount,
+      { ignoreReservePrices: options?.ignoreReservePrices }
+    );
+    const tx = await this.#multicallTx(
+      cm,
+      creditAccount.creditAccount,
+      callsWithPrices
+    );
+    if (options?.ethAmount && options.ethAmount > 0n) {
+      tx.value = options.ethAmount.toString(10);
+    }
+    return { tx, calls: callsWithPrices };
+  }
   #prepareDisableQuotas(ca) {
     const calls = [];
     for (const { token, quota } of ca.tokens) {

package/dist/esm/common-utils/utils/index.js

@@ -5,4 +5,5 @@ export * from "./constants.js";
 export * from "./creditAccount/index.js";
 export * from "./price-math.js";
 export * from "./strategies/index.js";
+export * from "./trace.js";
 export * from "./validation/index.js";

package/dist/esm/common-utils/utils/trace.js

@@ -0,0 +1,93 @@
+import {
+  decodeAbiParameters,
+  getAddress,
+  isAddressEqual
+} from "viem";
+const EXECUTE_BYTES_SELECTOR = "0x09c5eabe";
+function findExecuteBytes(node) {
+  const queue = [node];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current.error) {
+      continue;
+    }
+    if (current.input.slice(0, 10).toLowerCase() === EXECUTE_BYTES_SELECTOR) {
+      return current;
+    }
+    if (current.calls) {
+      queue.push(...current.calls);
+    }
+  }
+  return void 0;
+}
+function findCallWithInput(node, input) {
+  if (node.error) {
+    return void 0;
+  }
+  if (node.type === "CALL" && node.input.toLowerCase() === input.toLowerCase()) {
+    return node;
+  }
+  if (node.calls) {
+    for (const child of node.calls) {
+      const found = findCallWithInput(child, input);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveProtocolCall(node) {
+  const executeNode = findExecuteBytes(node);
+  if (!executeNode) {
+    return void 0;
+  }
+  const [calldata] = decodeAbiParameters(
+    [{ type: "bytes" }],
+    `0x${executeNode.input.slice(10)}`
+  );
+  const targetCall = findCallWithInput(executeNode, calldata);
+  if (!targetCall) {
+    return void 0;
+  }
+  return { contract: getAddress(targetCall.to), calldata };
+}
+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 {
+  EXECUTE_BYTES_SELECTOR,
+  collectTraces,
+  findCallTo,
+  findCallWithInput,
+  findExecuteBytes,
+  resolveProtocolCall
+};

package/dist/esm/dev/index.js

@@ -22,6 +22,7 @@ export * from "./replaceStorage.js";
 export * from "./resilientTransport.js";
 export * from "./transports.js";
 export * from "./types.js";
+export * from "./verifyTestnet.js";
 export {
   isRangeError,
   logSplitterTransport

package/dist/esm/dev/isOutOfSyncError.js

@@ -15,9 +15,7 @@ const OUT_OF_SYNC_PATTERNS = [
   // Optimism proxyd (code -32019) for future/non-existent blocks
   /block is out of range/i,
   // EIP-1474 standard (code -32001) when block/state is not available
-  /resource not found/i,
-  // DRPC when a requested block is ahead of the node's latest block
-  /greater than latest block/i
+  /resource not found/i
 ];
 function isOutOfSyncError(e) {
   if (e instanceof BaseError) {

package/dist/esm/dev/verifyTestnet.js

@@ -0,0 +1,98 @@
+const ONCHAIN_EXECUTION_ID_ADDRESS = "0x34131bc13eaa4ef5f98c2a423f93bc88d6ee01ba";
+const iOnchainExecutionIdAbi = [
+  {
+    type: "function",
+    name: "deployer",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "executionId",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "forkAlias",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "info",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct ExecutionId.Info",
+        components: [
+          {
+            name: "deployer",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "executionId",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "forkAlias",
+            type: "string",
+            internalType: "string"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+async function verifyTestnet(client, expected) {
+  try {
+    const { deployer, executionId, forkAlias } = await client.readContract({
+      abi: iOnchainExecutionIdAbi,
+      address: ONCHAIN_EXECUTION_ID_ADDRESS,
+      functionName: "info"
+    });
+    if (deployer !== "anvil-manager") {
+      return false;
+    }
+    if ("executionId" in expected && expected.executionId && expected.executionId !== executionId) {
+      return false;
+    }
+    if ("alias" in expected && expected.alias && expected.alias !== forkAlias) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  ONCHAIN_EXECUTION_ID_ADDRESS,
+  iOnchainExecutionIdAbi,
+  verifyTestnet
+};

package/dist/esm/history/assembleOperations.js

@@ -1,10 +1,12 @@
 import { AbstractAdapterContract } from "../plugins/adapters/index.js";
+import {
+  extractAdapterCallTraces
+} from "../preview/trace/index.js";
 import { classifyMulticallOperations } from "./classifyMulticallOperations.js";
-import { extractProtocolCalls } from "./extractProtocolCalls.js";
 function assembleOperations(input) {
   const {
     facadeCalls,
-    executeResults,
+    executeTransfers,
     register,
     underlying,
     liquidationRemainingFunds,
@@ -19,7 +21,7 @@ function assembleOperations(input) {
       return assemblePartialLiquidation(fc);
     }
     const count = countAdapterCalls(fc.innerCalls, register);
-    const sliced = executeResults.slice(executeOffset, executeOffset + count);
+    const sliced = executeTransfers.slice(executeOffset, executeOffset + count);
     executeOffset += count;
     const withdrawCount = countWithdrawCollateralCalls(fc.innerCalls);
     const slicedWithdrawEvents = withdrawCollateralEvents.slice(
@@ -27,11 +29,11 @@ function assembleOperations(input) {
       withdrawOffset + withdrawCount
     );
     withdrawOffset += withdrawCount;
-    const protocolCalldatas = extractProtocolCalls(fc.trace, sliced);
+    const adapterTraces = extractAdapterCallTraces(fc.trace);
     const multicall = classifyMulticallOperations({
       innerCalls: fc.innerCalls,
-      executeResults: sliced,
-      protocolCalldatas,
+      executeTransfers: sliced,
+      adapterTraces,
       register,
       creditAccount: fc.creditAccount,
       underlying,

package/dist/esm/history/classifyMulticallOperations.js

@@ -8,12 +8,12 @@ import {
   TransferAlignmentError,
   UnknownAdapterError,
   WithdrawCollateralAlignmentError
-} from "./errors.js";
+} from "../preview/trace/index.js";
 function classifyMulticallOperations(input) {
   const {
     innerCalls,
-    executeResults,
-    protocolCalldatas,
+    executeTransfers,
+    adapterTraces,
     register,
     creditAccount,
     underlying,
@@ -28,20 +28,27 @@ function classifyMulticallOperations(input) {
     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 transfers2 = executeTransfers[idx];
+      if (!transfers2) {
+        throw new TransferAlignmentError(executeTransfers.length, transferIdx);
       }
-      const { transfers: transfers2, targetContract: targetContract2 } = executeResult;
-      const protocolCalldata = protocolCalldatas[idx];
-      const partial = contract.parseAdapterOperation(
+      const protocol = contract.parseProtocolCall(adapterTraces[idx], strict);
+      const legacy = contract.classifyLegacyOperation(
         call,
-        transfers2,
-        creditAccount,
-        protocolCalldata,
-        strict
+        toNetTransfers(transfers2, creditAccount)
       );
-      if (partial) result.push({ ...partial, protocol: targetContract2 });
+      result.push({
+        operation: "Execute",
+        adapter: call.target,
+        adapterType: call.contractType,
+        version: call.version,
+        label: call.label,
+        adapterFunctionName: call.functionName,
+        adapterArgs: call.rawArgs,
+        protocol,
+        transfers: transfers2,
+        legacy
+      });
       continue;
     }
     if (contract !== void 0) {
@@ -60,23 +67,22 @@ function classifyMulticallOperations(input) {
       throw new UnknownAdapterError(call.target);
     }
     const unknownIdx = transferIdx++;
-    const unknownResult = executeResults[unknownIdx];
-    if (!unknownResult) {
-      throw new TransferAlignmentError(executeResults.length, transferIdx);
+    const transfers = executeTransfers[unknownIdx];
+    if (!transfers) {
+      throw new TransferAlignmentError(executeTransfers.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,
+      // Unknown adapter (non-strict): we have no ABI to decode the protocol
+      // call, so `protocol` is left absent rather than filled with placeholders.
+      protocol: void 0,
       transfers,
       legacy: {
         operation: "Swap",
@@ -84,8 +90,8 @@ function classifyMulticallOperations(input) {
       }
     });
   }
-  if (transferIdx !== executeResults.length) {
-    throw new TransferAlignmentError(executeResults.length, transferIdx);
+  if (transferIdx !== executeTransfers.length) {
+    throw new TransferAlignmentError(executeTransfers.length, transferIdx);
   }
   if (withdrawCollateralEvents && withdrawCollateralEvents.length > 0 && withdrawIdx !== withdrawCollateralEvents.length) {
     throw new WithdrawCollateralAlignmentError(

package/dist/esm/history/index.js

@@ -1,4 +1,3 @@
-export * from "./inner-operations.js";
 export * from "./mapOperations.js";
 import { parseCreditAccountTransaction } from "./parseCreditAccountTransaction.js";
 export * from "./populateContractsRegister.js";

package/dist/esm/history/parseCreditAccountTransaction.js

@@ -1,6 +1,5 @@
+import { extractTransfers, findFacadeCalls } from "../preview/trace/index.js";
 import { assembleOperations } from "./assembleOperations.js";
-import { extractTransfers } from "./extractTransfers.js";
-import { findFacadeCalls } from "./findFacadeCalls.js";
 function parseCreditAccountTransaction(input) {
   const {
     trace,
@@ -25,7 +24,7 @@ function parseCreditAccountTransaction(input) {
     strict
   );
   const {
-    executeResults,
+    executeTransfers,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,
@@ -40,7 +39,7 @@ function parseCreditAccountTransaction(input) {
   };
   const facadeOps = assembleOperations({
     facadeCalls,
-    executeResults,
+    executeTransfers,
     register,
     underlying,
     liquidationRemainingFunds,