envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/GlobalState.res.mjs

@@ -3,75 +3,75 @@
 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 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/lib/es6/belt_Option.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
 import * as LoadManager from "./LoadManager.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as ChainManager from "./ChainManager.res.mjs";
+import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as ReorgDetection from "./ReorgDetection.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as EventProcessing from "./EventProcessing.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 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);
+  let intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis;
+  let logger = Logging.createChild({
+    context: "Throttler for chain metadata writes",
+    intervalMillis: intervalMillis
+  });
+  let chainMetaData = Throttler.make(intervalMillis, logger);
+  let intervalMillis$1 = Env.ThrottleWrites.pruneStaleDataIntervalMillis;
+  let logger$1 = Logging.createChild({
+    context: "Throttler for pruning stale entity history data",
+    intervalMillis: intervalMillis$1
+  });
+  let pruneStaleEntityHistory = Throttler.make(intervalMillis$1, logger$1);
   return {
-          chainMetaData: chainMetaData,
-          pruneStaleEntityHistory: pruneStaleEntityHistory
-        };
+    chainMetaData: chainMetaData,
+    pruneStaleEntityHistory: pruneStaleEntityHistory
+  };
 }
 
-var WriteThrottlers = {
+let WriteThrottlers = {
   make: make
 };
 
 function make$1(ctx, chainManager, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt) {
-  var isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
-  var shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
-  var exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
+  let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
+  let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
+  let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
   return {
-          ctx: ctx,
-          chainManager: chainManager,
-          processedBatches: 0,
-          currentlyProcessingBatch: false,
-          rollbackState: "NoRollback",
-          indexerStartTime: new Date(),
-          writeThrottlers: make(),
-          loadManager: LoadManager.make(),
-          keepProcessAlive: isDevelopmentMode || shouldUseTui,
-          exitAfterFirstEventBlock: exitAfterFirstEventBlock,
-          id: 0
-        };
+    ctx: ctx,
+    chainManager: chainManager,
+    processedBatches: 0,
+    currentlyProcessingBatch: false,
+    rollbackState: "NoRollback",
+    indexerStartTime: new Date(),
+    writeThrottlers: make(),
+    loadManager: LoadManager.make(),
+    keepProcessAlive: isDevelopmentMode || shouldUseTui,
+    exitAfterFirstEventBlock: exitAfterFirstEventBlock,
+    id: 0
+  };
 }
 
 function getId(self) {
@@ -80,211 +80,202 @@ function getId(self) {
 
 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,
-          exitAfterFirstEventBlock: self.exitAfterFirstEventBlock,
-          id: self.id
-        };
+    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,
+    exitAfterFirstEventBlock: self.exitAfterFirstEventBlock,
+    id: self.id
+  };
 }
 
 function isPreparingRollback(state) {
-  var match = state.rollbackState;
+  let match = state.rollbackState;
   if (typeof match !== "object") {
-    if (match === "NoRollback") {
-      return false;
-    } else {
-      return true;
-    }
-  } else if (match.TAG === "RollbackReady") {
-    return false;
+    return match !== "NoRollback";
   } else {
-    return true;
+    return match.TAG !== "RollbackReady";
   }
 }
 
 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);
-        }));
+  let chainsData = {};
+  Belt_Array.forEach(ChainMap.values(cm.chainFetchers), cf => {
+    chainsData[String(cf.chainConfig.id)] = {
+      first_event_block: Stdlib_Null.fromOption(cf.fetchState.firstEventBlock),
+      buffer_block: FetchState.bufferBlockNumber(cf.fetchState),
+      ready_at: Stdlib_Null.fromOption(cf.timestampCaughtUpToHeadOrEndblock),
+      _is_hyper_sync: SourceManager.getActiveSource(cf.sourceManager).poweredByHyperSync
+    };
+  });
+  Throttler.schedule(throttler, () => persistence.storage.setChainMeta(chainsData));
 }
 
 function updateProgressedChains(chainManager, batch, ctx) {
-  var nextQueueItemIsNone = ChainManager.nextItemIsNone(chainManager);
-  var allChainsAtHead = ChainManager.isProgressAtHead(chainManager);
-  var allChainsReady = {
+  let nextQueueItemIsNone = ChainManager.nextItemIsNone(chainManager);
+  let allChainsAtHead = ChainManager.isProgressAtHead(chainManager);
+  let 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;
-        }));
+  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();
   }
-  var checkpointId = Utils.$$Array.last(batch.checkpointIds);
+  let checkpointId = Utils.$$Array.last(batch.checkpointIds);
   return {
-          committedCheckpointId: checkpointId !== undefined ? checkpointId : chainManager.committedCheckpointId,
-          chainFetchers: chainFetchers,
-          multichain: chainManager.multichain,
-          isInReorgThreshold: chainManager.isInReorgThreshold
-        };
+    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;
+  let response = partitionQueryResponse.response;
+  let chain = partitionQueryResponse.chain;
+  let chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+  let stats = response.stats;
+  let 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 = {
+  let match = ReorgDetection.registerReorgGuard(chainFetcher.reorgDetection, response.reorgGuard, knownHeight);
+  let reorgResult = match[1];
+  let updatedChainFetcher_logger = chainFetcher.logger;
+  let updatedChainFetcher_fetchState = chainFetcher.fetchState;
+  let updatedChainFetcher_sourceManager = chainFetcher.sourceManager;
+  let updatedChainFetcher_chainConfig = chainFetcher.chainConfig;
+  let updatedChainFetcher_isProgressAtHead = chainFetcher.isProgressAtHead;
+  let updatedChainFetcher_timestampCaughtUpToHeadOrEndblock = chainFetcher.timestampCaughtUpToHeadOrEndblock;
+  let updatedChainFetcher_committedProgressBlockNumber = chainFetcher.committedProgressBlockNumber;
+  let updatedChainFetcher_numEventsProcessed = chainFetcher.numEventsProcessed;
+  let updatedChainFetcher_reorgDetection = match[0];
+  let updatedChainFetcher_safeCheckpointTracking = chainFetcher.safeCheckpointTracking;
+  let updatedChainFetcher = {
     logger: updatedChainFetcher_logger,
     fetchState: updatedChainFetcher_fetchState,
     sourceManager: updatedChainFetcher_sourceManager,
@@ -296,24 +287,24 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     reorgDetection: updatedChainFetcher_reorgDetection,
     safeCheckpointTracking: updatedChainFetcher_safeCheckpointTracking
   };
-  var init = state.chainManager;
-  var nextState_ctx = state.ctx;
-  var nextState_chainManager = {
+  let init = state.chainManager;
+  let nextState_ctx = state.ctx;
+  let 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_exitAfterFirstEventBlock = state.exitAfterFirstEventBlock;
-  var nextState_id = state.id;
-  var nextState = {
+  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;
+  let nextState_loadManager = state.loadManager;
+  let nextState_keepProcessAlive = state.keepProcessAlive;
+  let nextState_exitAfterFirstEventBlock = state.exitAfterFirstEventBlock;
+  let nextState_id = state.id;
+  let nextState = {
     ctx: nextState_ctx,
     chainManager: nextState_chainManager,
     processedBatches: nextState_processedBatches,
@@ -326,11 +317,11 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     exitAfterFirstEventBlock: nextState_exitAfterFirstEventBlock,
     id: nextState_id
   };
-  var rollbackWithReorgDetectedBlockNumber;
+  let rollbackWithReorgDetectedBlockNumber;
   if (typeof reorgResult !== "object") {
     rollbackWithReorgDetectedBlockNumber = undefined;
   } else {
-    var reorgDetected = reorgResult._0;
+    let 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);
@@ -338,95 +329,93 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
   }
   if (rollbackWithReorgDetectedBlockNumber === undefined) {
     return [
-            nextState,
-            [{
-                TAG: "ProcessPartitionQueryResponse",
-                _0: partitionQueryResponse
-              }]
-          ];
+      nextState,
+      [{
+          TAG: "ProcessPartitionQueryResponse",
+          _0: partitionQueryResponse
+        }]
+    ];
   }
-  var match$1 = state.rollbackState;
-  var chainManager;
+  let match$1 = state.rollbackState;
+  let chainManager;
   if (typeof match$1 !== "object" || match$1.TAG !== "RollbackReady") {
     chainManager = state.chainManager;
   } else {
-    var eventsProcessedDiffByChain = match$1.eventsProcessedDiffByChain;
-    var init$1 = state.chainManager;
+    let eventsProcessedDiffByChain = match$1.eventsProcessedDiffByChain;
+    let 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;
-              }
-            })),
+      chainFetchers: ChainMap.mapWithKey(state.chainManager.chainFetchers, (c, chainFetcher) => {
+        let 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,
-            exitAfterFirstEventBlock: nextState_exitAfterFirstEventBlock,
-            id: nextState_id + 1 | 0
-          },
-          ["Rollback"]
-        ];
+    {
+      ctx: nextState_ctx,
+      chainManager: {
+        committedCheckpointId: chainManager.committedCheckpointId,
+        chainFetchers: ChainMap.map(chainManager.chainFetchers, chainFetcher => ({
+          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,
+      exitAfterFirstEventBlock: nextState_exitAfterFirstEventBlock,
+      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);
-  var updatedChainFetcher$1;
+  let chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+  let updatedChainFetcher = ChainFetcher.handleQueryResult(chainFetcher, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight);
+  let updatedChainFetcher$1;
   if (state.exitAfterFirstEventBlock && newItems.length !== 0) {
-    var firstEventBlock = newItems[0].blockNumber;
-    var currentEndBlock = updatedChainFetcher.fetchState.endBlock;
+    let firstEventBlock = newItems[0].blockNumber;
+    let currentEndBlock = updatedChainFetcher.fetchState.endBlock;
     if (currentEndBlock !== undefined) {
       if (firstEventBlock < currentEndBlock) {
-        var init = updatedChainFetcher.fetchState;
+        let init = updatedChainFetcher.fetchState;
         updatedChainFetcher$1 = {
           logger: updatedChainFetcher.logger,
           fetchState: {
@@ -434,7 +423,7 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
             startBlock: init.startBlock,
             endBlock: firstEventBlock,
             normalSelection: init.normalSelection,
-            indexingContracts: init.indexingContracts,
+            indexingAddresses: init.indexingAddresses,
             contractConfigs: init.contractConfigs,
             chainId: init.chainId,
             latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
@@ -458,7 +447,7 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
         updatedChainFetcher$1 = updatedChainFetcher;
       }
     } else {
-      var init$1 = updatedChainFetcher.fetchState;
+      let init$1 = updatedChainFetcher.fetchState;
       updatedChainFetcher$1 = {
         logger: updatedChainFetcher.logger,
         fetchState: {
@@ -466,7 +455,7 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
           startBlock: init$1.startBlock,
           endBlock: firstEventBlock,
           normalSelection: init$1.normalSelection,
-          indexingContracts: init$1.indexingContracts,
+          indexingAddresses: init$1.indexingAddresses,
           contractConfigs: init$1.contractConfigs,
           chainId: init$1.chainId,
           latestOnBlockBlockNumber: init$1.latestOnBlockBlockNumber,
@@ -493,24 +482,24 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
   if (!chainFetcher.isProgressAtHead && updatedChainFetcher$1.isProgressAtHead) {
     Logging.childInfo(updatedChainFetcher$1.logger, "All events have been fetched");
   }
-  var init$2 = state.chainManager;
-  var nextState_ctx = state.ctx;
-  var nextState_chainManager = {
+  let init$2 = state.chainManager;
+  let nextState_ctx = state.ctx;
+  let nextState_chainManager = {
     committedCheckpointId: init$2.committedCheckpointId,
     chainFetchers: ChainMap.set(state.chainManager.chainFetchers, chain, updatedChainFetcher$1),
     multichain: init$2.multichain,
     isInReorgThreshold: init$2.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_exitAfterFirstEventBlock = state.exitAfterFirstEventBlock;
-  var nextState_id = state.id;
-  var nextState = {
+  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;
+  let nextState_loadManager = state.loadManager;
+  let nextState_keepProcessAlive = state.keepProcessAlive;
+  let nextState_exitAfterFirstEventBlock = state.exitAfterFirstEventBlock;
+  let nextState_id = state.id;
+  let nextState = {
     ctx: nextState_ctx,
     chainManager: nextState_chainManager,
     processedBatches: nextState_processedBatches,
@@ -524,65 +513,122 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
     id: nextState_id
   };
   return [
-          nextState,
-          [
-            {
-              TAG: "UpdateChainMetaDataAndCheckForExit",
-              _0: "NoExit"
-            },
-            "ProcessEventBatch",
-            {
-              TAG: "NextQuery",
-              _0: {
-                TAG: "Chain",
-                _0: chain
-              }
-            }
-          ]
-        ];
+    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];
+  let response = param.response;
+  let parsedQueueItems = response.parsedQueueItems;
+  let itemsWithContractRegister = [];
+  let newItems = [];
+  for (let idx = 0, idx_finish = parsedQueueItems.length; idx < idx_finish; ++idx) {
+    let 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;
+  let newItemsWithDcs = itemsWithContractRegister.length !== 0 ? await ChainFetcher.runContractRegistersOrThrow(itemsWithContractRegister, 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
-            });
+    TAG: "SubmitPartitionQueryResponse",
+    newItems: newItems,
+    newItemsWithDcs: newItemsWithDcs,
+    knownHeight: response.knownHeight,
+    latestFetchedBlock: {
+      blockNumber: response.latestFetchedBlockNumber,
+      blockTimestamp: response.latestFetchedBlockTimestamp
+    },
+    query: param.query,
+    chain: param.chain
+  });
 }
 
 function updateChainFetcher(chainFetcherUpdate, state, chain) {
-  var init = state.chainManager;
+  let 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,
+      exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+      id: state.id
+    },
+    []
+  ];
+}
+
+function onEnterReorgThreshold(state) {
+  Logging.info("Reorg threshold reached");
+  Prometheus.ReorgThreshold.set(true);
+  let chainFetchers = ChainMap.map(state.chainManager.chainFetchers, chainFetcher => ({
+    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
+  }));
+  let 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,
+    exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+    id: state.id
+  };
+}
+
+function actionReducer(state, action) {
+  if (typeof action !== "object") {
+    switch (action) {
+      case "StartProcessingBatch" :
+        return [
           {
             ctx: state.ctx,
-            chainManager: {
-              committedCheckpointId: init.committedCheckpointId,
-              chainFetchers: ChainMap.update(state.chainManager.chainFetchers, chain, chainFetcherUpdate),
-              multichain: init.multichain,
-              isInReorgThreshold: init.isInReorgThreshold
-            },
+            chainManager: state.chainManager,
             processedBatches: state.processedBatches,
-            currentlyProcessingBatch: state.currentlyProcessingBatch,
+            currentlyProcessingBatch: true,
             rollbackState: state.rollbackState,
             indexerStartTime: state.indexerStartTime,
             writeThrottlers: state.writeThrottlers,
@@ -593,338 +639,274 @@ function updateChainFetcher(chainFetcherUpdate, state, chain) {
           },
           []
         ];
-}
-
-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,
-          exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-          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,
-                    exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-                    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,
-                    id: state.id
-                  },
-                  []
-                ];
+        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,
+            id: state.id
+          },
+          []
+        ];
       case "EnterReorgThreshold" :
-          return [
-                  onEnterReorgThreshold(state),
-                  [{
-                      TAG: "NextQuery",
-                      _0: "CheckAllChains"
-                    }]
-                ];
+        return [
+          onEnterReorgThreshold(state),
+          [{
+              TAG: "NextQuery",
+              _0: "CheckAllChains"
+            }]
+        ];
       case "SuccessExit" :
-          Logging.info("Exiting with success");
-          Process.exit(0);
-          return [
-                  state,
-                  []
-                ];
-      
+        Logging.info("Exiting with success");
+        Process.exit(0);
+        return [
+          state,
+          []
+        ];
     }
   } else {
     switch (action.TAG) {
       case "ValidatePartitionQueryResponse" :
-          return validatePartitionQueryResponse(state, action._0);
+        return validatePartitionQueryResponse(state, action._0);
       case "SubmitPartitionQueryResponse" :
-          return submitPartitionQueryResponse(state, action.newItems, action.newItemsWithDcs, action.knownHeight, action.latestFetchedBlock, action.query, action.chain);
+        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_exitAfterFirstEventBlock = state.exitAfterFirstEventBlock;
-          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,
-            exitAfterFirstEventBlock: state_exitAfterFirstEventBlock,
-            id: state_id
-          };
-          if (shouldEnterReorgThreshold) {
-            return [
-                    onEnterReorgThreshold(state$1),
-                    [
-                      {
-                        TAG: "NextQuery",
-                        _0: "CheckAllChains"
-                      },
-                      "ProcessEventBatch"
-                    ]
-                  ];
+        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 [
-                    state$1,
-                    [
-                      {
-                        TAG: "NextQuery",
-                        _0: {
-                          TAG: "Chain",
-                          _0: chain
-                        }
-                      },
-                      "ProcessEventBatch"
-                    ]
-                  ];
+            return chainFetcher;
           }
-      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_exitAfterFirstEventBlock$1 = state.exitAfterFirstEventBlock;
-          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,
-            exitAfterFirstEventBlock: state_exitAfterFirstEventBlock$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") : (
-              state_exitAfterFirstEventBlock$1 && Belt_Array.every(ChainMap.values(state_chainManager$1.chainFetchers), (function (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 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 = {
+          committedCheckpointId: init.committedCheckpointId,
+          chainFetchers: updatedChainFetchers,
+          multichain: init.multichain,
+          isInReorgThreshold: init.isInReorgThreshold
+        };
+        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_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,
+          id: state_id
+        };
+        if (shouldEnterReorgThreshold) {
           return [
-                  state$2,
-                  Belt_Array.concat([
-                        {
-                          TAG: "UpdateChainMetaDataAndCheckForExit",
-                          _0: shouldExit
-                        },
-                        "ProcessEventBatch"
-                      ], maybePruneEntityHistory)
-                ];
-      case "FindReorgDepth" :
+            onEnterReorgThreshold(state$1),
+            [
+              {
+                TAG: "NextQuery",
+                _0: "CheckAllChains"
+              },
+              "ProcessEventBatch"
+            ]
+          ];
+        } else {
           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,
-                    id: state.id
-                  },
-                  ["Rollback"]
-                ];
+            state$1,
+            [
+              {
+                TAG: "NextQuery",
+                _0: {
+                  TAG: "Chain",
+                  _0: chain
+                }
+              },
+              "ProcessEventBatch"
+            ]
+          ];
+        }
+      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_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,
+          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"
+          );
+        return [
+          state$2,
+          [
+            {
+              TAG: "UpdateChainMetaDataAndCheckForExit",
+              _0: shouldExit
+            },
+            "ProcessEventBatch"
+          ].concat(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,
+            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+            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
+        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
           };
-          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,
-                    id: state.id
-                  },
-                  [{
-                      TAG: "NextQuery",
-                      _0: "CheckAllChains"
-                    }]
-                ];
+        });
+        let init$1 = state.chainManager;
+        let chainManager_committedCheckpointId = init$1.committedCheckpointId;
+        let chainManager_multichain = init$1.multichain;
+        let chainManager_isInReorgThreshold = init$1.isInReorgThreshold;
+        let 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,
+            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+            id: state.id
+          },
+          [{
+              TAG: "NextQuery",
+              _0: "CheckAllChains"
+            }]
+        ];
       case "ErrorExit" :
-          ErrorHandling.log(action._0);
-          Process.exit(1);
-          return [
-                  state,
-                  []
-                ];
+        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,
-                    exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-                    id: state.id
-                  },
-                  [
-                    {
-                      TAG: "NextQuery",
-                      _0: "CheckAllChains"
-                    },
-                    "ProcessEventBatch"
-                  ]
-                ];
-      
+        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,
+            exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+            id: state.id
+          },
+          [
+            {
+              TAG: "NextQuery",
+              _0: "CheckAllChains"
+            },
+            "ProcessEventBatch"
+          ]
+        ];
     }
   }
 }
@@ -933,359 +915,343 @@ 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,
-                      exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
-                      id: state.id
-                    },
-                    ["Rollback"]
-                  ];
-          }
-          break;
+        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,
+              exitAfterFirstEventBlock: state.exitAfterFirstEventBlock,
+              id: state.id
+            },
+            ["Rollback"]
+          ];
+        }
+        break;
       case "ErrorExit" :
-          return actionReducer(state, action);
-      default:
-        
+        return actionReducer(state, action);
     }
   }
   Logging.trace({
-        msg: "Invalidated action discarded",
-        action: S$RescriptSchema.convertOrThrow(action, Utils.Schema.variantTag)
-      });
+    msg: "Invalidated action discarded",
+    action: S$RescriptSchema.convertOrThrow(action, Utils.Schema.variantTag)
+  });
   return [
-          state,
-          []
-        ];
+    state,
+    []
+  ];
 }
 
 function checkAndFetchForChain(waitForNewBlock, executeQuery, state, dispatchAction) {
-  return async function (chain) {
-    var chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+  return async chain => {
+    let chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
     if (isPreparingRollback(state)) {
-      return ;
+      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);
+    let fetchState = chainFetcher.fetchState;
+    let reducedPolling = state.ctx.config.shouldRollbackOnReorg ? !state.chainManager.isInReorgThreshold && FetchState.isReadyToEnterReorgThreshold(fetchState) : ChainFetcher.isReady(chainFetcher) && ChainMap.values(state.chainManager.chainFetchers).some(cf => !ChainFetcher.isReady(cf));
+    return await SourceManager.fetchNext(chainFetcher.sourceManager, fetchState, async query => {
+      try {
+        let 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) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        return dispatchAction({
+          TAG: "ErrorExit",
+          _0: ErrorHandling.make(exn, undefined, undefined)
+        });
+      }
+    }, knownHeight => waitForNewBlock(chainFetcher.sourceManager, knownHeight, ChainFetcher.isReady(chainFetcher), reducedPolling), knownHeight => dispatchAction({
+      TAG: "FinishWaitingForNewBlock",
+      chain: chain,
+      knownHeight: knownHeight
+    }), state.id);
   };
 }
 
 function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlock) {
-  return async function (state, task, dispatchAction) {
+  return async (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 ;
-                }
+          if (state.currentlyProcessingBatch || isPreparingRollback(state)) {
+            return;
+          }
+          let match = state.rollbackState;
+          let rollbackInMemStore;
+          rollbackInMemStore = typeof match !== "object" || match.TAG !== "RollbackReady" ? undefined : match.diffInMemoryStore;
+          let batch = ChainManager.createBatch(state.chainManager, state.ctx.config.batchSize, rollbackInMemStore !== undefined);
+          let progressedChainsById = batch.progressedChainsById;
+          let isInReorgThreshold = state.chainManager.isInReorgThreshold;
+          let shouldSaveHistory = Config.shouldSaveHistory(state.ctx.config, isInReorgThreshold);
+          let isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
+          let shouldEnterReorgThreshold = isBelowReorgThreshold && ChainMap.values(state.chainManager.chainFetchers).every(chainFetcher => {
+            let chainAfterBatch = progressedChainsById[chainFetcher.fetchState.chainId];
+            return FetchState.isReadyToEnterReorgThreshold(chainAfterBatch !== undefined ? chainAfterBatch.fetchState : chainFetcher.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 ;
+                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
-                        });
+              return;
             }
-            break;
+          }
+          dispatchAction("StartProcessingBatch");
+          dispatchAction({
+            TAG: "UpdateQueues",
+            progressedChainsById: progressedChainsById,
+            shouldEnterReorgThreshold: shouldEnterReorgThreshold
+          });
+          let inMemoryStore = Stdlib_Option.getOr(rollbackInMemStore, InMemoryStore.make(state.ctx.persistence.allEntities, undefined));
+          InMemoryStore.setBatchDcs(inMemoryStore, batch, shouldSaveHistory);
+          let res;
+          try {
+            res = await EventProcessing.processEventBatch(batch, inMemoryStore, isInReorgThreshold, state.loadManager, state.ctx, state.chainManager.chainFetchers);
+          } catch (raw_exn) {
+            let exn = Primitive_exceptions.internalToException(raw_exn);
+            let 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");
-              
+          let match$1 = state.rollbackState;
+          if (typeof match$1 !== "object") {
+            if (match$1 === "NoRollback") {
+              return Stdlib_JsError.throwWithMessage("Internal error: Rollback initiated with invalid state");
+            } else {
+              return;
             }
-        case "PruneStaleEntityHistory" :
-            var runPrune = async function () {
-              var safeCheckpointId = ChainManager.getSafeCheckpointId(state.chainManager);
-              if (safeCheckpointId === undefined) {
-                return ;
+          }
+          switch (match$1.TAG) {
+            case "ReorgDetected" :
+              let chain = match$1.chain;
+              let chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
+              dispatchAction("StartFindingReorgDepth");
+              let 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");
+              }
+              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, {
+                action: "Rollback",
+                reorgChain: reorgChain,
+                targetBlockNumber: rollbackTargetBlockNumber$1
+              });
+              Logging.childInfo(logger, "Started rollback on reorg");
+              Prometheus.RollbackTargetBlockNumber.set(rollbackTargetBlockNumber$1, reorgChain);
+              let checkpointId = await state.ctx.persistence.storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber$1);
+              let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
+              let eventsProcessedDiffByChain = {};
+              let newProgressBlockNumberPerChain = {};
+              let rollbackedProcessedEvents = 0;
+              let rollbackProgressDiff = await state.ctx.persistence.storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
+              for (let idx = 0, idx_finish = rollbackProgressDiff.length; idx < idx_finish; ++idx) {
+                let diff = rollbackProgressDiff[idx];
+                let eventsProcessedDiff = Stdlib_Option.getOrThrow(Stdlib_Float.fromString(diff.events_processed_diff), undefined);
+                rollbackedProcessedEvents = rollbackedProcessedEvents + eventsProcessedDiff;
+                eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
+                newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber$1) : diff.new_progress_block_number;
               }
-              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);
+              let chainFetchers = ChainMap.mapWithKey(state.chainManager.chainFetchers, (chain, cf) => {
+                let newProgressBlockNumber = newProgressBlockNumberPerChain[chain];
+                if (newProgressBlockNumber === undefined) {
+                  if (Primitive_object.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 entityConfig = state.ctx.persistence.allEntities[idx];
-                var timeRef = Hrtime.makeTimer();
-                try {
-                  await state.ctx.persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+                let fetchState = FetchState.rollback(cf.fetchState, newProgressBlockNumber);
+                let newTotalEventsProcessed = cf.numEventsProcessed - eventsProcessedDiffByChain[chain];
+                if (cf.committedProgressBlockNumber !== newProgressBlockNumber) {
+                  Prometheus.ProgressBlockNumber.set(newProgressBlockNumber, chain);
                 }
-                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);
+                if (cf.numEventsProcessed !== newTotalEventsProcessed) {
+                  Prometheus.ProgressEventsCount.set(newTotalEventsProcessed, chain);
                 }
-                Prometheus.RollbackHistoryPrune.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef)), entityConfig.name);
+                let 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: Primitive_object.equal(chain, reorgChain) ? ReorgDetection.rollbackToValidBlockNumber(cf.reorgDetection, rollbackTargetBlockNumber$1) : cf.reorgDetection,
+                  safeCheckpointTracking: safeCheckpointTracking !== undefined ? SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber) : undefined
+                };
+              });
+              let diff$1 = await Persistence.prepareRollbackDiff(state.ctx.persistence, rollbackTargetCheckpointId, state.chainManager.committedCheckpointId + 1n);
+              let init = state.chainManager;
+              let chainManager_committedCheckpointId = init.committedCheckpointId;
+              let chainManager_multichain = init.multichain;
+              let chainManager_isInReorgThreshold = init.isInReorgThreshold;
+              let 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 Stdlib_JsError.throwWithMessage("Internal error: Rollback initiated with invalid state");
+          }
+        case "PruneStaleEntityHistory" :
+          let runPrune = async () => {
+            let safeCheckpointId = ChainManager.getSafeCheckpointId(state.chainManager);
+            if (safeCheckpointId === undefined) {
+              return;
+            }
+            await state.ctx.persistence.storage.pruneStaleCheckpoints(safeCheckpointId);
+            for (let idx = 0, idx_finish = state.ctx.persistence.allEntities.length; idx < idx_finish; ++idx) {
+              if (idx !== 0) {
+                await Utils.delay(1000);
               }
-            };
-            return Throttler.schedule(state.writeThrottlers.pruneStaleEntityHistory, runPrune);
-        
+              let entityConfig = state.ctx.persistence.allEntities[idx];
+              let timeRef = Hrtime.makeTimer();
+              try {
+                await state.ctx.persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+              } catch (raw_exn) {
+                let exn = Primitive_exceptions.internalToException(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 ;
+          let chainCheck = task._0;
+          let fetchForChain = checkAndFetchForChain(waitForNewBlock, executeQuery, state, dispatchAction);
+          if (typeof chainCheck === "object") {
+            return await fetchForChain(chainCheck._0);
+          }
+          await Promise.all(ChainMap.keys(state.chainManager.chainFetchers).map(__x => fetchForChain(__x)));
+          return;
         case "ProcessPartitionQueryResponse" :
-            processPartitionQueryResponse(state, task._0, dispatchAction);
-            return ;
+          processPartitionQueryResponse(state, task._0, dispatchAction);
+          return;
         case "UpdateChainMetaDataAndCheckForExit" :
-            var writeThrottlers = state.writeThrottlers;
-            var chainManager$1 = state.chainManager;
-            var shouldExit = task._0;
-            if (typeof shouldExit === "object") {
-              return dispatchAction({
-                          TAG: "ErrorExit",
-                          _0: ErrorHandling.make(Js_exn.raiseError(shouldExit._0), undefined, undefined)
-                        });
-            }
-            if (shouldExit === "ExitWithSuccess") {
-              updateChainMetadataTable(chainManager$1, state.ctx.persistence, writeThrottlers.chainMetaData);
-              return dispatchAction("SuccessExit");
-            }
+          let writeThrottlers = state.writeThrottlers;
+          let chainManager$1 = state.chainManager;
+          let shouldExit = task._0;
+          if (typeof shouldExit === "object") {
+            return dispatchAction({
+              TAG: "ErrorExit",
+              _0: ErrorHandling.make(Stdlib_JsError.throwWithMessage(shouldExit._0), undefined, undefined)
+            });
+          }
+          if (shouldExit === "ExitWithSuccess") {
             updateChainMetadataTable(chainManager$1, state.ctx.persistence, writeThrottlers.chainMetaData);
-            return ;
-        
+            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);
-      }));
+let taskReducer = injectedTaskReducer(SourceManager.waitForNewBlock, SourceManager.executeQuery, (chainFetcher, reorgBlockNumber) => ChainFetcher.getLastKnownValidBlock(chainFetcher, reorgBlockNumber, undefined));
 
 export {
-  WriteThrottlers ,
+  WriteThrottlers,
   make$1 as make,
-  getId ,
-  setChainManager ,
-  isPreparingRollback ,
-  updateChainMetadataTable ,
-  updateProgressedChains ,
-  validatePartitionQueryResponse ,
-  submitPartitionQueryResponse ,
-  processPartitionQueryResponse ,
-  updateChainFetcher ,
-  onEnterReorgThreshold ,
-  actionReducer ,
-  invalidatedActionReducer ,
-  checkAndFetchForChain ,
-  injectedTaskReducer ,
-  taskReducer ,
+  getId,
+  setChainManager,
+  isPreparingRollback,
+  updateChainMetadataTable,
+  updateProgressedChains,
+  validatePartitionQueryResponse,
+  submitPartitionQueryResponse,
+  processPartitionQueryResponse,
+  updateChainFetcher,
+  onEnterReorgThreshold,
+  actionReducer,
+  invalidatedActionReducer,
+  checkAndFetchForChain,
+  injectedTaskReducer,
+  taskReducer,
 }
 /* taskReducer Not a pure module */