envio/src/ChainManager.res.mjs

A latency and sync speed optimized, developer friendly blockchain data indexer.

// Generated by ReScript, PLEASE EDIT WITH CARE

import * as Env from "./Env.res.mjs";
import * as Batch from "./Batch.res.mjs";
import * as Utils from "./Utils.res.mjs";
import * as Config from "./Config.res.mjs";
import * as ChainMap from "./ChainMap.res.mjs";
import * as Prometheus from "./Prometheus.res.mjs";
import * as ChainFetcher from "./ChainFetcher.res.mjs";
import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
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;
  }
}

function makeFromDbState(initialState, config, registrations, reducedPollingInterval) {
  let isInReorgThreshold = initialState.cleanRun ? false : initialState.chains.some(chain => isProgressInReorgThreshold(chain.progressBlockNumber, chain.sourceBlockNumber, chain.maxReorgDepth));
  let targetBufferSize = calculateTargetBufferSize(initialState.chains.length);
  Prometheus.ProcessingMaxBatchSize.set(config.batchSize);
  Prometheus.IndexingTargetBufferSize.set(targetBufferSize);
  Prometheus.ReorgThreshold.set(isInReorgThreshold);
  Utils.Dict.forEach(initialState.cache, param => {
    let count = param.count;
    Prometheus.EffectCacheCount.set(count, param.effectName);
  });
  let isRealtime = !Env.updateSyncTimeOnRestart && initialState.chains.length !== 0 && initialState.chains.every(c => Stdlib_Option.isSome(c.timestampCaughtUpToHeadOrEndblock));
  let chainFetchersArr = initialState.chains.map(resumedChainState => {
    let chain = Config.getChain(config, resumedChainState.id);
    let chainConfig = ChainMap.get(config.chainMap, chain);
    return [
      chain,
      ChainFetcher.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrations, targetBufferSize, reducedPollingInterval)
    ];
  });
  let chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr);
  let allChainsReady = {
    contents: chainFetchersArr.length !== 0
  };
  chainFetchersArr.forEach(param => {
    let cf = param[1];
    let 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 {
    chainFetchers: chainFetchers,
    isInReorgThreshold: isInReorgThreshold,
    isRealtime: isRealtime
  };
}

function getChainFetcher(chainManager, chain) {
  return ChainMap.get(chainManager.chainFetchers, chain);
}

function setChainFetcher(chainManager, chainFetcher) {
  return {
    chainFetchers: ChainMap.set(chainManager.chainFetchers, ChainMap.Chain.makeUnsafe(chainFetcher.chainConfig.id), chainFetcher),
    isInReorgThreshold: chainManager.isInReorgThreshold,
    isRealtime: chainManager.isRealtime
  };
}

function nextItemIsNone(chainManager) {
  return !Batch.hasReadyItem(ChainMap.map(chainManager.chainFetchers, cf => cf.fetchState));
}

function createBatch(chainManager, processedCheckpointId, batchSizeTarget, isRollback) {
  return Batch.make(processedCheckpointId + (
    isRollback ? 1n : 0n
  ), ChainMap.map(chainManager.chainFetchers, cf => ({
    fetchState: cf.fetchState,
    reorgDetection: cf.reorgDetection,
    progressBlockNumber: cf.committedProgressBlockNumber,
    sourceBlockNumber: cf.fetchState.knownHeight,
    totalEventsProcessed: cf.numEventsProcessed,
    chainConfig: cf.chainConfig
  })), batchSizeTarget, chainManager.isInReorgThreshold);
}

function isProgressAtHead(chainManager) {
  return ChainMap.values(chainManager.chainFetchers).every(cf => cf.isProgressAtHead);
}

function isActivelyIndexing(chainManager) {
  return ChainMap.values(chainManager.chainFetchers).every(ChainFetcher.isActivelyIndexing);
}

function getSafeCheckpointId(chainManager) {
  let chainFetchers = ChainMap.values(chainManager.chainFetchers);
  let result;
  for (let idx = 0, idx_finish = chainFetchers.length; idx < idx_finish; ++idx) {
    let chainFetcher = chainFetchers[idx];
    let safeCheckpointTracking = chainFetcher.safeCheckpointTracking;
    if (safeCheckpointTracking !== undefined) {
      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, chainFetcher.fetchState.knownHeight);
      let current = result;
      if (!(current !== undefined && safeCheckpointId >= current)) {
        result = safeCheckpointId;
      }
    }
  }
  let id = result;
  if (id !== undefined && id > 0n) {
    return id;
  }
}

function updateProgressedChains(chainManager, batch) {
  let nextQueueItemIsNone = nextItemIsNone(chainManager);
  let allChainsAtHead = isProgressAtHead(chainManager);
  let allChainsReady = {
    contents: true
  };
  let chainFetchers = ChainMap.map(chainManager.chainFetchers, prev => {
    let chain = ChainMap.Chain.makeUnsafe(prev.chainConfig.id);
    let maybeChainAfterBatch = batch.progressedChainsById[chain];
    let cf;
    if (maybeChainAfterBatch !== undefined) {
      if (prev.committedProgressBlockNumber !== maybeChainAfterBatch.progressBlockNumber) {
        Prometheus.ProgressBlockNumber.set(maybeChainAfterBatch.progressBlockNumber, chain);
      }
      if (prev.numEventsProcessed !== maybeChainAfterBatch.totalEventsProcessed) {
        Prometheus.ProgressEventsCount.set(maybeChainAfterBatch.totalEventsProcessed, chain);
      }
      let eventItem = Batch.findLastEventItem(batch, chain);
      if (eventItem !== undefined) {
        let blockTimestamp = eventItem.timestamp;
        let currentTimeMs = Date.now() | 0;
        let blockTimestampMs = blockTimestamp * 1000 | 0;
        let latencyMs = currentTimeMs - blockTimestampMs | 0;
        Prometheus.ProgressLatency.set(latencyMs, chain);
      }
      let match = prev.fetchState.firstEventBlock;
      let tmp;
      if (match !== undefined) {
        tmp = prev.fetchState;
      } else {
        let firstEventBlock = Batch.findFirstEventBlockNumber(batch, chain);
        if (firstEventBlock !== undefined) {
          let init = prev.fetchState;
          tmp = {
            optimizedPartitions: init.optimizedPartitions,
            startBlock: init.startBlock,
            endBlock: init.endBlock,
            normalSelection: init.normalSelection,
            indexingAddresses: init.indexingAddresses,
            contractConfigs: init.contractConfigs,
            chainId: init.chainId,
            latestOnBlockBlockNumber: init.latestOnBlockBlockNumber,
            blockLag: init.blockLag,
            buffer: init.buffer,
            targetBufferSize: init.targetBufferSize,
            onBlockConfigs: init.onBlockConfigs,
            knownHeight: init.knownHeight,
            firstEventBlock: firstEventBlock
          };
        } else {
          tmp = prev.fetchState;
        }
      }
      let safeCheckpointTracking = prev.safeCheckpointTracking;
      cf = {
        logger: prev.logger,
        fetchState: tmp,
        sourceManager: prev.sourceManager,
        chainConfig: prev.chainConfig,
        isProgressAtHead: prev.isProgressAtHead || maybeChainAfterBatch.isProgressAtHeadWhenBatchCreated,
        timestampCaughtUpToHeadOrEndblock: prev.timestampCaughtUpToHeadOrEndblock,
        committedProgressBlockNumber: maybeChainAfterBatch.progressBlockNumber,
        numEventsProcessed: maybeChainAfterBatch.totalEventsProcessed,
        reorgDetection: prev.reorgDetection,
        safeCheckpointTracking: safeCheckpointTracking !== undefined ? SafeCheckpointTracking.updateOnNewBatch(safeCheckpointTracking, prev.fetchState.knownHeight, chain, batch.checkpointIds, batch.checkpointBlockNumbers, batch.checkpointChainIds) : undefined
      };
    } else {
      cf = prev;
    }
    let cf$1;
    if (ChainFetcher.hasProcessedToEndblock(cf)) {
      let timestampCaughtUpToHeadOrEndblock = ChainFetcher.isReady(cf) ? cf.timestampCaughtUpToHeadOrEndblock : new Date();
      cf$1 = {
        logger: cf.logger,
        fetchState: cf.fetchState,
        sourceManager: cf.sourceManager,
        chainConfig: cf.chainConfig,
        isProgressAtHead: cf.isProgressAtHead,
        timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock,
        committedProgressBlockNumber: cf.committedProgressBlockNumber,
        numEventsProcessed: cf.numEventsProcessed,
        reorgDetection: cf.reorgDetection,
        safeCheckpointTracking: cf.safeCheckpointTracking
      };
    } else if (!ChainFetcher.isReady(cf) && cf.isProgressAtHead) {
      if (nextQueueItemIsNone && allChainsAtHead) {
        cf$1 = {
          logger: cf.logger,
          fetchState: cf.fetchState,
          sourceManager: cf.sourceManager,
          chainConfig: cf.chainConfig,
          isProgressAtHead: cf.isProgressAtHead,
          timestampCaughtUpToHeadOrEndblock: new Date(),
          committedProgressBlockNumber: cf.committedProgressBlockNumber,
          numEventsProcessed: cf.numEventsProcessed,
          reorgDetection: cf.reorgDetection,
          safeCheckpointTracking: cf.safeCheckpointTracking
        };
      } else {
        let hasNoMoreEventsToProcess = ChainFetcher.hasNoMoreEventsToProcess(cf);
        cf$1 = hasNoMoreEventsToProcess ? ({
            logger: cf.logger,
            fetchState: cf.fetchState,
            sourceManager: cf.sourceManager,
            chainConfig: cf.chainConfig,
            isProgressAtHead: cf.isProgressAtHead,
            timestampCaughtUpToHeadOrEndblock: new Date(),
            committedProgressBlockNumber: cf.committedProgressBlockNumber,
            numEventsProcessed: cf.numEventsProcessed,
            reorgDetection: cf.reorgDetection,
            safeCheckpointTracking: cf.safeCheckpointTracking
          }) : cf;
      }
    } else {
      cf$1 = cf;
    }
    if (ChainFetcher.isReady(cf$1)) {
      if (!ChainFetcher.isReady(prev)) {
        Prometheus.ProgressReady.set(chain);
      }
    } else {
      allChainsReady.contents = false;
    }
    return cf$1;
  });
  if (allChainsReady.contents) {
    Prometheus.ProgressReady.setAllReady();
  }
  return {
    chainFetchers: chainFetchers,
    isInReorgThreshold: chainManager.isInReorgThreshold,
    isRealtime: chainManager.isRealtime || allChainsReady.contents
  };
}

export {
  isProgressInReorgThreshold,
  calculateTargetBufferSize,
  makeFromDbState,
  getChainFetcher,
  setChainFetcher,
  nextItemIsNone,
  createBatch,
  isProgressAtHead,
  isActivelyIndexing,
  getSafeCheckpointId,
  updateProgressedChains,
}
/* Env Not a pure module */