@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.2

package/dist/cjs/sdk/options.js

@@ -18,19 +18,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var options_exports = {};
 __export(options_exports, {
-  AttachOptionsSchema: () => AttachOptionsSchema,
-  OnchainSDKOptionsSchema: () => OnchainSDKOptionsSchema
+  attachOptionsSchema: () => attachOptionsSchema,
+  onchainSDKOptionsSchema: () => onchainSDKOptionsSchema
 });
 module.exports = __toCommonJS(options_exports);
 var import_v4 = require("zod/v4");
 var import_updates = require("./market/pricefeeds/updates/index.js");
 var import_utils = require("./utils/index.js");
-const OnchainSDKOptionsSchema = import_v4.z.object({
-  /** When `true`, throw on unrecognised contract types. */
+const onchainSDKOptionsSchema = import_v4.z.object({
+  /**
+   * When `true`, throw on unrecognised contract types.
+   **/
   strictContractTypes: import_v4.z.boolean().optional(),
-  /** Plugins that extend SDK functionality. */
+  /**
+   * Plugins that extend SDK functionality.
+   **/
   plugins: import_v4.z.record(import_v4.z.string(), import_v4.z.any()).optional(),
-  /** Custom logger implementation. */
+  /**
+   * Custom logger implementation.
+   **/
   logger: import_v4.z.any(),
   /**
    * Explicit gas limit for read-only `eth_call` requests.
@@ -39,10 +45,14 @@ const OnchainSDKOptionsSchema = import_v4.z.object({
    **/
   gasLimit: import_v4.z.bigint().nonnegative().nullable().optional()
 });
-const AttachOptionsSchema = import_v4.z.object({
-  /** Override address of the Gearbox AddressProvider contract. */
+const attachOptionsSchema = import_v4.z.object({
+  /**
+   * Override address of the Gearbox AddressProvider contract.
+   **/
   addressProvider: (0, import_utils.ZodAddress)().optional(),
-  /** Addresses of market configurator contracts to load. */
+  /**
+   * Addresses of market configurator contracts to load.
+   **/
   marketConfigurators: import_v4.z.array((0, import_utils.ZodAddress)()).optional(),
   /**
    * Addresses of RWA factory contracts to load.
@@ -50,19 +60,33 @@ const AttachOptionsSchema = import_v4.z.object({
    * (from {@link GearboxChain.rwaFactories})
    **/
   rwaFactories: import_v4.z.array((0, import_utils.ZodAddress)()).optional(),
-  /** Pin SDK to a specific block number during attach. */
+  /**
+   * Pin SDK to a specific block number during attach.
+   **/
   blockNumber: import_v4.z.union([import_v4.z.bigint().nonnegative(), import_v4.z.number().int().nonnegative()]).optional(),
-  /** Skip fetching updatable price feeds on attach and sync. */
+  /**
+   * Skip fetching updatable price feeds on attach and sync.
+   **/
   ignoreUpdateablePrices: import_v4.z.boolean().optional(),
-  /** Pool addresses whose markets should be skipped. */
+  /**
+   * Pool addresses whose markets should be skipped.
+   **/
   ignoreMarkets: import_v4.z.array((0, import_utils.ZodAddress)()).optional(),
-  /** Options for Redstone price-feed updates. */
+  /**
+   * Options for Redstone price-feed updates.
+   **/
   redstone: import_updates.RedstoneOptions.optional(),
-  /** Options for Pyth price-feed updates. */
-  pyth: import_updates.PythOptions.optional()
+  /**
+   * Options for Pyth price-feed updates.
+   **/
+  pyth: import_updates.PythOptions.optional(),
+  /**
+   * When `true`, automatically load zappers during attach.
+   **/
+  loadZappers: import_v4.z.boolean().optional()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AttachOptionsSchema,
-  OnchainSDKOptionsSchema
+  attachOptionsSchema,
+  onchainSDKOptionsSchema
 });

package/dist/esm/abi/iZapper.js

@@ -1,80 +1,118 @@
 const iZapperAbi = [
   {
     type: "function",
+    name: "contractType",
     inputs: [],
+    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
     name: "pool",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "previewDeposit",
     inputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
-    name: "previewDeposit",
     outputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "previewRedeem",
     inputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" }
     ],
-    name: "previewRedeem",
     outputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "redeem",
     inputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" },
-      { name: "receiver", internalType: "address", type: "address" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" }
     ],
-    name: "redeem",
     outputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "nonpayable"
   },
   {
     type: "function",
+    name: "redeemWithPermit",
     inputs: [
-      { name: "tokenOutAmount", internalType: "uint256", type: "uint256" },
-      { name: "receiver", internalType: "address", type: "address" },
-      { name: "deadline", internalType: "uint256", type: "uint256" },
-      { name: "v", internalType: "uint8", type: "uint8" },
-      { name: "r", internalType: "bytes32", type: "bytes32" },
-      { name: "s", internalType: "bytes32", type: "bytes32" }
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" },
+      { name: "deadline", type: "uint256", internalType: "uint256" },
+      { name: "v", type: "uint8", internalType: "uint8" },
+      { name: "r", type: "bytes32", internalType: "bytes32" },
+      { name: "s", type: "bytes32", internalType: "bytes32" }
     ],
-    name: "redeemWithPermit",
     outputs: [
-      { name: "tokenInAmount", internalType: "uint256", type: "uint256" }
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "nonpayable"
   },
   {
     type: "function",
+    name: "redeemWithPermitAllowed",
+    inputs: [
+      { name: "tokenOutAmount", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" },
+      { name: "nonce", type: "uint256", internalType: "uint256" },
+      { name: "expiry", type: "uint256", internalType: "uint256" },
+      { name: "v", type: "uint8", internalType: "uint8" },
+      { name: "r", type: "bytes32", internalType: "bytes32" },
+      { name: "s", type: "bytes32", internalType: "bytes32" }
+    ],
+    outputs: [
+      { name: "tokenInAmount", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "serialize",
     inputs: [],
-    name: "tokenIn",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    outputs: [{ name: "serializedData", type: "bytes", internalType: "bytes" }],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "tokenIn",
     inputs: [],
-    name: "tokenOut",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
   },
   {
     type: "function",
+    name: "tokenOut",
     inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
     name: "underlying",
-    outputs: [{ name: "", internalType: "address", type: "address" }],
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "version",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
     stateMutability: "view"
   }
 ];

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

@@ -23,6 +23,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/verifyTestnet.js

@@ -0,0 +1,27 @@
+import { iOnchainExecutionIdAbi } from "./abi.js";
+const ONCHAIN_EXECUTION_ID_ADDRESS = "0x34131bc13eaa4ef5f98c2a423f93bc88d6ee01ba";
+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,
+  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,

package/dist/esm/history/toLegacyOperation.js

@@ -24,7 +24,11 @@ function createLegacyVisitor(params) {
         blockNum: ctx.blockNumber,
         timestamp: ctx.timestamp,
         sessionId: params.sessionId,
-        protocol: op.protocol
+        // `protocol` may be absent (migrator adapter, unknown adapter in
+        // non-strict mode, or undecodable calldata). The deprecated charts
+        // output still needs an address, so fall back to the on-chain adapter
+        // address, which is the closest meaningful value.
+        protocol: op.protocol?.contract ?? op.adapter
       };
     },
     IncreaseBorrowedAmount(op, ctx) {

package/dist/esm/plugins/adapters/contracts/AbstractAdapter.js

@@ -3,13 +3,16 @@ import {
   decodeFunctionData,
   zeroAddress
 } from "viem";
+import {
+  resolveProtocolCall
+} from "../../../common-utils/utils/trace.js";
 import {
   BaseContract,
   functionArgsToRecord,
   getFunctionSignature,
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
-import { swapFromTransfers, toNetTransfers } from "../transferHelpers.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 class AbstractAdapterContract extends BaseContract {
   #targetContract;
   #creditManager;
@@ -50,45 +53,33 @@ class AbstractAdapterContract extends BaseContract {
     };
   }
   /**
-   * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
+   * Decodes the protocol-level call (target contract + function name + args)
+   * performed by this adapter, recovered from its adapter-level call trace.
    *
-   * Returns `PartialBy<AdapterOperation, "targetContract">` because the adapter
-   * may not have `targetContract` (adapters created without SDK do not have serializedParams)
+   * Both the `targetContract` and the protocol calldata are taken from the
+   * execution trace.
    *
-   * @param protocolCalldata Raw calldata of the actual CALL to targetContract, extracted from trace
-   * @param strict When true, throws if protocol ABI is missing or decode fails
-   */
-  parseAdapterOperation(parsed, transfers, creditAccount, protocolCalldata, strict) {
-    const netTransfers = toNetTransfers(transfers, creditAccount);
-    const protocol = this.parseProtocolCall(protocolCalldata, strict);
-    return {
-      operation: "Execute",
-      adapter: this.address,
-      protocol: this.#targetContract,
-      adapterType: this.adapterType,
-      version: this.version,
-      label: parsed.label,
-      adapterFunctionName: parsed.functionName,
-      adapterArgs: parsed.rawArgs,
-      ...protocol,
-      transfers,
-      legacy: this.classifyLegacyOperation(parsed, netTransfers)
-    };
-  }
-  /**
-   * Decodes protocol-level function name and args from the raw calldata
-   * sent to targetContract.
+   * Returns `undefined` (in non-strict mode) when no external protocol call can
+   * be recovered, in strict mode throws instead.
+   *
+   * @param trace Adapter-level call trace (a direct child of the facade trace)
+   * @param strict When true, throws instead of returning `undefined`
    */
-  parseProtocolCall(calldata, strict) {
+  parseProtocolCall(trace, strict) {
+    const resolved = resolveProtocolCall(trace);
+    if (!resolved) {
+      if (strict) {
+        throw new Error("no external protocol call found in adapter trace");
+      }
+      return void 0;
+    }
+    const { contract, calldata } = resolved;
     const selector = calldata.slice(0, 10);
     if (this.protocolAbi.length === 0) {
       if (strict) {
         throw new Error(`Protocol ABI is missing for selector ${selector}`);
       }
-      return {
-        protocolFunctionName: `unknown function ${selector}`,
-        protocolArgs: {}
-      };
+      return void 0;
     }
     try {
       const decoded = decodeFunctionData({
@@ -96,12 +87,12 @@ class AbstractAdapterContract extends BaseContract {
         data: calldata
       });
       const functionName = getFunctionSignature(this.protocolAbi, calldata);
-      const protocolArgs = functionArgsToRecord(
+      const functionArgs = functionArgsToRecord(
         this.protocolAbi,
         decoded.functionName,
         decoded.args
       );
-      return { protocolFunctionName: functionName, protocolArgs };
+      return { contract, functionName, functionArgs };
     } catch (e) {
       if (strict) {
         throw new Error(
@@ -109,10 +100,7 @@ class AbstractAdapterContract extends BaseContract {
           { cause: e }
         );
       }
-      return {
-        protocolFunctionName: `unknown function ${selector}`,
-        protocolArgs: {}
-      };
+      return void 0;
     }
   }
   /**
@@ -126,6 +114,8 @@ class AbstractAdapterContract extends BaseContract {
    * Override in protocol-specific subclasses for richer classification.
    *
    * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/account_operation.go#L238-L264
+   *
+   * @deprecated Eventually will be gone, exists to produce output that legacy UI can display
    */
   classifyLegacyOperation(_parsed, transfers) {
     const swap = swapFromTransfers(transfers);