envio 3.1.1 → 3.2.0

package/src/GlobalState.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Env from "./Env.res.mjs";
-import * as Batch from "./Batch.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
@@ -9,10 +8,8 @@ import * as Logging from "./Logging.res.mjs";
 import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as FetchState from "./FetchState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
-import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
 import * as LoadManager from "./LoadManager.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
@@ -54,8 +51,6 @@ function make$1(ctx, chainManager, isDevelopmentModeOpt, shouldUseTuiOpt, exitAf
   return {
     ctx: ctx,
     chainManager: chainManager,
-    processedBatches: 0,
-    currentlyProcessingBatch: false,
     rollbackState: "NoRollback",
     indexerStartTime: new Date(),
     writeThrottlers: make(),
@@ -75,8 +70,6 @@ function setChainManager(self, chainManager) {
   return {
     ctx: self.ctx,
     chainManager: chainManager,
-    processedBatches: self.processedBatches,
-    currentlyProcessingBatch: self.currentlyProcessingBatch,
     rollbackState: self.rollbackState,
     indexerStartTime: self.indexerStartTime,
     writeThrottlers: self.writeThrottlers,
@@ -99,8 +92,8 @@ function isPreparingRollback(state) {
 
 function updateChainMetadataTable(cm, inMemoryStore) {
   let chainsData = {};
-  Belt_Array.forEach(ChainMap.values(cm.chainFetchers), cf => {
-    chainsData[String(cf.chainConfig.id)] = {
+  ChainMap.values(cm.chainFetchers).forEach(cf => {
+    chainsData[cf.chainConfig.id.toString()] = {
       first_event_block: Stdlib_Null.fromOption(cf.fetchState.firstEventBlock),
       buffer_block: FetchState.bufferBlockNumber(cf.fetchState),
       ready_at: Stdlib_Null.fromOption(cf.timestampCaughtUpToHeadOrEndblock),
@@ -110,141 +103,6 @@ function updateChainMetadataTable(cm, inMemoryStore) {
   InMemoryStore.setChainMeta(inMemoryStore, chainsData);
 }
 
-function updateProgressedChains(chainManager, batch, ctx) {
-  let nextQueueItemIsNone = ChainManager.nextItemIsNone(chainManager);
-  let allChainsAtHead = ChainManager.isProgressAtHead(chainManager);
-  let allChainsReady = {
-    contents: true
-  };
-  let chainFetchers = ChainMap.map(chainManager.chainFetchers, prev => {
-    let chain = ChainMap.Chain.makeUnsafe(prev.chainConfig.id);
-    let maybeChainAfterBatch = batch.progressedChainsById[chain];
-    let cf;
-    if (maybeChainAfterBatch !== undefined) {
-      if (prev.committedProgressBlockNumber !== maybeChainAfterBatch.progressBlockNumber) {
-        Prometheus.ProgressBlockNumber.set(maybeChainAfterBatch.progressBlockNumber, chain);
-      }
-      if (prev.numEventsProcessed !== maybeChainAfterBatch.totalEventsProcessed) {
-        Prometheus.ProgressEventsCount.set(maybeChainAfterBatch.totalEventsProcessed, chain);
-      }
-      let eventItem = Batch.findLastEventItem(batch, chain);
-      if (eventItem !== undefined) {
-        let blockTimestamp = ctx.config.ecosystem.getTimestamp(eventItem.event.block);
-        let currentTimeMs = Date.now() | 0;
-        let blockTimestampMs = blockTimestamp * 1000 | 0;
-        let latencyMs = currentTimeMs - blockTimestampMs | 0;
-        Prometheus.ProgressLatency.set(latencyMs, chain);
-      }
-      let match = prev.fetchState.firstEventBlock;
-      let tmp;
-      if (match !== undefined) {
-        tmp = prev.fetchState;
-      } else {
-        let firstEventBlock = Batch.findFirstEventBlockNumber(batch, chain);
-        if (firstEventBlock !== undefined) {
-          let init = prev.fetchState;
-          tmp = {
-            optimizedPartitions: init.optimizedPartitions,
-            startBlock: init.startBlock,
-            endBlock: init.endBlock,
-            normalSelection: init.normalSelection,
-            indexingAddresses: init.indexingAddresses,
-            contractConfigs: init.contractConfigs,
-            chainId: init.chainId,
-            latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
-            blockLag: init.blockLag,
-            buffer: init.buffer,
-            targetBufferSize: init.targetBufferSize,
-            onBlockConfigs: init.onBlockConfigs,
-            knownHeight: init.knownHeight,
-            firstEventBlock: firstEventBlock
-          };
-        } else {
-          tmp = prev.fetchState;
-        }
-      }
-      let safeCheckpointTracking = prev.safeCheckpointTracking;
-      cf = {
-        logger: prev.logger,
-        fetchState: tmp,
-        sourceManager: prev.sourceManager,
-        chainConfig: prev.chainConfig,
-        isProgressAtHead: prev.isProgressAtHead || maybeChainAfterBatch.isProgressAtHeadWhenBatchCreated,
-        timestampCaughtUpToHeadOrEndblock: prev.timestampCaughtUpToHeadOrEndblock,
-        committedProgressBlockNumber: maybeChainAfterBatch.progressBlockNumber,
-        numEventsProcessed: maybeChainAfterBatch.totalEventsProcessed,
-        reorgDetection: prev.reorgDetection,
-        safeCheckpointTracking: safeCheckpointTracking !== undefined ? SafeCheckpointTracking.updateOnNewBatch(safeCheckpointTracking, prev.fetchState.knownHeight, chain, batch.checkpointIds, batch.checkpointBlockNumbers, batch.checkpointChainIds) : undefined
-      };
-    } else {
-      cf = prev;
-    }
-    let cf$1;
-    if (ChainFetcher.hasProcessedToEndblock(cf)) {
-      let timestampCaughtUpToHeadOrEndblock = ChainFetcher.isReady(cf) ? cf.timestampCaughtUpToHeadOrEndblock : new Date();
-      cf$1 = {
-        logger: cf.logger,
-        fetchState: cf.fetchState,
-        sourceManager: cf.sourceManager,
-        chainConfig: cf.chainConfig,
-        isProgressAtHead: cf.isProgressAtHead,
-        timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock,
-        committedProgressBlockNumber: cf.committedProgressBlockNumber,
-        numEventsProcessed: cf.numEventsProcessed,
-        reorgDetection: cf.reorgDetection,
-        safeCheckpointTracking: cf.safeCheckpointTracking
-      };
-    } else if (!ChainFetcher.isReady(cf) && cf.isProgressAtHead) {
-      if (nextQueueItemIsNone && allChainsAtHead) {
-        cf$1 = {
-          logger: cf.logger,
-          fetchState: cf.fetchState,
-          sourceManager: cf.sourceManager,
-          chainConfig: cf.chainConfig,
-          isProgressAtHead: cf.isProgressAtHead,
-          timestampCaughtUpToHeadOrEndblock: new Date(),
-          committedProgressBlockNumber: cf.committedProgressBlockNumber,
-          numEventsProcessed: cf.numEventsProcessed,
-          reorgDetection: cf.reorgDetection,
-          safeCheckpointTracking: cf.safeCheckpointTracking
-        };
-      } else {
-        let hasNoMoreEventsToProcess = ChainFetcher.hasNoMoreEventsToProcess(cf);
-        cf$1 = hasNoMoreEventsToProcess ? ({
-            logger: cf.logger,
-            fetchState: cf.fetchState,
-            sourceManager: cf.sourceManager,
-            chainConfig: cf.chainConfig,
-            isProgressAtHead: cf.isProgressAtHead,
-            timestampCaughtUpToHeadOrEndblock: new Date(),
-            committedProgressBlockNumber: cf.committedProgressBlockNumber,
-            numEventsProcessed: cf.numEventsProcessed,
-            reorgDetection: cf.reorgDetection,
-            safeCheckpointTracking: cf.safeCheckpointTracking
-          }) : cf;
-      }
-    } else {
-      cf$1 = cf;
-    }
-    if (ChainFetcher.isReady(cf$1)) {
-      if (!ChainFetcher.isReady(prev)) {
-        Prometheus.ProgressReady.set(chain);
-      }
-    } else {
-      allChainsReady.contents = false;
-    }
-    return cf$1;
-  });
-  if (allChainsReady.contents) {
-    Prometheus.ProgressReady.setAllReady();
-  }
-  return {
-    chainFetchers: chainFetchers,
-    isInReorgThreshold: chainManager.isInReorgThreshold,
-    isRealtime: chainManager.isRealtime || allChainsReady.contents
-  };
-}
-
 function validatePartitionQueryResponse(state, partitionQueryResponse) {
   let response = partitionQueryResponse.response;
   let chain = partitionQueryResponse.chain;
@@ -254,7 +112,7 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
   if (knownHeight > chainFetcher.fetchState.knownHeight) {
     Prometheus.SourceHeight.set(SourceManager.getActiveSource(chainFetcher.sourceManager).name, chainFetcher.chainConfig.id, knownHeight);
   }
-  Prometheus.FetchingBlockRange.increment(chain, stats["total time elapsed (s)"], Belt_Option.getWithDefault(stats["parsing time (s)"], 0), response.parsedQueueItems.length, (response.latestFetchedBlockNumber - response.fromBlockQueried | 0) + 1 | 0);
+  Prometheus.FetchingBlockRange.increment(chain, stats["total time elapsed (s)"], Stdlib_Option.getOr(stats["parsing time (s)"], 0), response.parsedQueueItems.length, (response.latestFetchedBlockNumber - response.fromBlockQueried | 0) + 1 | 0);
   let match = ReorgDetection.registerReorgGuard(chainFetcher.reorgDetection, response.blockHashes, knownHeight);
   let reorgResult = match[1];
   let updatedChainFetcher_logger = chainFetcher.logger;
@@ -286,8 +144,6 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     isInReorgThreshold: init.isInReorgThreshold,
     isRealtime: init.isRealtime
   };
-  let nextState_processedBatches = state.processedBatches;
-  let nextState_currentlyProcessingBatch = state.currentlyProcessingBatch;
   let nextState_rollbackState = state.rollbackState;
   let nextState_indexerStartTime = state.indexerStartTime;
   let nextState_writeThrottlers = state.writeThrottlers;
@@ -299,8 +155,6 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
   let nextState = {
     ctx: nextState_ctx,
     chainManager: nextState_chainManager,
-    processedBatches: nextState_processedBatches,
-    currentlyProcessingBatch: nextState_currentlyProcessingBatch,
     rollbackState: nextState_rollbackState,
     indexerStartTime: nextState_indexerStartTime,
     writeThrottlers: nextState_writeThrottlers,
@@ -379,8 +233,6 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
         isInReorgThreshold: chainManager.isInReorgThreshold,
         isRealtime: chainManager.isRealtime
       },
-      processedBatches: nextState_processedBatches,
-      currentlyProcessingBatch: nextState_currentlyProcessingBatch,
       rollbackState: {
         TAG: "ReorgDetected",
         chain: chain,
@@ -481,8 +333,6 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
     isInReorgThreshold: init$2.isInReorgThreshold,
     isRealtime: init$2.isRealtime
   };
-  let nextState_processedBatches = state.processedBatches;
-  let nextState_currentlyProcessingBatch = state.currentlyProcessingBatch;
   let nextState_rollbackState = state.rollbackState;
   let nextState_indexerStartTime = state.indexerStartTime;
   let nextState_writeThrottlers = state.writeThrottlers;
@@ -494,8 +344,6 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
   let nextState = {
     ctx: nextState_ctx,
     chainManager: nextState_chainManager,
-    processedBatches: nextState_processedBatches,
-    currentlyProcessingBatch: nextState_currentlyProcessingBatch,
     rollbackState: nextState_rollbackState,
     indexerStartTime: nextState_indexerStartTime,
     writeThrottlers: nextState_writeThrottlers,
@@ -561,8 +409,6 @@ function updateChainFetcher(chainFetcherUpdate, state, chain) {
         isInReorgThreshold: init.isInReorgThreshold,
         isRealtime: init.isRealtime
       },
-      processedBatches: state.processedBatches,
-      currentlyProcessingBatch: state.currentlyProcessingBatch,
       rollbackState: state.rollbackState,
       indexerStartTime: state.indexerStartTime,
       writeThrottlers: state.writeThrottlers,
@@ -599,8 +445,6 @@ function onEnterReorgThreshold(state) {
       isInReorgThreshold: true,
       isRealtime: init.isRealtime
     },
-    processedBatches: state.processedBatches,
-    currentlyProcessingBatch: state.currentlyProcessingBatch,
     rollbackState: state.rollbackState,
     indexerStartTime: state.indexerStartTime,
     writeThrottlers: state.writeThrottlers,
@@ -612,324 +456,232 @@ function onEnterReorgThreshold(state) {
   };
 }
 
-function actionReducer(state, action) {
-  if (typeof action !== "object") {
-    switch (action) {
-      case "StartProcessingBatch" :
-        return [
-          {
-            ctx: state.ctx,
-            chainManager: state.chainManager,
-            processedBatches: state.processedBatches,
-            currentlyProcessingBatch: true,
-            rollbackState: state.rollbackState,
-            indexerStartTime: state.indexerStartTime,
-            writeThrottlers: state.writeThrottlers,
-            loadManager: state.loadManager,
-            keepProcessAlive: state.keepProcessAlive,
-            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-            onError: state.onError,
-            id: state.id
-          },
-          []
-        ];
-      case "StartFindingReorgDepth" :
-        return [
-          {
-            ctx: state.ctx,
-            chainManager: state.chainManager,
-            processedBatches: state.processedBatches,
-            currentlyProcessingBatch: state.currentlyProcessingBatch,
-            rollbackState: "FindingReorgDepth",
-            indexerStartTime: state.indexerStartTime,
-            writeThrottlers: state.writeThrottlers,
-            loadManager: state.loadManager,
-            keepProcessAlive: state.keepProcessAlive,
-            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-            onError: state.onError,
-            id: state.id
-          },
-          []
-        ];
-      case "EnterReorgThreshold" :
-        return [
-          onEnterReorgThreshold(state),
-          [{
-              TAG: "NextQuery",
-              _0: "CheckAllChains"
-            }]
-        ];
-      case "SuccessExit" :
-        Logging.info("Exiting with success");
-        Process.exit(0);
-        return [
-          state,
-          []
-        ];
-    }
-  } else {
-    switch (action.TAG) {
-      case "ValidatePartitionQueryResponse" :
-        return validatePartitionQueryResponse(state, action._0);
-      case "SubmitPartitionQueryResponse" :
-        return submitPartitionQueryResponse(state, action.newItems, action.newItemsWithDcs, action.knownHeight, action.latestFetchedBlock, action.query, action.chain);
-      case "FinishWaitingForNewBlock" :
-        let knownHeight = action.knownHeight;
-        let chain = action.chain;
-        let updatedChainFetchers = ChainMap.update(state.chainManager.chainFetchers, chain, chainFetcher => {
-          let updatedFetchState = FetchState.updateKnownHeight(chainFetcher.fetchState, knownHeight);
-          if (updatedFetchState !== chainFetcher.fetchState) {
-            return {
-              logger: chainFetcher.logger,
-              fetchState: updatedFetchState,
-              sourceManager: chainFetcher.sourceManager,
-              chainConfig: chainFetcher.chainConfig,
-              isProgressAtHead: chainFetcher.isProgressAtHead,
-              timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
-              committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
-              numEventsProcessed: chainFetcher.numEventsProcessed,
-              reorgDetection: chainFetcher.reorgDetection,
-              safeCheckpointTracking: chainFetcher.safeCheckpointTracking
-            };
-          } else {
-            return chainFetcher;
-          }
-        });
-        let isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
-        let shouldEnterReorgThreshold = isBelowReorgThreshold && ChainMap.values(updatedChainFetchers).every(chainFetcher => FetchState.isReadyToEnterReorgThreshold(chainFetcher.fetchState));
-        let init = state.chainManager;
-        let state_ctx = state.ctx;
-        let state_chainManager = {
-          chainFetchers: updatedChainFetchers,
-          isInReorgThreshold: init.isInReorgThreshold,
-          isRealtime: init.isRealtime
-        };
-        let state_processedBatches = state.processedBatches;
-        let state_currentlyProcessingBatch = state.currentlyProcessingBatch;
-        let state_rollbackState = state.rollbackState;
-        let state_indexerStartTime = state.indexerStartTime;
-        let state_writeThrottlers = state.writeThrottlers;
-        let state_loadManager = state.loadManager;
-        let state_keepProcessAlive = state.keepProcessAlive;
-        let state_exitAfterFirstEventBlock = state.exitAfterFirstEventBlock;
-        let state_onError = state.onError;
-        let state_id = state.id;
-        let state$1 = {
-          ctx: state_ctx,
-          chainManager: state_chainManager,
-          processedBatches: state_processedBatches,
-          currentlyProcessingBatch: state_currentlyProcessingBatch,
-          rollbackState: state_rollbackState,
-          indexerStartTime: state_indexerStartTime,
-          writeThrottlers: state_writeThrottlers,
-          loadManager: state_loadManager,
-          keepProcessAlive: state_keepProcessAlive,
-          exitAfterFirstEventBlock: state_exitAfterFirstEventBlock,
-          onError: state_onError,
-          id: state_id
-        };
-        if (shouldEnterReorgThreshold) {
+function injectedActionReducer(markBatchProcessed) {
+  return (state, action) => {
+    if (typeof action !== "object") {
+      switch (action) {
+        case "StartFindingReorgDepth" :
           return [
-            onEnterReorgThreshold(state$1),
-            [
-              {
+            {
+              ctx: state.ctx,
+              chainManager: state.chainManager,
+              rollbackState: "FindingReorgDepth",
+              indexerStartTime: state.indexerStartTime,
+              writeThrottlers: state.writeThrottlers,
+              loadManager: state.loadManager,
+              keepProcessAlive: state.keepProcessAlive,
+              exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+              onError: state.onError,
+              id: state.id
+            },
+            []
+          ];
+        case "EnterReorgThreshold" :
+          return [
+            onEnterReorgThreshold(state),
+            [{
                 TAG: "NextQuery",
                 _0: "CheckAllChains"
-              },
-              "ProcessEventBatch"
-            ]
+              }]
           ];
-        } else {
+        case "SuccessExit" :
+          Logging.info("Exiting with success");
+          Process.exit(0);
           return [
-            state$1,
-            [
-              {
-                TAG: "NextQuery",
-                _0: {
-                  TAG: "Chain",
-                  _0: chain
-                }
-              },
-              "ProcessEventBatch"
-            ]
+            state,
+            []
           ];
-        }
-      case "EventBatchProcessed" :
-        let maybePruneEntityHistory = Config.shouldPruneHistory(state.ctx.config, state.chainManager.isInReorgThreshold) ? ["PruneStaleEntityHistory"] : [];
-        let state_ctx$1 = state.ctx;
-        let state_chainManager$1 = updateProgressedChains(state.chainManager, action.batch, state.ctx);
-        let state_processedBatches$1 = state.processedBatches + 1 | 0;
-        let state_indexerStartTime$1 = state.indexerStartTime;
-        let state_writeThrottlers$1 = state.writeThrottlers;
-        let state_loadManager$1 = state.loadManager;
-        let state_keepProcessAlive$1 = state.keepProcessAlive;
-        let state_exitAfterFirstEventBlock$1 = state.exitAfterFirstEventBlock;
-        let state_onError$1 = state.onError;
-        let state_id$1 = state.id;
-        let state$2 = {
-          ctx: state_ctx$1,
-          chainManager: state_chainManager$1,
-          processedBatches: state_processedBatches$1,
-          currentlyProcessingBatch: false,
-          rollbackState: "NoRollback",
-          indexerStartTime: state_indexerStartTime$1,
-          writeThrottlers: state_writeThrottlers$1,
-          loadManager: state_loadManager$1,
-          keepProcessAlive: state_keepProcessAlive$1,
-          exitAfterFirstEventBlock: state_exitAfterFirstEventBlock$1,
-          onError: state_onError$1,
-          id: state_id$1
-        };
-        let shouldExit = EventProcessing.allChainsEventsProcessedToEndblock(state_chainManager$1.chainFetchers) ? (Logging.info("All chains are caught up to end blocks."), state_keepProcessAlive$1 ? "NoExit" : "ExitWithSuccess") : (
-            state_exitAfterFirstEventBlock$1 && ChainMap.values(state_chainManager$1.chainFetchers).every(cf => {
-              if (cf.isProgressAtHead) {
-                return Belt_Option.isNone(cf.fetchState.endBlock);
-              } else {
-                return false;
-              }
-            }) ? ({
-                TAG: "ExitWithError",
-                _0: "No events found between startBlock and chain head. Cannot auto-detect endBlock."
-              }) : "NoExit"
-          );
-        let tasks;
-        tasks = typeof shouldExit !== "object" ? (
-            shouldExit === "ExitWithSuccess" ? [{
-                  TAG: "UpdateChainMetaDataAndCheckForExit",
-                  _0: shouldExit
-                }] : [
+      }
+    } else {
+      switch (action.TAG) {
+        case "ValidatePartitionQueryResponse" :
+          return validatePartitionQueryResponse(state, action._0);
+        case "SubmitPartitionQueryResponse" :
+          return submitPartitionQueryResponse(state, action.newItems, action.newItemsWithDcs, action.knownHeight, action.latestFetchedBlock, action.query, action.chain);
+        case "FinishWaitingForNewBlock" :
+          let knownHeight = action.knownHeight;
+          let chain = action.chain;
+          let updatedChainFetchers = ChainMap.update(state.chainManager.chainFetchers, chain, chainFetcher => {
+            let updatedFetchState = FetchState.updateKnownHeight(chainFetcher.fetchState, knownHeight);
+            if (updatedFetchState !== chainFetcher.fetchState) {
+              return {
+                logger: chainFetcher.logger,
+                fetchState: updatedFetchState,
+                sourceManager: chainFetcher.sourceManager,
+                chainConfig: chainFetcher.chainConfig,
+                isProgressAtHead: chainFetcher.isProgressAtHead,
+                timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
+                committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
+                numEventsProcessed: chainFetcher.numEventsProcessed,
+                reorgDetection: chainFetcher.reorgDetection,
+                safeCheckpointTracking: chainFetcher.safeCheckpointTracking
+              };
+            } else {
+              return chainFetcher;
+            }
+          });
+          let isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
+          let shouldEnterReorgThreshold = isBelowReorgThreshold && ChainMap.values(updatedChainFetchers).every(chainFetcher => FetchState.isReadyToEnterReorgThreshold(chainFetcher.fetchState));
+          let init = state.chainManager;
+          let state_ctx = state.ctx;
+          let state_chainManager = {
+            chainFetchers: updatedChainFetchers,
+            isInReorgThreshold: init.isInReorgThreshold,
+            isRealtime: init.isRealtime
+          };
+          let state_rollbackState = state.rollbackState;
+          let state_indexerStartTime = state.indexerStartTime;
+          let state_writeThrottlers = state.writeThrottlers;
+          let state_loadManager = state.loadManager;
+          let state_keepProcessAlive = state.keepProcessAlive;
+          let state_exitAfterFirstEventBlock = state.exitAfterFirstEventBlock;
+          let state_onError = state.onError;
+          let state_id = state.id;
+          let state$1 = {
+            ctx: state_ctx,
+            chainManager: state_chainManager,
+            rollbackState: state_rollbackState,
+            indexerStartTime: state_indexerStartTime,
+            writeThrottlers: state_writeThrottlers,
+            loadManager: state_loadManager,
+            keepProcessAlive: state_keepProcessAlive,
+            exitAfterFirstEventBlock: state_exitAfterFirstEventBlock,
+            onError: state_onError,
+            id: state_id
+          };
+          if (shouldEnterReorgThreshold) {
+            return [
+              onEnterReorgThreshold(state$1),
+              [
                 {
-                  TAG: "UpdateChainMetaDataAndCheckForExit",
-                  _0: shouldExit
+                  TAG: "NextQuery",
+                  _0: "CheckAllChains"
                 },
                 "ProcessEventBatch"
-              ].concat(maybePruneEntityHistory)
-          ) : [{
-              TAG: "UpdateChainMetaDataAndCheckForExit",
-              _0: shouldExit
-            }];
-        return [
-          state$2,
-          tasks
-        ];
-      case "FindReorgDepth" :
-        return [
-          {
-            ctx: state.ctx,
-            chainManager: state.chainManager,
-            processedBatches: state.processedBatches,
-            currentlyProcessingBatch: state.currentlyProcessingBatch,
-            rollbackState: {
-              TAG: "FoundReorgDepth",
-              chain: action.chain,
-              rollbackTargetBlockNumber: action.rollbackTargetBlockNumber
-            },
-            indexerStartTime: state.indexerStartTime,
-            writeThrottlers: state.writeThrottlers,
-            loadManager: state.loadManager,
-            keepProcessAlive: state.keepProcessAlive,
-            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-            onError: state.onError,
-            id: state.id
-          },
-          ["Rollback"]
-        ];
-      case "UpdateQueues" :
-        let shouldEnterReorgThreshold$1 = action.shouldEnterReorgThreshold;
-        let progressedChainsById = action.progressedChainsById;
-        let chainFetchers = ChainMap.mapWithKey(state.chainManager.chainFetchers, (chain, cf) => {
-          let chainAfterBatch = progressedChainsById[chain];
-          let fs = chainAfterBatch !== undefined ? chainAfterBatch.fetchState : cf.fetchState;
-          return {
-            logger: cf.logger,
-            fetchState: shouldEnterReorgThreshold$1 ? FetchState.updateInternal(fs, undefined, undefined, undefined, cf.chainConfig.blockLag, undefined) : fs,
-            sourceManager: cf.sourceManager,
-            chainConfig: cf.chainConfig,
-            isProgressAtHead: cf.isProgressAtHead,
-            timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
-            committedProgressBlockNumber: cf.committedProgressBlockNumber,
-            numEventsProcessed: cf.numEventsProcessed,
-            reorgDetection: cf.reorgDetection,
-            safeCheckpointTracking: cf.safeCheckpointTracking
+              ]
+            ];
+          } else {
+            return [
+              state$1,
+              [
+                {
+                  TAG: "NextQuery",
+                  _0: {
+                    TAG: "Chain",
+                    _0: chain
+                  }
+                },
+                "ProcessEventBatch"
+              ]
+            ];
+          }
+        case "EventBatchProcessed" :
+          let maybePruneEntityHistory = Config.shouldPruneHistory(state.ctx.config, state.chainManager.isInReorgThreshold) ? ["PruneStaleEntityHistory"] : [];
+          markBatchProcessed();
+          let state_ctx$1 = state.ctx;
+          let state_chainManager$1 = ChainManager.updateProgressedChains(state.chainManager, action.batch);
+          let state_indexerStartTime$1 = state.indexerStartTime;
+          let state_writeThrottlers$1 = state.writeThrottlers;
+          let state_loadManager$1 = state.loadManager;
+          let state_keepProcessAlive$1 = state.keepProcessAlive;
+          let state_exitAfterFirstEventBlock$1 = state.exitAfterFirstEventBlock;
+          let state_onError$1 = state.onError;
+          let state_id$1 = state.id;
+          let state$2 = {
+            ctx: state_ctx$1,
+            chainManager: state_chainManager$1,
+            rollbackState: "NoRollback",
+            indexerStartTime: state_indexerStartTime$1,
+            writeThrottlers: state_writeThrottlers$1,
+            loadManager: state_loadManager$1,
+            keepProcessAlive: state_keepProcessAlive$1,
+            exitAfterFirstEventBlock: state_exitAfterFirstEventBlock$1,
+            onError: state_onError$1,
+            id: state_id$1
           };
-        });
-        let init$1 = state.chainManager;
-        let chainManager_isInReorgThreshold = init$1.isInReorgThreshold;
-        let chainManager_isRealtime = init$1.isRealtime;
-        let chainManager = {
-          chainFetchers: chainFetchers,
-          isInReorgThreshold: chainManager_isInReorgThreshold,
-          isRealtime: chainManager_isRealtime
-        };
-        return [
-          {
-            ctx: state.ctx,
-            chainManager: chainManager,
-            processedBatches: state.processedBatches,
-            currentlyProcessingBatch: state.currentlyProcessingBatch,
-            rollbackState: state.rollbackState,
-            indexerStartTime: state.indexerStartTime,
-            writeThrottlers: state.writeThrottlers,
-            loadManager: state.loadManager,
-            keepProcessAlive: state.keepProcessAlive,
-            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-            onError: state.onError,
-            id: state.id
-          },
-          [{
-              TAG: "NextQuery",
-              _0: "CheckAllChains"
-            }]
-        ];
-      case "ErrorExit" :
-        state.onError(action._0);
-        return [
-          state,
-          []
-        ];
-      case "SetRollbackState" :
-        return [
-          {
-            ctx: state.ctx,
-            chainManager: action.rollbackedChainManager,
-            processedBatches: state.processedBatches,
-            currentlyProcessingBatch: state.currentlyProcessingBatch,
-            rollbackState: {
-              TAG: "RollbackReady",
-              eventsProcessedDiffByChain: action.eventsProcessedDiffByChain
-            },
-            indexerStartTime: state.indexerStartTime,
-            writeThrottlers: state.writeThrottlers,
-            loadManager: state.loadManager,
-            keepProcessAlive: state.keepProcessAlive,
-            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-            onError: state.onError,
-            id: state.id
-          },
-          [
+          let shouldExit = EventProcessing.allChainsEventsProcessedToEndblock(state_chainManager$1.chainFetchers) ? (Logging.info("All chains are caught up to end blocks."), state_keepProcessAlive$1 ? "NoExit" : "ExitWithSuccess") : (
+              state_exitAfterFirstEventBlock$1 && ChainMap.values(state_chainManager$1.chainFetchers).every(cf => {
+                if (cf.isProgressAtHead) {
+                  return Stdlib_Option.isNone(cf.fetchState.endBlock);
+                } else {
+                  return false;
+                }
+              }) ? ({
+                  TAG: "ExitWithError",
+                  _0: "No events found between startBlock and chain head. Cannot auto-detect endBlock."
+                }) : "NoExit"
+            );
+          let tasks;
+          tasks = typeof shouldExit !== "object" ? (
+              shouldExit === "ExitWithSuccess" ? [{
+                    TAG: "UpdateChainMetaDataAndCheckForExit",
+                    _0: shouldExit
+                  }] : [
+                  {
+                    TAG: "UpdateChainMetaDataAndCheckForExit",
+                    _0: shouldExit
+                  },
+                  "ProcessEventBatch"
+                ].concat(maybePruneEntityHistory)
+            ) : [{
+                TAG: "UpdateChainMetaDataAndCheckForExit",
+                _0: shouldExit
+              }];
+          return [
+            state$2,
+            tasks
+          ];
+        case "FindReorgDepth" :
+          return [
             {
-              TAG: "NextQuery",
-              _0: "CheckAllChains"
+              ctx: state.ctx,
+              chainManager: state.chainManager,
+              rollbackState: {
+                TAG: "FoundReorgDepth",
+                chain: action.chain,
+                rollbackTargetBlockNumber: action.rollbackTargetBlockNumber
+              },
+              indexerStartTime: state.indexerStartTime,
+              writeThrottlers: state.writeThrottlers,
+              loadManager: state.loadManager,
+              keepProcessAlive: state.keepProcessAlive,
+              exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+              onError: state.onError,
+              id: state.id
             },
-            "ProcessEventBatch"
-          ]
-        ];
-    }
-  }
-}
-
-function invalidatedActionReducer(state, action) {
-  if (typeof action === "object") {
-    switch (action.TAG) {
-      case "EventBatchProcessed" :
-        if (isPreparingRollback(state)) {
-          Logging.info("Finished processing batch before rollback, actioning rollback");
+            ["Rollback"]
+          ];
+        case "UpdateQueues" :
+          let shouldEnterReorgThreshold$1 = action.shouldEnterReorgThreshold;
+          let progressedChainsById = action.progressedChainsById;
+          let chainFetchers = ChainMap.mapWithKey(state.chainManager.chainFetchers, (chain, cf) => {
+            let chainAfterBatch = progressedChainsById[chain];
+            let fs = chainAfterBatch !== undefined ? chainAfterBatch.fetchState : cf.fetchState;
+            return {
+              logger: cf.logger,
+              fetchState: shouldEnterReorgThreshold$1 ? FetchState.updateInternal(fs, undefined, undefined, undefined, cf.chainConfig.blockLag, undefined) : fs,
+              sourceManager: cf.sourceManager,
+              chainConfig: cf.chainConfig,
+              isProgressAtHead: cf.isProgressAtHead,
+              timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
+              committedProgressBlockNumber: cf.committedProgressBlockNumber,
+              numEventsProcessed: cf.numEventsProcessed,
+              reorgDetection: cf.reorgDetection,
+              safeCheckpointTracking: cf.safeCheckpointTracking
+            };
+          });
+          let init$1 = state.chainManager;
+          let chainManager_isInReorgThreshold = init$1.isInReorgThreshold;
+          let chainManager_isRealtime = init$1.isRealtime;
+          let chainManager = {
+            chainFetchers: chainFetchers,
+            isInReorgThreshold: chainManager_isInReorgThreshold,
+            isRealtime: chainManager_isRealtime
+          };
           return [
             {
               ctx: state.ctx,
-              chainManager: updateProgressedChains(state.chainManager, action.batch, state.ctx),
-              processedBatches: state.processedBatches + 1 | 0,
-              currentlyProcessingBatch: false,
+              chainManager: chainManager,
               rollbackState: state.rollbackState,
               indexerStartTime: state.indexerStartTime,
               writeThrottlers: state.writeThrottlers,
@@ -939,22 +691,85 @@ function invalidatedActionReducer(state, action) {
               onError: state.onError,
               id: state.id
             },
-            ["Rollback"]
+            [{
+                TAG: "NextQuery",
+                _0: "CheckAllChains"
+              }]
           ];
-        }
-        break;
-      case "ErrorExit" :
-        return actionReducer(state, action);
+        case "ErrorExit" :
+          state.onError(action._0);
+          return [
+            state,
+            []
+          ];
+        case "SetRollbackState" :
+          return [
+            {
+              ctx: state.ctx,
+              chainManager: action.rollbackedChainManager,
+              rollbackState: {
+                TAG: "RollbackReady",
+                eventsProcessedDiffByChain: action.eventsProcessedDiffByChain
+              },
+              indexerStartTime: state.indexerStartTime,
+              writeThrottlers: state.writeThrottlers,
+              loadManager: state.loadManager,
+              keepProcessAlive: state.keepProcessAlive,
+              exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+              onError: state.onError,
+              id: state.id
+            },
+            [
+              {
+                TAG: "NextQuery",
+                _0: "CheckAllChains"
+              },
+              "ProcessEventBatch"
+            ]
+          ];
+      }
     }
-  }
-  Logging.trace({
-    msg: "Invalidated action discarded",
-    action: S$RescriptSchema.convertOrThrow(action, Utils.Schema.variantTag)
-  });
-  return [
-    state,
-    []
-  ];
+  };
+}
+
+function injectedInvalidatedActionReducer(markBatchProcessed, actionReducer) {
+  return (state, action) => {
+    if (typeof action === "object") {
+      switch (action.TAG) {
+        case "EventBatchProcessed" :
+          if (isPreparingRollback(state)) {
+            Logging.info("Finished processing batch before rollback, actioning rollback");
+            markBatchProcessed();
+            return [
+              {
+                ctx: state.ctx,
+                chainManager: ChainManager.updateProgressedChains(state.chainManager, action.batch),
+                rollbackState: state.rollbackState,
+                indexerStartTime: state.indexerStartTime,
+                writeThrottlers: state.writeThrottlers,
+                loadManager: state.loadManager,
+                keepProcessAlive: state.keepProcessAlive,
+                exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+                onError: state.onError,
+                id: state.id
+              },
+              ["Rollback"]
+            ];
+          }
+          break;
+        case "ErrorExit" :
+          return actionReducer(state, action);
+      }
+    }
+    Logging.trace({
+      msg: "Invalidated action discarded",
+      action: S$RescriptSchema.convertOrThrow(action, Utils.Schema.variantTag)
+    });
+    return [
+      state,
+      []
+    ];
+  };
 }
 
 function checkAndFetchForChain(waitForNewBlock, executeQuery, state, dispatchAction) {
@@ -997,7 +812,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
     if (typeof task !== "object") {
       switch (task) {
         case "ProcessEventBatch" :
-          if (state.currentlyProcessingBatch || isPreparingRollback(state)) {
+          if (state.ctx.inMemoryStore.isProcessing || isPreparingRollback(state)) {
             return;
           }
           let match = state.rollbackState;
@@ -1027,13 +842,13 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
               return;
             }
           }
-          dispatchAction("StartProcessingBatch");
+          let inMemoryStore = state.ctx.inMemoryStore;
+          inMemoryStore.isProcessing = true;
           dispatchAction({
             TAG: "UpdateQueues",
             progressedChainsById: progressedChainsById,
             shouldEnterReorgThreshold: shouldEnterReorgThreshold
           });
-          let inMemoryStore = state.ctx.inMemoryStore;
           InMemoryStore.setBatchDcs(inMemoryStore, batch);
           let res;
           try {
@@ -1080,12 +895,11 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                 rollbackTargetBlockNumber: rollbackTargetBlockNumber
               });
             case "FoundReorgDepth" :
-              if (state.currentlyProcessingBatch) {
+              let rollbackTargetBlockNumber$1 = match$1.rollbackTargetBlockNumber;
+              let reorgChain = match$1.chain;
+              if (state.ctx.inMemoryStore.isProcessing) {
                 return Logging.info("Waiting for batch to finish processing before executing rollback");
               }
-              let match$2 = state.rollbackState;
-              let rollbackTargetBlockNumber$1 = match$2.rollbackTargetBlockNumber;
-              let reorgChain = match$2.chain;
               let startTime = Hrtime.makeTimer();
               let chainFetcher$1 = ChainMap.get(state.chainManager.chainFetchers, reorgChain);
               let logger = Logging.createChildFrom(chainFetcher$1.logger, {
@@ -1095,6 +909,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
               });
               Logging.childInfo(logger, "Started rollback on reorg");
               Prometheus.RollbackTargetBlockNumber.set(rollbackTargetBlockNumber$1, reorgChain);
+              await InMemoryStore.flush(state.ctx.inMemoryStore);
               let checkpointId = await state.ctx.persistence.storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber$1);
               let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
               let eventsProcessedDiffByChain = {};
@@ -1119,7 +934,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                       chainConfig: cf.chainConfig,
                       isProgressAtHead: cf.isProgressAtHead,
                       timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
-                      committedProgressBlockNumber: cf.committedProgressBlockNumber,
+                      committedProgressBlockNumber: Primitive_int.min(cf.committedProgressBlockNumber, rollbackTargetBlockNumber$1),
                       numEventsProcessed: cf.numEventsProcessed,
                       reorgDetection: ReorgDetection.rollbackToValidBlockNumber(cf.reorgDetection, rollbackTargetBlockNumber$1),
                       safeCheckpointTracking: cf.safeCheckpointTracking
@@ -1150,7 +965,6 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                   safeCheckpointTracking: safeCheckpointTracking !== undefined ? SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber) : undefined
                 };
               });
-              await InMemoryStore.flush(state.ctx.inMemoryStore);
               let diff$1 = await InMemoryStore.prepareRollbackDiff(state.ctx.inMemoryStore, state.ctx.persistence, rollbackTargetCheckpointId, state.ctx.inMemoryStore.committedCheckpointId + 1n, newProgressBlockNumberPerChain);
               let init = state.chainManager;
               let chainManager_isInReorgThreshold = init.isInReorgThreshold;
@@ -1239,7 +1053,17 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
   };
 }
 
-let taskReducer = injectedTaskReducer(SourceManager.waitForNewBlock, SourceManager.executeQuery, ChainFetcher.getLastKnownValidBlock);
+function makeReducers(waitForNewBlockOpt, executeQueryOpt, getLastKnownValidBlockOpt, markBatchProcessed) {
+  let waitForNewBlock = waitForNewBlockOpt !== undefined ? waitForNewBlockOpt : SourceManager.waitForNewBlock;
+  let executeQuery = executeQueryOpt !== undefined ? executeQueryOpt : SourceManager.executeQuery;
+  let getLastKnownValidBlock = getLastKnownValidBlockOpt !== undefined ? getLastKnownValidBlockOpt : ChainFetcher.getLastKnownValidBlock;
+  let actionReducer = injectedActionReducer(markBatchProcessed);
+  return {
+    actionReducer: actionReducer,
+    invalidatedActionReducer: injectedInvalidatedActionReducer(markBatchProcessed, actionReducer),
+    taskReducer: injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlock)
+  };
+}
 
 export {
   WriteThrottlers,
@@ -1248,16 +1072,15 @@ export {
   setChainManager,
   isPreparingRollback,
   updateChainMetadataTable,
-  updateProgressedChains,
   validatePartitionQueryResponse,
   submitPartitionQueryResponse,
   processPartitionQueryResponse,
   updateChainFetcher,
   onEnterReorgThreshold,
-  actionReducer,
-  invalidatedActionReducer,
+  injectedActionReducer,
+  injectedInvalidatedActionReducer,
   checkAndFetchForChain,
   injectedTaskReducer,
-  taskReducer,
+  makeReducers,
 }
-/* taskReducer Not a pure module */
+/* Env Not a pure module */