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

package/src/ChainFetcher.res.mjs

@@ -0,0 +1,339 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 ErrorHandling from "./ErrorHandling.res.mjs";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
+import * as ReorgDetection from "./ReorgDetection.res.mjs";
+import * as HyperFuelSource from "./sources/HyperFuelSource.res.mjs";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_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);
+        }));
+  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.");
+  }
+  var onBlockConfigs = registrations.onBlockByChainId[String(chainConfig.id)];
+  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.");
+            }
+            
+          }));
+  }
+  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;
+  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;
+    case "FuelSourceConfig" :
+        sources$1 = [HyperFuelSource.make({
+                chain: chain,
+                endpointUrl: sources.hypersync
+              })];
+        break;
+    case "SvmSourceConfig" :
+        sources$1 = [Svm.makeRPCSource(chain, sources.rpc)];
+        break;
+    case "CustomSources" :
+        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)
+        };
+}
+
+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);
+}
+
+async function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, config, registrations, targetBufferSize) {
+  var chainId = chainConfig.id;
+  var 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;
+              }));
+}
+
+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 = {
+      address: contractAddress,
+      contractName: contractName,
+      startBlock: contractStartBlock,
+      registrationBlock: dc_registrationBlock
+    };
+    var dcs = item.dcs;
+    if (dcs !== undefined) {
+      dcs.push(dc);
+    } else {
+      item.dcs = [dc];
+      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";
+    try {
+      var 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))));
+      } else {
+        params.isResolved = true;
+      }
+    }
+    catch (raw_exn){
+      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+      ErrorHandling.mkLogAndRaise(Logging.getItemLogger(item), errorMessage, exn);
+    }
+  }
+  if (Utils.$$Array.notEmpty(promises)) {
+    await Promise.all(promises);
+  }
+  return itemsWithDcs;
+}
+
+function handleQueryResult(chainFetcher, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight) {
+  var 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
+        };
+}
+
+function hasProcessedToEndblock(self) {
+  var endBlock = self.fetchState.endBlock;
+  if (endBlock !== undefined) {
+    return self.committedProgressBlockNumber >= endBlock;
+  } else {
+    return false;
+  }
+}
+
+function hasNoMoreEventsToProcess(self) {
+  return FetchState.bufferSize(self.fetchState) === 0;
+}
+
+function getHighestBlockBelowThreshold(cf) {
+  var highestBlockBelowThreshold = cf.fetchState.knownHeight - cf.chainConfig.maxReorgDepth | 0;
+  if (highestBlockBelowThreshold < 0) {
+    return 0;
+  } else {
+    return highestBlockBelowThreshold;
+  }
+}
+
+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);
+                }
+              });
+  };
+  if (scannedBlockNumbers.length === 0) {
+    return getHighestBlockBelowThreshold(chainFetcher);
+  }
+  var blockNumbersAndHashes = await getBlockHashes$1(scannedBlockNumbers);
+  var blockNumber = ReorgDetection.getLatestValidScannedBlock(chainFetcher.reorgDetection, blockNumbersAndHashes);
+  if (blockNumber !== undefined) {
+    return blockNumber;
+  } else {
+    return getHighestBlockBelowThreshold(chainFetcher);
+  }
+}
+
+function isActivelyIndexing(chainFetcher) {
+  return FetchState.isActivelyIndexing(chainFetcher.fetchState);
+}
+
+function isReady(chainFetcher) {
+  return chainFetcher.timestampCaughtUpToHeadOrEndblock !== undefined;
+}
+
+export {
+  make ,
+  makeFromConfig ,
+  makeFromDbState ,
+  getContractStartBlock ,
+  runContractRegistersOrThrow ,
+  handleQueryResult ,
+  hasProcessedToEndblock ,
+  hasNoMoreEventsToProcess ,
+  getHighestBlockBelowThreshold ,
+  getLastKnownValidBlock ,
+  isActivelyIndexing ,
+  isReady ,
+}
+/* Env Not a pure module */

package/src/ChainManager.res

@@ -0,0 +1,190 @@
+open Belt
+
+type t = {
+  committedCheckpointId: bigint,
+  chainFetchers: ChainMap.t<ChainFetcher.t>,
+  multichain: Config.multichain,
+  isInReorgThreshold: bool,
+}
+
+// Check if progress is past the reorg threshold (safe block).
+// A chain is in reorg threshold when progressBlockNumber > sourceBlockNumber - maxReorgDepth.
+// This matches the logic in InternalTable.Checkpoints.makeGetReorgCheckpointsQuery.
+let isProgressInReorgThreshold = (~progressBlockNumber, ~sourceBlockNumber, ~maxReorgDepth) => {
+  maxReorgDepth > 0 &&
+  sourceBlockNumber > 0 &&
+  progressBlockNumber > sourceBlockNumber - maxReorgDepth
+}
+
+let calculateTargetBufferSize = (~activeChainsCount) => {
+  switch Env.targetBufferSize {
+  | Some(size) => size
+  | None =>
+    switch activeChainsCount {
+    | 1 => 60_000
+    | 2 => 30_000
+    | 3 => 20_000
+    | 4 => 15_000
+    | 5 => 10_000
+    | _ => 5_000
+    }
+  }
+}
+
+let makeFromDbState = async (
+  ~initialState: Persistence.initialState,
+  ~config: Config.t,
+  ~registrations,
+): t => {
+  let isInReorgThreshold = if initialState.cleanRun {
+    false
+  } else {
+    // Check if any chain is in reorg threshold by comparing progress with sourceBlock - maxReorgDepth.
+    initialState.chains->Array.some(chain =>
+      isProgressInReorgThreshold(
+        ~progressBlockNumber=chain.progressBlockNumber,
+        ~sourceBlockNumber=chain.sourceBlockNumber,
+        ~maxReorgDepth=chain.maxReorgDepth,
+      )
+    )
+  }
+
+  let targetBufferSize = calculateTargetBufferSize(
+    ~activeChainsCount=initialState.chains->Array.length,
+  )
+  Prometheus.ProcessingMaxBatchSize.set(~maxBatchSize=config.batchSize)
+  Prometheus.IndexingTargetBufferSize.set(~targetBufferSize)
+  Prometheus.ReorgThreshold.set(~isInReorgThreshold)
+  initialState.cache->Utils.Dict.forEach(({effectName, count}) => {
+    Prometheus.EffectCacheCount.set(~count, ~effectName)
+  })
+
+  let chainFetchersArr =
+    await initialState.chains
+    ->Array.map(async (resumedChainState: Persistence.initialChainState) => {
+      let chain = Config.getChain(config, ~chainId=resumedChainState.id)
+      let chainConfig = config.chainMap->ChainMap.get(chain)
+
+      (
+        chain,
+        await chainConfig->ChainFetcher.makeFromDbState(
+          ~resumedChainState,
+          ~reorgCheckpoints=initialState.reorgCheckpoints,
+          ~isInReorgThreshold,
+          ~targetBufferSize,
+          ~config,
+          ~registrations,
+        ),
+      )
+    })
+    ->Promise.all
+
+  let chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr)
+
+  // Set initial progress metrics from DB state so dashboards reflect
+  // the persisted state immediately on restart
+  let allChainsReady = ref(chainFetchersArr->Array.length > 0)
+  chainFetchersArr->Array.forEach(((chain, cf)) => {
+    let chainId = chain->ChainMap.Chain.toChainId
+    Prometheus.ProgressBlockNumber.set(~blockNumber=cf.committedProgressBlockNumber, ~chainId)
+    Prometheus.ProgressReady.init(~chainId)
+    if cf->ChainFetcher.isReady {
+      Prometheus.ProgressReady.set(~chainId)
+    } else {
+      allChainsReady := false
+    }
+  })
+  if allChainsReady.contents {
+    Prometheus.ProgressReady.setAllReady()
+  }
+
+  {
+    committedCheckpointId: initialState.checkpointId,
+    multichain: config.multichain,
+    chainFetchers,
+    isInReorgThreshold,
+  }
+}
+
+let getChainFetcher = (chainManager: t, ~chain: ChainMap.Chain.t): ChainFetcher.t => {
+  chainManager.chainFetchers->ChainMap.get(chain)
+}
+
+let setChainFetcher = (chainManager: t, chainFetcher: ChainFetcher.t) => {
+  {
+    ...chainManager,
+    chainFetchers: chainManager.chainFetchers->ChainMap.set(
+      ChainMap.Chain.makeUnsafe(~chainId=chainFetcher.chainConfig.id),
+      chainFetcher,
+    ),
+  }
+}
+
+let nextItemIsNone = (chainManager: t): bool => {
+  !Batch.hasMultichainReadyItem(
+    chainManager.chainFetchers->ChainMap.map(cf => {
+      cf.fetchState
+    }),
+    ~multichain=chainManager.multichain,
+  )
+}
+
+let createBatch = (chainManager: t, ~batchSizeTarget: int, ~isRollback: bool): Batch.t => {
+  Batch.make(
+    ~checkpointIdBeforeBatch=chainManager.committedCheckpointId->BigInt.add(
+      // 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
+    ),
+    ~chainsBeforeBatch=chainManager.chainFetchers->ChainMap.map((cf): Batch.chainBeforeBatch => {
+      fetchState: cf.fetchState,
+      progressBlockNumber: cf.committedProgressBlockNumber,
+      totalEventsProcessed: cf.numEventsProcessed,
+      sourceBlockNumber: cf.fetchState.knownHeight,
+      reorgDetection: cf.reorgDetection,
+      chainConfig: cf.chainConfig,
+    }),
+    ~multichain=chainManager.multichain,
+    ~batchSizeTarget,
+  )
+}
+
+let isProgressAtHead = chainManager =>
+  chainManager.chainFetchers
+  ->ChainMap.values
+  ->Js.Array2.every(cf => cf.isProgressAtHead)
+
+let isActivelyIndexing = chainManager =>
+  chainManager.chainFetchers
+  ->ChainMap.values
+  ->Js.Array2.every(ChainFetcher.isActivelyIndexing)
+
+let getSafeCheckpointId = (chainManager: t) => {
+  let chainFetchers = chainManager.chainFetchers->ChainMap.values
+
+  let result: ref<option<bigint>> = ref(None)
+
+  for idx in 0 to chainFetchers->Array.length - 1 {
+    let chainFetcher = chainFetchers->Array.getUnsafe(idx)
+    switch chainFetcher.safeCheckpointTracking {
+    | None => () // Skip chains with maxReorgDepth = 0
+    | Some(safeCheckpointTracking) => {
+        let safeCheckpointId =
+          safeCheckpointTracking->SafeCheckpointTracking.getSafeCheckpointId(
+            ~sourceBlockNumber=chainFetcher.fetchState.knownHeight,
+          )
+        switch result.contents {
+        | None => result := Some(safeCheckpointId)
+        | Some(current) if safeCheckpointId < current => result := Some(safeCheckpointId)
+        | _ => ()
+        }
+      }
+    }
+  }
+
+  switch result.contents {
+  | Some(id) if id > 0n => Some(id)
+  | _ => None // No safe checkpoint found
+  }
+}

package/src/ChainManager.res.mjs

@@ -0,0 +1,166 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as Batch from "./Batch.res.mjs";
+import * as Utils from "./Utils.res.mjs";
+import * as $$BigInt from "./bindings/BigInt.res.mjs";
+import * as Config from "./Config.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as ChainFetcher from "./ChainFetcher.res.mjs";
+import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
+
+function isProgressInReorgThreshold(progressBlockNumber, sourceBlockNumber, maxReorgDepth) {
+  if (maxReorgDepth > 0 && sourceBlockNumber > 0) {
+    return progressBlockNumber > (sourceBlockNumber - maxReorgDepth | 0);
+  } else {
+    return false;
+  }
+}
+
+function calculateTargetBufferSize(activeChainsCount) {
+  if (Env.targetBufferSize !== undefined) {
+    return Env.targetBufferSize;
+  }
+  switch (activeChainsCount) {
+    case 1 :
+        return 60000;
+    case 2 :
+        return 30000;
+    case 3 :
+        return 20000;
+    case 4 :
+        return 15000;
+    case 5 :
+        return 10000;
+    default:
+      return 5000;
+  }
+}
+
+async function makeFromDbState(initialState, config, registrations) {
+  var isInReorgThreshold = initialState.cleanRun ? false : Belt_Array.some(initialState.chains, (function (chain) {
+            return isProgressInReorgThreshold(chain.progressBlockNumber, chain.sourceBlockNumber, chain.maxReorgDepth);
+          }));
+  var targetBufferSize = calculateTargetBufferSize(initialState.chains.length);
+  Prometheus.ProcessingMaxBatchSize.set(config.batchSize);
+  Prometheus.IndexingTargetBufferSize.set(targetBufferSize);
+  Prometheus.ReorgThreshold.set(isInReorgThreshold);
+  Utils.Dict.forEach(initialState.cache, (function (param) {
+          var count = param.count;
+          Prometheus.EffectCacheCount.set(count, param.effectName);
+        }));
+  var chainFetchersArr = await Promise.all(Belt_Array.map(initialState.chains, (async function (resumedChainState) {
+              var chain = Config.getChain(config, resumedChainState.id);
+              var chainConfig = ChainMap.get(config.chainMap, chain);
+              return [
+                      chain,
+                      await ChainFetcher.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, config, registrations, targetBufferSize)
+                    ];
+            })));
+  var chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr);
+  var allChainsReady = {
+    contents: chainFetchersArr.length !== 0
+  };
+  Belt_Array.forEach(chainFetchersArr, (function (param) {
+          var cf = param[1];
+          var chain = param[0];
+          Prometheus.ProgressBlockNumber.set(cf.committedProgressBlockNumber, chain);
+          Prometheus.ProgressReady.init(chain);
+          if (ChainFetcher.isReady(cf)) {
+            return Prometheus.ProgressReady.set(chain);
+          } else {
+            allChainsReady.contents = false;
+            return ;
+          }
+        }));
+  if (allChainsReady.contents) {
+    Prometheus.ProgressReady.setAllReady();
+  }
+  return {
+          committedCheckpointId: initialState.checkpointId,
+          chainFetchers: chainFetchers,
+          multichain: config.multichain,
+          isInReorgThreshold: isInReorgThreshold
+        };
+}
+
+function getChainFetcher(chainManager, chain) {
+  return ChainMap.get(chainManager.chainFetchers, chain);
+}
+
+function setChainFetcher(chainManager, chainFetcher) {
+  return {
+          committedCheckpointId: chainManager.committedCheckpointId,
+          chainFetchers: ChainMap.set(chainManager.chainFetchers, ChainMap.Chain.makeUnsafe(chainFetcher.chainConfig.id), chainFetcher),
+          multichain: chainManager.multichain,
+          isInReorgThreshold: chainManager.isInReorgThreshold
+        };
+}
+
+function nextItemIsNone(chainManager) {
+  return !Batch.hasMultichainReadyItem(ChainMap.map(chainManager.chainFetchers, (function (cf) {
+                    return cf.fetchState;
+                  })), chainManager.multichain);
+}
+
+function createBatch(chainManager, batchSizeTarget, isRollback) {
+  return Batch.make($$BigInt.add(chainManager.committedCheckpointId, isRollback ? 1n : 0n), ChainMap.map(chainManager.chainFetchers, (function (cf) {
+                    return {
+                            fetchState: cf.fetchState,
+                            reorgDetection: cf.reorgDetection,
+                            progressBlockNumber: cf.committedProgressBlockNumber,
+                            sourceBlockNumber: cf.fetchState.knownHeight,
+                            totalEventsProcessed: cf.numEventsProcessed,
+                            chainConfig: cf.chainConfig
+                          };
+                  })), chainManager.multichain, batchSizeTarget);
+}
+
+function isProgressAtHead(chainManager) {
+  return ChainMap.values(chainManager.chainFetchers).every(function (cf) {
+              return cf.isProgressAtHead;
+            });
+}
+
+function isActivelyIndexing(chainManager) {
+  return ChainMap.values(chainManager.chainFetchers).every(ChainFetcher.isActivelyIndexing);
+}
+
+function getSafeCheckpointId(chainManager) {
+  var chainFetchers = ChainMap.values(chainManager.chainFetchers);
+  var result;
+  for(var idx = 0 ,idx_finish = chainFetchers.length; idx < idx_finish; ++idx){
+    var chainFetcher = chainFetchers[idx];
+    var safeCheckpointTracking = chainFetcher.safeCheckpointTracking;
+    if (safeCheckpointTracking !== undefined) {
+      var safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, chainFetcher.fetchState.knownHeight);
+      var current = result;
+      if (!(current !== undefined && safeCheckpointId >= current)) {
+        result = safeCheckpointId;
+      }
+      
+    }
+    
+  }
+  var id = result;
+  if (id !== undefined && id > 0n) {
+    return id;
+  }
+  
+}
+
+export {
+  isProgressInReorgThreshold ,
+  calculateTargetBufferSize ,
+  makeFromDbState ,
+  getChainFetcher ,
+  setChainFetcher ,
+  nextItemIsNone ,
+  createBatch ,
+  isProgressAtHead ,
+  isActivelyIndexing ,
+  getSafeCheckpointId ,
+}
+/* Env Not a pure module */