envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/EventProcessing.res

@@ -1,5 +1,3 @@
-open Belt
-
 let allChainsEventsProcessedToEndblock = (chainFetchers: ChainMap.t<ChainFetcher.t>) => {
   chainFetchers
   ->ChainMap.values
@@ -7,7 +5,7 @@ let allChainsEventsProcessedToEndblock = (chainFetchers: ChainMap.t<ChainFetcher
 }
 
 let computeChainsState = (chainFetchers: ChainMap.t<ChainFetcher.t>): Internal.chains => {
-  let chains = Js.Dict.empty()
+  let chains = Dict.make()
 
   chainFetchers
   ->ChainMap.entries
@@ -15,7 +13,7 @@ let computeChainsState = (chainFetchers: ChainMap.t<ChainFetcher.t>): Internal.c
     let chainId = chain->ChainMap.Chain.toChainId->Int.toString
     let isLive = chainFetcher->ChainFetcher.isReady
 
-    chains->Js.Dict.set(
+    chains->Dict.set(
       chainId,
       {
         Internal.id: chain->ChainMap.Chain.toChainId,
@@ -30,26 +28,19 @@ let computeChainsState = (chainFetchers: ChainMap.t<ChainFetcher.t>): Internal.c
 let convertFieldsToJson = (fields: option<dict<unknown>>) => {
   switch fields {
   | None => %raw(`{}`)
-  | Some(fields) => {
-      let keys = fields->Js.Dict.keys
-      let new = Js.Dict.empty()
-      for i in 0 to keys->Js.Array2.length - 1 {
-        let key = keys->Js.Array2.unsafe_get(i)
-        let value = fields->Js.Dict.unsafeGet(key)
-        // Skip `undefined` values and convert bigint fields to string
-        // There are not fields with nested bigints, so this is safe
-        new->Js.Dict.set(
-          key,
-          Js.typeof(value) === "bigint"
-            ? value
-              ->(Utils.magic: unknown => bigint)
-              ->BigInt.toString
-              ->(Utils.magic: string => unknown)
-            : value,
-        )
-      }
-      new->(Utils.magic: dict<unknown> => Js.Json.t)
-    }
+  | Some(fields) =>
+    // Convert bigint fields to string. There are no fields with nested
+    // bigints, so iterating only the top level is safe.
+    fields
+    ->Utils.Dict.mapValues(value =>
+      typeof(value) === #bigint
+        ? value
+          ->(Utils.magic: unknown => bigint)
+          ->BigInt.toString
+          ->(Utils.magic: string => unknown)
+        : value
+    )
+    ->(Utils.magic: dict<unknown> => JSON.t)
   }
 }
 
@@ -77,7 +68,7 @@ let addItemToRawEvents = (
   let params =
     params
     ->S.reverseConvertOrThrow(eventConfig.paramsRawEventSchema)
-    ->(Utils.magic: unknown => Js.Json.t)
+    ->(Utils.magic: unknown => JSON.t)
   let params = if params === %raw(`null`) {
     // Should probably make the params field nullable
     // But this is currently needed to make events
@@ -149,7 +140,7 @@ let runEventHandlerOrThrow = async (
     contextParams.isResolved = true
   } catch {
   | exn =>
-    raise(
+    throw(
       ProcessingError({
         message: "Unexpected error in the event handler. Please handle the error to keep the indexer running smoothly.",
         item,
@@ -199,7 +190,7 @@ let runHandlerOrThrow = async (
       contextParams.isResolved = true
     } catch {
     | exn =>
-      raise(
+      throw(
         ProcessingError({
           message: "Unexpected error in the block handler. Please handle the error to keep the indexer running smoothly.",
           item,
@@ -249,12 +240,11 @@ let preloadBatchOrThrow = async (
   let itemIdx = ref(0)
 
   for checkpointIdx in 0 to batch.checkpointIds->Array.length - 1 {
-    let checkpointId = batch.checkpointIds->Js.Array2.unsafe_get(checkpointIdx)
-    let checkpointEventsProcessed =
-      batch.checkpointEventsProcessed->Js.Array2.unsafe_get(checkpointIdx)
+    let checkpointId = batch.checkpointIds->Array.getUnsafe(checkpointIdx)
+    let checkpointEventsProcessed = batch.checkpointEventsProcessed->Array.getUnsafe(checkpointIdx)
 
     for idx in 0 to checkpointEventsProcessed - 1 {
-      let item = batch.items->Js.Array2.unsafe_get(itemIdx.contents + idx)
+      let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
       | Event({eventConfig: {handler, contractName, name: eventName}, event}) =>
         switch handler {
@@ -287,7 +277,7 @@ let preloadBatchOrThrow = async (
                   ~event=eventName,
                 )
               })
-              ->Promise.silentCatch,
+              ->Utils.Promise.silentCatch,
               // Must have Promise.catch as well as normal catch,
               // because if user throws an error before await in the handler,
               // it won't create a rejected promise
@@ -316,7 +306,7 @@ let preloadBatchOrThrow = async (
                   config,
                 }),
               )
-            })->Promise.silentCatch,
+            })->Utils.Promise.silentCatch,
           )
         } catch {
         | _ => ()
@@ -341,12 +331,11 @@ let runBatchHandlersOrThrow = async (
   let itemIdx = ref(0)
 
   for checkpointIdx in 0 to batch.checkpointIds->Array.length - 1 {
-    let checkpointId = batch.checkpointIds->Js.Array2.unsafe_get(checkpointIdx)
-    let checkpointEventsProcessed =
-      batch.checkpointEventsProcessed->Js.Array2.unsafe_get(checkpointIdx)
+    let checkpointId = batch.checkpointIds->Array.getUnsafe(checkpointIdx)
+    let checkpointEventsProcessed = batch.checkpointEventsProcessed->Array.getUnsafe(checkpointIdx)
 
     for idx in 0 to checkpointEventsProcessed - 1 {
-      let item = batch.items->Js.Array2.unsafe_get(itemIdx.contents + idx)
+      let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
 
       await runHandlerOrThrow(
         item,
@@ -375,7 +364,7 @@ let registerProcessEventBatchMetrics = (
     "write_time_elapsed": dbWriteDuration,
   })
 
-  Prometheus.ProcessingBatch.registerMetrics(~loadDuration, ~handlerDuration, ~dbWriteDuration)
+  Prometheus.ProcessingBatch.registerMetrics(~loadDuration, ~handlerDuration)
 }
 
 type logPartitionInfo = {

package/src/EventProcessing.res.mjs

@@ -4,10 +4,8 @@ import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as $$Promise from "./bindings/Promise.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as EventUtils from "./EventUtils.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
@@ -15,63 +13,60 @@ import * as UserContext from "./UserContext.res.mjs";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function allChainsEventsProcessedToEndblock(chainFetchers) {
-  return Belt_Array.every(ChainMap.values(chainFetchers), (function (cf) {
-                return ChainFetcher.hasProcessedToEndblock(cf);
-              }));
+  return ChainMap.values(chainFetchers).every(ChainFetcher.hasProcessedToEndblock);
 }
 
 function computeChainsState(chainFetchers) {
-  var chains = {};
-  Belt_Array.forEach(ChainMap.entries(chainFetchers), (function (param) {
-          var chain = param[0];
-          var chainId = String(chain);
-          var isLive = ChainFetcher.isReady(param[1]);
-          chains[chainId] = {
-            id: chain,
-            isLive: isLive
-          };
-        }));
+  let chains = {};
+  ChainMap.entries(chainFetchers).forEach(param => {
+    let chain = param[0];
+    let chainId = chain.toString();
+    let isLive = ChainFetcher.isReady(param[1]);
+    chains[chainId] = {
+      id: chain,
+      isLive: isLive
+    };
+  });
   return chains;
 }
 
 function convertFieldsToJson(fields) {
-  if (fields === undefined) {
+  if (fields !== undefined) {
+    return Utils.Dict.mapValues(fields, value => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      } else {
+        return value;
+      }
+    });
+  } else {
     return {};
   }
-  var keys = Object.keys(fields);
-  var $$new = {};
-  for(var i = 0 ,i_finish = keys.length; i < i_finish; ++i){
-    var key = keys[i];
-    var value = fields[key];
-    $$new[key] = typeof value === "bigint" ? value.toString() : value;
-  }
-  return $$new;
 }
 
 function addItemToRawEvents(eventItem, inMemoryStore, config) {
-  var $$event = eventItem.event;
-  var block = $$event.block;
-  var logIndex = $$event.logIndex;
-  var blockNumber = eventItem.blockNumber;
-  var chain = eventItem.chain;
-  var eventConfig = eventItem.eventConfig;
-  var eventId = EventUtils.packEventIndex(blockNumber, logIndex);
-  var blockFields = convertFieldsToJson(block);
-  var transactionFields = convertFieldsToJson($$event.transaction);
+  let event = eventItem.event;
+  let block = event.block;
+  let logIndex = event.logIndex;
+  let blockNumber = eventItem.blockNumber;
+  let chain = eventItem.chain;
+  let eventConfig = eventItem.eventConfig;
+  let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
+  let blockFields = convertFieldsToJson(block);
+  let transactionFields = convertFieldsToJson(event.transaction);
   config.ecosystem.cleanUpRawEventFieldsInPlace(blockFields);
-  var params = S$RescriptSchema.reverseConvertOrThrow($$event.params, eventConfig.paramsRawEventSchema);
-  var params$1 = params === null ? "null" : params;
-  var rawEvent_event_name = eventConfig.name;
-  var rawEvent_contract_name = eventConfig.contractName;
-  var rawEvent_src_address = $$event.srcAddress;
-  var rawEvent_block_hash = config.ecosystem.getId(block);
-  var rawEvent_block_timestamp = eventItem.timestamp;
-  var rawEvent = {
+  let params = S$RescriptSchema.reverseConvertOrThrow(event.params, eventConfig.paramsRawEventSchema);
+  let params$1 = params === null ? "null" : params;
+  let rawEvent_event_name = eventConfig.name;
+  let rawEvent_contract_name = eventConfig.contractName;
+  let rawEvent_src_address = event.srcAddress;
+  let rawEvent_block_hash = config.ecosystem.getId(block);
+  let rawEvent_block_timestamp = eventItem.timestamp;
+  let rawEvent = {
     chain_id: chain,
     event_id: eventId,
     event_name: rawEvent_event_name,
@@ -85,19 +80,19 @@ function addItemToRawEvents(eventItem, inMemoryStore, config) {
     transaction_fields: transactionFields,
     params: params$1
   };
-  var eventIdStr = eventId.toString();
+  let eventIdStr = eventId.toString();
   InMemoryTable.set(inMemoryStore.rawEvents, {
-        chainId: chain,
-        eventId: eventIdStr
-      }, rawEvent);
+    chainId: chain,
+    eventId: eventIdStr
+  }, rawEvent);
 }
 
-var ProcessingError = /* @__PURE__ */Caml_exceptions.create("EventProcessing.ProcessingError");
+let ProcessingError = /* @__PURE__ */Primitive_exceptions.create("EventProcessing.ProcessingError");
 
 async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, persistence, shouldSaveHistory, chains, config) {
-  var timeBeforeHandler = Hrtime.makeTimer();
+  let timeBeforeHandler = Hrtime.makeTimer();
   try {
-    var contextParams = {
+    let contextParams = {
       item: item,
       checkpointId: checkpointId,
       inMemoryStore: inMemoryStore,
@@ -110,39 +105,38 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore
       isResolved: false
     };
     await handler({
-          event: item.event,
-          context: UserContext.getHandlerContext(contextParams)
-        });
+      event: item.event,
+      context: UserContext.getHandlerContext(contextParams)
+    });
     contextParams.isResolved = true;
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     throw {
-          RE_EXN_ID: ProcessingError,
-          message: "Unexpected error in the event handler. Please handle the error to keep the indexer running smoothly.",
-          exn: exn,
-          item: item,
-          Error: new Error()
-        };
+      RE_EXN_ID: ProcessingError,
+      message: "Unexpected error in the event handler. Please handle the error to keep the indexer running smoothly.",
+      exn: exn,
+      item: item,
+      Error: new Error()
+    };
   }
-  var handlerDuration = Hrtime.toSecondsFloat(Hrtime.timeSince(timeBeforeHandler));
+  let handlerDuration = Hrtime.toSecondsFloat(Hrtime.timeSince(timeBeforeHandler));
   return Prometheus.ProcessingHandler.increment(item.eventConfig.contractName, item.eventConfig.name, handlerDuration);
 }
 
 async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, shouldSaveHistory, chains) {
   if (item.kind === 0) {
-    var handler = item.eventConfig.handler;
+    let handler = item.eventConfig.handler;
     if (handler !== undefined) {
       await runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, ctx.persistence, shouldSaveHistory, chains, ctx.config);
     }
     if (ctx.config.enableRawEvents) {
       return addItemToRawEvents(item, inMemoryStore, ctx.config);
     } else {
-      return ;
+      return;
     }
   }
   try {
-    var contextParams = {
+    let contextParams = {
       item: item,
       checkpointId: checkpointId,
       inMemoryStore: inMemoryStore,
@@ -156,77 +150,69 @@ async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager,
     };
     await item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, ctx.config.ecosystem, UserContext.getHandlerContext(contextParams)));
     contextParams.isResolved = true;
-    return ;
-  }
-  catch (raw_exn){
-    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
     throw {
-          RE_EXN_ID: ProcessingError,
-          message: "Unexpected error in the block handler. Please handle the error to keep the indexer running smoothly.",
-          exn: exn,
-          item: item,
-          Error: new Error()
-        };
+      RE_EXN_ID: ProcessingError,
+      message: "Unexpected error in the block handler. Please handle the error to keep the indexer running smoothly.",
+      exn: exn,
+      item: item,
+      Error: new Error()
+    };
   }
 }
 
 async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMemoryStore, chains) {
-  var promises = [];
-  var itemIdx = 0;
-  for(var checkpointIdx = 0 ,checkpointIdx_finish = batch.checkpointIds.length; checkpointIdx < checkpointIdx_finish; ++checkpointIdx){
-    var checkpointId = batch.checkpointIds[checkpointIdx];
-    var checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpointIdx];
-    for(var idx = 0; idx < checkpointEventsProcessed; ++idx){
-      var item = batch.items[itemIdx + idx | 0];
+  let promises = [];
+  let itemIdx = 0;
+  for (let checkpointIdx = 0, checkpointIdx_finish = batch.checkpointIds.length; checkpointIdx < checkpointIdx_finish; ++checkpointIdx) {
+    let checkpointId = batch.checkpointIds[checkpointIdx];
+    let checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpointIdx];
+    for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
+      let item = batch.items[itemIdx + idx | 0];
       if (item.kind === 0) {
-        var match = item.eventConfig;
-        var handler = match.handler;
+        let match = item.eventConfig;
+        let handler = match.handler;
         if (handler !== undefined) {
-          var contractName = match.contractName;
-          var eventName = match.name;
+          let contractName = match.contractName;
+          let eventName = match.name;
           try {
-            var timerRef = Prometheus.PreloadHandler.startOperation(contractName, eventName);
-            promises.push($$Promise.silentCatch(handler({
-                            event: item.event,
-                            context: UserContext.getHandlerContext({
-                                  item: item,
-                                  checkpointId: checkpointId,
-                                  inMemoryStore: inMemoryStore,
-                                  loadManager: loadManager,
-                                  persistence: persistence,
-                                  isPreload: true,
-                                  shouldSaveHistory: false,
-                                  chains: chains,
-                                  config: config,
-                                  isResolved: false
-                                })
-                          }).then((function(eventName,contractName,timerRef){
-                        return function () {
-                          Prometheus.PreloadHandler.endOperation(timerRef, contractName, eventName);
-                        }
-                        }(eventName,contractName,timerRef)))));
-          }
-          catch (exn){
+            let timerRef = Prometheus.PreloadHandler.startOperation(contractName, eventName);
+            promises.push(Utils.$$Promise.silentCatch(handler({
+              event: item.event,
+              context: UserContext.getHandlerContext({
+                item: item,
+                checkpointId: checkpointId,
+                inMemoryStore: inMemoryStore,
+                loadManager: loadManager,
+                persistence: persistence,
+                isPreload: true,
+                shouldSaveHistory: false,
+                chains: chains,
+                config: config,
+                isResolved: false
+              })
+            }).then(() => Prometheus.PreloadHandler.endOperation(timerRef, contractName, eventName))));
+          } catch (exn) {
             
           }
         }
-        
       } else {
         try {
-          promises.push($$Promise.silentCatch(item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext({
-                                item: item,
-                                checkpointId: checkpointId,
-                                inMemoryStore: inMemoryStore,
-                                loadManager: loadManager,
-                                persistence: persistence,
-                                isPreload: true,
-                                shouldSaveHistory: false,
-                                chains: chains,
-                                config: config,
-                                isResolved: false
-                              })))));
-        }
-        catch (exn$1){
+          promises.push(Utils.$$Promise.silentCatch(item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext({
+            item: item,
+            checkpointId: checkpointId,
+            inMemoryStore: inMemoryStore,
+            loadManager: loadManager,
+            persistence: persistence,
+            isPreload: true,
+            shouldSaveHistory: false,
+            chains: chains,
+            config: config,
+            isResolved: false
+          })))));
+        } catch (exn$1) {
           
         }
       }
@@ -237,12 +223,12 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMe
 }
 
 async function runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, shouldSaveHistory, chains) {
-  var itemIdx = 0;
-  for(var checkpointIdx = 0 ,checkpointIdx_finish = batch.checkpointIds.length; checkpointIdx < checkpointIdx_finish; ++checkpointIdx){
-    var checkpointId = batch.checkpointIds[checkpointIdx];
-    var checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpointIdx];
-    for(var idx = 0; idx < checkpointEventsProcessed; ++idx){
-      var item = batch.items[itemIdx + idx | 0];
+  let itemIdx = 0;
+  for (let checkpointIdx = 0, checkpointIdx_finish = batch.checkpointIds.length; checkpointIdx < checkpointIdx_finish; ++checkpointIdx) {
+    let checkpointId = batch.checkpointIds[checkpointIdx];
+    let checkpointEventsProcessed = batch.checkpointEventsProcessed[checkpointIdx];
+    for (let idx = 0; idx < checkpointEventsProcessed; ++idx) {
+      let item = batch.items[itemIdx + idx | 0];
       await runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, shouldSaveHistory, chains);
     }
     itemIdx = itemIdx + checkpointEventsProcessed | 0;
@@ -251,87 +237,83 @@ async function runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, s
 
 function registerProcessEventBatchMetrics(logger, loadDuration, handlerDuration, dbWriteDuration) {
   Logging.childTrace(logger, {
-        msg: "Finished processing batch",
-        loader_time_elapsed: loadDuration,
-        handlers_time_elapsed: handlerDuration,
-        write_time_elapsed: dbWriteDuration
-      });
-  Prometheus.ProcessingBatch.registerMetrics(loadDuration, handlerDuration, dbWriteDuration);
+    msg: "Finished processing batch",
+    loader_time_elapsed: loadDuration,
+    handlers_time_elapsed: handlerDuration,
+    write_time_elapsed: dbWriteDuration
+  });
+  Prometheus.ProcessingBatch.registerMetrics(loadDuration, handlerDuration);
 }
 
 async function processEventBatch(batch, inMemoryStore, isInReorgThreshold, loadManager, ctx, chainFetchers) {
-  var totalBatchSize = batch.totalBatchSize;
-  var chains = computeChainsState(chainFetchers);
-  var logger = Logging.getLogger();
+  let totalBatchSize = batch.totalBatchSize;
+  let chains = computeChainsState(chainFetchers);
+  let logger = Logging.getLogger();
   Logging.childTrace(logger, {
-        msg: "Started processing batch",
-        totalBatchSize: totalBatchSize,
-        chains: Utils.Dict.mapValues(batch.progressedChainsById, (function (chainAfterBatch) {
-                return {
-                        batchSize: chainAfterBatch.batchSize,
-                        progress: chainAfterBatch.progressBlockNumber
-                      };
-              }))
-      });
+    msg: "Started processing batch",
+    totalBatchSize: totalBatchSize,
+    chains: Utils.Dict.mapValues(batch.progressedChainsById, chainAfterBatch => ({
+      batchSize: chainAfterBatch.batchSize,
+      progress: chainAfterBatch.progressBlockNumber
+    }))
+  });
   try {
-    var timeRef = Hrtime.makeTimer();
+    let timeRef = Hrtime.makeTimer();
     if (Utils.$$Array.notEmpty(batch.items)) {
       await preloadBatchOrThrow(batch, loadManager, ctx.persistence, ctx.config, inMemoryStore, chains);
     }
-    var elapsedTimeAfterLoaders = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
+    let elapsedTimeAfterLoaders = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
     if (Utils.$$Array.notEmpty(batch.items)) {
       await runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, Config.shouldSaveHistory(ctx.config, isInReorgThreshold), chains);
     }
-    var elapsedTimeAfterProcessing = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
+    let elapsedTimeAfterProcessing = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
     try {
       await Persistence.writeBatch(ctx.persistence, batch, ctx.config, inMemoryStore, isInReorgThreshold);
-      var elapsedTimeAfterDbWrite = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
-      var handlerDuration = elapsedTimeAfterProcessing - elapsedTimeAfterLoaders;
-      var dbWriteDuration = elapsedTimeAfterDbWrite - elapsedTimeAfterProcessing;
+      let elapsedTimeAfterDbWrite = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
+      let handlerDuration = elapsedTimeAfterProcessing - elapsedTimeAfterLoaders;
+      let dbWriteDuration = elapsedTimeAfterDbWrite - elapsedTimeAfterProcessing;
       registerProcessEventBatchMetrics(logger, elapsedTimeAfterLoaders, handlerDuration, dbWriteDuration);
       return {
-              TAG: "Ok",
-              _0: undefined
-            };
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+        TAG: "Ok",
+        _0: undefined
+      };
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
       if (exn.RE_EXN_ID === Persistence.StorageError) {
         return {
-                TAG: "Error",
-                _0: ErrorHandling.make(exn.reason, logger, exn.message)
-              };
+          TAG: "Error",
+          _0: ErrorHandling.make(exn.reason, logger, exn.message)
+        };
       } else {
         return {
-                TAG: "Error",
-                _0: ErrorHandling.make(exn, logger, "Failed writing batch to database")
-              };
+          TAG: "Error",
+          _0: ErrorHandling.make(exn, logger, "Failed writing batch to database")
+        };
       }
     }
-  }
-  catch (raw_exn$1){
-    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+  } catch (raw_exn$1) {
+    let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
     if (exn$1.RE_EXN_ID === ProcessingError) {
       return {
-              TAG: "Error",
-              _0: ErrorHandling.make(exn$1.exn, Logging.getItemLogger(exn$1.item), exn$1.message)
-            };
+        TAG: "Error",
+        _0: ErrorHandling.make(exn$1.exn, Logging.getItemLogger(exn$1.item), exn$1.message)
+      };
     }
     throw exn$1;
   }
 }
 
 export {
-  allChainsEventsProcessedToEndblock ,
-  computeChainsState ,
-  convertFieldsToJson ,
-  addItemToRawEvents ,
-  ProcessingError ,
-  runEventHandlerOrThrow ,
-  runHandlerOrThrow ,
-  preloadBatchOrThrow ,
-  runBatchHandlersOrThrow ,
-  registerProcessEventBatchMetrics ,
-  processEventBatch ,
+  allChainsEventsProcessedToEndblock,
+  computeChainsState,
+  convertFieldsToJson,
+  addItemToRawEvents,
+  ProcessingError,
+  runEventHandlerOrThrow,
+  runHandlerOrThrow,
+  preloadBatchOrThrow,
+  runBatchHandlersOrThrow,
+  registerProcessEventBatchMetrics,
+  processEventBatch,
 }
 /* Utils Not a pure module */