envio 3.2.0 → 3.3.0-alpha.0

package/src/EventProcessing.res.mjs

@@ -3,26 +3,27 @@
 import * as Utils from "./Utils.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as ChainMap from "./ChainMap.res.mjs";
+import * as Writing from "./Writing.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
+import * as ChainState from "./ChainState.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 InMemoryStore from "./InMemoryStore.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function allChainsEventsProcessedToEndblock(chainFetchers) {
-  return ChainMap.values(chainFetchers).every(ChainFetcher.hasProcessedToEndblock);
+function allChainsEventsProcessedToEndblock(chainStates) {
+  return Object.values(chainStates).every(ChainState.hasProcessedToEndblock);
 }
 
-function computeChainsState(chainFetchers) {
+function computeChainsState(chainStates) {
   let chains = {};
-  let isRealtime = ChainMap.values(chainFetchers).every(ChainFetcher.isReady);
-  ChainMap.keys(chainFetchers).forEach(chain => {
-    chains[chain.toString()] = {
-      id: chain,
+  let values = Object.values(chainStates);
+  let isRealtime = values.every(ChainState.isReady);
+  values.forEach(cs => {
+    let chainId = ChainState.chainConfig(cs).id;
+    chains[chainId.toString()] = {
+      id: chainId,
       isRealtime: isRealtime
     };
   });
@@ -31,13 +32,13 @@ function computeChainsState(chainFetchers) {
 
 let ProcessingError = /* @__PURE__ */Primitive_exceptions.create("EventProcessing.ProcessingError");
 
-async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, persistence, chains, config) {
+async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState, loadManager, persistence, chains, config) {
   let timeBeforeHandler = Hrtime.makeTimer();
   try {
     let contextParams = {
       item: item,
       checkpointId: checkpointId,
-      inMemoryStore: inMemoryStore,
+      indexerState: indexerState,
       loadManager: loadManager,
       persistence: persistence,
       isPreload: false,
@@ -46,7 +47,7 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore
       isResolved: false
     };
     await handler({
-      event: item.event,
+      event: Ecosystem.getItemEvent(item, config.ecosystem),
       context: UserContext.getHandlerContext(contextParams)
     });
     contextParams.isResolved = true;
@@ -64,11 +65,11 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore
   return Prometheus.ProcessingHandler.increment(item.eventConfig.contractName, item.eventConfig.name, handlerDuration);
 }
 
-async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager, ctx, chains) {
+async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager, persistence, config, chains) {
   if (item.kind === 0) {
     let handler = item.eventConfig.handler;
     if (handler !== undefined) {
-      return await runEventHandlerOrThrow(item, checkpointId, handler, inMemoryStore, loadManager, ctx.persistence, chains, ctx.config);
+      return await runEventHandlerOrThrow(item, checkpointId, handler, indexerState, loadManager, persistence, chains, config);
     } else {
       return;
     }
@@ -77,15 +78,15 @@ async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager,
     let contextParams = {
       item: item,
       checkpointId: checkpointId,
-      inMemoryStore: inMemoryStore,
+      indexerState: indexerState,
       loadManager: loadManager,
-      persistence: ctx.persistence,
+      persistence: persistence,
       isPreload: false,
       chains: chains,
-      config: ctx.config,
+      config: config,
       isResolved: false
     };
-    await item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, ctx.config.ecosystem, UserContext.getHandlerContext(contextParams)));
+    await item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext(contextParams)));
     contextParams.isResolved = true;
     return;
   } catch (raw_exn) {
@@ -100,7 +101,7 @@ async function runHandlerOrThrow(item, checkpointId, inMemoryStore, loadManager,
   }
 }
 
-async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMemoryStore, chains) {
+async function preloadBatchOrThrow(batch, loadManager, persistence, config, indexerState, chains) {
   let promises = [];
   let itemIdx = 0;
   for (let checkpointIdx = 0, checkpointIdx_finish = batch.checkpointIds.length; checkpointIdx < checkpointIdx_finish; ++checkpointIdx) {
@@ -117,11 +118,11 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMe
           try {
             let timerRef = Prometheus.PreloadHandler.startOperation(contractName, eventName);
             promises.push(Utils.$$Promise.silentCatch(handler({
-              event: item.event,
+              event: Ecosystem.getItemEvent(item, config.ecosystem),
               context: UserContext.getHandlerContext({
                 item: item,
                 checkpointId: checkpointId,
-                inMemoryStore: inMemoryStore,
+                indexerState: indexerState,
                 loadManager: loadManager,
                 persistence: persistence,
                 isPreload: true,
@@ -139,7 +140,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMe
           promises.push(Utils.$$Promise.silentCatch(item.onBlockConfig.handler(Ecosystem.makeOnBlockArgs(item.blockNumber, config.ecosystem, UserContext.getHandlerContext({
             item: item,
             checkpointId: checkpointId,
-            inMemoryStore: inMemoryStore,
+            indexerState: indexerState,
             loadManager: loadManager,
             persistence: persistence,
             isPreload: true,
@@ -157,14 +158,14 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inMe
   await Promise.all(promises);
 }
 
-async function runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, chains) {
+async function runBatchHandlersOrThrow(batch, indexerState, loadManager, persistence, config, chains) {
   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, chains);
+      await runHandlerOrThrow(item, checkpointId, indexerState, loadManager, persistence, config, chains);
     }
     itemIdx = itemIdx + checkpointEventsProcessed | 0;
   }
@@ -179,9 +180,9 @@ function registerProcessEventBatchMetrics(logger, loadDuration, handlerDuration)
   Prometheus.ProcessingBatch.registerMetrics(loadDuration, handlerDuration);
 }
 
-async function processEventBatch(batch, inMemoryStore, loadManager, ctx, chainFetchers) {
+async function processEventBatch(batch, indexerState, loadManager, persistence, config, chainStates) {
   let totalBatchSize = batch.totalBatchSize;
-  let chains = computeChainsState(chainFetchers);
+  let chains = computeChainsState(chainStates);
   let logger = Logging.getLogger();
   Logging.childTrace(logger, {
     msg: "Started processing batch",
@@ -192,17 +193,17 @@ async function processEventBatch(batch, inMemoryStore, loadManager, ctx, chainFe
     }))
   });
   try {
-    await InMemoryStore.awaitCapacity(inMemoryStore);
+    await Writing.awaitCapacity(indexerState);
     let timeRef = Hrtime.makeTimer();
     if (Utils.$$Array.notEmpty(batch.items)) {
-      await preloadBatchOrThrow(batch, loadManager, ctx.persistence, ctx.config, inMemoryStore, chains);
+      await preloadBatchOrThrow(batch, loadManager, persistence, config, indexerState, chains);
     }
     let elapsedTimeAfterLoaders = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
     if (Utils.$$Array.notEmpty(batch.items)) {
-      await runBatchHandlersOrThrow(batch, inMemoryStore, loadManager, ctx, chains);
+      await runBatchHandlersOrThrow(batch, indexerState, loadManager, persistence, config, chains);
     }
     let elapsedTimeAfterProcessing = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
-    InMemoryStore.commitBatch(inMemoryStore, batch);
+    Writing.commitBatch(indexerState, batch);
     let handlerDuration = elapsedTimeAfterProcessing - elapsedTimeAfterLoaders;
     registerProcessEventBatchMetrics(logger, elapsedTimeAfterLoaders, handlerDuration);
     return {
@@ -219,7 +220,7 @@ async function processEventBatch(batch, inMemoryStore, loadManager, ctx, chainFe
     } else if (exn.RE_EXN_ID === ProcessingError) {
       return {
         TAG: "Error",
-        _0: ErrorHandling.make(exn.exn, Logging.getItemLogger(exn.item), exn.message)
+        _0: ErrorHandling.make(exn.exn, Ecosystem.getItemLogger(exn.item, config.ecosystem), exn.message)
       };
     } else {
       return {

package/src/EventUtils.res

@@ -1,7 +1,3 @@
-let isEarlierUnordered = (item1: (int, int, int), item2: (int, int, int)) => {
-  item1 < item2
-}
-
 // type eventIndex = {
 //   blockNumber: int,
 //   logIndex: int,

package/src/EventUtils.res.mjs

@@ -1,8 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-
-let isEarlierUnordered = Primitive_object.lessthan;
 
 function packEventIndex(blockNumber, logIndex) {
   let blockNumber$1 = BigInt(blockNumber);
@@ -12,7 +9,6 @@ function packEventIndex(blockNumber, logIndex) {
 }
 
 export {
-  isEarlierUnordered,
   packEventIndex,
 }
 /* No side effect */

package/src/ExitOnCaughtUp.res

@@ -0,0 +1,10 @@
+// Flush, then exit unless a reorg landed during the flush (which parks a
+// rollback to recover instead).
+let run = async (state: IndexerState.t) => {
+  ChainMetadata.stage(state)
+  await state->Writing.flush
+  if !(state->IndexerState.isStopped) && !(state->IndexerState.isResolvingReorg) {
+    Logging.info("Exiting with success")
+    NodeJs.process->NodeJs.exitWithCode(Success)
+  }
+}

package/src/ExitOnCaughtUp.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Logging from "./Logging.res.mjs";
+import * as Writing from "./Writing.res.mjs";
+import * as Process from "process";
+import * as IndexerState from "./IndexerState.res.mjs";
+import * as ChainMetadata from "./ChainMetadata.res.mjs";
+
+async function run(state) {
+  ChainMetadata.stage(state);
+  await Writing.flush(state);
+  if (!IndexerState.isStopped(state) && !IndexerState.isResolvingReorg(state)) {
+    Logging.info("Exiting with success");
+    Process.exit(0);
+    return;
+  }
+}
+
+export {
+  run,
+}
+/* Logging Not a pure module */