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

package/src/GlobalState.res.mjs

@@ -0,0 +1,1183 @@
+// 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 $$BigInt from "./bindings/BigInt.res.mjs";
+import * as Config from "./Config.res.mjs";
+import * as Hrtime from "./bindings/Hrtime.res.mjs";
+import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Js_null from "rescript/lib/es6/js_null.js";
+import * as Logging from "./Logging.res.mjs";
+import * as Process from "process";
+import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as Throttler from "./Throttler.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Float from "rescript/lib/es6/belt_Float.js";
+import * as FetchState from "./FetchState.res.mjs";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as LoadManager from "./LoadManager.res.mjs";
+import * as Persistence from "./Persistence.res.mjs";
+import * as ChainFetcher from "./ChainFetcher.res.mjs";
+import * as ChainManager from "./ChainManager.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as InMemoryStore from "./InMemoryStore.res.mjs";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
+import * as ReorgDetection from "./ReorgDetection.res.mjs";
+import * as EventProcessing from "./EventProcessing.res.mjs";
+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 SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
+
+function make() {
+  var intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis;
+  var logger = Logging.createChild({
+        context: "Throttler for chain metadata writes",
+        intervalMillis: intervalMillis
+      });
+  var chainMetaData = Throttler.make(intervalMillis, logger);
+  var intervalMillis$1 = Env.ThrottleWrites.pruneStaleDataIntervalMillis;
+  var logger$1 = Logging.createChild({
+        context: "Throttler for pruning stale entity history data",
+        intervalMillis: intervalMillis$1
+      });
+  var pruneStaleEntityHistory = Throttler.make(intervalMillis$1, logger$1);
+  return {
+          chainMetaData: chainMetaData,
+          pruneStaleEntityHistory: pruneStaleEntityHistory
+        };
+}
+
+var WriteThrottlers = {
+  make: make
+};
+
+function make$1(ctx, chainManager, isDevelopmentModeOpt, shouldUseTuiOpt) {
+  var isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
+  var shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
+  return {
+          ctx: ctx,
+          chainManager: chainManager,
+          processedBatches: 0,
+          currentlyProcessingBatch: false,
+          rollbackState: "NoRollback",
+          indexerStartTime: new Date(),
+          writeThrottlers: make(),
+          loadManager: LoadManager.make(),
+          keepProcessAlive: isDevelopmentMode || shouldUseTui,
+          id: 0
+        };
+}
+
+function getId(self) {
+  return self.id;
+}
+
+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,
+          loadManager: self.loadManager,
+          keepProcessAlive: self.keepProcessAlive,
+          id: self.id
+        };
+}
+
+function isPreparingRollback(state) {
+  var match = state.rollbackState;
+  if (typeof match !== "object") {
+    if (match === "NoRollback") {
+      return false;
+    } else {
+      return true;
+    }
+  } else if (match.TAG === "RollbackReady") {
+    return false;
+  } else {
+    return true;
+  }
+}
+
+function updateChainMetadataTable(cm, persistence, throttler) {
+  var chainsData = {};
+  Belt_Array.forEach(ChainMap.values(cm.chainFetchers), (function (cf) {
+          chainsData[String(cf.chainConfig.id)] = {
+            first_event_block: Js_null.fromOption(cf.fetchState.firstEventBlock),
+            buffer_block: FetchState.bufferBlockNumber(cf.fetchState),
+            ready_at: Js_null.fromOption(cf.timestampCaughtUpToHeadOrEndblock),
+            _is_hyper_sync: SourceManager.getActiveSource(cf.sourceManager).poweredByHyperSync
+          };
+        }));
+  Throttler.schedule(throttler, (function () {
+          return persistence.storage.setChainMeta(chainsData);
+        }));
+}
+
+function updateProgressedChains(chainManager, batch, ctx) {
+  var nextQueueItemIsNone = ChainManager.nextItemIsNone(chainManager);
+  var allChainsAtHead = ChainManager.isProgressAtHead(chainManager);
+  var allChainsReady = {
+    contents: true
+  };
+  var chainFetchers = ChainMap.map(chainManager.chainFetchers, (function (prev) {
+          var chain = ChainMap.Chain.makeUnsafe(prev.chainConfig.id);
+          var maybeChainAfterBatch = batch.progressedChainsById[chain];
+          var 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);
+            }
+            var eventItem = Batch.findLastEventItem(batch, chain);
+            if (eventItem !== undefined) {
+              var blockTimestamp = ctx.config.ecosystem.getTimestamp(eventItem.event.block);
+              var currentTimeMs = Date.now() | 0;
+              var blockTimestampMs = Math.imul(blockTimestamp, 1000);
+              var latencyMs = currentTimeMs - blockTimestampMs | 0;
+              Prometheus.ProgressLatency.set(latencyMs, chain);
+            }
+            var match = prev.fetchState.firstEventBlock;
+            var tmp;
+            if (match !== undefined) {
+              tmp = prev.fetchState;
+            } else {
+              var firstEventBlock = Batch.findFirstEventBlockNumber(batch, chain);
+              if (firstEventBlock !== undefined) {
+                var init = prev.fetchState;
+                tmp = {
+                  optimizedPartitions: init.optimizedPartitions,
+                  startBlock: init.startBlock,
+                  endBlock: init.endBlock,
+                  normalSelection: init.normalSelection,
+                  indexingContracts: init.indexingContracts,
+                  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;
+              }
+            }
+            var 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;
+          }
+          var cf$1;
+          if (ChainFetcher.hasProcessedToEndblock(cf)) {
+            var timestampCaughtUpToHeadOrEndblock = ChainFetcher.isReady(cf) ? cf.timestampCaughtUpToHeadOrEndblock : Caml_option.some(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: Caml_option.some(new Date()),
+                committedProgressBlockNumber: cf.committedProgressBlockNumber,
+                numEventsProcessed: cf.numEventsProcessed,
+                reorgDetection: cf.reorgDetection,
+                safeCheckpointTracking: cf.safeCheckpointTracking
+              };
+            } else {
+              var hasNoMoreEventsToProcess = ChainFetcher.hasNoMoreEventsToProcess(cf);
+              cf$1 = hasNoMoreEventsToProcess ? ({
+                    logger: cf.logger,
+                    fetchState: cf.fetchState,
+                    sourceManager: cf.sourceManager,
+                    chainConfig: cf.chainConfig,
+                    isProgressAtHead: cf.isProgressAtHead,
+                    timestampCaughtUpToHeadOrEndblock: Caml_option.some(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();
+  }
+  var checkpointId = Utils.$$Array.last(batch.checkpointIds);
+  return {
+          committedCheckpointId: checkpointId !== undefined ? checkpointId : chainManager.committedCheckpointId,
+          chainFetchers: chainFetchers,
+          multichain: chainManager.multichain,
+          isInReorgThreshold: chainManager.isInReorgThreshold
+        };
+}
+
+function validatePartitionQueryResponse(state, partitionQueryResponse) {
+  var response = partitionQueryResponse.response;
+  var chain = partitionQueryResponse.chain;
+  var chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+  var stats = response.stats;
+  var knownHeight = response.knownHeight;
+  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);
+  var match = ReorgDetection.registerReorgGuard(chainFetcher.reorgDetection, response.reorgGuard, knownHeight);
+  var reorgResult = match[1];
+  var updatedChainFetcher_logger = chainFetcher.logger;
+  var updatedChainFetcher_fetchState = chainFetcher.fetchState;
+  var updatedChainFetcher_sourceManager = chainFetcher.sourceManager;
+  var updatedChainFetcher_chainConfig = chainFetcher.chainConfig;
+  var updatedChainFetcher_isProgressAtHead = chainFetcher.isProgressAtHead;
+  var updatedChainFetcher_timestampCaughtUpToHeadOrEndblock = chainFetcher.timestampCaughtUpToHeadOrEndblock;
+  var updatedChainFetcher_committedProgressBlockNumber = chainFetcher.committedProgressBlockNumber;
+  var updatedChainFetcher_numEventsProcessed = chainFetcher.numEventsProcessed;
+  var updatedChainFetcher_reorgDetection = match[0];
+  var updatedChainFetcher_safeCheckpointTracking = chainFetcher.safeCheckpointTracking;
+  var updatedChainFetcher = {
+    logger: updatedChainFetcher_logger,
+    fetchState: updatedChainFetcher_fetchState,
+    sourceManager: updatedChainFetcher_sourceManager,
+    chainConfig: updatedChainFetcher_chainConfig,
+    isProgressAtHead: updatedChainFetcher_isProgressAtHead,
+    timestampCaughtUpToHeadOrEndblock: updatedChainFetcher_timestampCaughtUpToHeadOrEndblock,
+    committedProgressBlockNumber: updatedChainFetcher_committedProgressBlockNumber,
+    numEventsProcessed: updatedChainFetcher_numEventsProcessed,
+    reorgDetection: updatedChainFetcher_reorgDetection,
+    safeCheckpointTracking: updatedChainFetcher_safeCheckpointTracking
+  };
+  var init = state.chainManager;
+  var nextState_ctx = state.ctx;
+  var nextState_chainManager = {
+    committedCheckpointId: init.committedCheckpointId,
+    chainFetchers: ChainMap.set(state.chainManager.chainFetchers, chain, updatedChainFetcher),
+    multichain: init.multichain,
+    isInReorgThreshold: init.isInReorgThreshold
+  };
+  var nextState_processedBatches = state.processedBatches;
+  var nextState_currentlyProcessingBatch = state.currentlyProcessingBatch;
+  var nextState_rollbackState = state.rollbackState;
+  var nextState_indexerStartTime = state.indexerStartTime;
+  var nextState_writeThrottlers = state.writeThrottlers;
+  var nextState_loadManager = state.loadManager;
+  var nextState_keepProcessAlive = state.keepProcessAlive;
+  var nextState_id = state.id;
+  var nextState = {
+    ctx: nextState_ctx,
+    chainManager: nextState_chainManager,
+    processedBatches: nextState_processedBatches,
+    currentlyProcessingBatch: nextState_currentlyProcessingBatch,
+    rollbackState: nextState_rollbackState,
+    indexerStartTime: nextState_indexerStartTime,
+    writeThrottlers: nextState_writeThrottlers,
+    loadManager: nextState_loadManager,
+    keepProcessAlive: nextState_keepProcessAlive,
+    id: nextState_id
+  };
+  var rollbackWithReorgDetectedBlockNumber;
+  if (typeof reorgResult !== "object") {
+    rollbackWithReorgDetectedBlockNumber = undefined;
+  } else {
+    var reorgDetected = reorgResult._0;
+    Logging.childInfo(chainFetcher.logger, ReorgDetection.reorgDetectedToLogParams(reorgDetected, state.ctx.config.shouldRollbackOnReorg));
+    Prometheus.ReorgCount.increment(chain);
+    Prometheus.ReorgDetectionBlockNumber.set(reorgDetected.scannedBlock.blockNumber, chain);
+    rollbackWithReorgDetectedBlockNumber = state.ctx.config.shouldRollbackOnReorg ? reorgDetected.scannedBlock.blockNumber : undefined;
+  }
+  if (rollbackWithReorgDetectedBlockNumber === undefined) {
+    return [
+            nextState,
+            [{
+                TAG: "ProcessPartitionQueryResponse",
+                _0: partitionQueryResponse
+              }]
+          ];
+  }
+  var match$1 = state.rollbackState;
+  var chainManager;
+  if (typeof match$1 !== "object" || match$1.TAG !== "RollbackReady") {
+    chainManager = state.chainManager;
+  } else {
+    var eventsProcessedDiffByChain = match$1.eventsProcessedDiffByChain;
+    var init$1 = state.chainManager;
+    chainManager = {
+      committedCheckpointId: init$1.committedCheckpointId,
+      chainFetchers: ChainMap.mapWithKey(state.chainManager.chainFetchers, (function (c, chainFetcher) {
+              var eventsProcessedDiff = eventsProcessedDiffByChain[c];
+              if (eventsProcessedDiff !== undefined) {
+                return {
+                        logger: chainFetcher.logger,
+                        fetchState: chainFetcher.fetchState,
+                        sourceManager: chainFetcher.sourceManager,
+                        chainConfig: chainFetcher.chainConfig,
+                        isProgressAtHead: chainFetcher.isProgressAtHead,
+                        timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
+                        committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
+                        numEventsProcessed: chainFetcher.numEventsProcessed + eventsProcessedDiff,
+                        reorgDetection: chainFetcher.reorgDetection,
+                        safeCheckpointTracking: chainFetcher.safeCheckpointTracking
+                      };
+              } else {
+                return chainFetcher;
+              }
+            })),
+      multichain: init$1.multichain,
+      isInReorgThreshold: init$1.isInReorgThreshold
+    };
+  }
+  return [
+          {
+            ctx: nextState_ctx,
+            chainManager: {
+              committedCheckpointId: chainManager.committedCheckpointId,
+              chainFetchers: ChainMap.map(chainManager.chainFetchers, (function (chainFetcher) {
+                      return {
+                              logger: chainFetcher.logger,
+                              fetchState: FetchState.resetPendingQueries(chainFetcher.fetchState),
+                              sourceManager: chainFetcher.sourceManager,
+                              chainConfig: chainFetcher.chainConfig,
+                              isProgressAtHead: chainFetcher.isProgressAtHead,
+                              timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
+                              committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
+                              numEventsProcessed: chainFetcher.numEventsProcessed,
+                              reorgDetection: chainFetcher.reorgDetection,
+                              safeCheckpointTracking: chainFetcher.safeCheckpointTracking
+                            };
+                    })),
+              multichain: chainManager.multichain,
+              isInReorgThreshold: chainManager.isInReorgThreshold
+            },
+            processedBatches: nextState_processedBatches,
+            currentlyProcessingBatch: nextState_currentlyProcessingBatch,
+            rollbackState: {
+              TAG: "ReorgDetected",
+              chain: chain,
+              blockNumber: rollbackWithReorgDetectedBlockNumber
+            },
+            indexerStartTime: nextState_indexerStartTime,
+            writeThrottlers: nextState_writeThrottlers,
+            loadManager: nextState_loadManager,
+            keepProcessAlive: nextState_keepProcessAlive,
+            id: nextState_id + 1 | 0
+          },
+          ["Rollback"]
+        ];
+}
+
+function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHeight, latestFetchedBlock, query, chain) {
+  var chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+  var updatedChainFetcher = ChainFetcher.handleQueryResult(chainFetcher, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight);
+  if (!chainFetcher.isProgressAtHead && updatedChainFetcher.isProgressAtHead) {
+    Logging.childInfo(updatedChainFetcher.logger, "All events have been fetched");
+  }
+  var init = state.chainManager;
+  var nextState_ctx = state.ctx;
+  var nextState_chainManager = {
+    committedCheckpointId: init.committedCheckpointId,
+    chainFetchers: ChainMap.set(state.chainManager.chainFetchers, chain, updatedChainFetcher),
+    multichain: init.multichain,
+    isInReorgThreshold: init.isInReorgThreshold
+  };
+  var nextState_processedBatches = state.processedBatches;
+  var nextState_currentlyProcessingBatch = state.currentlyProcessingBatch;
+  var nextState_rollbackState = state.rollbackState;
+  var nextState_indexerStartTime = state.indexerStartTime;
+  var nextState_writeThrottlers = state.writeThrottlers;
+  var nextState_loadManager = state.loadManager;
+  var nextState_keepProcessAlive = state.keepProcessAlive;
+  var nextState_id = state.id;
+  var nextState = {
+    ctx: nextState_ctx,
+    chainManager: nextState_chainManager,
+    processedBatches: nextState_processedBatches,
+    currentlyProcessingBatch: nextState_currentlyProcessingBatch,
+    rollbackState: nextState_rollbackState,
+    indexerStartTime: nextState_indexerStartTime,
+    writeThrottlers: nextState_writeThrottlers,
+    loadManager: nextState_loadManager,
+    keepProcessAlive: nextState_keepProcessAlive,
+    id: nextState_id
+  };
+  return [
+          nextState,
+          [
+            {
+              TAG: "UpdateChainMetaDataAndCheckForExit",
+              _0: "NoExit"
+            },
+            "ProcessEventBatch",
+            {
+              TAG: "NextQuery",
+              _0: {
+                TAG: "Chain",
+                _0: chain
+              }
+            }
+          ]
+        ];
+}
+
+async function processPartitionQueryResponse(state, param, dispatchAction) {
+  var response = param.response;
+  var chain = param.chain;
+  var parsedQueueItems = response.parsedQueueItems;
+  var itemsWithContractRegister = [];
+  var newItems = [];
+  for(var idx = 0 ,idx_finish = parsedQueueItems.length; idx < idx_finish; ++idx){
+    var item = parsedQueueItems[idx];
+    if (item.eventConfig.contractRegister !== undefined) {
+      itemsWithContractRegister.push(item);
+    }
+    newItems.push(item);
+  }
+  var newItemsWithDcs = itemsWithContractRegister.length !== 0 ? await ChainFetcher.runContractRegistersOrThrow(itemsWithContractRegister, chain, state.ctx.config) : itemsWithContractRegister;
+  return dispatchAction({
+              TAG: "SubmitPartitionQueryResponse",
+              newItems: newItems,
+              newItemsWithDcs: newItemsWithDcs,
+              knownHeight: response.knownHeight,
+              latestFetchedBlock: {
+                blockNumber: response.latestFetchedBlockNumber,
+                blockTimestamp: response.latestFetchedBlockTimestamp
+              },
+              query: param.query,
+              chain: chain
+            });
+}
+
+function updateChainFetcher(chainFetcherUpdate, state, chain) {
+  var init = state.chainManager;
+  return [
+          {
+            ctx: state.ctx,
+            chainManager: {
+              committedCheckpointId: init.committedCheckpointId,
+              chainFetchers: ChainMap.update(state.chainManager.chainFetchers, chain, chainFetcherUpdate),
+              multichain: init.multichain,
+              isInReorgThreshold: init.isInReorgThreshold
+            },
+            processedBatches: state.processedBatches,
+            currentlyProcessingBatch: state.currentlyProcessingBatch,
+            rollbackState: state.rollbackState,
+            indexerStartTime: state.indexerStartTime,
+            writeThrottlers: state.writeThrottlers,
+            loadManager: state.loadManager,
+            keepProcessAlive: state.keepProcessAlive,
+            id: state.id
+          },
+          []
+        ];
+}
+
+function onEnterReorgThreshold(state) {
+  Logging.info("Reorg threshold reached");
+  Prometheus.ReorgThreshold.set(true);
+  var chainFetchers = ChainMap.map(state.chainManager.chainFetchers, (function (chainFetcher) {
+          return {
+                  logger: chainFetcher.logger,
+                  fetchState: FetchState.updateInternal(chainFetcher.fetchState, undefined, undefined, undefined, chainFetcher.chainConfig.blockLag, undefined),
+                  sourceManager: chainFetcher.sourceManager,
+                  chainConfig: chainFetcher.chainConfig,
+                  isProgressAtHead: chainFetcher.isProgressAtHead,
+                  timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
+                  committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
+                  numEventsProcessed: chainFetcher.numEventsProcessed,
+                  reorgDetection: chainFetcher.reorgDetection,
+                  safeCheckpointTracking: chainFetcher.safeCheckpointTracking
+                };
+        }));
+  var init = state.chainManager;
+  return {
+          ctx: state.ctx,
+          chainManager: {
+            committedCheckpointId: init.committedCheckpointId,
+            chainFetchers: chainFetchers,
+            multichain: init.multichain,
+            isInReorgThreshold: true
+          },
+          processedBatches: state.processedBatches,
+          currentlyProcessingBatch: state.currentlyProcessingBatch,
+          rollbackState: state.rollbackState,
+          indexerStartTime: state.indexerStartTime,
+          writeThrottlers: state.writeThrottlers,
+          loadManager: state.loadManager,
+          keepProcessAlive: state.keepProcessAlive,
+          id: state.id
+        };
+}
+
+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,
+                    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,
+                    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" :
+          var knownHeight = action.knownHeight;
+          var chain = action.chain;
+          var updatedChainFetchers = ChainMap.update(state.chainManager.chainFetchers, chain, (function (chainFetcher) {
+                  var 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;
+                  }
+                }));
+          var isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
+          var shouldEnterReorgThreshold = isBelowReorgThreshold && Belt_Array.every(ChainMap.values(updatedChainFetchers), (function (chainFetcher) {
+                  return FetchState.isReadyToEnterReorgThreshold(chainFetcher.fetchState);
+                }));
+          var init = state.chainManager;
+          var state_ctx = state.ctx;
+          var state_chainManager = {
+            committedCheckpointId: init.committedCheckpointId,
+            chainFetchers: updatedChainFetchers,
+            multichain: init.multichain,
+            isInReorgThreshold: init.isInReorgThreshold
+          };
+          var state_processedBatches = state.processedBatches;
+          var state_currentlyProcessingBatch = state.currentlyProcessingBatch;
+          var state_rollbackState = state.rollbackState;
+          var state_indexerStartTime = state.indexerStartTime;
+          var state_writeThrottlers = state.writeThrottlers;
+          var state_loadManager = state.loadManager;
+          var state_keepProcessAlive = state.keepProcessAlive;
+          var state_id = state.id;
+          var 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,
+            id: state_id
+          };
+          if (shouldEnterReorgThreshold) {
+            return [
+                    onEnterReorgThreshold(state$1),
+                    [
+                      {
+                        TAG: "NextQuery",
+                        _0: "CheckAllChains"
+                      },
+                      "ProcessEventBatch"
+                    ]
+                  ];
+          } else {
+            return [
+                    state$1,
+                    [
+                      {
+                        TAG: "NextQuery",
+                        _0: {
+                          TAG: "Chain",
+                          _0: chain
+                        }
+                      },
+                      "ProcessEventBatch"
+                    ]
+                  ];
+          }
+      case "EventBatchProcessed" :
+          var maybePruneEntityHistory = Config.shouldPruneHistory(state.ctx.config, state.chainManager.isInReorgThreshold) ? ["PruneStaleEntityHistory"] : [];
+          var state_ctx$1 = state.ctx;
+          var state_chainManager$1 = updateProgressedChains(state.chainManager, action.batch, state.ctx);
+          var state_processedBatches$1 = state.processedBatches + 1 | 0;
+          var state_indexerStartTime$1 = state.indexerStartTime;
+          var state_writeThrottlers$1 = state.writeThrottlers;
+          var state_loadManager$1 = state.loadManager;
+          var state_keepProcessAlive$1 = state.keepProcessAlive;
+          var state_id$1 = state.id;
+          var 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,
+            id: state_id$1
+          };
+          var shouldExit = EventProcessing.allChainsEventsProcessedToEndblock(state_chainManager$1.chainFetchers) ? (Logging.info("All chains are caught up to end blocks."), state_keepProcessAlive$1 ? "NoExit" : "ExitWithSuccess") : "NoExit";
+          return [
+                  state$2,
+                  Belt_Array.concat([
+                        {
+                          TAG: "UpdateChainMetaDataAndCheckForExit",
+                          _0: shouldExit
+                        },
+                        "ProcessEventBatch"
+                      ], maybePruneEntityHistory)
+                ];
+      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,
+                    id: state.id
+                  },
+                  ["Rollback"]
+                ];
+      case "UpdateQueues" :
+          var shouldEnterReorgThreshold$1 = action.shouldEnterReorgThreshold;
+          var progressedChainsById = action.progressedChainsById;
+          var chainFetchers = ChainMap.mapWithKey(state.chainManager.chainFetchers, (function (chain, cf) {
+                  var chainAfterBatch = progressedChainsById[chain];
+                  var 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
+                        };
+                }));
+          var init$1 = state.chainManager;
+          var chainManager_committedCheckpointId = init$1.committedCheckpointId;
+          var chainManager_multichain = init$1.multichain;
+          var chainManager_isInReorgThreshold = init$1.isInReorgThreshold;
+          var chainManager = {
+            committedCheckpointId: chainManager_committedCheckpointId,
+            chainFetchers: chainFetchers,
+            multichain: chainManager_multichain,
+            isInReorgThreshold: chainManager_isInReorgThreshold
+          };
+          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,
+                    id: state.id
+                  },
+                  [{
+                      TAG: "NextQuery",
+                      _0: "CheckAllChains"
+                    }]
+                ];
+      case "ErrorExit" :
+          ErrorHandling.log(action._0);
+          Process.exit(1);
+          return [
+                  state,
+                  []
+                ];
+      case "SetRollbackState" :
+          return [
+                  {
+                    ctx: state.ctx,
+                    chainManager: action.rollbackedChainManager,
+                    processedBatches: state.processedBatches,
+                    currentlyProcessingBatch: state.currentlyProcessingBatch,
+                    rollbackState: {
+                      TAG: "RollbackReady",
+                      diffInMemoryStore: action.diffInMemoryStore,
+                      eventsProcessedDiffByChain: action.eventsProcessedDiffByChain
+                    },
+                    indexerStartTime: state.indexerStartTime,
+                    writeThrottlers: state.writeThrottlers,
+                    loadManager: state.loadManager,
+                    keepProcessAlive: state.keepProcessAlive,
+                    id: state.id
+                  },
+                  [
+                    {
+                      TAG: "NextQuery",
+                      _0: "CheckAllChains"
+                    },
+                    "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");
+            return [
+                    {
+                      ctx: state.ctx,
+                      chainManager: updateProgressedChains(state.chainManager, action.batch, state.ctx),
+                      processedBatches: state.processedBatches + 1 | 0,
+                      currentlyProcessingBatch: false,
+                      rollbackState: state.rollbackState,
+                      indexerStartTime: state.indexerStartTime,
+                      writeThrottlers: state.writeThrottlers,
+                      loadManager: state.loadManager,
+                      keepProcessAlive: state.keepProcessAlive,
+                      id: state.id
+                    },
+                    ["Rollback"]
+                  ];
+          }
+          break;
+      case "ErrorExit" :
+          return actionReducer(state, action);
+      default:
+        
+    }
+  }
+  Logging.trace({
+        msg: "Invalidated action discarded",
+        action: S$RescriptSchema.convertOrThrow(action, Utils.Schema.variantTag)
+      });
+  return [
+          state,
+          []
+        ];
+}
+
+function checkAndFetchForChain(waitForNewBlock, executeQuery, state, dispatchAction) {
+  return async function (chain) {
+    var chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+    if (isPreparingRollback(state)) {
+      return ;
+    }
+    var fetchState = chainFetcher.fetchState;
+    return await SourceManager.fetchNext(chainFetcher.sourceManager, fetchState, (async function (query) {
+                  try {
+                    var response = await executeQuery(chainFetcher.sourceManager, query, fetchState.knownHeight, ChainFetcher.isReady(chainFetcher));
+                    return dispatchAction({
+                                TAG: "ValidatePartitionQueryResponse",
+                                _0: {
+                                  chain: chain,
+                                  response: response,
+                                  query: query
+                                }
+                              });
+                  }
+                  catch (raw_exn){
+                    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+                    return dispatchAction({
+                                TAG: "ErrorExit",
+                                _0: ErrorHandling.make(exn, undefined, undefined)
+                              });
+                  }
+                }), (function (knownHeight) {
+                  return waitForNewBlock(chainFetcher.sourceManager, knownHeight, ChainFetcher.isReady(chainFetcher));
+                }), (function (knownHeight) {
+                  dispatchAction({
+                        TAG: "FinishWaitingForNewBlock",
+                        chain: chain,
+                        knownHeight: knownHeight
+                      });
+                }), state.id);
+  };
+}
+
+function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlock) {
+  return async function (state, task, dispatchAction) {
+    if (typeof task !== "object") {
+      switch (task) {
+        case "ProcessEventBatch" :
+            if (!(!state.currentlyProcessingBatch && !isPreparingRollback(state))) {
+              return ;
+            }
+            var match = state.rollbackState;
+            var rollbackInMemStore;
+            rollbackInMemStore = typeof match !== "object" || match.TAG !== "RollbackReady" ? undefined : match.diffInMemoryStore;
+            var batch = ChainManager.createBatch(state.chainManager, state.ctx.config.batchSize, rollbackInMemStore !== undefined);
+            var progressedChainsById = batch.progressedChainsById;
+            var isInReorgThreshold = state.chainManager.isInReorgThreshold;
+            var shouldSaveHistory = Config.shouldSaveHistory(state.ctx.config, isInReorgThreshold);
+            var isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
+            var shouldEnterReorgThreshold = isBelowReorgThreshold && Belt_Array.every(ChainMap.values(state.chainManager.chainFetchers), (function (chainFetcher) {
+                    var chainAfterBatch = progressedChainsById[chainFetcher.fetchState.chainId];
+                    var fetchState = chainAfterBatch !== undefined ? chainAfterBatch.fetchState : chainFetcher.fetchState;
+                    return FetchState.isReadyToEnterReorgThreshold(fetchState);
+                  }));
+            if (shouldEnterReorgThreshold) {
+              dispatchAction("EnterReorgThreshold");
+            }
+            if (Utils.Dict.isEmpty(progressedChainsById)) {
+              if (EventProcessing.allChainsEventsProcessedToEndblock(state.chainManager.chainFetchers)) {
+                Logging.info("All chains are caught up to end blocks.");
+                if (!state.keepProcessAlive) {
+                  updateChainMetadataTable(state.chainManager, state.ctx.persistence, state.writeThrottlers.chainMetaData);
+                  return dispatchAction("SuccessExit");
+                } else {
+                  return ;
+                }
+              } else {
+                return ;
+              }
+            }
+            dispatchAction("StartProcessingBatch");
+            dispatchAction({
+                  TAG: "UpdateQueues",
+                  progressedChainsById: progressedChainsById,
+                  shouldEnterReorgThreshold: shouldEnterReorgThreshold
+                });
+            var inMemoryStore = Belt_Option.getWithDefault(rollbackInMemStore, InMemoryStore.make(state.ctx.persistence.allEntities, undefined));
+            InMemoryStore.setBatchDcs(inMemoryStore, batch, shouldSaveHistory);
+            var res;
+            try {
+              res = await EventProcessing.processEventBatch(batch, inMemoryStore, isInReorgThreshold, state.loadManager, state.ctx, state.chainManager.chainFetchers);
+            }
+            catch (raw_exn){
+              var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+              var errHandler = ErrorHandling.make(exn, undefined, "A top level unexpected error occurred during processing");
+              return dispatchAction({
+                          TAG: "ErrorExit",
+                          _0: errHandler
+                        });
+            }
+            if (res.TAG === "Ok") {
+              return dispatchAction({
+                          TAG: "EventBatchProcessed",
+                          batch: batch
+                        });
+            } else {
+              return dispatchAction({
+                          TAG: "ErrorExit",
+                          _0: res._0
+                        });
+            }
+            break;
+        case "Rollback" :
+            var match$1 = state.rollbackState;
+            if (typeof match$1 !== "object") {
+              if (match$1 === "NoRollback") {
+                return Js_exn.raiseError("Internal error: Rollback initiated with invalid state");
+              } else {
+                return ;
+              }
+            }
+            switch (match$1.TAG) {
+              case "ReorgDetected" :
+                  var chain = match$1.chain;
+                  var chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+                  dispatchAction("StartFindingReorgDepth");
+                  var rollbackTargetBlockNumber = await getLastKnownValidBlock(chainFetcher, match$1.blockNumber);
+                  return dispatchAction({
+                              TAG: "FindReorgDepth",
+                              chain: chain,
+                              rollbackTargetBlockNumber: rollbackTargetBlockNumber
+                            });
+              case "FoundReorgDepth" :
+                  if (state.currentlyProcessingBatch) {
+                    return Logging.info("Waiting for batch to finish processing before executing rollback");
+                  }
+                  var match$2 = state.rollbackState;
+                  var rollbackTargetBlockNumber$1 = match$2.rollbackTargetBlockNumber;
+                  var reorgChain = match$2.chain;
+                  var startTime = Hrtime.makeTimer();
+                  var chainFetcher$1 = ChainMap.get(state.chainManager.chainFetchers, reorgChain);
+                  var logger = Logging.createChildFrom(chainFetcher$1.logger, {
+                        action: "Rollback",
+                        reorgChain: reorgChain,
+                        targetBlockNumber: rollbackTargetBlockNumber$1
+                      });
+                  Logging.childInfo(logger, "Started rollback on reorg");
+                  Prometheus.RollbackTargetBlockNumber.set(rollbackTargetBlockNumber$1, reorgChain);
+                  var checkpointId = await state.ctx.persistence.storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber$1);
+                  var rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
+                  var eventsProcessedDiffByChain = {};
+                  var newProgressBlockNumberPerChain = {};
+                  var rollbackedProcessedEvents = 0;
+                  var rollbackProgressDiff = await state.ctx.persistence.storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
+                  for(var idx = 0 ,idx_finish = rollbackProgressDiff.length; idx < idx_finish; ++idx){
+                    var diff = rollbackProgressDiff[idx];
+                    var eventsProcessedDiff = Belt_Option.getExn(Belt_Float.fromString(diff.events_processed_diff));
+                    rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessedDiff;
+                    eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
+                    newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain && diff.new_progress_block_number >= rollbackTargetBlockNumber$1 ? rollbackTargetBlockNumber$1 : diff.new_progress_block_number;
+                  }
+                  var chainFetchers = ChainMap.mapWithKey(state.chainManager.chainFetchers, (function (chain, cf) {
+                          var newProgressBlockNumber = newProgressBlockNumberPerChain[chain];
+                          if (newProgressBlockNumber === undefined) {
+                            if (Caml_obj.equal(chain, reorgChain)) {
+                              return {
+                                      logger: cf.logger,
+                                      fetchState: FetchState.rollback(cf.fetchState, rollbackTargetBlockNumber$1),
+                                      sourceManager: cf.sourceManager,
+                                      chainConfig: cf.chainConfig,
+                                      isProgressAtHead: cf.isProgressAtHead,
+                                      timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
+                                      committedProgressBlockNumber: cf.committedProgressBlockNumber,
+                                      numEventsProcessed: cf.numEventsProcessed,
+                                      reorgDetection: ReorgDetection.rollbackToValidBlockNumber(cf.reorgDetection, rollbackTargetBlockNumber$1),
+                                      safeCheckpointTracking: cf.safeCheckpointTracking
+                                    };
+                            } else {
+                              return cf;
+                            }
+                          }
+                          var fetchState = FetchState.rollback(cf.fetchState, newProgressBlockNumber);
+                          var newTotalEventsProcessed = cf.numEventsProcessed - eventsProcessedDiffByChain[chain];
+                          if (cf.committedProgressBlockNumber !== newProgressBlockNumber) {
+                            Prometheus.ProgressBlockNumber.set(newProgressBlockNumber, chain);
+                          }
+                          if (cf.numEventsProcessed !== newTotalEventsProcessed) {
+                            Prometheus.ProgressEventsCount.set(newTotalEventsProcessed, chain);
+                          }
+                          var safeCheckpointTracking = cf.safeCheckpointTracking;
+                          return {
+                                  logger: cf.logger,
+                                  fetchState: fetchState,
+                                  sourceManager: cf.sourceManager,
+                                  chainConfig: cf.chainConfig,
+                                  isProgressAtHead: cf.isProgressAtHead,
+                                  timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
+                                  committedProgressBlockNumber: newProgressBlockNumber,
+                                  numEventsProcessed: newTotalEventsProcessed,
+                                  reorgDetection: Caml_obj.equal(chain, reorgChain) ? ReorgDetection.rollbackToValidBlockNumber(cf.reorgDetection, rollbackTargetBlockNumber$1) : cf.reorgDetection,
+                                  safeCheckpointTracking: safeCheckpointTracking !== undefined ? SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber) : undefined
+                                };
+                        }));
+                  var diff$1 = await Persistence.prepareRollbackDiff(state.ctx.persistence, rollbackTargetCheckpointId, $$BigInt.add(state.chainManager.committedCheckpointId, 1n));
+                  var init = state.chainManager;
+                  var chainManager_committedCheckpointId = init.committedCheckpointId;
+                  var chainManager_multichain = init.multichain;
+                  var chainManager_isInReorgThreshold = init.isInReorgThreshold;
+                  var chainManager = {
+                    committedCheckpointId: chainManager_committedCheckpointId,
+                    chainFetchers: chainFetchers,
+                    multichain: chainManager_multichain,
+                    isInReorgThreshold: chainManager_isInReorgThreshold
+                  };
+                  Logging.childTrace(logger, {
+                        msg: "Finished rollback on reorg",
+                        entityChanges: {
+                          deleted: diff$1.deletedEntities,
+                          upserted: diff$1.setEntities
+                        },
+                        rollbackedEvents: rollbackedProcessedEvents,
+                        beforeCheckpointId: state.chainManager.committedCheckpointId,
+                        targetCheckpointId: rollbackTargetCheckpointId
+                      });
+                  Prometheus.RollbackSuccess.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(startTime)), rollbackedProcessedEvents);
+                  return dispatchAction({
+                              TAG: "SetRollbackState",
+                              diffInMemoryStore: diff$1.inMemStore,
+                              rollbackedChainManager: chainManager,
+                              eventsProcessedDiffByChain: eventsProcessedDiffByChain
+                            });
+              case "RollbackReady" :
+                  return Js_exn.raiseError("Internal error: Rollback initiated with invalid state");
+              
+            }
+        case "PruneStaleEntityHistory" :
+            var runPrune = async function () {
+              var safeCheckpointId = ChainManager.getSafeCheckpointId(state.chainManager);
+              if (safeCheckpointId === undefined) {
+                return ;
+              }
+              await state.ctx.persistence.storage.pruneStaleCheckpoints(safeCheckpointId);
+              for(var idx = 0 ,idx_finish = state.ctx.persistence.allEntities.length; idx < idx_finish; ++idx){
+                if (idx !== 0) {
+                  await Utils.delay(1000);
+                }
+                var entityConfig = state.ctx.persistence.allEntities[idx];
+                var timeRef = Hrtime.makeTimer();
+                try {
+                  await state.ctx.persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+                }
+                catch (raw_exn){
+                  var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+                  ErrorHandling.mkLogAndRaise(Logging.createChild({
+                            entityName: entityConfig.name,
+                            safeCheckpointId: safeCheckpointId
+                          }), "Failed to prune stale entity history", exn);
+                }
+                Prometheus.RollbackHistoryPrune.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef)), entityConfig.name);
+              }
+            };
+            return Throttler.schedule(state.writeThrottlers.pruneStaleEntityHistory, runPrune);
+        
+      }
+    } else {
+      switch (task.TAG) {
+        case "NextQuery" :
+            var chainCheck = task._0;
+            var fetchForChain = checkAndFetchForChain(waitForNewBlock, executeQuery, state, dispatchAction);
+            if (typeof chainCheck === "object") {
+              return await fetchForChain(chainCheck._0);
+            }
+            await Promise.all(Belt_Array.map(ChainMap.keys(state.chainManager.chainFetchers), (function (__x) {
+                        return fetchForChain(__x);
+                      })));
+            return ;
+        case "ProcessPartitionQueryResponse" :
+            processPartitionQueryResponse(state, task._0, dispatchAction);
+            return ;
+        case "UpdateChainMetaDataAndCheckForExit" :
+            var writeThrottlers = state.writeThrottlers;
+            var chainManager$1 = state.chainManager;
+            if (task._0 === "ExitWithSuccess") {
+              updateChainMetadataTable(chainManager$1, state.ctx.persistence, writeThrottlers.chainMetaData);
+              return dispatchAction("SuccessExit");
+            }
+            updateChainMetadataTable(chainManager$1, state.ctx.persistence, writeThrottlers.chainMetaData);
+            return ;
+        
+      }
+    }
+  };
+}
+
+var taskReducer = injectedTaskReducer(SourceManager.waitForNewBlock, SourceManager.executeQuery, (function (chainFetcher, reorgBlockNumber) {
+        return ChainFetcher.getLastKnownValidBlock(chainFetcher, reorgBlockNumber, undefined);
+      }));
+
+export {
+  WriteThrottlers ,
+  make$1 as make,
+  getId ,
+  setChainManager ,
+  isPreparingRollback ,
+  updateChainMetadataTable ,
+  updateProgressedChains ,
+  validatePartitionQueryResponse ,
+  submitPartitionQueryResponse ,
+  processPartitionQueryResponse ,
+  updateChainFetcher ,
+  onEnterReorgThreshold ,
+  actionReducer ,
+  invalidatedActionReducer ,
+  checkAndFetchForChain ,
+  injectedTaskReducer ,
+  taskReducer ,
+}
+/* taskReducer Not a pure module */