@eclesia/indexer-engine 2.12.0 → 2.14.0

package/dist/constants.cjs

@@ -27,6 +27,11 @@ const DEFAULT_PROMETHEUS_PORT = 9090;
 */
 const DEFAULT_POLLING_INTERVAL_MS = 5e3;
 /**
+* Timeout for connecting to the Tendermint RPC in milliseconds
+* If connection is not established within this time, it will be aborted
+*/
+const CONNECT_TIMEOUT_MS = 1e4;
+/**
 * Timeout for RPC calls in milliseconds
 * If a call takes longer than this, it will be rejected
 */
@@ -64,6 +69,7 @@ const PAGINATION_LIMITS = {
 const GENESIS_BATCH_SIZE = 1e3;
 
 //#endregion
+exports.CONNECT_TIMEOUT_MS = CONNECT_TIMEOUT_MS;
 exports.DB_CLIENT_RECYCLE_COUNT = DB_CLIENT_RECYCLE_COUNT;
 exports.DEFAULT_BATCH_SIZE = DEFAULT_BATCH_SIZE;
 exports.DEFAULT_HEALTH_CHECK_PORT = DEFAULT_HEALTH_CHECK_PORT;

package/dist/constants.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.cjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * Timeout for block queue dequeue operations in milliseconds\n * If no block is available within this time, an error will be thrown\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;AAMxC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}
+{"version":3,"file":"constants.cjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for connecting to the Tendermint RPC in milliseconds\n * If connection is not established within this time, it will be aborted\n  */\nexport const CONNECT_TIMEOUT_MS = 10000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * Timeout for block queue dequeue operations in milliseconds\n * If no block is available within this time, an error will be thrown\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,qBAAqB;;;;;AAMlC,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;AAMxC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}

package/dist/constants.d.cts

@@ -25,6 +25,11 @@ declare const DEFAULT_PROMETHEUS_PORT = 9090;
  * Default polling interval in milliseconds when using polling mode instead of WebSocket
  */
 declare const DEFAULT_POLLING_INTERVAL_MS = 5000;
+/**
+ * Timeout for connecting to the Tendermint RPC in milliseconds
+ * If connection is not established within this time, it will be aborted
+  */
+declare const CONNECT_TIMEOUT_MS = 10000;
 /**
  * Timeout for RPC calls in milliseconds
  * If a call takes longer than this, it will be rejected
@@ -67,5 +72,5 @@ declare const PAGINATION_LIMITS: {
  */
 declare const GENESIS_BATCH_SIZE = 1000;
 //#endregion
-export { DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
+export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
 //# sourceMappingURL=constants.d.cts.map

package/dist/constants.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.cts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAMa,cA5CA,kBAAA,GAmDH,GAAA;AAKV;AAWA;;cA9Da,oBAAA;;;;cAKA,yBAAA;;;;cAKA,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}
+{"version":3,"file":"constants.d.cts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAMa,cA5CA,kBAAA,GA4CuB,GAAA;AAMpC;AAYA;AAWA;cApEa,oBAAA;;;;cAKA,yBAAA;;;;cAKA,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,kBAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}

package/dist/constants.d.mts

@@ -25,6 +25,11 @@ declare const DEFAULT_PROMETHEUS_PORT = 9090;
  * Default polling interval in milliseconds when using polling mode instead of WebSocket
  */
 declare const DEFAULT_POLLING_INTERVAL_MS = 5000;
+/**
+ * Timeout for connecting to the Tendermint RPC in milliseconds
+ * If connection is not established within this time, it will be aborted
+  */
+declare const CONNECT_TIMEOUT_MS = 10000;
 /**
  * Timeout for RPC calls in milliseconds
  * If a call takes longer than this, it will be rejected
@@ -67,5 +72,5 @@ declare const PAGINATION_LIMITS: {
  */
 declare const GENESIS_BATCH_SIZE = 1000;
 //#endregion
-export { DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
+export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
 //# sourceMappingURL=constants.d.mts.map

package/dist/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAMa,cA5CA,kBAAA,GAmDH,GAAA;AAKV;AAWA;;cA9Da,oBAAA;;;;cAKA,yBAAA;;;;cAKA,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"sourcesContent":[],"mappings":";;AAUA;AAKA;AAKA;AAKA;AAKA;AAMA;AAMA;AAMA;AAMa,cA5CA,kBAAA,GA4CuB,GAAA;AAMpC;AAYA;AAWA;cApEa,oBAAA;;;;cAKA,yBAAA;;;;cAKA,uBAAA;;;;cAKA,2BAAA;;;;;cAMA,kBAAA;;;;;cAMA,cAAA;;;;;cAMA,wBAAA;;;;;cAMA,uBAAA;;;;;cAMA;;;;;;;;;;;cAYA;;;;;;;;;;cAWA,kBAAA"}

package/dist/constants.mjs

@@ -26,6 +26,11 @@ const DEFAULT_PROMETHEUS_PORT = 9090;
 */
 const DEFAULT_POLLING_INTERVAL_MS = 5e3;
 /**
+* Timeout for connecting to the Tendermint RPC in milliseconds
+* If connection is not established within this time, it will be aborted
+*/
+const CONNECT_TIMEOUT_MS = 1e4;
+/**
 * Timeout for RPC calls in milliseconds
 * If a call takes longer than this, it will be rejected
 */
@@ -63,5 +68,5 @@ const PAGINATION_LIMITS = {
 const GENESIS_BATCH_SIZE = 1e3;
 
 //#endregion
-export { DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
+export { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS };
 //# sourceMappingURL=constants.mjs.map

package/dist/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * Timeout for block queue dequeue operations in milliseconds\n * If no block is available within this time, an error will be thrown\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;AAMxC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}
+{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Configuration constants for the Eclesia indexer\n * These values control performance, timeouts, and connection management\n */\n\n/**\n * Number of blocks to prefetch and keep in the processing queue\n * Higher values increase memory usage but improve throughput\n * Recommended range: 300-1000 depending on block size and available memory\n */\nexport const DEFAULT_BATCH_SIZE = 500;\n\n/**\n * Default start height for indexing when no previous height is found\n */\nexport const DEFAULT_START_HEIGHT = 1;\n\n/**\n * Default port for health check HTTP server\n */\nexport const DEFAULT_HEALTH_CHECK_PORT = 8888;\n\n/**\n * Default port for Prometheus metrics server\n */\nexport const DEFAULT_PROMETHEUS_PORT = 9090;\n\n/**\n * Default polling interval in milliseconds when using polling mode instead of WebSocket\n */\nexport const DEFAULT_POLLING_INTERVAL_MS = 5000;\n\n/**\n * Timeout for connecting to the Tendermint RPC in milliseconds\n * If connection is not established within this time, it will be aborted\n  */\nexport const CONNECT_TIMEOUT_MS = 10000;\n\n/**\n * Timeout for RPC calls in milliseconds\n * If a call takes longer than this, it will be rejected\n */\nexport const RPC_TIMEOUT_MS = 20000;\n\n/**\n * Timeout for block queue dequeue operations in milliseconds\n * If no block is available within this time, an error will be thrown\n */\nexport const QUEUE_DEQUEUE_TIMEOUT_MS = 30000;\n\n/**\n * Number of successful transactions before recycling the database client\n * Prevents long-running connection issues and stale connections\n */\nexport const DB_CLIENT_RECYCLE_COUNT = 1500;\n\n/**\n * Block intervals for periodic event emission\n * Used for operations that should run at regular block intervals\n */\nexport const PERIODIC_INTERVALS = {\n  /** Emit periodic event every 50 blocks */\n  SMALL: 50,\n  /** Emit periodic event every 100 blocks */\n  MEDIUM: 100,\n  /** Emit periodic event every 1000 blocks - used for performance logging */\n  LARGE: 1000,\n} as const;\n\n/**\n * Pagination limits for blockchain queries\n */\nexport const PAGINATION_LIMITS = {\n  /** Default limit for validator queries */\n  VALIDATORS: 1000n,\n  /** Default limit for delegation queries */\n  DELEGATIONS: 250n,\n} as const;\n\n/**\n * Batch size for streaming genesis file processing\n * Number of entries to process at once from genesis JSON\n */\nexport const GENESIS_BATCH_SIZE = 1000;\n"],"mappings":";;;;;;;;;;AAUA,MAAa,qBAAqB;;;;AAKlC,MAAa,uBAAuB;;;;AAKpC,MAAa,4BAA4B;;;;AAKzC,MAAa,0BAA0B;;;;AAKvC,MAAa,8BAA8B;;;;;AAM3C,MAAa,qBAAqB;;;;;AAMlC,MAAa,iBAAiB;;;;;AAM9B,MAAa,2BAA2B;;;;;AAMxC,MAAa,0BAA0B;;;;;AAMvC,MAAa,qBAAqB;CAEhC,OAAO;CAEP,QAAQ;CAER,OAAO;CACR;;;;AAKD,MAAa,oBAAoB;CAE/B,YAAY;CAEZ,aAAa;CACd;;;;;AAMD,MAAa,qBAAqB"}

package/dist/index.cjs

@@ -10,6 +10,7 @@ const require_index$7 = require('./mocks/index.cjs');
 const require_index$8 = require('./types/index.cjs');
 
 exports.BlockProcessingError = require_index$1.BlockProcessingError;
+exports.CONNECT_TIMEOUT_MS = require_constants.CONNECT_TIMEOUT_MS;
 exports.CircularBuffer = require_index$3.CircularBuffer;
 exports.ConfigurationError = require_index$1.ConfigurationError;
 exports.DB_CLIENT_RECYCLE_COUNT = require_constants.DB_CLIENT_RECYCLE_COUNT;

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS } from "./constants.cjs";
+import { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS } from "./constants.cjs";
 import { IndexerMetrics } from "./metrics/index.cjs";
 import { EcleciaIndexer, defaultIndexerConfig } from "./indexer/index.cjs";
 import { CircularBuffer, PromiseQueue } from "./promise-queue/index.cjs";
@@ -8,4 +8,4 @@ import { BlockProcessingError, ConfigurationError, DatabaseError, GenesisError,
 import { index_d_exports } from "./mocks/index.cjs";
 import { index_d_exports as index_d_exports$2 } from "./utils/index.cjs";
 import { index_d_exports as index_d_exports$3 } from "./validation/index.cjs";
-export { BlockProcessingError, CircularBuffer, ConfigurationError, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, DatabaseError, EcleciaIndexer, EclesiaEmitter, GENESIS_BATCH_SIZE, GenesisError, IndexerError, IndexerMetrics, index_d_exports as Mocks, ModuleError, PAGINATION_LIMITS, PERIODIC_INTERVALS, PromiseQueue, QUEUE_DEQUEUE_TIMEOUT_MS, RPCError, RPC_TIMEOUT_MS, index_d_exports$1 as Types, index_d_exports$2 as Utils, index_d_exports$3 as Validation, defaultIndexerConfig };
+export { BlockProcessingError, CONNECT_TIMEOUT_MS, CircularBuffer, ConfigurationError, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, DatabaseError, EcleciaIndexer, EclesiaEmitter, GENESIS_BATCH_SIZE, GenesisError, IndexerError, IndexerMetrics, index_d_exports as Mocks, ModuleError, PAGINATION_LIMITS, PERIODIC_INTERVALS, PromiseQueue, QUEUE_DEQUEUE_TIMEOUT_MS, RPCError, RPC_TIMEOUT_MS, index_d_exports$1 as Types, index_d_exports$2 as Utils, index_d_exports$3 as Validation, defaultIndexerConfig };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS } from "./constants.mjs";
+import { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS } from "./constants.mjs";
 import { IndexerMetrics } from "./metrics/index.mjs";
 import { EcleciaIndexer, defaultIndexerConfig } from "./indexer/index.mjs";
 import { CircularBuffer, PromiseQueue } from "./promise-queue/index.mjs";
@@ -8,4 +8,4 @@ import { BlockProcessingError, ConfigurationError, DatabaseError, GenesisError,
 import { index_d_exports } from "./mocks/index.mjs";
 import { index_d_exports as index_d_exports$2 } from "./utils/index.mjs";
 import { index_d_exports as index_d_exports$3 } from "./validation/index.mjs";
-export { BlockProcessingError, CircularBuffer, ConfigurationError, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, DatabaseError, EcleciaIndexer, EclesiaEmitter, GENESIS_BATCH_SIZE, GenesisError, IndexerError, IndexerMetrics, index_d_exports as Mocks, ModuleError, PAGINATION_LIMITS, PERIODIC_INTERVALS, PromiseQueue, QUEUE_DEQUEUE_TIMEOUT_MS, RPCError, RPC_TIMEOUT_MS, index_d_exports$1 as Types, index_d_exports$2 as Utils, index_d_exports$3 as Validation, defaultIndexerConfig };
+export { BlockProcessingError, CONNECT_TIMEOUT_MS, CircularBuffer, ConfigurationError, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, DatabaseError, EcleciaIndexer, EclesiaEmitter, GENESIS_BATCH_SIZE, GenesisError, IndexerError, IndexerMetrics, index_d_exports as Mocks, ModuleError, PAGINATION_LIMITS, PERIODIC_INTERVALS, PromiseQueue, QUEUE_DEQUEUE_TIMEOUT_MS, RPCError, RPC_TIMEOUT_MS, index_d_exports$1 as Types, index_d_exports$2 as Utils, index_d_exports$3 as Validation, defaultIndexerConfig };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS } from "./constants.mjs";
+import { CONNECT_TIMEOUT_MS, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, GENESIS_BATCH_SIZE, PAGINATION_LIMITS, PERIODIC_INTERVALS, QUEUE_DEQUEUE_TIMEOUT_MS, RPC_TIMEOUT_MS } from "./constants.mjs";
 import { EclesiaEmitter } from "./emitter/index.mjs";
 import { BlockProcessingError, ConfigurationError, DatabaseError, GenesisError, IndexerError, ModuleError, RPCError } from "./errors/index.mjs";
 import { IndexerMetrics } from "./metrics/index.mjs";
@@ -9,4 +9,4 @@ import { EcleciaIndexer, defaultIndexerConfig } from "./indexer/index.mjs";
 import { mocks_exports } from "./mocks/index.mjs";
 import { types_exports } from "./types/index.mjs";
 
-export { BlockProcessingError, CircularBuffer, ConfigurationError, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, DatabaseError, EcleciaIndexer, EclesiaEmitter, GENESIS_BATCH_SIZE, GenesisError, IndexerError, IndexerMetrics, mocks_exports as Mocks, ModuleError, PAGINATION_LIMITS, PERIODIC_INTERVALS, PromiseQueue, QUEUE_DEQUEUE_TIMEOUT_MS, RPCError, RPC_TIMEOUT_MS, types_exports as Types, utils_exports as Utils, validation_exports as Validation, defaultIndexerConfig };
+export { BlockProcessingError, CONNECT_TIMEOUT_MS, CircularBuffer, ConfigurationError, DB_CLIENT_RECYCLE_COUNT, DEFAULT_BATCH_SIZE, DEFAULT_HEALTH_CHECK_PORT, DEFAULT_POLLING_INTERVAL_MS, DEFAULT_PROMETHEUS_PORT, DEFAULT_START_HEIGHT, DatabaseError, EcleciaIndexer, EclesiaEmitter, GENESIS_BATCH_SIZE, GenesisError, IndexerError, IndexerMetrics, mocks_exports as Mocks, ModuleError, PAGINATION_LIMITS, PERIODIC_INTERVALS, PromiseQueue, QUEUE_DEQUEUE_TIMEOUT_MS, RPCError, RPC_TIMEOUT_MS, types_exports as Types, utils_exports as Utils, validation_exports as Validation, defaultIndexerConfig };

package/dist/indexer/index.cjs

@@ -1,11 +1,12 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_constants = require('../constants.cjs');
 const require_index = require('../emitter/index.cjs');
-const require_index$1 = require('../metrics/index.cjs');
-const require_index$2 = require('../promise-queue/index.cjs');
+const require_index$1 = require('../errors/index.cjs');
+const require_index$2 = require('../metrics/index.cjs');
+const require_index$3 = require('../promise-queue/index.cjs');
 const require_text = require('../utils/text.cjs');
 require('../utils/index.cjs');
-const require_index$4 = require('../validation/index.cjs');
+const require_index$5 = require('../validation/index.cjs');
 let crypto = require("crypto");
 let fs = require("fs");
 fs = require_rolldown_runtime.__toESM(fs);
@@ -95,13 +96,13 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 	*/
 	constructor(config) {
 		super();
-		require_index$4.validateUrl(config.rpcUrl, "rpcUrl");
-		require_index$4.validatePositiveInteger(config.batchSize, "batchSize");
-		if (config.genesisPath) require_index$4.validateFilePath(config.genesisPath, "genesisPath");
-		if (config.healthCheckPort !== void 0) require_index$4.validatePort(config.healthCheckPort, "healthCheckPort");
-		if (config.prometheusPort !== void 0) require_index$4.validatePort(config.prometheusPort, "prometheusPort");
-		if (config.startHeight !== void 0) require_index$4.validatePositiveInteger(config.startHeight, "startHeight");
-		if (config.pollingInterval !== void 0) require_index$4.validatePositiveInteger(config.pollingInterval, "pollingInterval");
+		require_index$5.validateUrl(config.rpcUrl, "rpcUrl");
+		require_index$5.validatePositiveInteger(config.batchSize, "batchSize");
+		if (config.genesisPath) require_index$5.validateFilePath(config.genesisPath, "genesisPath");
+		if (config.healthCheckPort !== void 0) require_index$5.validatePort(config.healthCheckPort, "healthCheckPort");
+		if (config.prometheusPort !== void 0) require_index$5.validatePort(config.prometheusPort, "prometheusPort");
+		if (config.startHeight !== void 0) require_index$5.validatePositiveInteger(config.startHeight, "startHeight");
+		if (config.pollingInterval !== void 0) require_index$5.validatePositiveInteger(config.pollingInterval, "pollingInterval");
 		this.config = {
 			...defaultIndexerConfig,
 			...config
@@ -126,8 +127,8 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			this.prometheus?.recordError("rpc");
 			this.log.error("Error enqueueing block data: " + e);
 		};
-		if (this.config.minimal) this.blockQueue = new require_index$2.CircularBuffer(this.config.batchSize, queueErrorHandler);
-		else this.blockQueue = new require_index$2.CircularBuffer(this.config.batchSize, queueErrorHandler);
+		if (this.config.minimal) this.blockQueue = new require_index$3.CircularBuffer(this.config.batchSize, queueErrorHandler);
+		else this.blockQueue = new require_index$3.CircularBuffer(this.config.batchSize, queueErrorHandler);
 		this.on("_unhandled", (msg) => {
 			if (msg.uuid) {
 				this.log.verbose("Unhandled event: " + msg.type);
@@ -138,7 +139,7 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			}
 		});
 		if (this.config.enablePrometheus) {
-			this.prometheus = new require_index$1.IndexerMetrics();
+			this.prometheus = new require_index$2.IndexerMetrics();
 			this.prometheusServer = (0, fastify.default)({ logger: false });
 			this.prometheusServer.get("/metrics", async (_req, res) => {
 				res.header("Content-Type", this.prometheus.registry.contentType);
@@ -199,9 +200,12 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 				this.blockClient.disconnect();
 				this.log.verbose("Disconnected from RPC");
 			}
-			this.client = await (0, __cosmjs_tendermint_rpc.connectComet)(this.config.rpcUrl);
+			const connectTimeoutPromise = new Promise((resolve, reject) => {
+				setTimeout(reject, require_constants.CONNECT_TIMEOUT_MS, []);
+			});
+			this.client = await Promise.race([(0, __cosmjs_tendermint_rpc.connectComet)(this.config.rpcUrl), connectTimeoutPromise]);
 			this.log.info("Connected to RPC for ad hoc queries");
-			this.blockClient = await (0, __cosmjs_tendermint_rpc.connectComet)(this.config.rpcUrl);
+			this.blockClient = await Promise.race([(0, __cosmjs_tendermint_rpc.connectComet)(this.config.rpcUrl), connectTimeoutPromise]);
 			this.log.info("Connected to RPC for block & validator info");
 			return true;
 		} catch (error) {
@@ -211,15 +215,7 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			return false;
 		}
 	}
-	stop() {
-		this.started = false;
-	}
-	async start() {
-		this.started = true;
-		if (this.blockQueue) {
-			this.blockQueue.clear();
-			this.log.verbose("Starting, clearing block queue");
-		}
+	async initialize() {
 		if (!this.initialized) {
 			try {
 				if (this.config.init) await this.config.init();
@@ -239,15 +235,32 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			}
 			this.initialized = true;
 		}
+	}
+	stop() {
+		this.started = false;
+	}
+	clearBlockQueue() {
+		if (this.blockQueue) {
+			this.blockQueue.clear();
+			this.log.verbose("Starting, clearing block queue");
+		}
+	}
+	async setupBlockListening() {
+		if (!await this.connect()) {
+			this.setStatus("FAILED");
+			throw new require_index$1.RPCError("Failed to connect to RPC");
+		}
 		try {
-			await this.connect();
 			if (!this.config.usePolling && this.subscription) {
 				this.subscription.removeListener(this.blockListener);
 				this.subscription = null;
 				this.log.verbose("Removed existing block listener and subscription");
 			}
 			if (!this.config.usePolling) this.subscription = this.client.subscribeNewBlock ? this.client.subscribeNewBlock() : null;
-			this.latestHeight = (await this.client.status()).syncInfo.latestBlockHeight;
+			const statusPromise = new Promise((resolve, reject) => {
+				setTimeout(reject, require_constants.RPC_TIMEOUT_MS, false);
+			});
+			this.latestHeight = (await Promise.race([this.client.status(), statusPromise])).syncInfo.latestBlockHeight;
 			this.log.info("Current chain height: " + this.latestHeight);
 			this.heightToProcess = await this.config.getNextHeight();
 			if (this.config.usePolling) this.pollForBlock();
@@ -262,6 +275,12 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			this.setStatus("FAILED");
 			throw e;
 		}
+	}
+	async start() {
+		this.started = true;
+		this.clearBlockQueue();
+		await this.initialize();
+		await this.setupBlockListening();
 		this.log.debug("Starting main processing loop");
 		this.tryToRecover = false;
 		this.fetcher().catch((e) => {
@@ -269,12 +288,9 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			this.prometheus?.recordError("rpc");
 			throw new Error("Error in fetching service: " + e);
 		});
-		const hrTime = process.hrtime();
-		let ms = hrTime[0] * 1e6 + hrTime[1] / 1e3;
-		while (this.blockQueue.size() > 0 && !this.tryToRecover && this.started && (this.config.endHeight === void 0 || this.heightToProcess <= this.config.endHeight)) {
-			if (this.config.enablePrometheus) this.prometheus.updateRetryCount(this.retryCount);
+		while (this.started && !this.tryToRecover && (this.config.endHeight === void 0 || this.heightToProcess <= this.config.endHeight) && this.blockQueue.size() > 0) {
 			try {
-				if (this.tryToRecover) throw new Error("Exiting processing loop. Attempting to recover indexer");
+				this.prometheus?.updateRetryCount(this.retryCount);
 				await this.config.beginTransaction();
 				this.log.silly("Started db tx");
 				let height, timestamp;
@@ -284,10 +300,7 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 					});
 					const toProcess = await Promise.race([this.blockQueue.dequeue(), timeoutPromise]);
 					this.log.silly("Retrieved block data");
-					if (!toProcess || !toProcess[0] || !toProcess[1]) {
-						this.prometheus?.recordError("rpc");
-						throw new Error("Could not fetch block");
-					}
+					if (!toProcess || !toProcess[0] || !toProcess[1]) throw new require_index$1.RPCError("Could not fetch block(minimal)");
 					height = toProcess[0].block.header.height;
 					timestamp = (0, __cosmjs_tendermint_rpc.toRfc3339WithNanoseconds)(toProcess[0].block.header.time);
 					await this.processBlock(toProcess[0], toProcess[1]);
@@ -297,34 +310,23 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 					});
 					const toProcess = await Promise.race([this.blockQueue.dequeue(), timeoutPromise]);
 					this.log.silly("Retrieved block data");
-					if (!toProcess || !toProcess[0] || !toProcess[1] || !toProcess[2]) {
-						this.prometheus?.recordError("rpc");
-						throw new Error("Could not fetch block");
-					}
+					if (!toProcess || !toProcess[0] || !toProcess[1] || !toProcess[2]) throw new require_index$1.RPCError("Could not fetch block(full)");
 					this.log.silly("Decoded block");
 					height = toProcess[0].block.header.height;
 					timestamp = (0, __cosmjs_tendermint_rpc.toRfc3339WithNanoseconds)(toProcess[0].block.header.time);
 					await this.processBlock(toProcess[0], toProcess[1], cosmjs_types_cosmos_staking_v1beta1_query_js.QueryValidatorsResponse.decode(toProcess[2]).validators);
 				}
-				if (height % require_constants.PERIODIC_INTERVALS.LARGE == 0) {
-					const hrTime$1 = process.hrtime();
-					const newms = hrTime$1[0] * 1e6 + hrTime$1[1] / 1e3;
-					const duration = newms - ms;
-					ms = newms;
-					const rate = 1e9 / duration;
-					this.log.info("Processing:" + rate.toFixed(2) + "blocks/sec");
-					await this.asyncEmit("periodic/1000", {
-						value: null,
-						height,
-						timestamp
-					});
-				}
-				if (height % require_constants.PERIODIC_INTERVALS.MEDIUM == 0) await this.asyncEmit("periodic/100", {
+				if (height % require_constants.PERIODIC_INTERVALS.LARGE == 0) await this.asyncEmit("periodic/large", {
+					value: null,
+					height,
+					timestamp
+				});
+				if (height % require_constants.PERIODIC_INTERVALS.MEDIUM == 0) await this.asyncEmit("periodic/medium", {
 					value: null,
 					height,
 					timestamp
 				});
-				if (height % require_constants.PERIODIC_INTERVALS.SMALL == 0) await this.asyncEmit("periodic/50", {
+				if (height % require_constants.PERIODIC_INTERVALS.SMALL == 0) await this.asyncEmit("periodic/small", {
 					value: null,
 					height,
 					timestamp
@@ -349,12 +351,18 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			this.retryCount = 0;
 			this.setStatus("OK");
 		}
+		if (!this.started) {
+			this.log.info("Indexer manually stopped.");
+			return;
+		}
 		if (this.config.endHeight !== void 0 && this.heightToProcess >= this.config.endHeight) {
 			this.log.info("Reached configured end height. Stopping indexer.");
 			this.stop();
+			return;
 		}
-		if (this.started) if (this.retryCount < 3) {
+		if (this.retryCount < 3) {
 			this.log.debug("Indexer retryCount: " + this.retryCount);
+			this.retryCount++;
 			this.log.info("Indexer is restarting");
 			setTimeout(() => this.start(), this.retryCount * 5e3);
 		} else {
@@ -387,10 +395,7 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 		return prom;
 	};
 	async processBlock(block, block_results, validators) {
-		let processStart = [0, 0];
-		if (this.config.logLevel == "silly") processStart = process.hrtime();
-		let endTimer;
-		if (this.config.enablePrometheus) endTimer = this.prometheus.timeBlockProcessing();
+		const endTimer = this.prometheus?.timeBlockProcessing();
 		const height = block.block.header.height;
 		this.heightToProcess = height;
 		this.log.debug("Processing block: %d", height);
@@ -497,28 +502,23 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 			}
 		}
 		this.log.silly("Modules handled msg events");
-		if (this.config.enablePrometheus) this.prometheus.recordTransactions(block.block.txs.length);
+		this.prometheus?.recordTransactions(block.block.txs.length);
 		await this.asyncEmit("end_block", {
 			value: endBlockEvents,
 			height,
 			timestamp
 		});
 		this.log.silly("Modules handled end_block events");
-		if (this.config.logLevel == "silly") {
-			const processEnd = process.hrtime(processStart);
-			const processTime = processEnd[0] * 1e3 + processEnd[1] / 1e6;
-			this.log.silly("Processed block %d in %d ms", height, processTime.toFixed(2));
-		}
-		if (this.config.enablePrometheus) endTimer();
-		if (this.config.enablePrometheus) this.prometheus.updateBlockMetrics(height, this.latestHeight, this.blockQueue.size());
+		endTimer?.();
+		this.prometheus?.updateBlockMetrics(height, this.latestHeight, this.blockQueue.size());
 	}
 	async fetcher() {
 		for (let i = this.heightToProcess; i <= this.latestHeight; i++) {
-			this.log.debug("Fetching: " + i);
 			if (this.tryToRecover) {
 				this.log.verbose("Exiting fetcher loop. Attempting to recover indexer");
 				break;
 			}
+			this.log.debug("Fetching: " + i);
 			try {
 				if (this.isMinimal(this.blockQueue)) {
 					const timeoutPromise = new Promise((resolve, reject) => {
@@ -526,6 +526,7 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 					});
 					const toIndex = Promise.race([Promise.all([this.blockClient.block(i), this.blockClient.blockResults(i)]), timeoutPromise]).catch((e) => {
 						this.log.error("Error fetching block: " + i + " : " + e);
+						this.prometheus?.recordError("rpc");
 						this.tryToRecover = true;
 						return Promise.resolve([]);
 					});
@@ -547,15 +548,15 @@ var EcleciaIndexer = class extends require_index.EclesiaEmitter {
 					});
 					this.blockQueue.enqueue(toIndex);
 				}
-				await this.blockQueue.continue();
-				if (this.tryToRecover) {
-					this.retryCount++;
-					throw new Error("RPC not responding");
-				}
 			} catch (e) {
 				this.log.error("Fetching error: " + e);
 				break;
 			}
+			await this.blockQueue.continue();
+			if (this.tryToRecover) {
+				this.log.verbose("Exiting fetcher loop. Attempting to recover indexer");
+				break;
+			}
 		}
 		if (!this.tryToRecover) {
 			this.blockQueue.setSynced();