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

package/dist/types/sdk/market/zapper/IETHZapperContract.d.ts

@@ -1,8 +1,8 @@
 import type { Address } from "viem";
-import { BaseContract } from "../../base/index.js";
 import type { OnchainSDK } from "../../OnchainSDK.js";
 import type { RawTx } from "../../types/index.js";
 import type { ZapperData } from "../types.js";
+import { ZapperContract } from "./ZapperContract.js";
 declare const abi: readonly [{
     readonly type: "function";
     readonly inputs: readonly [{
@@ -37,132 +37,195 @@ declare const abi: readonly [{
     readonly stateMutability: "payable";
 }, {
     readonly type: "function";
+    readonly name: "contractType";
     readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
     readonly name: "pool";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
+    readonly name: "previewDeposit";
     readonly inputs: readonly [{
         readonly name: "tokenInAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
-    readonly name: "previewDeposit";
     readonly outputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
+    readonly name: "previewRedeem";
     readonly inputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
-    readonly name: "previewRedeem";
     readonly outputs: readonly [{
         readonly name: "tokenInAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
+    readonly name: "redeem";
     readonly inputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }, {
         readonly name: "receiver";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
-    readonly name: "redeem";
     readonly outputs: readonly [{
         readonly name: "tokenInAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
+    readonly name: "redeemWithPermit";
     readonly inputs: readonly [{
         readonly name: "tokenOutAmount";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }, {
         readonly name: "receiver";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }, {
         readonly name: "deadline";
-        readonly internalType: "uint256";
         readonly type: "uint256";
+        readonly internalType: "uint256";
     }, {
         readonly name: "v";
-        readonly internalType: "uint8";
         readonly type: "uint8";
+        readonly internalType: "uint8";
     }, {
         readonly name: "r";
-        readonly internalType: "bytes32";
         readonly type: "bytes32";
+        readonly internalType: "bytes32";
     }, {
         readonly name: "s";
-        readonly internalType: "bytes32";
         readonly type: "bytes32";
+        readonly internalType: "bytes32";
     }];
-    readonly name: "redeemWithPermit";
     readonly outputs: readonly [{
         readonly name: "tokenInAmount";
+        readonly type: "uint256";
         readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "redeemWithPermitAllowed";
+    readonly inputs: readonly [{
+        readonly name: "tokenOutAmount";
         readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "receiver";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "expiry";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "v";
+        readonly type: "uint8";
+        readonly internalType: "uint8";
+    }, {
+        readonly name: "r";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "s";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "tokenInAmount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
+    readonly name: "serialize";
     readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "serializedData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
     readonly name: "tokenIn";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly inputs: readonly [];
     readonly name: "tokenOut";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly inputs: readonly [];
     readonly name: "underlying";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly internalType: "address";
         readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "version";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
 }];
 type abi = typeof abi;
-export declare class IETHZapperContract extends BaseContract<abi> implements ZapperData {
-    readonly pool: ZapperData["pool"];
-    readonly type: ZapperData["type"];
-    readonly baseParams: ZapperData["baseParams"];
-    readonly tokenIn: ZapperData["tokenIn"];
-    readonly tokenOut: ZapperData["tokenOut"];
+export declare class IETHZapperContract extends ZapperContract<abi> {
     constructor(sdk: OnchainSDK, data: ZapperData);
     /**
      * Deposits native ETH into the pool via this zapper.
@@ -173,14 +236,5 @@ export declare class IETHZapperContract extends BaseContract<abi> implements Zap
      * The caller must attach the deposit amount as msg.value.
      */
     depositWithReferral(receiver: Address, referralCode: bigint): RawTx;
-    /**
-     * Redeems pool shares (diesel tokens) for the underlying asset via this zapper.
-     */
-    redeem(tokenInAmount: bigint, receiver: Address): RawTx;
-    /**
-     * Redeems pool shares via this zapper with an EIP-2612 permit signature,
-     * skipping a separate approve transaction.
-     */
-    redeemWithPermit(tokenInAmount: bigint, receiver: Address, deadline: bigint, v: number, r: Address, s: Address): RawTx;
 }
 export {};

package/dist/types/sdk/market/zapper/ZapperContract.d.ts

@@ -0,0 +1,35 @@
+import type { Abi, Address, Hex } from "viem";
+import { BaseContract } from "../../base/index.js";
+import type { OnchainSDK } from "../../OnchainSDK.js";
+import type { RawTx } from "../../types/index.js";
+import type { ZapperData } from "../types.js";
+import type { IZapperContract, ParsedZapperOperation } from "./types.js";
+/**
+ * Base contract for every Gearbox zapper. Specialized zappers (e.g.
+ * {@link IERC20ZapperContract}, {@link IETHZapperContract}) extend this and add
+ * their type-specific deposit helpers; unknown zapper types are represented by
+ * this class directly, decoding against the common {@link iZapperAbi}.
+ */
+export declare class ZapperContract<A extends Abi = Abi> extends BaseContract<A> implements IZapperContract {
+    readonly sdk: OnchainSDK;
+    readonly pool: ZapperData["pool"];
+    readonly type: ZapperData["type"];
+    readonly baseParams: ZapperData["baseParams"];
+    readonly tokenIn: ZapperData["tokenIn"];
+    readonly tokenOut: ZapperData["tokenOut"];
+    constructor(sdk: OnchainSDK, data: ZapperData, abi?: A, namePrefix?: string);
+    /**
+     * Decodes zapper calldata into {@link ParsedZapperOperation}.
+     * Throws {@link UnsupportedZapperFunctionError} for unknown selectors.
+     */
+    parseOperation(calldata: Hex, value?: bigint): ParsedZapperOperation;
+    /**
+     * Redeems pool shares (diesel tokens) for the underlying asset via this zapper.
+     */
+    redeem(tokenInAmount: bigint, receiver: Address): RawTx;
+    /**
+     * Redeems pool shares via this zapper with an EIP-2612 permit signature,
+     * skipping a separate approve transaction.
+     */
+    redeemWithPermit(tokenInAmount: bigint, receiver: Address, deadline: bigint, v: number, r: Hex, s: Hex): RawTx;
+}

package/dist/types/sdk/market/zapper/createZapper.d.ts

@@ -1,6 +1,4 @@
 import type { OnchainSDK } from "../../OnchainSDK.js";
 import type { ZapperData } from "../types.js";
-import { IERC20ZapperContract } from "./IERC20ZapperContract.js";
-import { IETHZapperContract } from "./IETHZapperContract.js";
-import { Zapper } from "./Zapper.js";
-export declare function createZapper(sdk: OnchainSDK, data: ZapperData): Zapper | IETHZapperContract | IERC20ZapperContract;
+import type { IZapperContract } from "./types.js";
+export declare function createZapper(sdk: OnchainSDK, data: ZapperData): IZapperContract;

package/dist/types/sdk/market/zapper/errors.d.ts

@@ -0,0 +1,10 @@
+import type { Address } from "viem";
+/**
+ * Thrown when a zapper call uses a function other than a known
+ * `deposit`/`redeem` variant.
+ */
+export declare class UnsupportedZapperFunctionError extends Error {
+    readonly zapper: Address;
+    readonly functionName: string;
+    constructor(zapper: Address, functionName: string);
+}

package/dist/types/sdk/market/zapper/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./createZapper.js";
+export * from "./errors.js";
 export * from "./IERC20ZapperContract.js";
 export * from "./IETHZapperContract.js";
-export * from "./Zapper.js";
+export * from "./types.js";
+export * from "./ZapperContract.js";

package/dist/types/sdk/market/zapper/types.d.ts

@@ -0,0 +1,64 @@
+import type { Address, Hex } from "viem";
+import type { IBaseContract } from "../../base/index.js";
+import type { RawTx } from "../../types/index.js";
+import type { ZapperData } from "../types.js";
+/**
+ * Deposit decoded from a zapper call
+ */
+export interface ParsedZapperDeposit {
+    operation: "Deposit";
+    /** Destination pool the zapper deposits into. */
+    pool: Address;
+    /** Zapper contract the call is sent to. */
+    zapper: Address;
+    receiver: Address;
+    /** Amount of `token` supplied to the zapper. */
+    assets: bigint;
+    /** Token actually deposited into the zapper (the zapper's `tokenIn`). */
+    token: Address;
+    /** Underlying token of the destination pool. */
+    underlying: Address;
+    /** Referral code, present only for `depositWithReferral(...)` calls. */
+    referralCode?: bigint;
+}
+/**
+ * Redeem decoded from a zapper call. The zapper burns pool shares and returns
+ * `token` to the receiver.
+ */
+export interface ParsedZapperRedeem {
+    operation: "Redeem";
+    /** Source pool the zapper redeems from. */
+    pool: Address;
+    /** Zapper contract the call is sent to. */
+    zapper: Address;
+    receiver: Address;
+    /** Pool shares (diesel) burned. */
+    shares: bigint;
+    /** Token returned to the receiver (the zapper's `tokenIn`). */
+    token: Address;
+    /** Underlying token of the source pool. */
+    underlying: Address;
+}
+export type ParsedZapperOperation = ParsedZapperDeposit | ParsedZapperRedeem;
+/**
+ * Public interface for any Gearbox zapper contract wrapper.
+ *
+ * Based on contracts/interfaces/zappers/IZapper.sol in intergrations-v3 repo
+ */
+export interface IZapperContract extends IBaseContract, ZapperData {
+    /**
+     * Decodes zapper calldata into a {@link ParsedZapperOperation}.
+     * @param calldata - Raw ABI-encoded calldata sent to the zapper.
+     * @param value - Transaction `msg.value`, used for native-token deposits.
+     */
+    parseOperation(calldata: Hex, value?: bigint): ParsedZapperOperation;
+    /**
+     * Redeems pool shares (diesel tokens) for the underlying asset via this zapper.
+     */
+    redeem(tokenInAmount: bigint, receiver: Address): RawTx;
+    /**
+     * Redeems pool shares via this zapper with an EIP-2612 permit signature,
+     * skipping a separate approve transaction.
+     */
+    redeemWithPermit(tokenInAmount: bigint, receiver: Address, deadline: bigint, v: number, r: Hex, s: Hex): RawTx;
+}

package/dist/types/sdk/options.d.ts

@@ -4,7 +4,7 @@ import type { ILogger } from "./types/index.js";
 /**
  * Zod schema for validating {@link OnchainSDKOptions} at runtime.
  **/
-export declare const OnchainSDKOptionsSchema: z.ZodObject<{
+export declare const onchainSDKOptionsSchema: z.ZodObject<{
     strictContractTypes: z.ZodOptional<z.ZodBoolean>;
     plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     logger: z.ZodAny;
@@ -13,7 +13,7 @@ export declare const OnchainSDKOptionsSchema: z.ZodObject<{
 /**
  * Zod schema for validating {@link AttachOptions} at runtime.
  **/
-export declare const AttachOptionsSchema: z.ZodObject<{
+export declare const attachOptionsSchema: z.ZodObject<{
     addressProvider: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>;
     marketConfigurators: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>>;
     rwaFactories: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>>>;
@@ -33,15 +33,20 @@ export declare const AttachOptionsSchema: z.ZodObject<{
         cacheTTL: z.ZodOptional<z.ZodNumber>;
         failOnMissingFeeds: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    loadZappers: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 /**
  * SDK constructor options type.
  *
  * @typeParam Plugins - Map of plugin names to plugin instances.
  **/
-export type SDKOptions<Plugins extends PluginsMap> = Omit<z.infer<typeof OnchainSDKOptionsSchema>, "logger" | "plugins"> & {
-    /** Plugins that extend SDK functionality. */
+export type SDKOptions<Plugins extends PluginsMap> = Omit<z.infer<typeof onchainSDKOptionsSchema>, "logger" | "plugins"> & {
+    /**
+     * Plugins that extend SDK functionality.
+     **/
     plugins?: Plugins;
-    /** Custom logger implementation. */
+    /**
+     * Custom logger implementation.
+     **/
     logger?: ILogger;
 };

package/dist/types/sdk/pools/types.d.ts

@@ -1,5 +1,5 @@
 import type { Abi, Address, ContractFunctionArgs, ContractFunctionName } from "viem";
-import type { Zapper } from "../market/index.js";
+import type { IZapperContract } from "../market/index.js";
 import type { Asset } from "../router/index.js";
 import type { MultiCall, RawTx } from "../types/transactions.js";
 interface PermitResult {
@@ -62,7 +62,7 @@ export interface DepositMetadata {
     /**
      * Zapper that will perform the deposit, undefined in case of direct pool underlying deposit
      */
-    zapper?: Zapper;
+    zapper?: IZapperContract;
     /**
      * Before deposit user will nedd to call approve method on token that he wants to deposit,
      * this is the spender address that will be used to call approve method.
@@ -82,7 +82,7 @@ export interface WithdrawalMetadata {
     /**
      * Zapper that will perform the withdrawal, undefined in case of direct pool underlying withdrawal
      */
-    zapper?: Zapper;
+    zapper?: IZapperContract;
     /**
      * Before withdrawal user will need to call approve method on token that he wants to withdraw (diesel token),
      * this is the spender address that will be used to call approve method.

package/dist/types/sdk/types/state-human.d.ts

@@ -193,6 +193,14 @@ export interface MarketStateHuman {
     unpausableAdmins: string[];
     emergencyLiquidators: string[];
 }
+export interface ZapperStateHuman {
+    address: string;
+    contractType: string;
+    type: "migration" | "rwa" | "base";
+    pool: string;
+    tokenIn: string;
+    tokenOut: string;
+}
 export interface GearboxStateHuman {
     network: string;
     block: number;
@@ -202,6 +210,7 @@ export interface GearboxStateHuman {
     plugins: Record<string, unknown>;
     tokens: TokenMetaData[];
     rwa: RWAStateHuman;
+    zappers?: ZapperStateHuman[];
 }
 /**
  * Human-readable state for all chains managed by {@link MultichainSDK}.

package/dist/types/sdk/types/state.d.ts

@@ -1,6 +1,7 @@
 import type { MarketData } from "../base/index.js";
 import type { NetworkType } from "../chain/chains.js";
 import type { AddressProviderState } from "../core/index.js";
+import type { ZapperData } from "../market/index.js";
 import type { RWAState } from "../market/rwa/index.js";
 import type { PluginStatesMap, PluginsMap } from "../plugins/index.js";
 /**
@@ -45,6 +46,12 @@ export interface GearboxState<Plugins extends PluginsMap = {}> {
      * RWA compressor state snapshot, if RWA factories were loaded.
      **/
     rwa?: RWAState;
+    /**
+     * All loaded zappers, keyed implicitly by their `pool` field.
+     *
+     * Present only when zappers were loaded (they are optional)
+     **/
+    zappers?: ZapperData[];
     /**
      * Per-plugin serialised state.
      **/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "14.11.3",
+  "version": "14.12.0-next.2",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {
@@ -44,6 +44,11 @@
       "import": "./dist/esm/permissionless/index.js",
       "default": "./dist/cjs/permissionless/index.js"
     },
+    "./preview": {
+      "types": "./dist/types/preview/index.d.ts",
+      "import": "./dist/esm/preview/index.js",
+      "default": "./dist/cjs/preview/index.js"
+    },
     "./common-utils": {
       "types": "./dist/types/common-utils/index.d.ts",
       "import": "./dist/esm/common-utils/index.js",
@@ -62,13 +67,13 @@
     "clean": "rm -rf dist",
     "build": "tsup",
     "dev": "tsup --watch",
-    "example": "tsx --env-file .env scripts/example.ts | pino-pretty",
+    "example": "tsx scripts/example.ts | pino-pretty",
     "test:watch": "vitest --project unit",
     "test:unit": "vitest run --project unit",
     "test:e2e": "vitest run --project e2e",
     "test:all": "vitest run",
     "test": "vitest run",
-    "generate:e2e": "NODE_OPTIONS='--max-old-space-size=8192' tsx --env-file .env scripts/generate-e2e-fixtures.ts",
+    "generate:e2e": "NODE_OPTIONS='--max-old-space-size=8192' tsx scripts/generate-e2e-fixtures.ts",
     "prepare": "husky",
     "check": "biome check --write",
     "check:ci": "biome check --diagnostic-level=error",

package/dist/cjs/history/extractProtocolCalls.js

@@ -1,53 +0,0 @@
-"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 extractProtocolCalls_exports = {};
-__export(extractProtocolCalls_exports, {
-  extractProtocolCalls: () => extractProtocolCalls
-});
-module.exports = __toCommonJS(extractProtocolCalls_exports);
-var import_errors = require("./errors.js");
-var import_trace_utils = require("./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 = (0, import_trace_utils.findCallTo)(subtraces[subtraceIdx], targetContract);
-      subtraceIdx++;
-    }
-    if (!found) {
-      throw new import_errors.ProtocolCallNotFoundError(targetContract, i);
-    }
-    result.push(found.input);
-  }
-  if (result.length !== executeResults.length) {
-    throw new import_errors.AdapterTraceAlignmentError(executeResults.length, result.length);
-  }
-  return result;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  extractProtocolCalls
-});

package/dist/esm/history/extractProtocolCalls.js

@@ -1,32 +0,0 @@
-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/trace-utils.js

@@ -1,36 +0,0 @@
-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/sdk/market/zapper/Zapper.js

@@ -1,23 +0,0 @@
-import { bytes32ToString } from "../../utils/index.js";
-class Zapper {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
-  contractType;
-  constructor(data) {
-    this.pool = data.pool;
-    this.type = data.type;
-    this.baseParams = data.baseParams;
-    this.tokenIn = data.tokenIn;
-    this.tokenOut = data.tokenOut;
-    this.contractType = Zapper.contractType(data.baseParams);
-  }
-  static contractType(baseParams) {
-    return bytes32ToString(baseParams.contractType);
-  }
-}
-export {
-  Zapper
-};