envio 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/EventProcessing.res.mjs

@@ -0,0 +1,337 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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";
+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";
+
+function allChainsEventsProcessedToEndblock(chainFetchers) {
+  return Belt_Array.every(ChainMap.values(chainFetchers), (function (cf) {
+                return ChainFetcher.hasProcessedToEndblock(cf);
+              }));
+}
+
+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
+          };
+        }));
+  return chains;
+}
+
+function convertFieldsToJson(fields) {
+  if (fields === undefined) {
+    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);
+  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 = {
+    chain_id: chain,
+    event_id: eventId,
+    event_name: rawEvent_event_name,
+    contract_name: rawEvent_contract_name,
+    block_number: blockNumber,
+    log_index: logIndex,
+    src_address: rawEvent_src_address,
+    block_hash: rawEvent_block_hash,
+    block_timestamp: rawEvent_block_timestamp,
+    block_fields: blockFields,
+    transaction_fields: transactionFields,
+    params: params$1
+  };
+  var eventIdStr = eventId.toString();
+  InMemoryTable.set(inMemoryStore.rawEvents, {
+        chainId: chain,
+        eventId: eventIdStr
+      }, rawEvent);
+}
+
+var ProcessingError = /* @__PURE__ */Caml_exceptions.create("EventProcessing.ProcessingError");
+
+async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, persistence, shouldSaveHistory, chains, config) {
+  var timeBeforeHandler = Hrtime.makeTimer();
+  try {
+    var contextParams = {
+      item: item,
+      checkpointId: checkpointId,
+      inMemoryStore: inMemoryStore,
+      loadManager: loadManager,
+      persistence: persistence,
+      isPreload: false,
+      shouldSaveHistory: shouldSaveHistory,
+      chains: chains,
+      config: config,
+      isResolved: false
+    };
+    await handler({
+          event: item.event,
+          context: UserContext.getHandlerContext(contextParams)
+        });
+    contextParams.isResolved = true;
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(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()
+        };
+  }
+  var 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;
+    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 ;
+    }
+  }
+  try {
+    var contextParams = {
+      item: item,
+      checkpointId: checkpointId,
+      inMemoryStore: inMemoryStore,
+      loadManager: loadManager,
+      persistence: ctx.persistence,
+      isPreload: false,
+      shouldSaveHistory: shouldSaveHistory,
+      chains: chains,
+      config: ctx.config,
+      isResolved: false
+    };
+    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);
+    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()
+        };
+  }
+}
+
+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];
+      if (item.kind === 0) {
+        var match = item.eventConfig;
+        var handler = match.handler;
+        if (handler !== undefined) {
+          var contractName = match.contractName;
+          var 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){
+            
+          }
+        }
+        
+      } 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){
+          
+        }
+      }
+    }
+    itemIdx = itemIdx + checkpointEventsProcessed | 0;
+  }
+  await Promise.all(promises);
+}
+
+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];
+      await runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, shouldSaveHistory, chains);
+    }
+    itemIdx = itemIdx + checkpointEventsProcessed | 0;
+  }
+}
+
+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);
+}
+
+async function processEventBatch(batch, inMemoryStore, isInReorgThreshold, loadManager, ctx, chainFetchers) {
+  var totalBatchSize = batch.totalBatchSize;
+  var chains = computeChainsState(chainFetchers);
+  var 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
+                      };
+              }))
+      });
+  try {
+    var 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));
+    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));
+    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;
+      registerProcessEventBatchMetrics(logger, elapsedTimeAfterLoaders, handlerDuration, dbWriteDuration);
+      return {
+              TAG: "Ok",
+              _0: undefined
+            };
+    }
+    catch (raw_exn){
+      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      if (exn.RE_EXN_ID === Persistence.StorageError) {
+        return {
+                TAG: "Error",
+                _0: ErrorHandling.make(exn.reason, logger, exn.message)
+              };
+      } else {
+        return {
+                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);
+    if (exn$1.RE_EXN_ID === ProcessingError) {
+      return {
+              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 ,
+}
+/* Utils Not a pure module */

package/src/EvmTypes.gen.ts

@@ -0,0 +1,6 @@
+/* TypeScript file generated from EvmTypes.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+export abstract class Abi_t { protected opaque!: any }; /* simulate opaque types */

package/src/EvmTypes.res

@@ -10,5 +10,6 @@ module Hex = {
 }
 
 module Abi = {
+  @genType
   type t
 }