@polygonlabs/servercore 1.5.1-dev.0 → 1.5.1

package/dist/index.js

@@ -1,9 +1,952 @@
-export * from "./api";
-export * from "./logger";
-export * from "./constants";
-export * from "./types";
-export * from "./errors";
-export * from "./storage";
-export * from "./consumers";
-export * from "./utils";
+// src/constants/error_codes.ts
+var errorCodes = {
+  // Base error identifier
+  base: { BASE_ERROR: 100 },
+  // Consumer related error codes
+  consumer: {
+    UNKNOWN_CONSUMER_ERR: 1e3
+  },
+  // Datastore related error codes
+  datastore: {
+    UNKNOWN_DATASTORE_ERR: 2e3,
+    DATASTORE_AUTH_ERR: 2001,
+    DATASTORE_READ_ERROR: 2002,
+    DATASTORE_WRITE_ERROR: 2003
+  },
+  // External dependencies errors codes
+  external: {
+    UNKNOWN_EXTERNAL_DEPENDENCY_ERROR: 3e3
+  },
+  // API related error codes
+  api: {
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    TOO_MANY_REQUESTS: 429,
+    INTERNAL_SERVER_ERROR: 500,
+    GATEWAY_ERROR: 502,
+    TIMEOUT_ERROR: 504
+  }
+};
+
+// src/constants/http_success_codes.ts
+var httpResponseCodes = {
+  OK_RESPONSE: 200
+};
+
+// src/errors/base_error.ts
+var BaseError = class extends Error {
+  name;
+  code;
+  isFatal;
+  origin;
+  context;
+  /**
+   * @param name {string} - The error name
+   * @param code {number} - The error code
+   * @param isFatal {boolean} - Flag to know if it is a fatal error
+   * @param message {string} - The actual error message
+   * @param origin {string} - The point this error originated
+   * @param context Record<string, any> - The stack trace
+   */
+  constructor(name, code, message = "Unknown error", isFatal, origin, context) {
+    super(message);
+    this.name = name;
+    this.code = code;
+    this.isFatal = isFatal ?? true;
+    this.origin = origin ?? "base_error";
+    this.context = context ?? {};
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  identifier = errorCodes.base.BASE_ERROR;
+};
+
+// src/errors/api_errors.ts
+var ApiError = class extends BaseError {
+  constructor(message, {
+    name = "INTERNAL_SERVER_ERROR",
+    code = errorCodes.api.INTERNAL_SERVER_ERROR,
+    isFatal = false,
+    origin = "api_errors",
+    context = {}
+  } = {}) {
+    super(name, code, message, isFatal, origin, context);
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var UnauthorizedError = class extends ApiError {
+  constructor(message = "Invalid auth credentials", context = {}, origin = "api_errors") {
+    super(message, {
+      name: "UNAUTHORIZED",
+      code: errorCodes.api.UNAUTHORIZED,
+      isFatal: false,
+      origin,
+      context
+    });
+  }
+};
+var ForbiddenError = class extends ApiError {
+  constructor(message = "You do not have permission to perform this action", context = {}, origin = "api_errors") {
+    super(message, {
+      name: "FORBIDDEN",
+      code: errorCodes.api.FORBIDDEN,
+      isFatal: false,
+      origin,
+      context
+    });
+  }
+};
+var BadRequestError = class extends ApiError {
+  validationErrors;
+  constructor(message = "Malformed or invalid request", validationErrors = {}, context = {}, origin = "api_errors") {
+    super(message, {
+      name: "BAD_REQUEST",
+      code: errorCodes.api.BAD_REQUEST,
+      isFatal: false,
+      origin,
+      context
+    });
+    this.validationErrors = validationErrors;
+  }
+};
+var NotFoundError = class extends ApiError {
+  constructor(message, entity = "Path", identifier, context = {}, origin = "api_errors") {
+    if (!message) {
+      message = identifier ? `${entity} with identifier ${identifier} not found` : `${entity} not found`;
+    }
+    super(message, {
+      name: "NOT_FOUND",
+      code: errorCodes.api.NOT_FOUND,
+      isFatal: false,
+      origin,
+      context: { entity, identifier, ...context }
+    });
+  }
+};
+var RateLimitError = class extends ApiError {
+  constructor(message = "Rate limit exceeded", context = {}, origin = "api_errors") {
+    super(message, {
+      name: "RATE_LIMIT",
+      code: errorCodes.api.TOO_MANY_REQUESTS,
+      isFatal: false,
+      origin,
+      context
+    });
+  }
+};
+var TimeoutError = class extends ApiError {
+  constructor(operation, timeoutMs, context = {}, origin = "api_errors") {
+    super(`Operation '${operation}' timed out after ${timeoutMs}ms`, {
+      name: "TIMEOUT",
+      code: errorCodes.api.TIMEOUT_ERROR,
+      // Gateway Timeout
+      isFatal: false,
+      origin,
+      context: { operation, timeoutMs, ...context }
+    });
+  }
+};
+
+// src/errors/database_errors.ts
+var DatabaseError = class extends BaseError {
+  constructor(message, originalError, {
+    name = "DATABASE_ERROR",
+    code = errorCodes.consumer.UNKNOWN_CONSUMER_ERR,
+    isFatal = true,
+    origin = "databse_errors",
+    context = {}
+  } = {}) {
+    super(name, code, message, isFatal, origin, context);
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+
+// src/errors/external_dependency_error.ts
+var ExternalDependencyError = class extends BaseError {
+  apiName;
+  externalCode;
+  rawError;
+  constructor(apiName, message, {
+    externalCode,
+    rawError,
+    context = {},
+    origin = "external_dependency_error"
+  } = {}) {
+    super(
+      "EXTERNAL_DEPENDENCY_ERROR",
+      errorCodes.external.UNKNOWN_EXTERNAL_DEPENDENCY_ERROR,
+      `${apiName} API error: ${message}`,
+      false,
+      origin,
+      { apiName, externalCode, ...context }
+    );
+    this.apiName = apiName;
+    this.externalCode = externalCode;
+    this.rawError = rawError;
+  }
+};
+
+// src/errors/consumer_errors.ts
+var ConsumerError = class extends BaseError {
+  constructor(message, {
+    name = "CONSUMER_ERROR",
+    code = errorCodes.consumer.UNKNOWN_CONSUMER_ERR,
+    isFatal = true,
+    origin = "consumer_errors",
+    context = {}
+  } = {}) {
+    super(name, code, message, isFatal, origin, context);
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+
+// src/api/response_handler.ts
+var handleResponse = (c, data, pagination) => {
+  return c.status(httpResponseCodes.OK_RESPONSE).json({
+    status: "success",
+    data,
+    pagination
+  });
+};
+var handleError = (c, error) => {
+  return c.status(error.code ?? errorCodes.api.INTERNAL_SERVER_ERROR).json({
+    status: "error",
+    message: error.message,
+    name: error.name,
+    code: error.code,
+    details: error.context
+  });
+};
+
+// src/api/zod_utils.ts
+import "zod";
+var validateBody = (schema, data) => {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Invalid body: ${JSON.stringify(result.error.format(), null, 2)}`
+    );
+  }
+  return result.data;
+};
+var validateQuery = (schema, query) => {
+  const result = schema.safeParse(query);
+  if (!result.success) {
+    throw new Error(
+      `Invalid query params: ${JSON.stringify(
+        result.error.format(),
+        null,
+        2
+      )}`
+    );
+  }
+  return result.data;
+};
+var validateParams = (schema, params) => {
+  const result = schema.safeParse(params);
+  if (!result.success) {
+    throw new Error(
+      `Invalid path params: ${JSON.stringify(
+        result.error.format(),
+        null,
+        2
+      )}`
+    );
+  }
+  return result.data;
+};
+
+// src/api/health-check.ts
+var HealthCheck = class {
+  constructor(urls) {
+    this.urls = urls;
+  }
+  async checkHealth() {
+    try {
+      const results = await Promise.all(
+        this.urls.map(async (url) => {
+          const response = await fetch(`${url}`);
+          if (!response.ok) {
+            throw new Error(`Health check failed for ${url}`);
+          }
+          return response;
+        })
+      );
+      if (results.every((res) => res.ok)) {
+        return "ok";
+      }
+      throw new Error("One or more URLs failed the health check.");
+    } catch (error) {
+      const failedUrlChecks = await Promise.all(
+        this.urls.map(async (url) => {
+          try {
+            const response = await fetch(`${url}`);
+            return { url, failed: !response.ok };
+          } catch {
+            return { url, failed: true };
+          }
+        })
+      );
+      const failedUrls = failedUrlChecks.filter((check) => check.failed).map((check) => check.url);
+      throw new ApiError(
+        `Health check failed for the following URLs: ${failedUrls.join(
+          ", "
+        )}. Original error: ${error.message}`
+      );
+    }
+  }
+};
+function createResponseContext(c) {
+  c.status = c.status || 200;
+  return {
+    status: (statusCode) => {
+      c.status = statusCode;
+      return createResponseContext(c);
+    },
+    json: (body) => {
+      return new Response(JSON.stringify(body), {
+        status: c.status,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+}
+function setupHealthCheckServer(urls, serverPort, func) {
+  const healthCheck = new HealthCheck(urls);
+  Bun.serve({
+    port: serverPort,
+    routes: {
+      "/health-check": {
+        GET: async (c) => {
+          try {
+            if (func) {
+              await func();
+            } else {
+              await healthCheck.checkHealth();
+            }
+            return handleResponse(createResponseContext(c), "ok");
+          } catch (error) {
+            return handleError(
+              createResponseContext(c),
+              error
+            );
+          }
+        }
+      }
+    }
+  });
+  console.log(
+    `Health check server running on http://localhost:${serverPort}/health-check`
+  );
+}
+
+// src/logger/logger.ts
+import winston from "winston";
+
+// src/logger/sentry_transport.ts
+import * as Sentry from "@sentry/node";
+import Transport from "winston-transport";
+import { LEVEL } from "triple-beam";
+var DEFAULT_LEVELS_MAP = {
+  silly: "debug" /* Debug */,
+  verbose: "debug" /* Debug */,
+  info: "info" /* Info */,
+  debug: "debug" /* Debug */,
+  warn: "warning" /* Warning */,
+  error: "error" /* Error */
+};
+var ExtendedError = class extends Error {
+  constructor(info) {
+    super(info.message);
+    this.name = info.name || "Error";
+    if (info.stack && typeof info.stack === "string") {
+      this.stack = info.stack;
+    }
+  }
+};
+var SentryTransport = class _SentryTransport extends Transport {
+  silent = false;
+  levelsMap = {};
+  constructor(opts) {
+    super(opts);
+    this.levelsMap = this.setLevelsMap(opts && opts.levelsMap);
+    this.silent = opts && opts.silent || false;
+    if (!opts || !opts.skipSentryInit) {
+      Sentry.init(_SentryTransport.withDefaults(opts && opts.sentry || {}));
+    }
+  }
+  log(info, callback) {
+    setImmediate(() => {
+      this.emit("logged", info);
+    });
+    if (this.silent) return callback();
+    const { message, tags, user, ...meta } = info;
+    const winstonLevel = info[LEVEL];
+    const sentryLevel = this.levelsMap[winstonLevel];
+    const scope = Sentry.getCurrentScope();
+    scope.clear();
+    if (tags !== void 0 && _SentryTransport.isObject(tags)) {
+      scope.setTags(tags);
+    }
+    scope.setExtras(meta);
+    if (user !== void 0 && _SentryTransport.isObject(user)) {
+      scope.setUser(user);
+    }
+    if (_SentryTransport.shouldLogException(sentryLevel)) {
+      const error = Object.values(info).find((value) => value instanceof Error) ?? new ExtendedError(info);
+      Sentry.captureException(error, { tags, level: sentryLevel });
+      return callback();
+    }
+    Sentry.captureMessage(message, sentryLevel);
+    return callback();
+  }
+  end(...args) {
+    Sentry.flush().then(() => {
+      super.end(...args);
+    });
+    return this;
+  }
+  get sentry() {
+    return Sentry;
+  }
+  setLevelsMap = (options) => {
+    if (!options) return DEFAULT_LEVELS_MAP;
+    const customLevelsMap = Object.keys(options).reduce(
+      (acc, winstonSeverity) => {
+        acc[winstonSeverity] = options[winstonSeverity];
+        return acc;
+      },
+      {}
+    );
+    return { ...DEFAULT_LEVELS_MAP, ...customLevelsMap };
+  };
+  static withDefaults(options) {
+    return {
+      ...options,
+      dsn: options && options.dsn || process.env.SENTRY_DSN || "",
+      serverName: options && options.serverName || "winston-transport-sentry-node",
+      environment: options && options.environment || process.env.SENTRY_ENVIRONMENT || process.env.NODE_ENV || "production",
+      debug: options && options.debug || !!process.env.SENTRY_DEBUG || false,
+      sampleRate: options && options.sampleRate || 1,
+      maxBreadcrumbs: options && options.maxBreadcrumbs || 100
+    };
+  }
+  static isObject(obj) {
+    const type = typeof obj;
+    return type === "function" || type === "object" && !!obj;
+  }
+  static shouldLogException(level) {
+    return level === "fatal" /* Fatal */ || level === "error" /* Error */;
+  }
+};
+
+// src/logger/logger.ts
+var Logger = class {
+  static logger;
+  /**
+   * @static
+   * Create method must first be called before using the logger. It creates a singleton, which will then
+   * be referred to throughout the application.
+   */
+  static create(config) {
+    if (!this.logger) {
+      this.logger = winston.createLogger({
+        format: winston.format.json(),
+        transports: [
+          new winston.transports.Console({
+            level: config.console?.level || "info"
+          }),
+          new SentryTransport({
+            sentry: {
+              dsn: config.sentry?.dsn
+            },
+            level: config.sentry?.level || "error"
+          })
+        ],
+        ...config.winston
+      });
+    }
+  }
+  static ensureInitialized() {
+    if (!this.logger) {
+      throw new BaseError(
+        "LOGGER_ERROR",
+        errorCodes.base.BASE_ERROR,
+        "Logger not initialized. Please call Logger.create() first.",
+        true,
+        "Logger",
+        void 0
+      );
+    }
+  }
+  /**
+   * @static
+   * Method to log for level - "info", this should not be called if it has been custom levels are
+   * set which does not include "info"
+   *
+   * @param {string|object} message - String or object to log.
+   */
+  static info(message) {
+    this.ensureInitialized();
+    if (typeof message === "string") {
+      this.logger.info(message);
+    } else {
+      this.logger.info(JSON.stringify(message));
+    }
+  }
+  /**
+   * @static
+   * Method to log for level - "debug", this should not be called if it has been custom levels are
+   * set which does not include "debug"
+   *
+   * @param {string|object} message - String or object to log.
+   */
+  static debug(message) {
+    this.ensureInitialized();
+    if (typeof message === "string") {
+      this.logger?.debug(message);
+    } else {
+      this.logger?.debug(JSON.stringify(message));
+    }
+  }
+  /**
+   * @static
+   * Method to log for level - "error", this should not be called if it has been custom levels are
+   * set which does not include "error"
+   *
+   * @param {string|object} error - String or object to log.
+   */
+  static error(error) {
+    this.ensureInitialized();
+    if (typeof error === "string") {
+      this.logger?.error(error);
+    } else {
+      this.logger?.error(
+        `${error.message ? `${error.message} : ` : ""}${JSON.stringify(error)}`
+      );
+    }
+  }
+  /**
+   * @static
+   * Method to log for level - "warn", this should not be called if it has been custom levels are
+   * set which does not include "warn"
+   *
+   * @param {string|object} message - String or object to log.
+   */
+  static warn(message) {
+    this.ensureInitialized();
+    if (typeof message === "string") {
+      this.logger?.warn(message);
+    } else {
+      this.logger?.warn(JSON.stringify(message));
+    }
+  }
+  /**
+   * @static
+   * Method to log for any level, which should be used to log all custom levels that may be added.
+   *
+   * @param {string|object} message - String or object to log.
+   */
+  static log(level, message) {
+    this.ensureInitialized();
+    if (typeof message === "string") {
+      this.logger?.log(level, message);
+    } else {
+      this.logger?.log(level, JSON.stringify(message));
+    }
+  }
+};
+
+// src/types/logger_config.ts
+import "winston";
+
+// src/consumers/event_consumer.ts
+import { createPublicClient, http } from "viem";
+
+// src/consumers/abstract_event_consumer.ts
+import { EventEmitter } from "events";
+var AbstractEventConsumer = class extends EventEmitter {
+  constructor() {
+    super();
+  }
+  /**
+   * @public
+   *
+   * Method to register listener for events. The Abstract Event Consumer emits fatalError
+   * event.
+   *
+   * @param {"fatalError"} eventName - Event name to register listener for.
+   * @param listener - Listener to be called when emitting the event.
+   *
+   * @returns {this} - Returns an instance of the class.
+   */
+  on(eventName, listener) {
+    return super.on(eventName, listener);
+  }
+  /**
+   * @public
+   *
+   * Method to register listener for events that will be called only once. The Abstract Event Consumer emits fatalError
+   * event.
+   *
+   * @param {"fatalError"} eventName - Event name to register listener for.
+   * @param listener - Listener to be called when emitting the event.
+   *
+   * @returns {this} - Returns an instance of the class.
+   */
+  once(eventName, listener) {
+    return super.on(eventName, listener);
+  }
+  onFatalError(error) {
+    this.emit("fatalError", error);
+  }
+};
+
+// src/consumers/event_consumer.ts
+var EventConsumer = class extends AbstractEventConsumer {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.client = createPublicClient({
+      chain: {
+        id: config.chainId,
+        name: "custom",
+        rpcUrls: { default: { http: [config.rpcUrl] } },
+        nativeCurrency: config.nativeCurrency
+      },
+      transport: http(config.rpcUrl)
+    });
+  }
+  client = null;
+  observer = null;
+  isBackfillingInProcess = false;
+  unWatchFunction;
+  async _backfillEvents(fromBlock, toBlock, step) {
+    Logger.info({
+      location: "event_consumer",
+      functon: "_backfillEvents",
+      status: `[Backfill] Starting backfill from block ${fromBlock.toString()} to ${toBlock.toString()}`
+    });
+    for (let start = fromBlock; start <= toBlock; start += step) {
+      const end = start + step - 1n > toBlock ? toBlock : start + step - 1n;
+      Logger.debug({
+        location: "event_consumer",
+        functon: "_backfillEvents",
+        status: `[Backfill] Fetching logs from block ${start.toString()} to ${end.toString()}`
+      });
+      const getLogsConfig = {
+        address: this.config.contractAddress,
+        fromBlock: start,
+        toBlock: end
+      };
+      if (this.config.events.length > 1) {
+        getLogsConfig.events = this.config.events;
+      } else {
+        getLogsConfig.event = this.config.events[0];
+      }
+      const logs = await this.client?.getLogs(getLogsConfig);
+      Logger.debug({
+        location: "event_consumer",
+        functon: "_backfillEvents",
+        status: `[Backfill] ${logs?.length} logs from block ${start.toString()} to ${end.toString()}`
+      });
+      await this.observer?.next(logs);
+    }
+  }
+  async start(observer) {
+    try {
+      this.isBackfillingInProcess = true;
+      this.observer = observer;
+      const latestBlock = await this.client?.getBlockNumber() ?? BigInt(0);
+      Logger.debug({
+        location: "event_consumer",
+        functon: "start",
+        data: {
+          latestBlock: latestBlock.toString(),
+          startBlock: this.config.startBlock.toString(),
+          pollBatchSize: this.config.pollBatchSize.toString()
+        }
+      });
+      if (latestBlock - this.config.startBlock > BigInt(0)) {
+        await this._backfillEvents(
+          this.config.startBlock,
+          latestBlock,
+          this.config.pollBatchSize
+        );
+      }
+      this.isBackfillingInProcess = false;
+      Logger.debug({
+        location: "event_consumer",
+        functon: "start",
+        status: `Starting event subscription`
+      });
+      this.unWatchFunction = this.client?.watchEvent({
+        address: this.config.contractAddress,
+        events: this.config.events,
+        fromBlock: latestBlock,
+        onLogs: (logs) => {
+          const transformedLogs = logs;
+          this.observer?.next(transformedLogs);
+        },
+        onError: (error) => {
+          this.onDisconnect();
+          this.onFatalError(
+            new ConsumerError(error.name, {
+              name: "CONSUMER_ERROR",
+              code: 1001,
+              isFatal: true,
+              origin: "EventConsumer",
+              context: { eventName: this.config.events }
+            })
+          );
+        }
+      });
+      Logger.debug({
+        location: "event_consumer",
+        functon: "start",
+        status: `Subscribed to event`
+      });
+    } catch (error) {
+      this.onDisconnect();
+      this.onFatalError(
+        new ExternalDependencyError(
+          this.config.rpcUrl,
+          "Failed to start the event consumer",
+          {
+            externalCode: errorCodes.external.UNKNOWN_EXTERNAL_DEPENDENCY_ERROR,
+            rawError: error,
+            origin: "EventConsumer",
+            context: { eventName: this.config.events }
+          }
+        )
+      );
+    }
+  }
+  /**
+   * Private method which updates the connection status of consumer to disconnected, and removes all listeners.
+   *
+   * @returns {void}
+   */
+  onDisconnect() {
+    this.removeAllListeners();
+    if (this.unWatchFunction) {
+      this.unWatchFunction();
+    }
+    this.observer?.closed();
+  }
+};
+
+// src/consumers/abstract_cron_event_consumer.ts
+import { Cron } from "croner";
+var AbstractCronEventConsumer = class extends AbstractEventConsumer {
+  cronJob = null;
+  /**
+   * Start the cron job with the given cron expression.
+   * @param cronExpr Cron expression string
+   */
+  startCron(cronExpr) {
+    if (this.cronJob) {
+      this.cronJob.stop();
+    }
+    this.cronJob = new Cron(cronExpr, { protect: true }, async () => {
+      await this.onTick();
+    });
+  }
+  /**
+   * Stop the cron job.
+   */
+  stopCron() {
+    if (this.cronJob) {
+      this.cronJob.stop();
+      this.cronJob = null;
+    }
+  }
+};
+
+// src/consumers/rest_api_consumer.ts
+var RestAPIConsumer = class extends AbstractCronEventConsumer {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.highestValueSeen = this.config.startCount.value;
+  }
+  observer = null;
+  currentPage = 0;
+  highestValueSeen = 0;
+  async start(observer) {
+    this.observer = observer;
+    this.currentPage = 1;
+    if (this.config.cronExpr) {
+      this.startCron(this.config.cronExpr);
+    } else {
+      await this.onTick();
+    }
+  }
+  stop() {
+    this.stopCron();
+  }
+  async onTick() {
+    this.currentPage = 1;
+    let shouldFetchNextPage = true;
+    while (shouldFetchNextPage) {
+      shouldFetchNextPage = await this.fetchPage();
+    }
+    this.config.startCount.value = this.highestValueSeen;
+    this.observer?.summary({
+      [`${this.config.startCount.key}`]: this.config.startCount.value
+    });
+  }
+  async fetchPage() {
+    try {
+      const paginationParam = this.config.paginationParam || "page";
+      const params = {
+        ...this.config.params || {},
+        [paginationParam]: this.currentPage.toString()
+      };
+      let url = this.config.apiUrl.toString();
+      if (Object.keys(params).length > 0) {
+        const queryString = new URLSearchParams(params).toString();
+        url += (url.includes("?") ? "&" : "?") + queryString;
+      }
+      const response = await fetch(url, {
+        method: this.config.method || "GET",
+        headers: this.config.headers,
+        body: this.config.body ? JSON.stringify(this.config.body) : void 0
+      });
+      if (!response.ok) {
+        throw new ConsumerError(
+          `Failed to fetch from API: ${response.statusText}`,
+          {
+            code: errorCodes.external.UNKNOWN_EXTERNAL_DEPENDENCY_ERROR,
+            isFatal: true,
+            origin: "rest_api_consumer"
+          }
+        );
+      }
+      let data = await response.json();
+      if (this.config.resultPath) {
+        data = this.getValueByPath(data, this.config.resultPath);
+      }
+      const countKey = this.config.startCount.key;
+      let currentValue = void 0;
+      if (Array.isArray(data)) {
+        if (data.length === 0) {
+          return false;
+        }
+        for (const elem of data) {
+          currentValue = this.processDataForCurrentCountValue(
+            elem,
+            countKey
+          );
+        }
+      } else {
+        currentValue = this.processDataForCurrentCountValue(
+          data,
+          countKey
+        );
+      }
+      this.observer?.next(data);
+      this.currentPage++;
+      if (currentValue === void 0) {
+        return false;
+      }
+      return currentValue >= this.config.startCount.value;
+    } catch (error) {
+      this.onFatalError(error);
+      return false;
+    }
+  }
+  // Utility to get nested values using dot notation (e.g., "response.data.count")
+  getValueByPath(obj, path) {
+    return path.split(".").reduce((prev, curr) => {
+      return prev && prev[curr] !== void 0 ? prev[curr] : void 0;
+    }, obj);
+  }
+  processDataForCurrentCountValue(item, countKey) {
+    const value = this.getValueByPath(item, countKey);
+    if (value === void 0) {
+      throw new ConsumerError(
+        `Count key '${countKey}' not found in API response`,
+        {
+          code: errorCodes.external.UNKNOWN_EXTERNAL_DEPENDENCY_ERROR,
+          isFatal: false,
+          origin: "rest_api_consumer"
+        }
+      );
+    }
+    this.highestValueSeen = Math.max(this.highestValueSeen, value);
+    return value;
+  }
+  /**
+   * Updates the start count value to a specific value.
+   * This allows reprocessing data from a specified point.
+   *
+   * @param value The value to set as the new start count
+   */
+  setStartValue(value) {
+    this.config.startCount.value = value;
+    this.highestValueSeen = value;
+  }
+};
+
+// src/utils/decoder.ts
+import { decodeEventLog, parseAbi, decodeAbiParameters } from "viem";
+var parseEventLog = (eventSignature, data, topics) => {
+  return decodeEventLog({ abi: parseAbi(eventSignature), data, topics });
+};
+var decodeAbiParams = (params, data) => {
+  return decodeAbiParameters(params, data);
+};
+
+// src/utils/ulid.ts
+import { monotonicFactory, ulid } from "ulid";
+function deterministicPRNG(seed) {
+  let t = seed;
+  return () => {
+    t += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function generateDeterministicULID(dataToEncode, timeSeed, separator) {
+  if (!Array.isArray(dataToEncode) || !dataToEncode.every((item) => typeof item === "string")) {
+    throw new Error("dataToEncode must be an array of strings");
+  }
+  const monotonicULID = monotonicFactory();
+  const timestampPart = timeSeed ? ulid(timeSeed, deterministicPRNG(timeSeed)) : monotonicULID();
+  return [timestampPart, ...dataToEncode.filter(Boolean)].join(
+    separator || "-"
+  );
+}
+export {
+  AbstractCronEventConsumer,
+  ApiError,
+  BadRequestError,
+  BaseError,
+  ConsumerError,
+  DatabaseError,
+  EventConsumer,
+  ExternalDependencyError,
+  ForbiddenError,
+  HealthCheck,
+  Logger,
+  NotFoundError,
+  RateLimitError,
+  RestAPIConsumer,
+  TimeoutError,
+  UnauthorizedError,
+  decodeAbiParams,
+  errorCodes,
+  generateDeterministicULID,
+  handleError,
+  handleResponse,
+  httpResponseCodes,
+  parseEventLog,
+  setupHealthCheckServer,
+  validateBody,
+  validateParams,
+  validateQuery
+};
 //# sourceMappingURL=index.js.map