envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/ChainFetcher.res.mjs

@@ -2,207 +2,184 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Svm from "./sources/Svm.res.mjs";
-import * as Caml from "rescript/lib/es6/caml.js";
 import * as Utils from "./Utils.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Logging from "./Logging.res.mjs";
-import * as $$Promise from "./bindings/Promise.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as EvmChain from "./sources/EvmChain.res.mjs";
-import * as Belt_Array from "rescript/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 EventRouter from "./sources/EventRouter.res.mjs";
 import * as UserContext from "./UserContext.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as ErrorHandling from "./ErrorHandling.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 Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as HyperFuelSource from "./sources/HyperFuelSource.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 
-function make(chainConfig, dynamicContracts, startBlock, endBlock, firstEventBlockOpt, progressBlockNumber, config, registrations, targetBufferSize, logger, timestampCaughtUpToHeadOrEndblock, numEventsProcessed, isInReorgThreshold, reorgCheckpoints, maxReorgDepth, knownHeightOpt) {
-  var firstEventBlock = firstEventBlockOpt !== undefined ? Caml_option.valFromOption(firstEventBlockOpt) : undefined;
-  var knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : 0;
-  var eventRouter = EventRouter.empty();
-  var contracts = [];
-  var eventConfigs = [];
-  var notRegisteredEvents = [];
-  Belt_Array.forEach(chainConfig.contracts, (function (contract) {
-          var contractName = contract.name;
-          Belt_Array.forEach(contract.events, (function (eventConfig) {
-                  var hasContractRegister = Belt_Option.isSome(eventConfig.contractRegister);
-                  EventRouter.addOrThrow(eventRouter, eventConfig.id, undefined, contractName, eventConfig.isWildcard, eventConfig.name, ChainMap.Chain.makeUnsafe(chainConfig.id));
-                  var shouldBeIncluded;
-                  if (config.enableRawEvents) {
-                    shouldBeIncluded = true;
-                  } else {
-                    var isRegistered = hasContractRegister || Belt_Option.isSome(eventConfig.handler);
-                    if (!isRegistered) {
-                      notRegisteredEvents.push(eventConfig);
-                    }
-                    shouldBeIncluded = isRegistered;
-                  }
-                  var shouldSkip;
-                  try {
-                    var getEventFiltersOrThrow = eventConfig.getEventFiltersOrThrow;
-                    if (getEventFiltersOrThrow) {
-                      var match = getEventFiltersOrThrow(ChainMap.Chain.makeUnsafe(chainConfig.id));
-                      shouldSkip = match.TAG === "Static" ? match._0.length === 0 : false;
-                    } else {
-                      shouldSkip = false;
-                    }
-                  }
-                  catch (exn){
-                    shouldSkip = false;
-                  }
-                  if (shouldBeIncluded && !shouldSkip) {
-                    eventConfigs.push(eventConfig);
-                    return ;
-                  }
-                  
-                }));
-          var startBlock = contract.startBlock;
-          if (startBlock !== undefined && startBlock < chainConfig.startBlock) {
-            Js_exn.raiseError("The start block for contract \"" + contractName + "\" is less than the chain start block. This is not supported yet.");
-          }
-          Belt_Array.forEach(contract.addresses, (function (address) {
-                  var startBlock = contract.startBlock;
-                  contracts.push({
-                        address: address,
-                        contractName: contract.name,
-                        startBlock: startBlock !== undefined ? startBlock : chainConfig.startBlock,
-                        registrationBlock: undefined
-                      });
-                }));
-        }));
-  Belt_Array.forEach(dynamicContracts, (function (dc) {
-          contracts.push(dc);
-        }));
+function configAddresses(chainConfig) {
+  let addresses = [];
+  chainConfig.contracts.forEach(contract => {
+    contract.addresses.forEach(address => {
+      addresses.push({
+        address: address,
+        contractName: contract.name,
+        registrationBlock: -1
+      });
+    });
+  });
+  return addresses;
+}
+
+function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBlockOpt, progressBlockNumber, config, registrations, targetBufferSize, logger, timestampCaughtUpToHeadOrEndblock, numEventsProcessed, isInReorgThreshold, reorgCheckpoints, maxReorgDepth, knownHeightOpt) {
+  let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
+  let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : 0;
+  let eventRouter = EventRouter.empty();
+  let eventConfigs = [];
+  let notRegisteredEvents = [];
+  chainConfig.contracts.forEach(contract => {
+    let contractName = contract.name;
+    contract.events.forEach(eventConfig => {
+      let hasContractRegister = Stdlib_Option.isSome(eventConfig.contractRegister);
+      EventRouter.addOrThrow(eventRouter, eventConfig.id, undefined, contractName, eventConfig.isWildcard, eventConfig.name, ChainMap.Chain.makeUnsafe(chainConfig.id));
+      let shouldBeIncluded;
+      if (config.enableRawEvents) {
+        shouldBeIncluded = true;
+      } else {
+        let isRegistered = hasContractRegister || Stdlib_Option.isSome(eventConfig.handler);
+        if (!isRegistered) {
+          notRegisteredEvents.push(eventConfig);
+        }
+        shouldBeIncluded = isRegistered;
+      }
+      let shouldSkip;
+      try {
+        let getEventFiltersOrThrow = eventConfig.getEventFiltersOrThrow;
+        if (getEventFiltersOrThrow) {
+          let match = getEventFiltersOrThrow(ChainMap.Chain.makeUnsafe(chainConfig.id));
+          shouldSkip = match.TAG === "Static" ? match._0.length === 0 : false;
+        } else {
+          shouldSkip = false;
+        }
+      } catch (exn) {
+        shouldSkip = false;
+      }
+      if (shouldBeIncluded && !shouldSkip) {
+        eventConfigs.push(eventConfig);
+        return;
+      }
+    });
+    let startBlock = contract.startBlock;
+    if (startBlock !== undefined && startBlock < chainConfig.startBlock) {
+      return Stdlib_JsError.throwWithMessage(`The start block for contract "` + contractName + `" is less than the chain start block. This is not supported yet.`);
+    }
+  });
   if (Utils.$$Array.notEmpty(notRegisteredEvents)) {
-    Logging.childInfo(logger, "The event" + (
-          notRegisteredEvents.length > 1 ? "s" : ""
-        ) + " " + Belt_Array.map(notRegisteredEvents, (function (eventConfig) {
-                  return eventConfig.contractName + "." + eventConfig.name;
-                })).join(", ") + " don't have an event handler and skipped for indexing.");
+    Logging.childInfo(logger, `The event` + (
+      notRegisteredEvents.length > 1 ? "s" : ""
+    ) + ` ` + notRegisteredEvents.map(eventConfig => eventConfig.contractName + `.` + eventConfig.name).join(", ") + ` don't have an event handler and skipped for indexing.`);
   }
-  var onBlockConfigs = registrations.onBlockByChainId[String(chainConfig.id)];
+  let onBlockConfigs = registrations.onBlockByChainId[chainConfig.id.toString()];
   if (onBlockConfigs !== undefined) {
-    Belt_Array.forEach(onBlockConfigs, (function (onBlockConfig) {
-            if (Belt_Option.getWithDefault(onBlockConfig.startBlock, startBlock) < startBlock) {
-              Js_exn.raiseError("The start block for onBlock handler \"" + onBlockConfig.name + "\" is less than the chain start block (" + String(startBlock) + "). This is not supported yet.");
-            }
-            if (endBlock !== undefined && Belt_Option.getWithDefault(onBlockConfig.endBlock, endBlock) > endBlock) {
-              return Js_exn.raiseError("The end block for onBlock handler \"" + onBlockConfig.name + "\" is greater than the chain end block (" + String(endBlock) + "). This is not supported yet.");
-            }
-            
-          }));
+    onBlockConfigs.forEach(onBlockConfig => {
+      if (Stdlib_Option.getOr(onBlockConfig.startBlock, startBlock) < startBlock) {
+        Stdlib_JsError.throwWithMessage(`The start block for onBlock handler "` + onBlockConfig.name + `" is less than the chain start block (` + String(startBlock) + `). This is not supported yet.`);
+      }
+      if (endBlock !== undefined && Stdlib_Option.getOr(onBlockConfig.endBlock, endBlock) > endBlock) {
+        return Stdlib_JsError.throwWithMessage(`The end block for onBlock handler "` + onBlockConfig.name + `" is greater than the chain end block (` + String(endBlock) + `). This is not supported yet.`);
+      }
+    });
   }
-  var fetchState = FetchState.make(startBlock, endBlock, eventConfigs, contracts, config.maxAddrInPartition, chainConfig.id, targetBufferSize, knownHeight, progressBlockNumber, onBlockConfigs, Caml.int_max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Caml_option.some(firstEventBlock));
-  var chainReorgCheckpoints = Belt_Array.keepMapU(reorgCheckpoints, (function (reorgCheckpoint) {
-          if (reorgCheckpoint.chain_id === chainConfig.id) {
-            return reorgCheckpoint;
-          }
-          
-        }));
-  var chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
-  var lowercaseAddresses = config.lowercaseAddresses;
-  var sources = chainConfig.sourceConfig;
-  var sources$1;
+  let fetchState = FetchState.make(startBlock, endBlock, eventConfigs, indexingAddresses, config.maxAddrInPartition, chainConfig.id, targetBufferSize, knownHeight, progressBlockNumber, onBlockConfigs, Primitive_int.max(!config.shouldRollbackOnReorg || isInReorgThreshold ? 0 : chainConfig.maxReorgDepth, chainConfig.blockLag), Primitive_option.some(firstEventBlock));
+  let chainReorgCheckpoints = Stdlib_Array.filterMap(reorgCheckpoints, reorgCheckpoint => {
+    if (reorgCheckpoint.chain_id === chainConfig.id) {
+      return reorgCheckpoint;
+    }
+  });
+  let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
+  let lowercaseAddresses = config.lowercaseAddresses;
+  let sources = chainConfig.sourceConfig;
+  let sources$1;
   switch (sources.TAG) {
     case "EvmSourceConfig" :
-        var evmContracts = Belt_Array.map(chainConfig.contracts, (function (contract) {
-                return {
-                        name: contract.name,
-                        abi: contract.abi,
-                        events: contract.events
-                      };
-              }));
-        var allEventSignatures = Belt_Array.flatMap(chainConfig.contracts, (function (contract) {
-                return contract.eventSignatures;
-              }));
-        var evmRpcs = Belt_Array.map(sources.rpcs, (function (rpc) {
-                var syncConfig = rpc.syncConfig;
-                var ws = rpc.ws;
-                return {
-                        url: rpc.url,
-                        sourceFor: rpc.sourceFor,
-                        syncConfig: syncConfig,
-                        ws: ws
-                      };
-              }));
-        sources$1 = EvmChain.makeSources(chain, evmContracts, sources.hypersync, allEventSignatures, evmRpcs, lowercaseAddresses);
-        break;
+      let evmContracts = chainConfig.contracts.map(contract => ({
+        name: contract.name,
+        abi: contract.abi,
+        events: contract.events
+      }));
+      let allEventSignatures = chainConfig.contracts.flatMap(contract => contract.eventSignatures);
+      let evmRpcs = sources.rpcs.map(rpc => {
+        let syncConfig = rpc.syncConfig;
+        let ws = rpc.ws;
+        return {
+          url: rpc.url,
+          sourceFor: rpc.sourceFor,
+          syncConfig: syncConfig,
+          ws: ws
+        };
+      });
+      sources$1 = EvmChain.makeSources(chain, evmContracts, sources.hypersync, allEventSignatures, evmRpcs, lowercaseAddresses);
+      break;
     case "FuelSourceConfig" :
-        sources$1 = [HyperFuelSource.make({
-                chain: chain,
-                endpointUrl: sources.hypersync
-              })];
-        break;
+      sources$1 = [HyperFuelSource.make({
+          chain: chain,
+          endpointUrl: sources.hypersync
+        })];
+      break;
     case "SvmSourceConfig" :
-        sources$1 = [Svm.makeRPCSource(chain, sources.rpc)];
-        break;
+      sources$1 = [Svm.makeRPCSource(chain, sources.rpc)];
+      break;
     case "CustomSources" :
-        sources$1 = sources._0;
-        break;
-    
+      sources$1 = sources._0;
+      break;
   }
   return {
-          logger: logger,
-          fetchState: fetchState,
-          sourceManager: SourceManager.make(sources$1, Env.maxPartitionConcurrency, Belt_Option.isSome(timestampCaughtUpToHeadOrEndblock), undefined, undefined, undefined, undefined, undefined),
-          chainConfig: chainConfig,
-          isProgressAtHead: false,
-          timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock,
-          committedProgressBlockNumber: progressBlockNumber,
-          numEventsProcessed: numEventsProcessed,
-          reorgDetection: ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg),
-          safeCheckpointTracking: SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)
-        };
+    logger: logger,
+    fetchState: fetchState,
+    sourceManager: SourceManager.make(sources$1, Env.maxPartitionConcurrency, Stdlib_Option.isSome(timestampCaughtUpToHeadOrEndblock), undefined, undefined, undefined, undefined, undefined, undefined),
+    chainConfig: chainConfig,
+    isProgressAtHead: false,
+    timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock,
+    committedProgressBlockNumber: progressBlockNumber,
+    numEventsProcessed: numEventsProcessed,
+    reorgDetection: ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg),
+    safeCheckpointTracking: SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)
+  };
 }
 
 function makeFromConfig(chainConfig, config, registrations, targetBufferSize, knownHeight) {
-  var logger = Logging.createChild({
-        chainId: chainConfig.id
-      });
-  return make(chainConfig, [], chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrations, targetBufferSize, logger, undefined, 0, false, [], chainConfig.maxReorgDepth, knownHeight);
+  let logger = Logging.createChild({
+    chainId: chainConfig.id
+  });
+  return make(chainConfig, configAddresses(chainConfig), chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrations, targetBufferSize, logger, undefined, 0, false, [], chainConfig.maxReorgDepth, knownHeight);
 }
 
-async function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, config, registrations, targetBufferSize) {
-  var chainId = chainConfig.id;
-  var logger = Logging.createChild({
-        chainId: chainId
-      });
+function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, config, registrations, targetBufferSize) {
+  let chainId = chainConfig.id;
+  let logger = Logging.createChild({
+    chainId: chainId
+  });
   Prometheus.ProgressEventsCount.set(resumedChainState.numEventsProcessed, chainId);
-  var progressBlockNumber = resumedChainState.progressBlockNumber >= 0 ? resumedChainState.progressBlockNumber : resumedChainState.startBlock - 1 | 0;
-  return make(chainConfig, resumedChainState.dynamicContracts, resumedChainState.startBlock, resumedChainState.endBlock, Caml_option.some(resumedChainState.firstEventBlockNumber), progressBlockNumber, config, registrations, targetBufferSize, logger, Env.updateSyncTimeOnRestart ? undefined : resumedChainState.timestampCaughtUpToHeadOrEndblock, resumedChainState.numEventsProcessed, isInReorgThreshold, reorgCheckpoints, resumedChainState.maxReorgDepth, resumedChainState.sourceBlockNumber);
-}
-
-function getContractStartBlock(config, chain, contractName) {
-  var chainConfig = ChainMap.get(config.chainMap, chain);
-  return Belt_Option.flatMap(Caml_option.undefined_to_opt(chainConfig.contracts.find(function (contract) {
-                      return contract.name === contractName;
-                    })), (function (contract) {
-                return contract.startBlock;
-              }));
+  let progressBlockNumber = resumedChainState.progressBlockNumber >= 0 ? resumedChainState.progressBlockNumber : resumedChainState.startBlock - 1 | 0;
+  return make(chainConfig, resumedChainState.indexingAddresses, resumedChainState.startBlock, resumedChainState.endBlock, Primitive_option.some(resumedChainState.firstEventBlockNumber), progressBlockNumber, config, registrations, targetBufferSize, logger, Env.updateSyncTimeOnRestart ? undefined : resumedChainState.timestampCaughtUpToHeadOrEndblock, resumedChainState.numEventsProcessed, isInReorgThreshold, reorgCheckpoints, resumedChainState.maxReorgDepth, resumedChainState.sourceBlockNumber);
 }
 
-async function runContractRegistersOrThrow(itemsWithContractRegister, chain, config) {
-  var itemsWithDcs = [];
-  var onRegister = function (item, contractAddress, contractName) {
-    var blockNumber = item.blockNumber;
-    var configuredStartBlock = getContractStartBlock(config, chain, contractName);
-    var contractStartBlock = configuredStartBlock !== undefined ? configuredStartBlock : blockNumber;
-    var dc_registrationBlock = blockNumber;
-    var dc = {
+async function runContractRegistersOrThrow(itemsWithContractRegister, config) {
+  let itemsWithDcs = [];
+  let onRegister = (item, contractAddress, contractName) => {
+    let dc_registrationBlock = item.blockNumber;
+    let dc = {
       address: contractAddress,
       contractName: contractName,
-      startBlock: contractStartBlock,
       registrationBlock: dc_registrationBlock
     };
-    var dcs = item.dcs;
+    let dcs = item.dcs;
     if (dcs !== undefined) {
       dcs.push(dc);
     } else {
@@ -210,39 +187,34 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, chain, con
       itemsWithDcs.push(item);
     }
   };
-  var promises = [];
-  for(var idx = 0 ,idx_finish = itemsWithContractRegister.length; idx < idx_finish; ++idx){
-    var item = itemsWithContractRegister[idx];
-    var match = item.eventConfig;
-    var contractRegister = match.contractRegister;
-    var contractRegister$1 = contractRegister !== undefined ? contractRegister : Js_exn.raiseError("Contract register is not set for event " + match.name);
-    var errorMessage = "Event contractRegister failed, please fix the error to keep the indexer running smoothly";
+  let promises = [];
+  for (let idx = 0, idx_finish = itemsWithContractRegister.length; idx < idx_finish; ++idx) {
+    let item = itemsWithContractRegister[idx];
+    let match = item.eventConfig;
+    let contractRegister = match.contractRegister;
+    let contractRegister$1 = contractRegister !== undefined ? contractRegister : Stdlib_JsError.throwWithMessage("Contract register is not set for event " + match.name);
+    let errorMessage = "Event contractRegister failed, please fix the error to keep the indexer running smoothly";
     try {
-      var params = {
+      let params = {
         item: item,
         onRegister: onRegister,
         config: config,
         isResolved: false
       };
-      var result = contractRegister$1(UserContext.getContractRegisterArgs(params));
-      if ($$Promise.isCatchable(result)) {
-        promises.push($$Promise.$$catch(result.then((function(params){
-                    return function (r) {
-                      params.isResolved = true;
-                      
-                    }
-                    }(params))), (function(item,params){
-                return function (exn) {
-                  params.isResolved = true;
-                  return ErrorHandling.mkLogAndRaise(Logging.getItemLogger(item), errorMessage, exn);
-                }
-                }(item,params))));
+      let result = contractRegister$1(UserContext.getContractRegisterArgs(params));
+      if (Utils.$$Promise.isCatchable(result)) {
+        promises.push(Stdlib_Promise.$$catch(result.then(r => {
+          params.isResolved = true;
+          
+        }), exn => {
+          params.isResolved = true;
+          return ErrorHandling.mkLogAndRaise(Logging.getItemLogger(item), errorMessage, exn);
+        }));
       } else {
         params.isResolved = true;
       }
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
       ErrorHandling.mkLogAndRaise(Logging.getItemLogger(item), errorMessage, exn);
     }
   }
@@ -253,23 +225,23 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, chain, con
 }
 
 function handleQueryResult(chainFetcher, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight) {
-  var fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(chainFetcher.fetchState, newItemsWithDcs) : chainFetcher.fetchState;
+  let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(chainFetcher.fetchState, newItemsWithDcs) : chainFetcher.fetchState;
   return {
-          logger: chainFetcher.logger,
-          fetchState: FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight),
-          sourceManager: chainFetcher.sourceManager,
-          chainConfig: chainFetcher.chainConfig,
-          isProgressAtHead: chainFetcher.isProgressAtHead,
-          timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
-          committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
-          numEventsProcessed: chainFetcher.numEventsProcessed,
-          reorgDetection: chainFetcher.reorgDetection,
-          safeCheckpointTracking: chainFetcher.safeCheckpointTracking
-        };
+    logger: chainFetcher.logger,
+    fetchState: FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight),
+    sourceManager: chainFetcher.sourceManager,
+    chainConfig: chainFetcher.chainConfig,
+    isProgressAtHead: chainFetcher.isProgressAtHead,
+    timestampCaughtUpToHeadOrEndblock: chainFetcher.timestampCaughtUpToHeadOrEndblock,
+    committedProgressBlockNumber: chainFetcher.committedProgressBlockNumber,
+    numEventsProcessed: chainFetcher.numEventsProcessed,
+    reorgDetection: chainFetcher.reorgDetection,
+    safeCheckpointTracking: chainFetcher.safeCheckpointTracking
+  };
 }
 
 function hasProcessedToEndblock(self) {
-  var endBlock = self.fetchState.endBlock;
+  let endBlock = self.fetchState.endBlock;
   if (endBlock !== undefined) {
     return self.committedProgressBlockNumber >= endBlock;
   } else {
@@ -282,7 +254,7 @@ function hasNoMoreEventsToProcess(self) {
 }
 
 function getHighestBlockBelowThreshold(cf) {
-  var highestBlockBelowThreshold = cf.fetchState.knownHeight - cf.chainConfig.maxReorgDepth | 0;
+  let highestBlockBelowThreshold = cf.fetchState.knownHeight - cf.chainConfig.maxReorgDepth | 0;
   if (highestBlockBelowThreshold < 0) {
     return 0;
   } else {
@@ -291,22 +263,20 @@ function getHighestBlockBelowThreshold(cf) {
 }
 
 async function getLastKnownValidBlock(chainFetcher, reorgBlockNumber, getBlockHashesOpt) {
-  var getBlockHashes = getBlockHashesOpt !== undefined ? getBlockHashesOpt : SourceManager.getActiveSource(chainFetcher.sourceManager).getBlockHashes;
-  var scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(chainFetcher.reorgDetection, reorgBlockNumber, chainFetcher.fetchState.knownHeight);
-  var getBlockHashes$1 = function (blockNumbers) {
-    return getBlockHashes(blockNumbers, chainFetcher.logger).then(function (res) {
-                if (res.TAG === "Ok") {
-                  return res._0;
-                } else {
-                  return ErrorHandling.mkLogAndRaise(undefined, "Failed to fetch blockHashes for given blockNumbers during rollback", res._0);
-                }
-              });
-  };
+  let getBlockHashes = getBlockHashesOpt !== undefined ? getBlockHashesOpt : SourceManager.getActiveSource(chainFetcher.sourceManager).getBlockHashes;
+  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(chainFetcher.reorgDetection, reorgBlockNumber, chainFetcher.fetchState.knownHeight);
+  let getBlockHashes$1 = blockNumbers => getBlockHashes(blockNumbers, chainFetcher.logger).then(res => {
+    if (res.TAG === "Ok") {
+      return res._0;
+    } else {
+      return ErrorHandling.mkLogAndRaise(undefined, "Failed to fetch blockHashes for given blockNumbers during rollback", res._0);
+    }
+  });
   if (scannedBlockNumbers.length === 0) {
     return getHighestBlockBelowThreshold(chainFetcher);
   }
-  var blockNumbersAndHashes = await getBlockHashes$1(scannedBlockNumbers);
-  var blockNumber = ReorgDetection.getLatestValidScannedBlock(chainFetcher.reorgDetection, blockNumbersAndHashes);
+  let blockNumbersAndHashes = await getBlockHashes$1(scannedBlockNumbers);
+  let blockNumber = ReorgDetection.getLatestValidScannedBlock(chainFetcher.reorgDetection, blockNumbersAndHashes);
   if (blockNumber !== undefined) {
     return blockNumber;
   } else {
@@ -323,17 +293,17 @@ function isReady(chainFetcher) {
 }
 
 export {
-  make ,
-  makeFromConfig ,
-  makeFromDbState ,
-  getContractStartBlock ,
-  runContractRegistersOrThrow ,
-  handleQueryResult ,
-  hasProcessedToEndblock ,
-  hasNoMoreEventsToProcess ,
-  getHighestBlockBelowThreshold ,
-  getLastKnownValidBlock ,
-  isActivelyIndexing ,
-  isReady ,
+  configAddresses,
+  make,
+  makeFromConfig,
+  makeFromDbState,
+  runContractRegistersOrThrow,
+  handleQueryResult,
+  hasProcessedToEndblock,
+  hasNoMoreEventsToProcess,
+  getHighestBlockBelowThreshold,
+  getLastKnownValidBlock,
+  isActivelyIndexing,
+  isReady,
 }
 /* Env Not a pure module */

package/src/ChainManager.res

@@ -1,5 +1,3 @@
-open Belt
-
 type t = {
   committedCheckpointId: bigint,
   chainFetchers: ChainMap.t<ChainFetcher.t>,
@@ -31,7 +29,7 @@ let calculateTargetBufferSize = (~activeChainsCount) => {
   }
 }
 
-let makeFromDbState = async (
+let makeFromDbState = (
   ~initialState: Persistence.initialState,
   ~config: Config.t,
   ~registrations,
@@ -60,14 +58,13 @@ let makeFromDbState = async (
   })
 
   let chainFetchersArr =
-    await initialState.chains
-    ->Array.map(async (resumedChainState: Persistence.initialChainState) => {
+    initialState.chains->Array.map((resumedChainState: Persistence.initialChainState) => {
       let chain = Config.getChain(config, ~chainId=resumedChainState.id)
       let chainConfig = config.chainMap->ChainMap.get(chain)
 
       (
         chain,
-        await chainConfig->ChainFetcher.makeFromDbState(
+        chainConfig->ChainFetcher.makeFromDbState(
           ~resumedChainState,
           ~reorgCheckpoints=initialState.reorgCheckpoints,
           ~isInReorgThreshold,
@@ -77,7 +74,6 @@ let makeFromDbState = async (
         ),
       )
     })
-    ->Promise.all
 
   let chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr)
 
@@ -135,7 +131,7 @@ let createBatch = (chainManager: t, ~batchSizeTarget: int, ~isRollback: bool): B
       // Since for rollback we have a diff checkpoint id.
       // This is needed to currectly overwrite old state
       // in an append-only ClickHouse insert.
-      isRollback ? 1n : 0n
+      isRollback ? 1n : 0n,
     ),
     ~chainsBeforeBatch=chainManager.chainFetchers->ChainMap.map((cf): Batch.chainBeforeBatch => {
       fetchState: cf.fetchState,
@@ -151,14 +147,10 @@ let createBatch = (chainManager: t, ~batchSizeTarget: int, ~isRollback: bool): B
 }
 
 let isProgressAtHead = chainManager =>
-  chainManager.chainFetchers
-  ->ChainMap.values
-  ->Js.Array2.every(cf => cf.isProgressAtHead)
+  chainManager.chainFetchers->ChainMap.values->Array.every(cf => cf.isProgressAtHead)
 
 let isActivelyIndexing = chainManager =>
-  chainManager.chainFetchers
-  ->ChainMap.values
-  ->Js.Array2.every(ChainFetcher.isActivelyIndexing)
+  chainManager.chainFetchers->ChainMap.values->Array.every(ChainFetcher.isActivelyIndexing)
 
 let getSafeCheckpointId = (chainManager: t) => {
   let chainFetchers = chainManager.chainFetchers->ChainMap.values