@gearbox-protocol/sdk 13.1.1 → 13.2.0

package/dist/cjs/dev/index.js

@@ -3,6 +3,10 @@ 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))
@@ -14,6 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var dev_exports = {};
+__export(dev_exports, {
+  GetLogsTransportOptions: () => import_logSplitterTransport.LogSplitterTransportOptions,
+  isRangeError: () => import_logSplitterTransport.isRangeError,
+  logSplitterTransport: () => import_logSplitterTransport.logSplitterTransport
+});
 module.exports = __toCommonJS(dev_exports);
 __reExport(dev_exports, require("./AccountOpener.js"), module.exports);
 __reExport(dev_exports, require("./CachedStateSubscriber.js"), module.exports);
@@ -26,6 +35,7 @@ __reExport(dev_exports, require("./EthCallSpy.js"), module.exports);
 __reExport(dev_exports, require("./isOutOfSyncError.js"), module.exports);
 __reExport(dev_exports, require("./isRateLimitError.js"), module.exports);
 __reExport(dev_exports, require("./isTransientError.js"), module.exports);
+var import_logSplitterTransport = require("./logSplitterTransport.js");
 __reExport(dev_exports, require("./ltUtils.js"), module.exports);
 __reExport(dev_exports, require("./migrateFaucet.js"), module.exports);
 __reExport(dev_exports, require("./mint/index.js"), module.exports);
@@ -37,6 +47,9 @@ __reExport(dev_exports, require("./transports.js"), module.exports);
 __reExport(dev_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  GetLogsTransportOptions,
+  isRangeError,
+  logSplitterTransport,
   ...require("./AccountOpener.js"),
   ...require("./CachedStateSubscriber.js"),
   ...require("./calcLiquidatableLTs.js"),

package/dist/cjs/dev/isTransientError.js

@@ -57,7 +57,11 @@ const TRANSIENT_PATTERNS = [
   // EIP-1474 ResourceUnavailableRpcError (code -32002): node is syncing or the
   // requested resource is temporarily unavailable.
   // Matches both the RPC message and viem's shortMessage "Requested resource not available."
-  /resource unavailable|requested resource not available/i
+  /resource unavailable|requested resource not available/i,
+  // sometimes happens on DRPC: "GRPC Context cancellation"
+  /context cancel/i,
+  // DRPC error: Can't route your request to suitable provider, if you specified certain providers revise the list
+  /suitable provider/i
 ];
 function isTransientError(e) {
   if (e instanceof import_viem.BaseError) {

package/dist/cjs/dev/logSplitterTransport.js

@@ -0,0 +1,154 @@
+"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 logSplitterTransport_exports = {};
+__export(logSplitterTransport_exports, {
+  fetchLogsWithPagination: () => fetchLogsWithPagination,
+  isFixedBlockRange: () => isFixedBlockRange,
+  isRangeError: () => isRangeError,
+  logSplitterTransport: () => logSplitterTransport,
+  parsePageSizeHint: () => parsePageSizeHint
+});
+module.exports = __toCommonJS(logSplitterTransport_exports);
+var import_viem = require("viem");
+function isFixedBlockRange(filter) {
+  if (filter.blockHash != null) return false;
+  return isHexBlockNumber(filter.fromBlock) && isHexBlockNumber(filter.toBlock);
+}
+function isHexBlockNumber(value) {
+  return typeof value === "string" && value.startsWith("0x");
+}
+const RANGE_ERROR_PATTERNS = [
+  /block range/i,
+  /too many results/i,
+  /response size/i,
+  /result window/i,
+  /exceeds allowed/i,
+  /cannot request logs over more than/i,
+  /eth_getLogs is limited to/i,
+  /eth_getLogs requests with up to/i,
+  /range is too large/i,
+  /exceeded max allowed range/i
+];
+function isRangeError(error) {
+  const msg = errorMessage(error);
+  return RANGE_ERROR_PATTERNS.some((re) => re.test(msg));
+}
+const GENERIC_BLOCKS_RE = /(\d+)\s*block/i;
+const ALCHEMY_RANGE_RE = /this block range should work: \[(0x[0-9a-fA-F]+),\s*(0x[0-9a-fA-F]+)\]/;
+function parsePageSizeHint(error) {
+  const alchemy = tryAlchemyHint(error);
+  if (alchemy != null) return alchemy;
+  const msg = errorMessage(error);
+  const m = msg.match(GENERIC_BLOCKS_RE);
+  return m ? Number(m[1]) : null;
+}
+function tryAlchemyHint(error) {
+  if (!(error instanceof import_viem.HttpRequestError)) return void 0;
+  try {
+    const parsed = JSON.parse(error.details);
+    if (typeof parsed.message !== "string") return void 0;
+    const match = parsed.message.match(ALCHEMY_RANGE_RE);
+    if (!match) return void 0;
+    const from = (0, import_viem.hexToNumber)(match[1]);
+    const to = (0, import_viem.hexToNumber)(match[2]);
+    return to - from + 1;
+  } catch {
+    return void 0;
+  }
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    const details = error.details;
+    return details ? `${error.message} ${details}` : error.message;
+  }
+  return String(error);
+}
+async function fetchLogsWithPagination(callRpc, from, to, options) {
+  if (from > to) {
+    throw new import_viem.InvalidParamsRpcError(
+      new Error(`Invalid parameters: from (${from}) > to (${to})`)
+    );
+  }
+  const { softLimit, hardLimit } = options ?? {};
+  let pageSize = hardLimit ?? to - from + 1;
+  const results = [];
+  let cursor = from;
+  while (cursor <= to) {
+    const chunkEnd = Math.min(to, cursor + pageSize - 1);
+    try {
+      const logs = await callRpc(cursor, chunkEnd);
+      results.push(...logs);
+      cursor = chunkEnd + 1;
+    } catch (error) {
+      if (!isRangeError(error)) {
+        throw error;
+      }
+      if (cursor === chunkEnd) {
+        throw error;
+      }
+      const hint = parsePageSizeHint(error);
+      if (hint) {
+        pageSize = hint;
+      } else {
+        const half = Math.max(1, Math.floor((chunkEnd - cursor + 1) / 2));
+        pageSize = softLimit ? Math.min(softLimit, half) : half;
+      }
+    }
+  }
+  return results;
+}
+function logSplitterTransport(transport, logOptions) {
+  return (opts) => {
+    const base = transport(opts);
+    const rpcRequest = base.request;
+    const request = (async (args) => {
+      const { method, params } = args;
+      if (method !== "eth_getLogs") {
+        return rpcRequest(args);
+      }
+      const filter = params?.[0] ?? {};
+      if (!isFixedBlockRange(filter)) {
+        return rpcRequest(args);
+      }
+      const from = (0, import_viem.hexToNumber)(filter.fromBlock);
+      const to = (0, import_viem.hexToNumber)(filter.toBlock);
+      const callRpc = async (f, t) => {
+        const paginatedFilter = {
+          ...filter,
+          fromBlock: (0, import_viem.numberToHex)(f),
+          toBlock: (0, import_viem.numberToHex)(t)
+        };
+        return rpcRequest({
+          method: "eth_getLogs",
+          params: [paginatedFilter]
+        });
+      };
+      return fetchLogsWithPagination(callRpc, from, to, logOptions);
+    });
+    return { ...base, request };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchLogsWithPagination,
+  isFixedBlockRange,
+  isRangeError,
+  logSplitterTransport,
+  parsePageSizeHint
+});

package/dist/esm/dev/index.js

@@ -9,6 +9,11 @@ export * from "./EthCallSpy.js";
 export * from "./isOutOfSyncError.js";
 export * from "./isRateLimitError.js";
 export * from "./isTransientError.js";
+import {
+  isRangeError,
+  LogSplitterTransportOptions,
+  logSplitterTransport
+} from "./logSplitterTransport.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";
 export * from "./mint/index.js";
@@ -18,3 +23,8 @@ export * from "./replaceStorage.js";
 export * from "./resilientTransport.js";
 export * from "./transports.js";
 export * from "./types.js";
+export {
+  LogSplitterTransportOptions as GetLogsTransportOptions,
+  isRangeError,
+  logSplitterTransport
+};

package/dist/esm/dev/isTransientError.js

@@ -34,7 +34,11 @@ const TRANSIENT_PATTERNS = [
   // EIP-1474 ResourceUnavailableRpcError (code -32002): node is syncing or the
   // requested resource is temporarily unavailable.
   // Matches both the RPC message and viem's shortMessage "Requested resource not available."
-  /resource unavailable|requested resource not available/i
+  /resource unavailable|requested resource not available/i,
+  // sometimes happens on DRPC: "GRPC Context cancellation"
+  /context cancel/i,
+  // DRPC error: Can't route your request to suitable provider, if you specified certain providers revise the list
+  /suitable provider/i
 ];
 function isTransientError(e) {
   if (e instanceof BaseError) {

package/dist/esm/dev/logSplitterTransport.js

@@ -0,0 +1,131 @@
+import {
+  HttpRequestError,
+  hexToNumber,
+  InvalidParamsRpcError,
+  numberToHex
+} from "viem";
+function isFixedBlockRange(filter) {
+  if (filter.blockHash != null) return false;
+  return isHexBlockNumber(filter.fromBlock) && isHexBlockNumber(filter.toBlock);
+}
+function isHexBlockNumber(value) {
+  return typeof value === "string" && value.startsWith("0x");
+}
+const RANGE_ERROR_PATTERNS = [
+  /block range/i,
+  /too many results/i,
+  /response size/i,
+  /result window/i,
+  /exceeds allowed/i,
+  /cannot request logs over more than/i,
+  /eth_getLogs is limited to/i,
+  /eth_getLogs requests with up to/i,
+  /range is too large/i,
+  /exceeded max allowed range/i
+];
+function isRangeError(error) {
+  const msg = errorMessage(error);
+  return RANGE_ERROR_PATTERNS.some((re) => re.test(msg));
+}
+const GENERIC_BLOCKS_RE = /(\d+)\s*block/i;
+const ALCHEMY_RANGE_RE = /this block range should work: \[(0x[0-9a-fA-F]+),\s*(0x[0-9a-fA-F]+)\]/;
+function parsePageSizeHint(error) {
+  const alchemy = tryAlchemyHint(error);
+  if (alchemy != null) return alchemy;
+  const msg = errorMessage(error);
+  const m = msg.match(GENERIC_BLOCKS_RE);
+  return m ? Number(m[1]) : null;
+}
+function tryAlchemyHint(error) {
+  if (!(error instanceof HttpRequestError)) return void 0;
+  try {
+    const parsed = JSON.parse(error.details);
+    if (typeof parsed.message !== "string") return void 0;
+    const match = parsed.message.match(ALCHEMY_RANGE_RE);
+    if (!match) return void 0;
+    const from = hexToNumber(match[1]);
+    const to = hexToNumber(match[2]);
+    return to - from + 1;
+  } catch {
+    return void 0;
+  }
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    const details = error.details;
+    return details ? `${error.message} ${details}` : error.message;
+  }
+  return String(error);
+}
+async function fetchLogsWithPagination(callRpc, from, to, options) {
+  if (from > to) {
+    throw new InvalidParamsRpcError(
+      new Error(`Invalid parameters: from (${from}) > to (${to})`)
+    );
+  }
+  const { softLimit, hardLimit } = options ?? {};
+  let pageSize = hardLimit ?? to - from + 1;
+  const results = [];
+  let cursor = from;
+  while (cursor <= to) {
+    const chunkEnd = Math.min(to, cursor + pageSize - 1);
+    try {
+      const logs = await callRpc(cursor, chunkEnd);
+      results.push(...logs);
+      cursor = chunkEnd + 1;
+    } catch (error) {
+      if (!isRangeError(error)) {
+        throw error;
+      }
+      if (cursor === chunkEnd) {
+        throw error;
+      }
+      const hint = parsePageSizeHint(error);
+      if (hint) {
+        pageSize = hint;
+      } else {
+        const half = Math.max(1, Math.floor((chunkEnd - cursor + 1) / 2));
+        pageSize = softLimit ? Math.min(softLimit, half) : half;
+      }
+    }
+  }
+  return results;
+}
+function logSplitterTransport(transport, logOptions) {
+  return (opts) => {
+    const base = transport(opts);
+    const rpcRequest = base.request;
+    const request = (async (args) => {
+      const { method, params } = args;
+      if (method !== "eth_getLogs") {
+        return rpcRequest(args);
+      }
+      const filter = params?.[0] ?? {};
+      if (!isFixedBlockRange(filter)) {
+        return rpcRequest(args);
+      }
+      const from = hexToNumber(filter.fromBlock);
+      const to = hexToNumber(filter.toBlock);
+      const callRpc = async (f, t) => {
+        const paginatedFilter = {
+          ...filter,
+          fromBlock: numberToHex(f),
+          toBlock: numberToHex(t)
+        };
+        return rpcRequest({
+          method: "eth_getLogs",
+          params: [paginatedFilter]
+        });
+      };
+      return fetchLogsWithPagination(callRpc, from, to, logOptions);
+    });
+    return { ...base, request };
+  };
+}
+export {
+  fetchLogsWithPagination,
+  isFixedBlockRange,
+  isRangeError,
+  logSplitterTransport,
+  parsePageSizeHint
+};

package/dist/types/dev/index.d.ts

@@ -9,6 +9,7 @@ export * from "./EthCallSpy.js";
 export * from "./isOutOfSyncError.js";
 export * from "./isRateLimitError.js";
 export * from "./isTransientError.js";
+export { isRangeError, LogSplitterTransportOptions as GetLogsTransportOptions, logSplitterTransport, } from "./logSplitterTransport.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";
 export * from "./mint/index.js";

package/dist/types/dev/logSplitterTransport.d.ts

@@ -0,0 +1,118 @@
+import { type PublicRpcSchema, type Transport } from "viem";
+/** Schema entry for `eth_getLogs` extracted from viem's {@link PublicRpcSchema}. */
+type EthGetLogsSchema = Extract<PublicRpcSchema[number], {
+    Method: "eth_getLogs";
+}>;
+/**
+ * Filter parameter for `eth_getLogs` as defined by viem's {@link PublicRpcSchema}.
+ * A discriminated union of block-range filters and block-hash filters.
+ */
+export type EthGetLogsFilter = EthGetLogsSchema["Parameters"][0];
+/** Raw RPC return type for `eth_getLogs` (logs with hex-encoded quantities). */
+export type EthGetLogsResult = EthGetLogsSchema["ReturnType"];
+/**
+ * Options controlling pagination behaviour of {@link logSplitterTransport}.
+ */
+export interface LogSplitterTransportOptions {
+    /**
+     * Acts as a min page size hint when there's no explit hint in rpc error message.
+     * Has no effect once the page size is already below `softLimit`.
+     */
+    softLimit?: number;
+    /**
+     * Initial page size. The block range is walked in `hardLimit`-sized pages
+     * from the start without attempting the full range first.
+     */
+    hardLimit?: number;
+}
+/**
+ * @internal
+ * Returns `true` when both `fromBlock` and `toBlock` are concrete hex-encoded
+ * block numbers and `blockHash` is absent. Only fixed numeric ranges can be
+ * split into sub-ranges for pagination.
+ *
+ * At the RPC transport level, block numbers are always `0x`-prefixed hex
+ * strings, while named tags (`"latest"`, `"safe"`, etc.) are plain words.
+ * The `0x` prefix check is sufficient to distinguish the two.
+ *
+ * @param filter - The `eth_getLogs` filter object.
+ * @returns Whether the filter describes a fixed, splittable block range.
+ */
+export declare function isFixedBlockRange(filter: EthGetLogsFilter): boolean;
+/**
+ * Returns `true` when the error message matches known RPC range/size limit
+ * patterns. Transient errors (timeouts, rate limits, 5xx) are explicitly
+ * excluded — they should be retried by the underlying transport.
+ *
+ * @param error - Any thrown value.
+ * @returns Whether the error indicates a block-range or result-size limit.
+ */
+export declare function isRangeError(error: unknown): boolean;
+/**
+ * @internal
+ * Attempts to extract a concrete page-size hint from an error thrown by an
+ * RPC provider. Two strategies are tried:
+ *
+ * 1. **Alchemy JSON details** — parses the `details` field of a
+ *    {@link HttpRequestError} for a suggested `[fromHex, toHex]` range and
+ *    computes the span as `toHex - fromHex + 1`.
+ * 2. **Generic N-blocks pattern** — matches `/<number> block(s)/i` in the
+ *    error message.
+ *
+ * @param error - Any thrown value.
+ * @returns The suggested page size, or `null` if no hint could be extracted.
+ */
+export declare function parsePageSizeHint(error: unknown): number | null;
+/**
+ * @internal
+ * Callback that performs a single `eth_getLogs` RPC call for the given
+ * inclusive block range `[from, to]`.
+ */
+export type CallRpcFn = (from: number, to: number) => Promise<EthGetLogsResult>;
+/**
+ * @internal
+ * Fetches logs over `[from, to]` using a sequential linear walk with
+ * dynamically adjustable page size. On range errors the page is bisected
+ * (optionally capped by {@link LogSplitterTransportOptions.softLimit | softLimit}).
+ * Reduced page sizes persist for all subsequent pages in the same call.
+ *
+ * @param callRpc - Callback that performs a single `eth_getLogs` RPC call.
+ * @param from    - Inclusive start block number.
+ * @param to      - Inclusive end block number.
+ * @param options - Optional pagination limits.
+ * @returns All logs in the requested range, concatenated in order.
+ *
+ * @throws {@link InvalidParamsRpcError} when `from > to`.
+ * @throws The original error when a single-block request fails or the error
+ *         is not a recognised range error.
+ */
+export declare function fetchLogsWithPagination(callRpc: CallRpcFn, from: number, to: number, options?: LogSplitterTransportOptions): Promise<EthGetLogsResult>;
+/**
+ * Wraps a viem {@link Transport} to transparently split `eth_getLogs` requests
+ * that exceed RPC provider block-range or result-size limits.
+ *
+ * Only requests with concrete numeric `fromBlock`/`toBlock` values (hex or
+ * bigint) are intercepted. Calls using block tags (`"latest"`, `"earliest"`,
+ * etc.) or `blockHash` are passed through unmodified.
+ *
+ * @param transport - The underlying viem transport to wrap.
+ * @param options   - Optional pagination configuration.
+ * @returns A new transport that performs automatic log pagination.
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, http } from "viem";
+ * import { mainnet } from "viem/chains";
+ * import { logSplitterTransport } from "./logSplitterTransport.js";
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: logSplitterTransport(http("https://rpc.example.com"), {
+ *     hardLimit: 10_000,
+ *     softLimit: 2_000,
+ *   }),
+ * });
+ * ```
+ */
+export declare function logSplitterTransport(transport: Transport, logOptions?: LogSplitterTransportOptions): Transport;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "13.1.1",
+  "version": "13.2.0",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",
@@ -83,10 +83,10 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.9",
+    "@biomejs/biome": "^2.4.10",
     "@commitlint/cli": "^20.5.0",
     "@commitlint/config-conventional": "^20.5.0",
-    "@gearbox-protocol/biome-config": "^1.0.24",
+    "@gearbox-protocol/biome-config": "^1.0.25",
     "@types/cross-spawn": "^6.0.6",
     "axios": "^1.14.0",
     "cross-spawn": "^7.0.6",