envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/Prometheus.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as PromClient from "./bindings/PromClient.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -290,10 +290,10 @@ function startOperation(contract, event) {
   } else {
     operations[key] = {
       pendingCount: 1,
-      timerRef: Hrtime.makeTimer()
+      timerRef: Performance.now()
     };
   }
-  return Hrtime.makeTimer();
+  return Performance.now();
 }
 
 function endOperation(timerRef, contract, event) {
@@ -305,10 +305,10 @@ function endOperation(timerRef, contract, event) {
   let operationRef = operations[key];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleFloat(timeCounter$1, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    handleFloat(timeCounter$1, labels, Performance.secondsSince(operationRef.timerRef));
     Utils.Dict.deleteInPlace(operations, key);
   }
-  handleFloat(sumTimeCounter, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  handleFloat(sumTimeCounter, labels, Performance.secondsSince(timerRef));
   increment(count$1, labels);
 }
 
@@ -389,39 +389,28 @@ let ProcessStartTimeSeconds = {
   set: set$3
 };
 
-let gauge$4 = makeOrThrow$1("envio_indexing_addresses", "The number of addresses indexed on chain. Includes both static and dynamic addresses.", chainIdLabelsSchema);
+let gauge$4 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
 
-function set$4(addressesCount, chainId) {
-  handleInt$1(gauge$4, chainId, addressesCount);
+function set$4(concurrency, chainId) {
+  handleInt$1(gauge$4, chainId, concurrency);
 }
 
-let IndexingAddresses = {
+let IndexingConcurrency = {
   gauge: gauge$4,
   set: set$4
 };
 
-let gauge$5 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
+let gauge$5 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
 
-function set$5(concurrency, chainId) {
-  handleInt$1(gauge$5, chainId, concurrency);
+function set$5(partitionsCount, chainId) {
+  handleInt$1(gauge$5, chainId, partitionsCount);
 }
 
-let IndexingConcurrency = {
+let IndexingPartitions = {
   gauge: gauge$5,
   set: set$5
 };
 
-let gauge$6 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
-
-function set$6(partitionsCount, chainId) {
-  handleInt$1(gauge$6, chainId, partitionsCount);
-}
-
-let IndexingPartitions = {
-  gauge: gauge$6,
-  set: set$6
-};
-
 let counter = makeOrThrow("envio_indexing_idle_seconds", "The time the indexer source syncing has been idle. A high value may indicate the source sync is a bottleneck.", chainIdLabelsSchema);
 
 let IndexingIdleTime = {
@@ -440,51 +429,51 @@ let IndexingQueryTime = {
   counter: counter$2
 };
 
-let gauge$7 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
+let gauge$6 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
 
-function set$7(bufferSize, chainId) {
-  handleInt$1(gauge$7, chainId, bufferSize);
+function set$6(bufferSize, chainId) {
+  handleInt$1(gauge$6, chainId, bufferSize);
 }
 
 let IndexingBufferSize = {
-  gauge: gauge$7,
-  set: set$7
+  gauge: gauge$6,
+  set: set$6
 };
 
-let gauge$8 = PromClient.Gauge.makeGauge({
+let gauge$7 = PromClient.Gauge.makeGauge({
   name: "envio_indexing_target_buffer_size",
   help: "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target."
 });
 
-function set$8(targetBufferSize) {
-  gauge$8.set(targetBufferSize);
+function set$7(targetBufferSize) {
+  gauge$7.set(targetBufferSize);
 }
 
 let IndexingTargetBufferSize = {
-  gauge: gauge$8,
-  set: set$8
+  gauge: gauge$7,
+  set: set$7
 };
 
-let gauge$9 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
+let gauge$8 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
 
-function set$9(blockNumber, chainId) {
-  handleInt$1(gauge$9, chainId, blockNumber);
+function set$8(blockNumber, chainId) {
+  handleInt$1(gauge$8, chainId, blockNumber);
 }
 
 let IndexingBufferBlockNumber = {
-  gauge: gauge$9,
-  set: set$9
+  gauge: gauge$8,
+  set: set$8
 };
 
-let gauge$10 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
+let gauge$9 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
 
-function set$10(endBlock, chainId) {
-  handleInt$1(gauge$10, chainId, endBlock);
+function set$9(endBlock, chainId) {
+  handleInt$1(gauge$9, chainId, endBlock);
 }
 
 let IndexingEndBlock = {
-  gauge: gauge$10,
-  set: set$10
+  gauge: gauge$9,
+  set: set$9
 };
 
 let sourceLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -492,101 +481,68 @@ let sourceLabelsSchema = S$RescriptSchema.schema(s => ({
   chainId: s.m(S$RescriptSchema.coerce(S$RescriptSchema.string, S$RescriptSchema.int))
 }));
 
-let sourceRequestLabelsSchema = S$RescriptSchema.schema(s => ({
-  source: s.m(S$RescriptSchema.string),
-  chainId: s.m(S$RescriptSchema.coerce(S$RescriptSchema.string, S$RescriptSchema.int)),
-  method: s.m(S$RescriptSchema.string)
-}));
+let gauge$10 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
 
-let counter$3 = makeOrThrow("envio_source_request_total", "The number of requests made to data sources.", sourceRequestLabelsSchema);
-
-let sumTimeCounter$1 = makeOrThrow("envio_source_request_seconds_total", "Cumulative time spent on data source requests.", sourceRequestLabelsSchema);
-
-function increment$4(sourceName, chainId, method) {
-  increment(counter$3, {
-    source: sourceName,
-    chainId: chainId,
-    method: method
-  });
-}
-
-function addSeconds(sourceName, chainId, method, seconds) {
-  handleFloat(sumTimeCounter$1, {
-    source: sourceName,
-    chainId: chainId,
-    method: method
-  }, seconds);
-}
-
-let SourceRequestCount = {
-  counter: counter$3,
-  sumTimeCounter: sumTimeCounter$1,
-  increment: increment$4,
-  addSeconds: addSeconds
-};
-
-let gauge$11 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
-
-function set$11(sourceName, chainId, blockNumber) {
-  handleInt$1(gauge$11, {
+function set$10(sourceName, chainId, blockNumber) {
+  handleInt$1(gauge$10, {
     source: sourceName,
     chainId: chainId
   }, blockNumber);
 }
 
 let SourceHeight = {
-  gauge: gauge$11,
-  set: set$11
+  gauge: gauge$10,
+  set: set$10
 };
 
-let counter$4 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
+let counter$3 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
 
-function increment$5(chain) {
-  increment(counter$4, chain);
+function increment$4(chain) {
+  increment(counter$3, chain);
 }
 
 let ReorgCount = {
-  counter: counter$4,
-  increment: increment$5
+  counter: counter$3,
+  increment: increment$4
 };
 
-let gauge$12 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
+let gauge$11 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
 
-function set$12(blockNumber, chain) {
-  handleInt$1(gauge$12, chain, blockNumber);
+function set$11(blockNumber, chain) {
+  handleInt$1(gauge$11, chain, blockNumber);
 }
 
 let ReorgDetectionBlockNumber = {
-  gauge: gauge$12,
-  set: set$12
+  gauge: gauge$11,
+  set: set$11
 };
 
-let gauge$13 = PromClient.Gauge.makeGauge({
+let gauge$12 = PromClient.Gauge.makeGauge({
   name: "envio_reorg_threshold",
   help: "Whether indexing is currently within the reorg threshold"
 });
 
-function set$13(isInReorgThreshold) {
-  gauge$13.set(isInReorgThreshold ? 1 : 0);
+function set$12(isInReorgThreshold) {
+  gauge$12.set(isInReorgThreshold ? 1 : 0);
 }
 
 let ReorgThreshold = {
-  gauge: gauge$13,
-  set: set$13
+  gauge: gauge$12,
+  set: set$12
 };
 
-let gauge$14 = PromClient.Gauge.makeGauge({
+let gauge$13 = PromClient.Gauge.makeGauge({
   name: "envio_rollback_enabled",
   help: "Whether rollback on reorg is enabled"
 });
 
-function set$14(enabled) {
-  gauge$14.set(enabled ? 1 : 0);
+function set$13(enabled) {
+  gauge$13.set(enabled ? 1 : 0);
 }
 
 let RollbackEnabled = {
-  gauge: gauge$14,
-  set: set$14
+  gauge: gauge$13,
+  set: set$13
 };
 
 let timeCounter$3 = PromClient.Counter.makeCounter({
@@ -594,7 +550,7 @@ let timeCounter$3 = PromClient.Counter.makeCounter({
   help: "Rollback on reorg total time."
 });
 
-let counter$5 = PromClient.Counter.makeCounter({
+let counter$4 = PromClient.Counter.makeCounter({
   name: "envio_rollback_total",
   help: "Number of successful rollbacks on reorg"
 });
@@ -604,100 +560,100 @@ let eventsCounter = PromClient.Counter.makeCounter({
   help: "Number of events rollbacked on reorg"
 });
 
-function increment$6(timeSeconds, rollbackedProcessedEvents) {
+function increment$5(timeSeconds, rollbackedProcessedEvents) {
   timeCounter$3.inc(timeSeconds);
-  counter$5.inc();
+  counter$4.inc();
   eventsCounter.inc(Math.trunc(rollbackedProcessedEvents));
 }
 
 let RollbackSuccess = {
   timeCounter: timeCounter$3,
-  counter: counter$5,
+  counter: counter$4,
   eventsCounter: eventsCounter,
-  increment: increment$6
+  increment: increment$5
 };
 
 let entityNameLabelsSchema = S$RescriptSchema.object(s => s.f("entity", S$RescriptSchema.string));
 
 let timeCounter$4 = makeOrThrow("envio_rollback_history_prune_seconds", "The total time spent pruning entity history which is not in the reorg threshold.", entityNameLabelsSchema);
 
-let counter$6 = makeOrThrow("envio_rollback_history_prune_total", "Number of successful entity history prunes", entityNameLabelsSchema);
+let counter$5 = makeOrThrow("envio_rollback_history_prune_total", "Number of successful entity history prunes", entityNameLabelsSchema);
 
-function increment$7(timeSeconds, entityName) {
+function increment$6(timeSeconds, entityName) {
   handleFloat(timeCounter$4, entityName, timeSeconds);
-  increment(counter$6, entityName);
+  increment(counter$5, entityName);
 }
 
 let RollbackHistoryPrune = {
   entityNameLabelsSchema: entityNameLabelsSchema,
   timeCounter: timeCounter$4,
-  counter: counter$6,
-  increment: increment$7
+  counter: counter$5,
+  increment: increment$6
 };
 
-let gauge$15 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
+let gauge$14 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
 
-function set$15(blockNumber, chain) {
-  handleInt$1(gauge$15, chain, blockNumber);
+function set$14(blockNumber, chain) {
+  handleInt$1(gauge$14, chain, blockNumber);
 }
 
 let RollbackTargetBlockNumber = {
-  gauge: gauge$15,
-  set: set$15
+  gauge: gauge$14,
+  set: set$14
 };
 
-let gauge$16 = PromClient.Gauge.makeGauge({
+let gauge$15 = PromClient.Gauge.makeGauge({
   name: "envio_processing_max_batch_size",
   help: "The maximum number of items to process in a single batch."
 });
 
-function set$16(maxBatchSize) {
-  gauge$16.set(maxBatchSize);
+function set$15(maxBatchSize) {
+  gauge$15.set(maxBatchSize);
 }
 
 let ProcessingMaxBatchSize = {
-  gauge: gauge$16,
-  set: set$16
+  gauge: gauge$15,
+  set: set$15
 };
 
-let gauge$17 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+let gauge$16 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$17(blockNumber, chainId) {
-  handleInt$1(gauge$17, chainId, blockNumber);
+function set$16(blockNumber, chainId) {
+  handleInt$1(gauge$16, chainId, blockNumber);
 }
 
 let ProgressBlockNumber = {
-  gauge: gauge$17,
-  set: set$17
+  gauge: gauge$16,
+  set: set$16
 };
 
-let gauge$18 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+let gauge$17 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$18(processedCount, chainId) {
-  handleFloat$1(gauge$18, chainId, processedCount);
+function set$17(processedCount, chainId) {
+  handleFloat$1(gauge$17, chainId, processedCount);
 }
 
 let ProgressEventsCount = {
-  gauge: gauge$18,
-  set: set$18
+  gauge: gauge$17,
+  set: set$17
 };
 
-let gauge$19 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
+let gauge$18 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
 
-function set$19(latencyMs, chainId) {
-  handleInt$1(gauge$19, chainId, latencyMs);
+function set$18(latencyMs, chainId) {
+  handleInt$1(gauge$18, chainId, latencyMs);
 }
 
 let ProgressLatency = {
-  gauge: gauge$19,
-  set: set$19
+  gauge: gauge$18,
+  set: set$18
 };
 
 let effectLabelsSchema = S$RescriptSchema.object(s => s.f("effect", S$RescriptSchema.string));
 
 let timeCounter$5 = makeOrThrow("envio_effect_call_seconds", "Processing time taken to call the Effect function.", effectLabelsSchema);
 
-let sumTimeCounter$2 = makeOrThrow("envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", effectLabelsSchema);
+let sumTimeCounter$1 = makeOrThrow("envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", effectLabelsSchema);
 
 let totalCallsCount = makeOrThrow("envio_effect_call_total", "Cumulative number of resolved Effect function calls during the indexing process.", effectLabelsSchema);
 
@@ -705,45 +661,45 @@ let activeCallsCount = makeOrThrow$1("envio_effect_active_calls", "The number of
 
 let EffectCalls = {
   timeCounter: timeCounter$5,
-  sumTimeCounter: sumTimeCounter$2,
+  sumTimeCounter: sumTimeCounter$1,
   totalCallsCount: totalCallsCount,
   activeCallsCount: activeCallsCount
 };
 
-let gauge$20 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
+let gauge$19 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$20(count, effectName) {
-  handleInt$1(gauge$20, effectName, count);
+function set$19(count, effectName) {
+  handleInt$1(gauge$19, effectName, count);
 }
 
 let EffectCacheCount = {
-  gauge: gauge$20,
-  set: set$20
+  gauge: gauge$19,
+  set: set$19
 };
 
-let counter$7 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
+let counter$6 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
 
-function increment$8(effectName) {
-  increment(counter$7, effectName);
+function increment$7(effectName) {
+  increment(counter$6, effectName);
 }
 
 let EffectCacheInvalidationsCount = {
-  counter: counter$7,
-  increment: increment$8
+  counter: counter$6,
+  increment: increment$7
 };
 
-let gauge$21 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
+let gauge$20 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
 
 let timeCounter$6 = makeOrThrow("envio_effect_queue_wait_seconds", "The time spent waiting in the rate limit queue.", effectLabelsSchema);
 
-function set$21(count, effectName) {
-  handleInt$1(gauge$21, effectName, count);
+function set$20(count, effectName) {
+  handleInt$1(gauge$20, effectName, count);
 }
 
 let EffectQueueCount = {
-  gauge: gauge$21,
+  gauge: gauge$20,
   timeCounter: timeCounter$6,
-  set: set$21
+  set: set$20
 };
 
 let loadLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -753,9 +709,9 @@ let loadLabelsSchema = S$RescriptSchema.schema(s => ({
 
 let timeCounter$7 = makeOrThrow("envio_storage_load_seconds", "Processing time taken to load data from storage.", loadLabelsSchema);
 
-let sumTimeCounter$3 = makeOrThrow("envio_storage_load_seconds_total", "Cumulative time spent loading data from storage during the indexing process.", loadLabelsSchema);
+let sumTimeCounter$2 = makeOrThrow("envio_storage_load_seconds_total", "Cumulative time spent loading data from storage during the indexing process.", loadLabelsSchema);
 
-let counter$8 = makeOrThrow("envio_storage_load_total", "Cumulative number of successful storage load operations during the indexing process.", loadLabelsSchema);
+let counter$7 = makeOrThrow("envio_storage_load_total", "Cumulative number of successful storage load operations during the indexing process.", loadLabelsSchema);
 
 let whereSizeCounter = makeOrThrow("envio_storage_load_where_size", "Cumulative number of filter conditions ('where' items) used in storage load operations during the indexing process.", loadLabelsSchema);
 
@@ -775,10 +731,10 @@ function startOperation$1(storage, operation) {
   } else {
     operations$1[key] = {
       pendingCount: 1,
-      timerRef: Hrtime.makeTimer()
+      timerRef: Performance.now()
     };
   }
-  return Hrtime.makeTimer();
+  return Performance.now();
 }
 
 function endOperation$1(timerRef, storage, operation, whereSize, size) {
@@ -790,11 +746,11 @@ function endOperation$1(timerRef, storage, operation, whereSize, size) {
   let operationRef = operations$1[key];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleFloat(timeCounter$7, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    handleFloat(timeCounter$7, labels, Performance.secondsSince(operationRef.timerRef));
     Utils.Dict.deleteInPlace(operations$1, key);
   }
-  handleFloat(sumTimeCounter$3, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
-  increment(counter$8, labels);
+  handleFloat(sumTimeCounter$2, labels, Performance.secondsSince(timerRef));
+  increment(counter$7, labels);
   handleInt(whereSizeCounter, labels, whereSize);
   handleInt(sizeCounter$1, labels, size);
 }
@@ -802,8 +758,8 @@ function endOperation$1(timerRef, storage, operation, whereSize, size) {
 let StorageLoad = {
   loadLabelsSchema: loadLabelsSchema,
   timeCounter: timeCounter$7,
-  sumTimeCounter: sumTimeCounter$3,
-  counter: counter$8,
+  sumTimeCounter: sumTimeCounter$2,
+  counter: counter$7,
   whereSizeCounter: whereSizeCounter,
   sizeCounter: sizeCounter$1,
   operations: operations$1,
@@ -816,18 +772,18 @@ let storageLabelsSchema = S$RescriptSchema.object(s => s.f("storage", S$Rescript
 
 let timeCounter$8 = makeOrThrow("envio_storage_write_seconds", "Cumulative time spent writing batch data to storage.", storageLabelsSchema);
 
-let counter$9 = makeOrThrow("envio_storage_write_total", "Cumulative number of successful storage write operations during the indexing process.", storageLabelsSchema);
+let counter$8 = makeOrThrow("envio_storage_write_total", "Cumulative number of successful storage write operations during the indexing process.", storageLabelsSchema);
 
-function increment$9(storage, timeSeconds) {
+function increment$8(storage, timeSeconds) {
   handleFloat(timeCounter$8, storage, timeSeconds);
-  increment(counter$9, storage);
+  increment(counter$8, storage);
 }
 
 let StorageWrite = {
   storageLabelsSchema: storageLabelsSchema,
   timeCounter: timeCounter$8,
-  counter: counter$9,
-  increment: increment$9
+  counter: counter$8,
+  increment: increment$8
 };
 
 export {
@@ -846,7 +802,6 @@ export {
   IndexingKnownHeight,
   Info,
   ProcessStartTimeSeconds,
-  IndexingAddresses,
   IndexingConcurrency,
   IndexingPartitions,
   IndexingIdleTime,
@@ -857,8 +812,6 @@ export {
   IndexingBufferBlockNumber,
   IndexingEndBlock,
   sourceLabelsSchema,
-  sourceRequestLabelsSchema,
-  SourceRequestCount,
   SourceHeight,
   ReorgCount,
   ReorgDetectionBlockNumber,

package/src/PruneStaleHistory.res

@@ -14,7 +14,7 @@ let runPrune = async (state: IndexerState.t) => {
         await Utils.delay(1000)
       }
       let entityConfig = persistence.allEntities->Array.getUnsafe(idx)
-      let timeRef = Hrtime.makeTimer()
+      let timeRef = Performance.now()
       try {
         let () = await persistence.storage.pruneStaleEntityHistory(
           ~entityName=entityConfig.name,
@@ -34,7 +34,7 @@ let runPrune = async (state: IndexerState.t) => {
         )
       }
       Prometheus.RollbackHistoryPrune.increment(
-        ~timeSeconds=Hrtime.timeSince(timeRef)->Hrtime.toSecondsFloat,
+        ~timeSeconds=Performance.secondsSince(timeRef),
         ~entityName=entityConfig.name,
       )
     }

package/src/PruneStaleHistory.res.mjs

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -21,7 +21,7 @@ async function runPrune(state) {
       await Utils.delay(1000);
     }
     let entityConfig = persistence.allEntities[idx];
-    let timeRef = Hrtime.makeTimer();
+    let timeRef = Performance.now();
     try {
       await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
     } catch (raw_exn) {
@@ -31,7 +31,7 @@ async function runPrune(state) {
         safeCheckpointId: safeCheckpointId
       }), `Failed to prune stale entity history`, exn);
     }
-    Prometheus.RollbackHistoryPrune.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef)), entityConfig.name);
+    Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
   }
 }
 

package/src/RawEvent.res

@@ -19,16 +19,21 @@ let convertFieldsToJson = (fields: option<dict<unknown>>) => {
 
 // Block and transaction are passed already extracted from the ecosystem's
 // concrete payload (EVM or Fuel) — `RawEvent` stays payload-shape-agnostic and
-// only needs them as opaque field bags to serialise.
+// only needs them as opaque field bags to serialise. The dedicated
+// `block_hash`/`block_timestamp` column values are extracted from the payload
+// block by the ecosystem caller (the field names differ per ecosystem).
 let make = (
   eventItem: Internal.eventItem,
   ~block,
   ~transaction,
   ~params: Internal.eventParams,
   ~srcAddress: Address.t,
+  ~blockHash: string,
+  ~blockTimestamp: int,
   ~cleanUpRawEventFieldsInPlace: JSON.t => unit,
 ): Internal.rawEvent => {
-  let {eventConfig, chain, blockNumber, blockHash, timestamp: blockTimestamp, logIndex} = eventItem
+  let {chain, blockNumber, logIndex} = eventItem
+  let eventConfig = eventItem.onEventRegistration.eventConfig
   let chainId = chain->ChainMap.Chain.toChainId
   let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
   let blockFields =