@eclesia/indexer-engine 2.9.9 → 2.10.0-next.1

package/dist/metrics/index.js

@@ -0,0 +1,145 @@
+import { Counter, Gauge, Histogram, Registry, collectDefaultMetrics } from "prom-client";
+
+//#region src/metrics/index.ts
+/**
+* Prometheus metrics for monitoring indexer performance and health
+* Exposes metrics for blocks indexed, queue depth, errors, and processing times
+*/
+/** Prometheus metrics registry */
+var IndexerMetrics = class {
+	constructor() {
+		this.registry = new Registry();
+		collectDefaultMetrics({ register: this.registry });
+		this.blocksIndexed = new Counter({
+			name: "indexer_blocks_indexed_total",
+			help: "Total number of blocks indexed",
+			registers: [this.registry]
+		});
+		this.currentHeight = new Gauge({
+			name: "indexer_current_height",
+			help: "Current block height being processed",
+			registers: [this.registry]
+		});
+		this.latestHeight = new Gauge({
+			name: "indexer_latest_chain_height",
+			help: "Latest block height on the chain",
+			registers: [this.registry]
+		});
+		this.blocksBehind = new Gauge({
+			name: "indexer_blocks_behind",
+			help: "Number of blocks behind chain tip",
+			registers: [this.registry]
+		});
+		this.queueDepth = new Gauge({
+			name: "indexer_queue_depth",
+			help: "Current depth of block processing queue",
+			registers: [this.registry]
+		});
+		this.errors = new Counter({
+			name: "indexer_errors_total",
+			help: "Total number of indexer errors",
+			labelNames: ["type"],
+			registers: [this.registry]
+		});
+		this.rpcErrors = new Counter({
+			name: "indexer_rpc_errors_total",
+			help: "Total number of RPC errors",
+			registers: [this.registry]
+		});
+		this.databaseErrors = new Counter({
+			name: "indexer_database_errors_total",
+			help: "Total number of database errors",
+			registers: [this.registry]
+		});
+		this.blockProcessingDuration = new Histogram({
+			name: "indexer_block_processing_duration_seconds",
+			help: "Time spent processing a single block",
+			buckets: [
+				.001,
+				.005,
+				.01,
+				.05,
+				.1,
+				.5,
+				1,
+				2,
+				5
+			],
+			registers: [this.registry]
+		});
+		this.rpcCallDuration = new Histogram({
+			name: "indexer_rpc_call_duration_seconds",
+			help: "Duration of RPC calls",
+			buckets: [
+				.01,
+				.05,
+				.1,
+				.5,
+				1,
+				2,
+				5,
+				10
+			],
+			labelNames: ["method"],
+			registers: [this.registry]
+		});
+		this.databaseQueryDuration = new Histogram({
+			name: "indexer_database_query_duration_seconds",
+			help: "Duration of database queries",
+			buckets: [
+				.001,
+				.005,
+				.01,
+				.05,
+				.1,
+				.5,
+				1
+			],
+			labelNames: ["query_type"],
+			registers: [this.registry]
+		});
+		this.retryCount = new Gauge({
+			name: "indexer_retry_count",
+			help: "Current number of retry attempts",
+			registers: [this.registry]
+		});
+		this.transactionsProcessed = new Counter({
+			name: "indexer_transactions_processed_total",
+			help: "Total number of transactions processed",
+			registers: [this.registry]
+		});
+	}
+	/**
+	* Updates block indexing metrics
+	* @param currentHeight - Current height being processed
+	* @param latestHeight - Latest height on chain
+	* @param queueSize - Current queue depth
+	*/
+	updateBlockMetrics(currentHeight, latestHeight, queueSize) {
+		this.blocksIndexed.inc();
+		this.currentHeight.set(currentHeight);
+		this.latestHeight.set(latestHeight);
+		this.blocksBehind.set(latestHeight - currentHeight);
+		this.queueDepth.set(queueSize);
+	}
+	/**
+	* Records an error occurrence
+	* @param type - Error type (rpc, database, processing, etc.)
+	*/
+	recordError(type) {
+		this.errors.inc({ type });
+		if (type === "rpc") this.rpcErrors.inc();
+		else if (type === "database") this.databaseErrors.inc();
+	}
+	/**
+	* Gets metrics in Prometheus format
+	* @returns Prometheus metrics string
+	*/
+	async getMetrics() {
+		return this.registry.metrics();
+	}
+};
+
+//#endregion
+export { IndexerMetrics };
+//# sourceMappingURL=index.js.map

package/dist/metrics/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/metrics/index.ts"],"sourcesContent":["/**\n * Prometheus metrics for monitoring indexer performance and health\n * Exposes metrics for blocks indexed, queue depth, errors, and processing times\n */\n\nimport {\n  collectDefaultMetrics, Counter, Gauge, Histogram, Registry,\n} from \"prom-client\";\n\n/** Prometheus metrics registry */\nexport class IndexerMetrics {\n  /** Prometheus registry instance */\n  public readonly registry: Registry;\n\n  /** Counter for total blocks indexed */\n  public readonly blocksIndexed: Counter;\n\n  /** Gauge for current block height */\n  public readonly currentHeight: Gauge;\n\n  /** Gauge for latest chain block height */\n  public readonly latestHeight: Gauge;\n\n  /** Gauge for blocks behind chain tip */\n  public readonly blocksBehind: Gauge;\n\n  /** Gauge for block queue depth */\n  public readonly queueDepth: Gauge;\n\n  /** Counter for total errors */\n  public readonly errors: Counter;\n\n  /** Counter for RPC errors */\n  public readonly rpcErrors: Counter;\n\n  /** Counter for database errors */\n  public readonly databaseErrors: Counter;\n\n  /** Histogram for block processing duration */\n  public readonly blockProcessingDuration: Histogram;\n\n  /** Histogram for RPC call duration */\n  public readonly rpcCallDuration: Histogram;\n\n  /** Histogram for database query duration */\n  public readonly databaseQueryDuration: Histogram;\n\n  /** Gauge for retry count */\n  public readonly retryCount: Gauge;\n\n  /** Counter for total transactions processed */\n  public readonly transactionsProcessed: Counter;\n\n  constructor() {\n    this.registry = new Registry();\n\n    // Collect default Node.js metrics (memory, CPU, etc.)\n    collectDefaultMetrics({\n      register: this.registry,\n    });\n\n    // Block indexing metrics\n    this.blocksIndexed = new Counter({\n      name: \"indexer_blocks_indexed_total\",\n      help: \"Total number of blocks indexed\",\n      registers: [this.registry],\n    });\n\n    this.currentHeight = new Gauge({\n      name: \"indexer_current_height\",\n      help: \"Current block height being processed\",\n      registers: [this.registry],\n    });\n\n    this.latestHeight = new Gauge({\n      name: \"indexer_latest_chain_height\",\n      help: \"Latest block height on the chain\",\n      registers: [this.registry],\n    });\n\n    this.blocksBehind = new Gauge({\n      name: \"indexer_blocks_behind\",\n      help: \"Number of blocks behind chain tip\",\n      registers: [this.registry],\n    });\n\n    this.queueDepth = new Gauge({\n      name: \"indexer_queue_depth\",\n      help: \"Current depth of block processing queue\",\n      registers: [this.registry],\n    });\n\n    // Error metrics\n    this.errors = new Counter({\n      name: \"indexer_errors_total\",\n      help: \"Total number of indexer errors\",\n      labelNames: [\"type\"],\n      registers: [this.registry],\n    });\n\n    this.rpcErrors = new Counter({\n      name: \"indexer_rpc_errors_total\",\n      help: \"Total number of RPC errors\",\n      registers: [this.registry],\n    });\n\n    this.databaseErrors = new Counter({\n      name: \"indexer_database_errors_total\",\n      help: \"Total number of database errors\",\n      registers: [this.registry],\n    });\n\n    // Performance metrics\n    this.blockProcessingDuration = new Histogram({\n      name: \"indexer_block_processing_duration_seconds\",\n      help: \"Time spent processing a single block\",\n      buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 2, 5],\n      registers: [this.registry],\n    });\n\n    this.rpcCallDuration = new Histogram({\n      name: \"indexer_rpc_call_duration_seconds\",\n      help: \"Duration of RPC calls\",\n      buckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5, 10],\n      labelNames: [\"method\"],\n      registers: [this.registry],\n    });\n\n    this.databaseQueryDuration = new Histogram({\n      name: \"indexer_database_query_duration_seconds\",\n      help: \"Duration of database queries\",\n      buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1],\n      labelNames: [\"query_type\"],\n      registers: [this.registry],\n    });\n\n    // Operational metrics\n    this.retryCount = new Gauge({\n      name: \"indexer_retry_count\",\n      help: \"Current number of retry attempts\",\n      registers: [this.registry],\n    });\n\n    this.transactionsProcessed = new Counter({\n      name: \"indexer_transactions_processed_total\",\n      help: \"Total number of transactions processed\",\n      registers: [this.registry],\n    });\n  }\n\n  /**\n   * Updates block indexing metrics\n   * @param currentHeight - Current height being processed\n   * @param latestHeight - Latest height on chain\n   * @param queueSize - Current queue depth\n   */\n  updateBlockMetrics(currentHeight: number, latestHeight: number, queueSize: number) {\n    this.blocksIndexed.inc();\n    this.currentHeight.set(currentHeight);\n    this.latestHeight.set(latestHeight);\n    this.blocksBehind.set(latestHeight - currentHeight);\n    this.queueDepth.set(queueSize);\n  }\n\n  /**\n   * Records an error occurrence\n   * @param type - Error type (rpc, database, processing, etc.)\n   */\n  recordError(type: string) {\n    this.errors.inc({\n      type,\n    });\n\n    if (type === \"rpc\") {\n      this.rpcErrors.inc();\n    }\n    else if (type === \"database\") {\n      this.databaseErrors.inc();\n    }\n  }\n\n  /**\n   * Gets metrics in Prometheus format\n   * @returns Prometheus metrics string\n   */\n  async getMetrics(): Promise<string> {\n    return this.registry.metrics();\n  }\n}\n"],"mappings":";;;;;;;;AAUA,IAAa,iBAAb,MAA4B;CA2C1B,cAAc;AACZ,OAAK,WAAW,IAAI,UAAU;AAG9B,wBAAsB,EACpB,UAAU,KAAK,UAChB,CAAC;AAGF,OAAK,gBAAgB,IAAI,QAAQ;GAC/B,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,gBAAgB,IAAI,MAAM;GAC7B,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,eAAe,IAAI,MAAM;GAC5B,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,eAAe,IAAI,MAAM;GAC5B,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,aAAa,IAAI,MAAM;GAC1B,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAGF,OAAK,SAAS,IAAI,QAAQ;GACxB,MAAM;GACN,MAAM;GACN,YAAY,CAAC,OAAO;GACpB,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,YAAY,IAAI,QAAQ;GAC3B,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,iBAAiB,IAAI,QAAQ;GAChC,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAGF,OAAK,0BAA0B,IAAI,UAAU;GAC3C,MAAM;GACN,MAAM;GACN,SAAS;IAAC;IAAO;IAAO;IAAM;IAAM;IAAK;IAAK;IAAG;IAAG;IAAE;GACtD,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,kBAAkB,IAAI,UAAU;GACnC,MAAM;GACN,MAAM;GACN,SAAS;IAAC;IAAM;IAAM;IAAK;IAAK;IAAG;IAAG;IAAG;IAAG;GAC5C,YAAY,CAAC,SAAS;GACtB,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,wBAAwB,IAAI,UAAU;GACzC,MAAM;GACN,MAAM;GACN,SAAS;IAAC;IAAO;IAAO;IAAM;IAAM;IAAK;IAAK;IAAE;GAChD,YAAY,CAAC,aAAa;GAC1B,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAGF,OAAK,aAAa,IAAI,MAAM;GAC1B,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;AAEF,OAAK,wBAAwB,IAAI,QAAQ;GACvC,MAAM;GACN,MAAM;GACN,WAAW,CAAC,KAAK,SAAS;GAC3B,CAAC;;;;;;;;CASJ,mBAAmB,eAAuB,cAAsB,WAAmB;AACjF,OAAK,cAAc,KAAK;AACxB,OAAK,cAAc,IAAI,cAAc;AACrC,OAAK,aAAa,IAAI,aAAa;AACnC,OAAK,aAAa,IAAI,eAAe,cAAc;AACnD,OAAK,WAAW,IAAI,UAAU;;;;;;CAOhC,YAAY,MAAc;AACxB,OAAK,OAAO,IAAI,EACd,MACD,CAAC;AAEF,MAAI,SAAS,MACX,MAAK,UAAU,KAAK;WAEb,SAAS,WAChB,MAAK,eAAe,KAAK;;;;;;CAQ7B,MAAM,aAA8B;AAClC,SAAO,KAAK,SAAS,SAAS"}

package/dist/promise-queue/index.cjs

@@ -7,12 +7,13 @@
 * - size() is always at minimum 1 item which is the promise for the next enqueued item
 */
 var PromiseQueue = class {
-	constructor(batchSize) {
+	constructor(batchSize, errorHandler) {
 		this.synced = false;
 		const nextVal = new Promise((resolve, _reject) => {
 			this.enqueuer = resolve;
 		});
 		this.batchSize = batchSize;
+		this.errorHandler = errorHandler;
 		this.continuePromise = new Promise((resolve, _reject) => {
 			this.batcher = resolve;
 		});
@@ -30,7 +31,7 @@ var PromiseQueue = class {
 				this.batcher = resolve;
 			});
 		} catch (e) {
-			console.error("Enqueing rejected data: " + e);
+			if (this.errorHandler) this.errorHandler(e);
 		}
 	}
 	clear() {
@@ -68,7 +69,7 @@ var PromiseQueue = class {
 * Used by the indexer for managing block processing queues
 */
 var CircularBuffer = class {
-	constructor(batchSize) {
+	constructor(batchSize, errorHandler) {
 		this.count = 0;
 		this.next = 0;
 		this.synced = false;
@@ -79,6 +80,7 @@ var CircularBuffer = class {
 		});
 		this.items = new Array(batchSize);
 		this.batchSize = batchSize;
+		this.errorHandler = errorHandler;
 		this.items[this.nextAvail] = nextVal;
 		this.count = 1;
 		this.nextAvail++;
@@ -102,7 +104,7 @@ var CircularBuffer = class {
 				this.batcher = resolve;
 			});
 		} catch (e) {
-			console.error("Enqueing rejected data: " + e);
+			if (this.errorHandler) this.errorHandler(e);
 		}
 	}
 	dequeue() {

package/dist/promise-queue/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":["/**\n * Implements an \"infinite\" FIFO queue of fixed size using promises\n * - await `continue()` before enqueing items to ensure fixed size (resolves when space available)\n * - await `dequeue()` to pop an item (resolves when next item is available)\n * - size() is always at minimum 1 item which is the promise for the next enqueued item\n */\nexport class PromiseQueue<T> {\n  /** Array of promises representing queued items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the queue is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items to keep in the queue */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  constructor(batchSize: number) {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.batchSize = batchSize;\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items.push(nextVal);\n      if (this.size() > this.batchSize) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      console.error(\"Enqueing rejected data: \" + e);\n    }\n  }\n\n  clear() {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  dequeue() {\n    const item = this.items.shift();\n    if (this.size() <= this.batchSize) {\n      this.batcher(true);\n    }\n\n    return item as Promise<T>;\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.items.length == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.items.length;\n  }\n}\n\n/**\n * Circular buffer implementation using promises for efficient memory usage\n * Reuses array slots in a circular fashion to maintain constant memory footprint\n * Used by the indexer for managing block processing queues\n */\nexport class CircularBuffer<T> {\n  /** Fixed-size array of promises representing buffered items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Current number of items in the buffer */\n  private count: number = 0;\n\n  /** Index of the next item to dequeue */\n  private next: number = 0;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the buffer is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items the buffer can hold */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  /** Index of the next available slot for enqueueing */\n  private nextAvail: number = 0;\n\n  constructor(batchSize: number) {\n    if (batchSize <= 1) {\n      throw new Error(\"Batch size must be greater than 1\");\n    }\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(batchSize);\n    this.batchSize = batchSize;\n    this.items[this.nextAvail] = nextVal;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items[this.nextAvail] = nextVal;\n      this.count++;\n      this.nextAvail++;\n      if (this.nextAvail >= this.batchSize) {\n        this.nextAvail = 0;\n      }\n\n      if (this.nextAvail == this.next) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      console.error(\"Enqueing rejected data: \" + e);\n    }\n  }\n\n  dequeue() {\n    const item = this.items[this.next];\n    this.next++;\n    this.count--;\n    if (this.next >= this.batchSize) {\n      this.next = 0;\n    }\n    if (this.count <= this.batchSize) {\n      this.batcher(true);\n    }\n    return item;\n  }\n\n  clear() {\n    this.next = 0;\n    this.nextAvail = 0;\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(this.batchSize);\n    this.items[this.nextAvail] = nextVal;\n    this.synced = false;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.count == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.count;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":["/**\n * Implements an \"infinite\" FIFO queue of fixed size using promises\n * - await `continue()` before enqueing items to ensure fixed size (resolves when space available)\n * - await `dequeue()` to pop an item (resolves when next item is available)\n * - size() is always at minimum 1 item which is the promise for the next enqueued item\n */\nexport class PromiseQueue<T> {\n  /** Optional error handler for enqueue failures */\n  private errorHandler?: (error: unknown) => void;\n  /** Array of promises representing queued items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the queue is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items to keep in the queue */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  constructor(batchSize: number, errorHandler?: (error: unknown) => void) {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.batchSize = batchSize;\n    this.errorHandler = errorHandler;\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items.push(nextVal);\n      if (this.size() > this.batchSize) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      if (this.errorHandler) {\n        this.errorHandler(e);\n      }\n      // If no error handler provided, silently ignore (existing behavior for backward compatibility)\n    }\n  }\n\n  clear() {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  dequeue() {\n    const item = this.items.shift();\n    if (this.size() <= this.batchSize) {\n      this.batcher(true);\n    }\n\n    return item as Promise<T>;\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.items.length == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.items.length;\n  }\n}\n\n/**\n * Circular buffer implementation using promises for efficient memory usage\n * Reuses array slots in a circular fashion to maintain constant memory footprint\n * Used by the indexer for managing block processing queues\n */\nexport class CircularBuffer<T> {\n  /** Optional error handler for enqueue failures */\n  private errorHandler?: (error: unknown) => void;\n\n  /** Fixed-size array of promises representing buffered items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Current number of items in the buffer */\n  private count: number = 0;\n\n  /** Index of the next item to dequeue */\n  private next: number = 0;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the buffer is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items the buffer can hold */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  /** Index of the next available slot for enqueueing */\n  private nextAvail: number = 0;\n\n  constructor(batchSize: number, errorHandler?: (error: unknown) => void) {\n    if (batchSize <= 1) {\n      throw new Error(\"Batch size must be greater than 1\");\n    }\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(batchSize);\n    this.batchSize = batchSize;\n    this.errorHandler = errorHandler;\n    this.items[this.nextAvail] = nextVal;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items[this.nextAvail] = nextVal;\n      this.count++;\n      this.nextAvail++;\n      if (this.nextAvail >= this.batchSize) {\n        this.nextAvail = 0;\n      }\n\n      if (this.nextAvail == this.next) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      if (this.errorHandler) {\n        this.errorHandler(e);\n      }\n      // If no error handler provided, silently ignore (existing behavior for backward compatibility)\n    }\n  }\n\n  dequeue() {\n    const item = this.items[this.next];\n    this.next++;\n    this.count--;\n    if (this.next >= this.batchSize) {\n      this.next = 0;\n    }\n    if (this.count <= this.batchSize) {\n      this.batcher(true);\n    }\n    return item;\n  }\n\n  clear() {\n    this.next = 0;\n    this.nextAvail = 0;\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(this.batchSize);\n    this.items[this.nextAvail] = nextVal;\n    this.synced = false;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.count == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.count;\n  }\n}\n"],"mappings":"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"}

package/dist/promise-queue/index.d.cts

@@ -6,6 +6,8 @@
  * - size() is always at minimum 1 item which is the promise for the next enqueued item
  */
 declare class PromiseQueue<T> {
+  /** Optional error handler for enqueue failures */
+  private errorHandler?;
   /** Array of promises representing queued items */
   private items;
   /** Function to resolve the next enqueued promise */
@@ -18,7 +20,7 @@ declare class PromiseQueue<T> {
   private batchSize;
   /** Promise that resolves when it's safe to enqueue more items */
   private continuePromise;
-  constructor(batchSize: number);
+  constructor(batchSize: number, errorHandler?: (error: unknown) => void);
   enqueue(item: T | PromiseLike<T>): void;
   clear(): void;
   dequeue(): Promise<T>;
@@ -33,6 +35,8 @@ declare class PromiseQueue<T> {
  * Used by the indexer for managing block processing queues
  */
 declare class CircularBuffer<T> {
+  /** Optional error handler for enqueue failures */
+  private errorHandler?;
   /** Fixed-size array of promises representing buffered items */
   private items;
   /** Function to resolve the next enqueued promise */
@@ -51,7 +55,7 @@ declare class CircularBuffer<T> {
   private continuePromise;
   /** Index of the next available slot for enqueueing */
   private nextAvail;
-  constructor(batchSize: number);
+  constructor(batchSize: number, errorHandler?: (error: unknown) => void);
   enqueue(item: T | PromiseLike<T>): void;
   dequeue(): Promise<T>;
   clear(): void;

package/dist/promise-queue/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;;AAkE2B,cAlEd,YAkEc,CAAA,CAAA,CAAA,CAAA;;UAGjB,KAAA;EAAA;EA2BG,QAAA,QAAA;EAAc;UAkDX,OAAA;;QAAI,EAAA,OAAA;;UAwBX,SAAA;;EAkCC,QAAA,eAAA;;gBA7KM,IAAI,YAAY;;aAmCb,QAAQ;cAGjB;;;;;;;;;;cA2BG;;;;;;;;;;;;;;;;;;;;gBAkDG,IAAI,YAAY;aAwBvB,QAAA;;cAkCC"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;;AAwE2B,cAxEd,YAwEc,CAAA,CAAA,CAAA,CAAA;;UAGjB,YAAA;EAAA;EA2BG,QAAA,KAAA;EAAc;UAsDX,QAAA;;UAAI,OAAA;;QA2BX,EAAA,OAAA;;EAkCC,QAAA,SAAA;;;;gBAvLM,IAAI,YAAY;;aAsCb,QAAQ;cAGjB;;;;;;;;;;cA2BG;;;;;;;;;;;;;;;;;;;;;;gBAsDG,IAAI,YAAY;aA2BvB,QAAA;;cAkCC"}

package/dist/promise-queue/index.d.ts

@@ -6,6 +6,8 @@
  * - size() is always at minimum 1 item which is the promise for the next enqueued item
  */
 declare class PromiseQueue<T> {
+  /** Optional error handler for enqueue failures */
+  private errorHandler?;
   /** Array of promises representing queued items */
   private items;
   /** Function to resolve the next enqueued promise */
@@ -18,7 +20,7 @@ declare class PromiseQueue<T> {
   private batchSize;
   /** Promise that resolves when it's safe to enqueue more items */
   private continuePromise;
-  constructor(batchSize: number);
+  constructor(batchSize: number, errorHandler?: (error: unknown) => void);
   enqueue(item: T | PromiseLike<T>): void;
   clear(): void;
   dequeue(): Promise<T>;
@@ -33,6 +35,8 @@ declare class PromiseQueue<T> {
  * Used by the indexer for managing block processing queues
  */
 declare class CircularBuffer<T> {
+  /** Optional error handler for enqueue failures */
+  private errorHandler?;
   /** Fixed-size array of promises representing buffered items */
   private items;
   /** Function to resolve the next enqueued promise */
@@ -51,7 +55,7 @@ declare class CircularBuffer<T> {
   private continuePromise;
   /** Index of the next available slot for enqueueing */
   private nextAvail;
-  constructor(batchSize: number);
+  constructor(batchSize: number, errorHandler?: (error: unknown) => void);
   enqueue(item: T | PromiseLike<T>): void;
   dequeue(): Promise<T>;
   clear(): void;

package/dist/promise-queue/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;;AAkE2B,cAlEd,YAkEc,CAAA,CAAA,CAAA,CAAA;;UAGjB,KAAA;EAAA;EA2BG,QAAA,QAAA;EAAc;UAkDX,OAAA;;QAAI,EAAA,OAAA;;UAwBX,SAAA;;EAkCC,QAAA,eAAA;;gBA7KM,IAAI,YAAY;;aAmCb,QAAQ;cAGjB;;;;;;;;;;cA2BG;;;;;;;;;;;;;;;;;;;;gBAkDG,IAAI,YAAY;aAwBvB,QAAA;;cAkCC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;;AAwE2B,cAxEd,YAwEc,CAAA,CAAA,CAAA,CAAA;;UAGjB,YAAA;EAAA;EA2BG,QAAA,KAAA;EAAc;UAsDX,QAAA;;UAAI,OAAA;;QA2BX,EAAA,OAAA;;EAkCC,QAAA,SAAA;;;;gBAvLM,IAAI,YAAY;;aAsCb,QAAQ;cAGjB;;;;;;;;;;cA2BG;;;;;;;;;;;;;;;;;;;;;;gBAsDG,IAAI,YAAY;aA2BvB,QAAA;;cAkCC"}

package/dist/promise-queue/index.js

@@ -6,12 +6,13 @@
 * - size() is always at minimum 1 item which is the promise for the next enqueued item
 */
 var PromiseQueue = class {
-	constructor(batchSize) {
+	constructor(batchSize, errorHandler) {
 		this.synced = false;
 		const nextVal = new Promise((resolve, _reject) => {
 			this.enqueuer = resolve;
 		});
 		this.batchSize = batchSize;
+		this.errorHandler = errorHandler;
 		this.continuePromise = new Promise((resolve, _reject) => {
 			this.batcher = resolve;
 		});
@@ -29,7 +30,7 @@ var PromiseQueue = class {
 				this.batcher = resolve;
 			});
 		} catch (e) {
-			console.error("Enqueing rejected data: " + e);
+			if (this.errorHandler) this.errorHandler(e);
 		}
 	}
 	clear() {
@@ -67,7 +68,7 @@ var PromiseQueue = class {
 * Used by the indexer for managing block processing queues
 */
 var CircularBuffer = class {
-	constructor(batchSize) {
+	constructor(batchSize, errorHandler) {
 		this.count = 0;
 		this.next = 0;
 		this.synced = false;
@@ -78,6 +79,7 @@ var CircularBuffer = class {
 		});
 		this.items = new Array(batchSize);
 		this.batchSize = batchSize;
+		this.errorHandler = errorHandler;
 		this.items[this.nextAvail] = nextVal;
 		this.count = 1;
 		this.nextAvail++;
@@ -101,7 +103,7 @@ var CircularBuffer = class {
 				this.batcher = resolve;
 			});
 		} catch (e) {
-			console.error("Enqueing rejected data: " + e);
+			if (this.errorHandler) this.errorHandler(e);
 		}
 	}
 	dequeue() {

package/dist/promise-queue/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":["/**\n * Implements an \"infinite\" FIFO queue of fixed size using promises\n * - await `continue()` before enqueing items to ensure fixed size (resolves when space available)\n * - await `dequeue()` to pop an item (resolves when next item is available)\n * - size() is always at minimum 1 item which is the promise for the next enqueued item\n */\nexport class PromiseQueue<T> {\n  /** Array of promises representing queued items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the queue is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items to keep in the queue */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  constructor(batchSize: number) {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.batchSize = batchSize;\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items.push(nextVal);\n      if (this.size() > this.batchSize) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      console.error(\"Enqueing rejected data: \" + e);\n    }\n  }\n\n  clear() {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  dequeue() {\n    const item = this.items.shift();\n    if (this.size() <= this.batchSize) {\n      this.batcher(true);\n    }\n\n    return item as Promise<T>;\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.items.length == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.items.length;\n  }\n}\n\n/**\n * Circular buffer implementation using promises for efficient memory usage\n * Reuses array slots in a circular fashion to maintain constant memory footprint\n * Used by the indexer for managing block processing queues\n */\nexport class CircularBuffer<T> {\n  /** Fixed-size array of promises representing buffered items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Current number of items in the buffer */\n  private count: number = 0;\n\n  /** Index of the next item to dequeue */\n  private next: number = 0;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the buffer is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items the buffer can hold */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  /** Index of the next available slot for enqueueing */\n  private nextAvail: number = 0;\n\n  constructor(batchSize: number) {\n    if (batchSize <= 1) {\n      throw new Error(\"Batch size must be greater than 1\");\n    }\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(batchSize);\n    this.batchSize = batchSize;\n    this.items[this.nextAvail] = nextVal;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items[this.nextAvail] = nextVal;\n      this.count++;\n      this.nextAvail++;\n      if (this.nextAvail >= this.batchSize) {\n        this.nextAvail = 0;\n      }\n\n      if (this.nextAvail == this.next) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      console.error(\"Enqueing rejected data: \" + e);\n    }\n  }\n\n  dequeue() {\n    const item = this.items[this.next];\n    this.next++;\n    this.count--;\n    if (this.next >= this.batchSize) {\n      this.next = 0;\n    }\n    if (this.count <= this.batchSize) {\n      this.batcher(true);\n    }\n    return item;\n  }\n\n  clear() {\n    this.next = 0;\n    this.nextAvail = 0;\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(this.batchSize);\n    this.items[this.nextAvail] = nextVal;\n    this.synced = false;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.count == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.count;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/promise-queue/index.ts"],"sourcesContent":["/**\n * Implements an \"infinite\" FIFO queue of fixed size using promises\n * - await `continue()` before enqueing items to ensure fixed size (resolves when space available)\n * - await `dequeue()` to pop an item (resolves when next item is available)\n * - size() is always at minimum 1 item which is the promise for the next enqueued item\n */\nexport class PromiseQueue<T> {\n  /** Optional error handler for enqueue failures */\n  private errorHandler?: (error: unknown) => void;\n  /** Array of promises representing queued items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the queue is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items to keep in the queue */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  constructor(batchSize: number, errorHandler?: (error: unknown) => void) {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.batchSize = batchSize;\n    this.errorHandler = errorHandler;\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items.push(nextVal);\n      if (this.size() > this.batchSize) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      if (this.errorHandler) {\n        this.errorHandler(e);\n      }\n      // If no error handler provided, silently ignore (existing behavior for backward compatibility)\n    }\n  }\n\n  clear() {\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n    this.items = [nextVal];\n  }\n\n  dequeue() {\n    const item = this.items.shift();\n    if (this.size() <= this.batchSize) {\n      this.batcher(true);\n    }\n\n    return item as Promise<T>;\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.items.length == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.items.length;\n  }\n}\n\n/**\n * Circular buffer implementation using promises for efficient memory usage\n * Reuses array slots in a circular fashion to maintain constant memory footprint\n * Used by the indexer for managing block processing queues\n */\nexport class CircularBuffer<T> {\n  /** Optional error handler for enqueue failures */\n  private errorHandler?: (error: unknown) => void;\n\n  /** Fixed-size array of promises representing buffered items */\n  private items: Array<Promise<T>>;\n\n  /** Function to resolve the next enqueued promise */\n  private enqueuer!: (val: T | PromiseLike<T>) => void;\n\n  /** Current number of items in the buffer */\n  private count: number = 0;\n\n  /** Index of the next item to dequeue */\n  private next: number = 0;\n\n  /** Function to resolve the continue promise when space is available */\n  private batcher!: (val: boolean) => void;\n\n  /** Flag indicating if the buffer is synced with the data source */\n  public synced = false;\n\n  /** Maximum number of items the buffer can hold */\n  private batchSize: number;\n\n  /** Promise that resolves when it's safe to enqueue more items */\n  private continuePromise: Promise<boolean>;\n\n  /** Index of the next available slot for enqueueing */\n  private nextAvail: number = 0;\n\n  constructor(batchSize: number, errorHandler?: (error: unknown) => void) {\n    if (batchSize <= 1) {\n      throw new Error(\"Batch size must be greater than 1\");\n    }\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(batchSize);\n    this.batchSize = batchSize;\n    this.errorHandler = errorHandler;\n    this.items[this.nextAvail] = nextVal;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  enqueue(item: T | PromiseLike<T>) {\n    try {\n      this.enqueuer(item);\n      const nextVal = new Promise<T>((resolve, _reject) => {\n        this.enqueuer = resolve;\n      });\n      this.items[this.nextAvail] = nextVal;\n      this.count++;\n      this.nextAvail++;\n      if (this.nextAvail >= this.batchSize) {\n        this.nextAvail = 0;\n      }\n\n      if (this.nextAvail == this.next) {\n        this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n          this.batcher = resolve;\n        });\n      }\n    }\n    catch (e) {\n      if (this.errorHandler) {\n        this.errorHandler(e);\n      }\n      // If no error handler provided, silently ignore (existing behavior for backward compatibility)\n    }\n  }\n\n  dequeue() {\n    const item = this.items[this.next];\n    this.next++;\n    this.count--;\n    if (this.next >= this.batchSize) {\n      this.next = 0;\n    }\n    if (this.count <= this.batchSize) {\n      this.batcher(true);\n    }\n    return item;\n  }\n\n  clear() {\n    this.next = 0;\n    this.nextAvail = 0;\n    const nextVal = new Promise<T>((resolve, _reject) => {\n      this.enqueuer = resolve;\n    });\n    this.items = new Array<Promise<T>>(this.batchSize);\n    this.items[this.nextAvail] = nextVal;\n    this.synced = false;\n    this.count = 1;\n    this.nextAvail++;\n    if (this.nextAvail >= this.batchSize) {\n      this.nextAvail = 0;\n    }\n\n    this.continuePromise = new Promise<boolean>((resolve, _reject) => {\n      this.batcher = resolve;\n    });\n    this.batcher(true);\n  }\n\n  continue() {\n    return this.continuePromise;\n  }\n\n  setSynced() {\n    this.synced = true;\n  }\n\n  isEmpty() {\n    if (this.count == 0) {\n      return true;\n    }\n    else {\n      return false;\n    }\n  }\n\n  size() {\n    return this.count;\n  }\n}\n"],"mappings":"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"}

package/dist/types/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":["/* eslint-disable @stylistic/no-multi-spaces */\nimport {\n  BlockResponse, BlockResultsResponse,\n} from \"@cosmjs/tendermint-rpc\";\nimport {\n  BlockResultsResponse as BlockResultsResponse38, Event,\n} from \"@cosmjs/tendermint-rpc/build/comet38/responses\";\nimport {\n  Validator,\n} from \"cosmjs-types/cosmos/staking/v1beta1/staking\";\nimport {\n  TxBody,\n} from \"cosmjs-types/cosmos/tx/v1beta1/tx\";\n\nimport {\n  EcleciaIndexer,\n} from \"../indexer\";\nimport {\n  CircularBuffer,\n} from \"../promise-queue\";\n\n/** Configuration interface for the Eclesia indexer */\nexport type EcleciaIndexerConfig = {\n  startHeight?: number                                           // Block height to start indexing from\n  endHeight?: number                                             // Block height to stop indexing at (optional)\n  batchSize: number                                              // Number of blocks to process in parallel\n  modules: string[]                                              // List of module names to enable\n  getNextHeight: () => number | PromiseLike<number>             // Function to determine next block to process\n  logLevel: \"error\" | \"warn\" | \"info\" | \"http\" | \"verbose\" | \"debug\" | \"silly\" // Logging verbosity level\n  rpcUrl: string                                                 // Tendermint RPC endpoint URL\n  shouldProcessGenesis: () => Promise<boolean>                   // Whether to process genesis state\n  genesisPath?: string                                           // Path to genesis file\n  usePolling?: boolean                                           // Use polling instead of WebSocket subscription\n  pollingInterval?: number                                       // Interval between polls in milliseconds\n  minimal?: boolean                                              // Use minimal indexing mode (blocks only)\n  init?: () => Promise<void>                                     // Custom initialization function\n  beginTransaction: () => Promise<void>                          // Function to begin database transaction\n  endTransaction: (status: boolean) => Promise<void>            // Function to end database transaction\n};\n\n/** Queue for full indexing mode with validator data */\nexport type FullBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse, Uint8Array]>;\n\n/** Queue for minimal indexing mode without validator data */\nexport type MinimalBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse]>;\n\n/** Union type for block queues */\nexport type BlockQueue = FullBlockQueue | MinimalBlockQueue;\n\n/** Utility type to add height, timestamp, and UUID to event types */\nexport type WithHeightAndUUID<T> = {\n  [K in keyof T]: T[K] & {\n    uuid?: string      // Unique identifier for event tracking\n    height?: number    // Block height when event occurred\n    timestamp?: string // Block timestamp when event occurred\n  };\n};\n\n/** Function signature for emitting events asynchronously */\nexport type EmitFunc<K extends keyof WithHeightAndUUID<EventMap>> = (\n  t: K,\n  e: WithHeightAndUUID<EventMap>[K]\n) => Promise<void | void[]>;\n\nexport type LogEvent = {\n  type: \"log\" | \"info\" | \"warning\" | \"error\" | \"verbose\" | \"transient\"\n  message: string\n};\nexport type UUIDEvent = {\n  uuid: string\n  error?: string\n  status: boolean\n};\nexport type Events = {\n  log: LogEvent\n  uuid: UUIDEvent\n  begin_block: {\n    value: {\n      events: BlockResultsResponse[\"beginBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n      validators: Validator[] | undefined\n    }\n  }\n\n  block: {\n    value: {\n      block: BlockResponse\n      block_results: BlockResultsResponse | BlockResultsResponse38\n    }\n  }\n  end_block: {\n    value: BlockResultsResponse[\"endBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n  }\n  tx_events: {\n    value: BlockResultsResponse[\"results\"] | BlockResultsResponse38[\"results\"]\n  }\n  tx_memo: {\n    value: {\n      txHash: string\n      txBody: TxBody\n    }\n  }\n  _unhandled: {\n    type: string\n    event: unknown\n  }\n  \"periodic/50\": {\n    value: null\n  }\n  \"periodic/100\": {\n    value: null\n  }\n  \"periodic/1000\": {\n    value: null\n  }\n};\nexport type TxResult<T> = {\n  tx: T\n  events: Event[]\n};\n\n/** Interface that all indexing modules must implement */\nexport interface IndexingModule {\n  indexer: EcleciaIndexer                    // Reference to the main indexer instance\n  name: string                               // Unique module name\n  depends: string[]                          // Array of module names this module depends on\n  provides: string[]                         // Array of capabilities this module provides\n  setup: () => Promise<void>                 // Async setup function for database schema initialization\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  init: (...args: any[]) => void            // Initialization function called by the indexer\n}\n"],"mappings":""}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":["/* eslint-disable @stylistic/no-multi-spaces */\nimport {\n  BlockResponse, BlockResultsResponse,\n} from \"@cosmjs/tendermint-rpc\";\nimport {\n  BlockResultsResponse as BlockResultsResponse38, Event,\n} from \"@cosmjs/tendermint-rpc/build/comet38/responses\";\nimport {\n  Validator,\n} from \"cosmjs-types/cosmos/staking/v1beta1/staking\";\nimport {\n  TxBody,\n} from \"cosmjs-types/cosmos/tx/v1beta1/tx\";\n\nimport {\n  EcleciaIndexer,\n} from \"../indexer\";\nimport {\n  CircularBuffer,\n} from \"../promise-queue\";\n\n/** Configuration interface for the Eclesia indexer */\nexport type EcleciaIndexerConfig = {\n  startHeight?: number                                           // Block height to start indexing from\n  endHeight?: number                                             // Block height to stop indexing at (optional)\n  batchSize: number                                              // Number of blocks to process in parallel\n  modules: string[]                                              // List of module names to enable\n  getNextHeight: () => number | PromiseLike<number>             // Function to determine next block to process\n  logLevel: \"error\" | \"warn\" | \"info\" | \"http\" | \"verbose\" | \"debug\" | \"silly\" // Logging verbosity level\n  rpcUrl: string                                                 // Tendermint RPC endpoint URL\n  shouldProcessGenesis: () => Promise<boolean>                   // Whether to process genesis state\n  genesisPath?: string                                           // Path to genesis file\n  usePolling?: boolean                                           // Use polling instead of WebSocket subscription\n  pollingInterval?: number                                       // Interval between polls in milliseconds\n  minimal?: boolean                                              // Use minimal indexing mode (blocks only)\n  healthCheckPort?: number                                       // Port for health check HTTP server (default: 8080)\n  init?: () => Promise<void>                                     // Custom initialization function\n  beginTransaction: () => Promise<void>                          // Function to begin database transaction\n  endTransaction: (status: boolean) => Promise<void>            // Function to end database transaction\n};\n\n/** Queue for full indexing mode with validator data */\nexport type FullBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse, Uint8Array]>;\n\n/** Queue for minimal indexing mode without validator data */\nexport type MinimalBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse]>;\n\n/** Union type for block queues */\nexport type BlockQueue = FullBlockQueue | MinimalBlockQueue;\n\n/** Utility type to add height, timestamp, and UUID to event types */\nexport type WithHeightAndUUID<T> = {\n  [K in keyof T]: T[K] & {\n    uuid?: string      // Unique identifier for event tracking\n    height?: number    // Block height when event occurred\n    timestamp?: string // Block timestamp when event occurred\n  };\n};\n\n/** Function signature for emitting events asynchronously */\nexport type EmitFunc<K extends keyof WithHeightAndUUID<EventMap>> = (\n  t: K,\n  e: WithHeightAndUUID<EventMap>[K]\n) => Promise<void | void[]>;\n\nexport type LogEvent = {\n  type: \"log\" | \"info\" | \"warning\" | \"error\" | \"verbose\" | \"transient\"\n  message: string\n};\nexport type UUIDEvent = {\n  uuid: string\n  error?: string\n  status: boolean\n};\nexport type Events = {\n  log: LogEvent\n  uuid: UUIDEvent\n  \"fatal-error\": {\n    error: Error\n    message: string\n    retryCount?: number\n  }\n  begin_block: {\n    value: {\n      events: BlockResultsResponse[\"beginBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n      validators: Validator[] | undefined\n    }\n  }\n\n  block: {\n    value: {\n      block: BlockResponse\n      block_results: BlockResultsResponse | BlockResultsResponse38\n    }\n  }\n  end_block: {\n    value: BlockResultsResponse[\"endBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n  }\n  tx_events: {\n    value: BlockResultsResponse[\"results\"] | BlockResultsResponse38[\"results\"]\n  }\n  tx_memo: {\n    value: {\n      txHash: string\n      txBody: TxBody\n    }\n  }\n  _unhandled: {\n    type: string\n    event: unknown\n  }\n  \"periodic/50\": {\n    value: null\n  }\n  \"periodic/100\": {\n    value: null\n  }\n  \"periodic/1000\": {\n    value: null\n  }\n};\nexport type TxResult<T> = {\n  tx: T\n  events: Event[]\n};\n\n/** Interface that all indexing modules must implement */\nexport interface IndexingModule {\n  indexer: EcleciaIndexer                    // Reference to the main indexer instance\n  name: string                               // Unique module name\n  depends: string[]                          // Array of module names this module depends on\n  provides: string[]                         // Array of capabilities this module provides\n  setup: () => Promise<void>                 // Async setup function for database schema initialization\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  init: (...args: any[]) => void            // Initialization function called by the indexer\n}\n"],"mappings":""}

package/dist/types/index.d.cts

@@ -23,6 +23,7 @@ type EcleciaIndexerConfig = {
   usePolling?: boolean;
   pollingInterval?: number;
   minimal?: boolean;
+  healthCheckPort?: number;
   init?: () => Promise<void>;
   beginTransaction: () => Promise<void>;
   endTransaction: (status: boolean) => Promise<void>;
@@ -53,6 +54,11 @@ type UUIDEvent = {
 type Events = {
   log: LogEvent;
   uuid: UUIDEvent;
+  "fatal-error": {
+    error: Error;
+    message: string;
+    retryCount?: number;
+  };
   begin_block: {
     value: {
       events: BlockResultsResponse["beginBlockEvents"] | BlockResultsResponse$1["finalizeBlockEvents"];

package/dist/types/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;KAsBY,oBAAA;;;;;gCAKoB;;;8BAGF;;;;;eAKf;0BACW;EAdd,cAAA,EAAA,CAAA,MAAoB,EAAA,OAAA,EAAA,GAeO,OAfP,CAAA,IAAA,CAAA;CAAA;;AAQF,KAWlB,cAAA,GAAiB,cAXC,CAAA,CAWe,aAXf,EAW8B,oBAX9B,EAWoD,UAXpD,CAAA,CAAA;;AAMJ,KAQd,iBAAA,GAAoB,cARN,CAAA,CAQsB,aARtB,EAQqC,oBARrC,CAAA,CAAA;;AACoB,KAUlC,UAAA,GAAa,cAVqB,GAUJ,iBAVI;AAI9C;AAA0B,KASd,iBATc,CAAA,CAAA,CAAA,GAAA,QAAmB,MAU/B,CAV+B,GAU3B,CAV2B,CAUzB,CAVyB,CAAA,GAAA;EAAe,IAAA,CAAA,EAAA,MAAA;EAAsB,MAAA,CAAA,EAAA,MAAA;EAArD,SAAA,CAAA,EAAA,MAAA;AAAc,CAAA,EAG3C;;AAAgD,KAepC,QAfoC,CAAA,UAAA,MAeX,iBAfW,CAeO,QAfP,CAAA,CAAA,GAAA,CAAA,CAAA,EAgB3C,CAhB2C,EAAA,CAAA,EAiB3C,iBAjB2C,CAiBzB,QAjByB,CAAA,CAiBf,CAjBe,CAAA,EAAA,GAkB3C,OAlB2C,CAAA,IAAA,GAAA,IAAA,EAAA,CAAA;AAAe,KAoBnD,QAAA,GApBmD;MAA/B,EAAA,KAAA,GAAA,MAAA,GAAA,SAAA,GAAA,OAAA,GAAA,SAAA,GAAA,WAAA;EAAc,OAAA,EAAA,MAAA;AAG9C,CAAA;AAAsB,KAqBV,SAAA,GArBU;MAAG,EAAA,MAAA;OAAiB,CAAA,EAAA,MAAA;EAAiB,MAAA,EAAA,OAAA;AAG3D,CAAA;AAA6B,KAuBjB,MAAA,GAvBiB;KACf,EAuBP,QAvBO;MAAI,EAwBV,SAxBU;aAAE,EAAA;IAAC,KAAA,EAAA;MAQT,MAAQ,EAmBN,oBAnBM,CAAA,kBAAA,CAAA,GAmBqC,sBAnBrC,CAAA,qBAAA,CAAA;MAAA,UAAA,EAoBF,SApBE,EAAA,GAAA,SAAA;IAAmC,CAAA;;OAClD,EAAA;IACkB,KAAA,EAAA;MAAlB,KAAA,EAwBQ,aAxBR;MAA4B,aAAA,EAyBZ,oBAzBY,GAyBW,sBAzBX;IAC5B,CAAA;EAAO,CAAA;EAEA,SAAA,EAAQ;IAIR,KAAA,EAsBD,oBAtBU,CAAA,gBAAA,CAAA,GAsB+B,sBAtB/B,CAAA,qBAAA,CAAA;EAKT,CAAA;EAAM,SAAA,EAAA;IACX,KAAA,EAmBI,oBAnBJ,CAAA,SAAA,CAAA,GAmBsC,sBAnBtC,CAAA,SAAA,CAAA;;SAIO,EAAA;IAA2C,KAAA,EAAA;MACvC,MAAA,EAAA,MAAA;MAML,MAAA,EAaC,MAbD;IACQ,CAAA;;YAIV,EAAA;IAAyC,IAAA,EAAA,MAAA;IAGzC,KAAA,EAAA,OAAA;;eAKG,EAAA;IAAM,KAAA,EAAA,IAAA;EAiBR,CAAA;EAAQ,cAAA,EAAA;IACd,KAAA,EAAA,IAAA;;EACS,eAAA,EAAA;IAIE,KAAA,EAAA,IAAA;EAAc,CAAA;;AAKhB,KAXH,QAWG,CAAA,CAAA,CAAA,GAAA;EAAO,EAAA,EAVhB,CAUgB;UATZ;;;UAIO,cAAA;WACN;;;;eAII"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;KAsBY,oBAAA;;;;;gCAKoB;;;8BAGF;;;;;;eAMf;EAdH,gBAAA,EAAA,GAAA,GAec,OAfM,CAAA,IAAA,CAAA;EAAA,cAAA,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,GAgBO,OAhBP,CAAA,IAAA,CAAA;;;AAcjB,KAMH,cAAA,GAAiB,cANd,CAAA,CAM8B,aAN9B,EAM6C,oBAN7C,EAMmE,UANnE,CAAA,CAAA;;AAEwB,KAO3B,iBAAA,GAAoB,cAPO,CAAA,CAOS,aAPT,EAOwB,oBAPxB,CAAA,CAAA;;AAI3B,KAMA,UAAA,GAAa,cANC,GAMgB,iBANhB;;AAAmB,KASjC,iBATiC,CAAA,CAAA,CAAA,GAAA,QAAe,MAU9C,CAV8C,GAU1C,CAV0C,CAUxC,CAVwC,CAAA,GAAA;EAAsB,IAAA,CAAA,EAAA,MAAA;EAArD,MAAA,CAAA,EAAA,MAAA;EAAc,SAAA,CAAA,EAAA,MAAA;AAG/B,CAAA,EAAiB;;AAAkC,KAenD,QAfmD,CAAA,UAAA,MAe1B,iBAf0B,CAeR,QAfQ,CAAA,CAAA,GAAA,CAAA,CAAA,EAgB1D,CAhB0D,EAAA,CAAA,EAiB1D,iBAjB0D,CAiBxC,QAjBwC,CAAA,CAiB9B,CAjB8B,CAAA,EAAA,GAkB1D,OAlB0D,CAAA,IAAA,GAAA,IAAA,EAAA,CAAA;AAA/B,KAoBpB,QAAA,GApBoB;EAAc,IAAA,EAAA,KAAA,GAAA,MAAA,GAAA,SAAA,GAAA,OAAA,GAAA,SAAA,GAAA,WAAA;EAGlC,OAAA,EAAA,MAAU;CAAA;AAAG,KAqBb,SAAA,GArBa;MAAiB,EAAA,MAAA;EAAiB,KAAA,CAAA,EAAA,MAAA;EAG/C,MAAA,EAAA,OAAA;CAAiB;AACf,KAsBF,MAAA,GAtBE;KAAI,EAuBX,QAvBW;MAAE,EAwBZ,SAxBY;EAAC,aAAA,EAAA;IAQT,KAAA,EAkBD,KAlBS;IAAA,OAAA,EAAA,MAAA;IAAmC,UAAA,CAAA,EAAA,MAAA;;aAClD,EAAA;IACkB,KAAA,EAAA;MAAlB,MAAA,EAsBS,oBAtBT,CAAA,kBAAA,CAAA,GAsBoD,sBAtBpD,CAAA,qBAAA,CAAA;MAA4B,UAAA,EAuBf,SAvBe,EAAA,GAAA,SAAA;IAC5B,CAAA;EAAO,CAAA;EAEA,KAAA,EAAA;IAIA,KAAA,EAAA;MAKA,KAAM,EAiBL,aAjBK;MAAA,aAAA,EAkBG,oBAlBH,GAkB0B,sBAlB1B;IACX,CAAA;;WAGI,EAAA;IAMG,KAAA,EAYH,oBAZG,CAAA,gBAAA,CAAA,GAYsC,sBAZtC,CAAA,qBAAA,CAAA;;WACI,EAAA;IAML,KAAA,EAQF,oBARE,CAAA,SAAA,CAAA,GAQgC,sBARhC,CAAA,SAAA,CAAA;;SAC+B,EAAA;IAIjC,KAAA,EAAA;MAAyC,MAAA,EAAA,MAAA;MAGzC,MAAA,EAKG,MALH;IAAkC,CAAA;;EAKzB,UAAA,EAAA;IAiBR,IAAA,EAAA,MAAQ;IAAA,KAAA,EAAA,OAAA;;eAEV,EAAA;IAAK,KAAA,EAAA,IAAA;EAIE,CAAA;EAAc,cAAA,EAAA;IACpB,KAAA,EAAA,IAAA;;EAIW,eAAA,EAAA;;;;KAXV;MACN;UACI;;;UAIO,cAAA;WACN;;;;eAII"}

package/dist/types/index.d.ts

@@ -23,6 +23,7 @@ type EcleciaIndexerConfig = {
   usePolling?: boolean;
   pollingInterval?: number;
   minimal?: boolean;
+  healthCheckPort?: number;
   init?: () => Promise<void>;
   beginTransaction: () => Promise<void>;
   endTransaction: (status: boolean) => Promise<void>;
@@ -53,6 +54,11 @@ type UUIDEvent = {
 type Events = {
   log: LogEvent;
   uuid: UUIDEvent;
+  "fatal-error": {
+    error: Error;
+    message: string;
+    retryCount?: number;
+  };
   begin_block: {
     value: {
       events: BlockResultsResponse["beginBlockEvents"] | BlockResultsResponse$1["finalizeBlockEvents"];

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;KAsBY,oBAAA;;;;;gCAKoB;;;8BAGF;;;;;eAKf;0BACW;EAdd,cAAA,EAAA,CAAA,MAAoB,EAAA,OAAA,EAAA,GAeO,OAfP,CAAA,IAAA,CAAA;CAAA;;AAQF,KAWlB,cAAA,GAAiB,cAXC,CAAA,CAWe,aAXf,EAW8B,oBAX9B,EAWoD,UAXpD,CAAA,CAAA;;AAMJ,KAQd,iBAAA,GAAoB,cARN,CAAA,CAQsB,aARtB,EAQqC,oBARrC,CAAA,CAAA;;AACoB,KAUlC,UAAA,GAAa,cAVqB,GAUJ,iBAVI;AAI9C;AAA0B,KASd,iBATc,CAAA,CAAA,CAAA,GAAA,QAAmB,MAU/B,CAV+B,GAU3B,CAV2B,CAUzB,CAVyB,CAAA,GAAA;EAAe,IAAA,CAAA,EAAA,MAAA;EAAsB,MAAA,CAAA,EAAA,MAAA;EAArD,SAAA,CAAA,EAAA,MAAA;AAAc,CAAA,EAG3C;;AAAgD,KAepC,QAfoC,CAAA,UAAA,MAeX,iBAfW,CAeO,QAfP,CAAA,CAAA,GAAA,CAAA,CAAA,EAgB3C,CAhB2C,EAAA,CAAA,EAiB3C,iBAjB2C,CAiBzB,QAjByB,CAAA,CAiBf,CAjBe,CAAA,EAAA,GAkB3C,OAlB2C,CAAA,IAAA,GAAA,IAAA,EAAA,CAAA;AAAe,KAoBnD,QAAA,GApBmD;MAA/B,EAAA,KAAA,GAAA,MAAA,GAAA,SAAA,GAAA,OAAA,GAAA,SAAA,GAAA,WAAA;EAAc,OAAA,EAAA,MAAA;AAG9C,CAAA;AAAsB,KAqBV,SAAA,GArBU;MAAG,EAAA,MAAA;OAAiB,CAAA,EAAA,MAAA;EAAiB,MAAA,EAAA,OAAA;AAG3D,CAAA;AAA6B,KAuBjB,MAAA,GAvBiB;KACf,EAuBP,QAvBO;MAAI,EAwBV,SAxBU;aAAE,EAAA;IAAC,KAAA,EAAA;MAQT,MAAQ,EAmBN,oBAnBM,CAAA,kBAAA,CAAA,GAmBqC,sBAnBrC,CAAA,qBAAA,CAAA;MAAA,UAAA,EAoBF,SApBE,EAAA,GAAA,SAAA;IAAmC,CAAA;;OAClD,EAAA;IACkB,KAAA,EAAA;MAAlB,KAAA,EAwBQ,aAxBR;MAA4B,aAAA,EAyBZ,oBAzBY,GAyBW,sBAzBX;IAC5B,CAAA;EAAO,CAAA;EAEA,SAAA,EAAQ;IAIR,KAAA,EAsBD,oBAtBU,CAAA,gBAAA,CAAA,GAsB+B,sBAtB/B,CAAA,qBAAA,CAAA;EAKT,CAAA;EAAM,SAAA,EAAA;IACX,KAAA,EAmBI,oBAnBJ,CAAA,SAAA,CAAA,GAmBsC,sBAnBtC,CAAA,SAAA,CAAA;;SAIO,EAAA;IAA2C,KAAA,EAAA;MACvC,MAAA,EAAA,MAAA;MAML,MAAA,EAaC,MAbD;IACQ,CAAA;;YAIV,EAAA;IAAyC,IAAA,EAAA,MAAA;IAGzC,KAAA,EAAA,OAAA;;eAKG,EAAA;IAAM,KAAA,EAAA,IAAA;EAiBR,CAAA;EAAQ,cAAA,EAAA;IACd,KAAA,EAAA,IAAA;;EACS,eAAA,EAAA;IAIE,KAAA,EAAA,IAAA;EAAc,CAAA;;AAKhB,KAXH,QAWG,CAAA,CAAA,CAAA,GAAA;EAAO,EAAA,EAVhB,CAUgB;UATZ;;;UAIO,cAAA;WACN;;;;eAII"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;KAsBY,oBAAA;;;;;gCAKoB;;;8BAGF;;;;;;eAMf;EAdH,gBAAA,EAAA,GAAA,GAec,OAfM,CAAA,IAAA,CAAA;EAAA,cAAA,EAAA,CAAA,MAAA,EAAA,OAAA,EAAA,GAgBO,OAhBP,CAAA,IAAA,CAAA;;;AAcjB,KAMH,cAAA,GAAiB,cANd,CAAA,CAM8B,aAN9B,EAM6C,oBAN7C,EAMmE,UANnE,CAAA,CAAA;;AAEwB,KAO3B,iBAAA,GAAoB,cAPO,CAAA,CAOS,aAPT,EAOwB,oBAPxB,CAAA,CAAA;;AAI3B,KAMA,UAAA,GAAa,cANC,GAMgB,iBANhB;;AAAmB,KASjC,iBATiC,CAAA,CAAA,CAAA,GAAA,QAAe,MAU9C,CAV8C,GAU1C,CAV0C,CAUxC,CAVwC,CAAA,GAAA;EAAsB,IAAA,CAAA,EAAA,MAAA;EAArD,MAAA,CAAA,EAAA,MAAA;EAAc,SAAA,CAAA,EAAA,MAAA;AAG/B,CAAA,EAAiB;;AAAkC,KAenD,QAfmD,CAAA,UAAA,MAe1B,iBAf0B,CAeR,QAfQ,CAAA,CAAA,GAAA,CAAA,CAAA,EAgB1D,CAhB0D,EAAA,CAAA,EAiB1D,iBAjB0D,CAiBxC,QAjBwC,CAAA,CAiB9B,CAjB8B,CAAA,EAAA,GAkB1D,OAlB0D,CAAA,IAAA,GAAA,IAAA,EAAA,CAAA;AAA/B,KAoBpB,QAAA,GApBoB;EAAc,IAAA,EAAA,KAAA,GAAA,MAAA,GAAA,SAAA,GAAA,OAAA,GAAA,SAAA,GAAA,WAAA;EAGlC,OAAA,EAAA,MAAU;CAAA;AAAG,KAqBb,SAAA,GArBa;MAAiB,EAAA,MAAA;EAAiB,KAAA,CAAA,EAAA,MAAA;EAG/C,MAAA,EAAA,OAAA;CAAiB;AACf,KAsBF,MAAA,GAtBE;KAAI,EAuBX,QAvBW;MAAE,EAwBZ,SAxBY;EAAC,aAAA,EAAA;IAQT,KAAA,EAkBD,KAlBS;IAAA,OAAA,EAAA,MAAA;IAAmC,UAAA,CAAA,EAAA,MAAA;;aAClD,EAAA;IACkB,KAAA,EAAA;MAAlB,MAAA,EAsBS,oBAtBT,CAAA,kBAAA,CAAA,GAsBoD,sBAtBpD,CAAA,qBAAA,CAAA;MAA4B,UAAA,EAuBf,SAvBe,EAAA,GAAA,SAAA;IAC5B,CAAA;EAAO,CAAA;EAEA,KAAA,EAAA;IAIA,KAAA,EAAA;MAKA,KAAM,EAiBL,aAjBK;MAAA,aAAA,EAkBG,oBAlBH,GAkB0B,sBAlB1B;IACX,CAAA;;WAGI,EAAA;IAMG,KAAA,EAYH,oBAZG,CAAA,gBAAA,CAAA,GAYsC,sBAZtC,CAAA,qBAAA,CAAA;;WACI,EAAA;IAML,KAAA,EAQF,oBARE,CAAA,SAAA,CAAA,GAQgC,sBARhC,CAAA,SAAA,CAAA;;SAC+B,EAAA;IAIjC,KAAA,EAAA;MAAyC,MAAA,EAAA,MAAA;MAGzC,MAAA,EAKG,MALH;IAAkC,CAAA;;EAKzB,UAAA,EAAA;IAiBR,IAAA,EAAA,MAAQ;IAAA,KAAA,EAAA,OAAA;;eAEV,EAAA;IAAK,KAAA,EAAA,IAAA;EAIE,CAAA;EAAc,cAAA,EAAA;IACpB,KAAA,EAAA,IAAA;;EAIW,eAAA,EAAA;;;;KAXV;MACN;UACI;;;UAIO,cAAA;WACN;;;;eAII"}

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":["/* eslint-disable @stylistic/no-multi-spaces */\nimport {\n  BlockResponse, BlockResultsResponse,\n} from \"@cosmjs/tendermint-rpc\";\nimport {\n  BlockResultsResponse as BlockResultsResponse38, Event,\n} from \"@cosmjs/tendermint-rpc/build/comet38/responses\";\nimport {\n  Validator,\n} from \"cosmjs-types/cosmos/staking/v1beta1/staking\";\nimport {\n  TxBody,\n} from \"cosmjs-types/cosmos/tx/v1beta1/tx\";\n\nimport {\n  EcleciaIndexer,\n} from \"../indexer\";\nimport {\n  CircularBuffer,\n} from \"../promise-queue\";\n\n/** Configuration interface for the Eclesia indexer */\nexport type EcleciaIndexerConfig = {\n  startHeight?: number                                           // Block height to start indexing from\n  endHeight?: number                                             // Block height to stop indexing at (optional)\n  batchSize: number                                              // Number of blocks to process in parallel\n  modules: string[]                                              // List of module names to enable\n  getNextHeight: () => number | PromiseLike<number>             // Function to determine next block to process\n  logLevel: \"error\" | \"warn\" | \"info\" | \"http\" | \"verbose\" | \"debug\" | \"silly\" // Logging verbosity level\n  rpcUrl: string                                                 // Tendermint RPC endpoint URL\n  shouldProcessGenesis: () => Promise<boolean>                   // Whether to process genesis state\n  genesisPath?: string                                           // Path to genesis file\n  usePolling?: boolean                                           // Use polling instead of WebSocket subscription\n  pollingInterval?: number                                       // Interval between polls in milliseconds\n  minimal?: boolean                                              // Use minimal indexing mode (blocks only)\n  init?: () => Promise<void>                                     // Custom initialization function\n  beginTransaction: () => Promise<void>                          // Function to begin database transaction\n  endTransaction: (status: boolean) => Promise<void>            // Function to end database transaction\n};\n\n/** Queue for full indexing mode with validator data */\nexport type FullBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse, Uint8Array]>;\n\n/** Queue for minimal indexing mode without validator data */\nexport type MinimalBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse]>;\n\n/** Union type for block queues */\nexport type BlockQueue = FullBlockQueue | MinimalBlockQueue;\n\n/** Utility type to add height, timestamp, and UUID to event types */\nexport type WithHeightAndUUID<T> = {\n  [K in keyof T]: T[K] & {\n    uuid?: string      // Unique identifier for event tracking\n    height?: number    // Block height when event occurred\n    timestamp?: string // Block timestamp when event occurred\n  };\n};\n\n/** Function signature for emitting events asynchronously */\nexport type EmitFunc<K extends keyof WithHeightAndUUID<EventMap>> = (\n  t: K,\n  e: WithHeightAndUUID<EventMap>[K]\n) => Promise<void | void[]>;\n\nexport type LogEvent = {\n  type: \"log\" | \"info\" | \"warning\" | \"error\" | \"verbose\" | \"transient\"\n  message: string\n};\nexport type UUIDEvent = {\n  uuid: string\n  error?: string\n  status: boolean\n};\nexport type Events = {\n  log: LogEvent\n  uuid: UUIDEvent\n  begin_block: {\n    value: {\n      events: BlockResultsResponse[\"beginBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n      validators: Validator[] | undefined\n    }\n  }\n\n  block: {\n    value: {\n      block: BlockResponse\n      block_results: BlockResultsResponse | BlockResultsResponse38\n    }\n  }\n  end_block: {\n    value: BlockResultsResponse[\"endBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n  }\n  tx_events: {\n    value: BlockResultsResponse[\"results\"] | BlockResultsResponse38[\"results\"]\n  }\n  tx_memo: {\n    value: {\n      txHash: string\n      txBody: TxBody\n    }\n  }\n  _unhandled: {\n    type: string\n    event: unknown\n  }\n  \"periodic/50\": {\n    value: null\n  }\n  \"periodic/100\": {\n    value: null\n  }\n  \"periodic/1000\": {\n    value: null\n  }\n};\nexport type TxResult<T> = {\n  tx: T\n  events: Event[]\n};\n\n/** Interface that all indexing modules must implement */\nexport interface IndexingModule {\n  indexer: EcleciaIndexer                    // Reference to the main indexer instance\n  name: string                               // Unique module name\n  depends: string[]                          // Array of module names this module depends on\n  provides: string[]                         // Array of capabilities this module provides\n  setup: () => Promise<void>                 // Async setup function for database schema initialization\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  init: (...args: any[]) => void            // Initialization function called by the indexer\n}\n"],"mappings":""}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/types/index.ts"],"sourcesContent":["/* eslint-disable @stylistic/no-multi-spaces */\nimport {\n  BlockResponse, BlockResultsResponse,\n} from \"@cosmjs/tendermint-rpc\";\nimport {\n  BlockResultsResponse as BlockResultsResponse38, Event,\n} from \"@cosmjs/tendermint-rpc/build/comet38/responses\";\nimport {\n  Validator,\n} from \"cosmjs-types/cosmos/staking/v1beta1/staking\";\nimport {\n  TxBody,\n} from \"cosmjs-types/cosmos/tx/v1beta1/tx\";\n\nimport {\n  EcleciaIndexer,\n} from \"../indexer\";\nimport {\n  CircularBuffer,\n} from \"../promise-queue\";\n\n/** Configuration interface for the Eclesia indexer */\nexport type EcleciaIndexerConfig = {\n  startHeight?: number                                           // Block height to start indexing from\n  endHeight?: number                                             // Block height to stop indexing at (optional)\n  batchSize: number                                              // Number of blocks to process in parallel\n  modules: string[]                                              // List of module names to enable\n  getNextHeight: () => number | PromiseLike<number>             // Function to determine next block to process\n  logLevel: \"error\" | \"warn\" | \"info\" | \"http\" | \"verbose\" | \"debug\" | \"silly\" // Logging verbosity level\n  rpcUrl: string                                                 // Tendermint RPC endpoint URL\n  shouldProcessGenesis: () => Promise<boolean>                   // Whether to process genesis state\n  genesisPath?: string                                           // Path to genesis file\n  usePolling?: boolean                                           // Use polling instead of WebSocket subscription\n  pollingInterval?: number                                       // Interval between polls in milliseconds\n  minimal?: boolean                                              // Use minimal indexing mode (blocks only)\n  healthCheckPort?: number                                       // Port for health check HTTP server (default: 8080)\n  init?: () => Promise<void>                                     // Custom initialization function\n  beginTransaction: () => Promise<void>                          // Function to begin database transaction\n  endTransaction: (status: boolean) => Promise<void>            // Function to end database transaction\n};\n\n/** Queue for full indexing mode with validator data */\nexport type FullBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse, Uint8Array]>;\n\n/** Queue for minimal indexing mode without validator data */\nexport type MinimalBlockQueue = CircularBuffer<[BlockResponse, BlockResultsResponse]>;\n\n/** Union type for block queues */\nexport type BlockQueue = FullBlockQueue | MinimalBlockQueue;\n\n/** Utility type to add height, timestamp, and UUID to event types */\nexport type WithHeightAndUUID<T> = {\n  [K in keyof T]: T[K] & {\n    uuid?: string      // Unique identifier for event tracking\n    height?: number    // Block height when event occurred\n    timestamp?: string // Block timestamp when event occurred\n  };\n};\n\n/** Function signature for emitting events asynchronously */\nexport type EmitFunc<K extends keyof WithHeightAndUUID<EventMap>> = (\n  t: K,\n  e: WithHeightAndUUID<EventMap>[K]\n) => Promise<void | void[]>;\n\nexport type LogEvent = {\n  type: \"log\" | \"info\" | \"warning\" | \"error\" | \"verbose\" | \"transient\"\n  message: string\n};\nexport type UUIDEvent = {\n  uuid: string\n  error?: string\n  status: boolean\n};\nexport type Events = {\n  log: LogEvent\n  uuid: UUIDEvent\n  \"fatal-error\": {\n    error: Error\n    message: string\n    retryCount?: number\n  }\n  begin_block: {\n    value: {\n      events: BlockResultsResponse[\"beginBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n      validators: Validator[] | undefined\n    }\n  }\n\n  block: {\n    value: {\n      block: BlockResponse\n      block_results: BlockResultsResponse | BlockResultsResponse38\n    }\n  }\n  end_block: {\n    value: BlockResultsResponse[\"endBlockEvents\"] | BlockResultsResponse38[\"finalizeBlockEvents\"]\n  }\n  tx_events: {\n    value: BlockResultsResponse[\"results\"] | BlockResultsResponse38[\"results\"]\n  }\n  tx_memo: {\n    value: {\n      txHash: string\n      txBody: TxBody\n    }\n  }\n  _unhandled: {\n    type: string\n    event: unknown\n  }\n  \"periodic/50\": {\n    value: null\n  }\n  \"periodic/100\": {\n    value: null\n  }\n  \"periodic/1000\": {\n    value: null\n  }\n};\nexport type TxResult<T> = {\n  tx: T\n  events: Event[]\n};\n\n/** Interface that all indexing modules must implement */\nexport interface IndexingModule {\n  indexer: EcleciaIndexer                    // Reference to the main indexer instance\n  name: string                               // Unique module name\n  depends: string[]                          // Array of module names this module depends on\n  provides: string[]                         // Array of capabilities this module provides\n  setup: () => Promise<void>                 // Async setup function for database schema initialization\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  init: (...args: any[]) => void            // Initialization function called by the indexer\n}\n"],"mappings":""}

package/dist/utils/bech32.cjs

@@ -1,6 +1,5 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 let bech32 = require("bech32");
-bech32 = require_rolldown_runtime.__toESM(bech32);
 
 //#region src/utils/bech32.ts
 /**

package/dist/utils/bech32.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"bech32.cjs","names":[],"sources":["../../src/utils/bech32.ts"],"sourcesContent":["import {\n  bech32,\n} from \"bech32\";\n\n/**\n * Converts a byte array to a hexadecimal string representation\n * @param byteArray - Array of bytes to convert\n * @returns Hexadecimal string\n */\nfunction toHexString(byteArray: number[]) {\n  return Array.prototype.map\n    .call(\n      byteArray, (byte) => {\n        return (\"0\" + (byte & 0xff).toString(16)).slice(-2);\n      },\n    )\n    .join(\"\");\n}\n\n/**\n * Extracts the key hash from a bech32-encoded address\n * @param address - Bech32-encoded address string\n * @returns Hexadecimal key hash\n * @throws Error if address cannot be decoded\n */\nfunction keyHashfromAddress(address: string): string {\n  try {\n    return toHexString(bech32.fromWords(bech32.decode(address).words));\n  }\n  catch (_e) {\n    throw new Error(\"Could not decode address\");\n  }\n}\n\n/**\n * Creates a bech32-encoded address from a key hash and prefix\n * @param prefix - Address prefix (e.g., \"cosmos\", \"cosmosvalcons\")\n * @param keyhash - Hexadecimal key hash\n * @returns Bech32-encoded address or empty string if keyhash is empty\n */\nfunction chainAddressfromKeyhash(prefix: string, keyhash: string) {\n  const words = bech32.toWords(Buffer.from(\n    keyhash, \"hex\",\n  ));\n\n  return keyhash !== \"\"\n    ? bech32.encode(\n      prefix, words,\n    )\n    : \"\";\n}\n\nexport {\n  chainAddressfromKeyhash, keyHashfromAddress, toHexString,\n};\n"],"mappings":";;;;;;;;;;AASA,SAAS,YAAY,WAAqB;AACxC,QAAO,MAAM,UAAU,IACpB,KACC,YAAY,SAAS;AACnB,UAAQ,OAAO,OAAO,KAAM,SAAS,GAAG,EAAE,MAAM,GAAG;GAEtD,CACA,KAAK,GAAG;;;;;;;;AASb,SAAS,mBAAmB,SAAyB;AACnD,KAAI;AACF,SAAO,YAAY,cAAO,UAAU,cAAO,OAAO,QAAQ,CAAC,MAAM,CAAC;UAE7D,IAAI;AACT,QAAM,IAAI,MAAM,2BAA2B;;;;;;;;;AAU/C,SAAS,wBAAwB,QAAgB,SAAiB;CAChE,MAAM,QAAQ,cAAO,QAAQ,OAAO,KAClC,SAAS,MACV,CAAC;AAEF,QAAO,YAAY,KACf,cAAO,OACP,QAAQ,MACT,GACC"}
+{"version":3,"file":"bech32.cjs","names":[],"sources":["../../src/utils/bech32.ts"],"sourcesContent":["import {\n  bech32,\n} from \"bech32\";\n\n/**\n * Converts a byte array to a hexadecimal string representation\n * @param byteArray - Array of bytes to convert\n * @returns Hexadecimal string\n */\nfunction toHexString(byteArray: number[]) {\n  return Array.prototype.map\n    .call(\n      byteArray, (byte) => {\n        return (\"0\" + (byte & 0xff).toString(16)).slice(-2);\n      },\n    )\n    .join(\"\");\n}\n\n/**\n * Extracts the key hash from a bech32-encoded address\n * @param address - Bech32-encoded address string\n * @returns Hexadecimal key hash\n * @throws Error if address cannot be decoded\n */\nfunction keyHashfromAddress(address: string): string {\n  try {\n    return toHexString(bech32.fromWords(bech32.decode(address).words));\n  }\n  catch (_e) {\n    throw new Error(\"Could not decode address\");\n  }\n}\n\n/**\n * Creates a bech32-encoded address from a key hash and prefix\n * @param prefix - Address prefix (e.g., \"cosmos\", \"cosmosvalcons\")\n * @param keyhash - Hexadecimal key hash\n * @returns Bech32-encoded address or empty string if keyhash is empty\n */\nfunction chainAddressfromKeyhash(prefix: string, keyhash: string) {\n  const words = bech32.toWords(Buffer.from(\n    keyhash, \"hex\",\n  ));\n\n  return keyhash !== \"\"\n    ? bech32.encode(\n      prefix, words,\n    )\n    : \"\";\n}\n\nexport {\n  chainAddressfromKeyhash, keyHashfromAddress, toHexString,\n};\n"],"mappings":";;;;;;;;;AASA,SAAS,YAAY,WAAqB;AACxC,QAAO,MAAM,UAAU,IACpB,KACC,YAAY,SAAS;AACnB,UAAQ,OAAO,OAAO,KAAM,SAAS,GAAG,EAAE,MAAM,GAAG;GAEtD,CACA,KAAK,GAAG;;;;;;;;AASb,SAAS,mBAAmB,SAAyB;AACnD,KAAI;AACF,SAAO,YAAY,cAAO,UAAU,cAAO,OAAO,QAAQ,CAAC,MAAM,CAAC;UAE7D,IAAI;AACT,QAAM,IAAI,MAAM,2BAA2B;;;;;;;;;AAU/C,SAAS,wBAAwB,QAAgB,SAAiB;CAChE,MAAM,QAAQ,cAAO,QAAQ,OAAO,KAClC,SAAS,MACV,CAAC;AAEF,QAAO,YAAY,KACf,cAAO,OACP,QAAQ,MACT,GACC"}

package/dist/utils/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["// Utility function exports\nexport * from \"./bech32\";  // Bech32 address encoding/decoding utilities\nexport * from \"./bigint\";  // BigInt handling utilities\nexport * from \"./text\";    // Text processing and encoding utilities\n"],"mappings":""}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["/* eslint-disable @stylistic/no-multi-spaces */\n// Utility function exports\nexport * from \"./bech32\";  // Bech32 address encoding/decoding utilities\nexport * from \"./bigint\";  // BigInt handling utilities\nexport * from \"./text\";    // Text processing and encoding utilities\n"],"mappings":""}

package/dist/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["// Utility function exports\nexport * from \"./bech32\";  // Bech32 address encoding/decoding utilities\nexport * from \"./bigint\";  // BigInt handling utilities\nexport * from \"./text\";    // Text processing and encoding utilities\n"],"mappings":""}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/utils/index.ts"],"sourcesContent":["/* eslint-disable @stylistic/no-multi-spaces */\n// Utility function exports\nexport * from \"./bech32\";  // Bech32 address encoding/decoding utilities\nexport * from \"./bigint\";  // BigInt handling utilities\nexport * from \"./text\";    // Text processing and encoding utilities\n"],"mappings":""}