envio 3.2.1 → 3.3.0-alpha.0

package/src/ContractRegisterContext.res

@@ -0,0 +1,106 @@
+// The contractRegister handler context: context.chain.ContractName.add(address).
+// Independent of the in-memory store, so it stays off IndexerState and the
+// fetch-time contract registration in ChainState doesn't pull the state in.
+
+type contractRegisterParams = {
+  item: Internal.item,
+  onRegister: (~item: Internal.item, ~contractAddress: Address.t, ~contractName: string) => unit,
+  config: Config.t,
+  mutable isResolved: bool,
+}
+
+// Helper to create a validated add function for contract registration.
+// The isResolved check has to live inside the returned closure (not just in the
+// outer proxy trap) because users can capture `const add = context.chain.X.add`
+// before awaiting — a later call would otherwise bypass the resolved guard.
+let makeAddFunction = (~params: contractRegisterParams, ~contractName: string): (
+  Address.t => unit
+) => {
+  (contractAddress: Address.t) => {
+    if params.isResolved {
+      Utils.Error.make(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`)->ErrorHandling.mkLogAndRaise(
+        ~logger=Ecosystem.getItemLogger(params.item, ~ecosystem=params.config.ecosystem),
+      )
+    }
+    let validatedAddress = if params.config.ecosystem.name === Evm {
+      // The value is passed from the user-land,
+      // so we need to validate and checksum/lowercase the address.
+      if params.config.lowercaseAddresses {
+        contractAddress->Address.Evm.fromAddressLowercaseOrThrow
+      } else {
+        contractAddress->Address.Evm.fromAddressOrThrow
+      }
+    } else {
+      // TODO: Ideally we should do the same for other ecosystems
+      contractAddress
+    }
+
+    params.onRegister(~item=params.item, ~contractAddress=validatedAddress, ~contractName)
+  }
+}
+
+// Chain proxy for contractRegister context: context.chain.ContractName.add(address)
+let contractRegisterChainTraps: Utils.Proxy.traps<contractRegisterParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+    switch prop {
+    | "id" =>
+      let eventItem = params.item->Internal.castUnsafeEventItem
+      eventItem.chain->ChainMap.Chain.toChainId->(Utils.magic: int => unknown)
+    | _ =>
+      // Look up the contract name directly in config contracts across all chains.
+      let contractName = prop
+      let isValidContract =
+        params.config.chainMap
+        ->ChainMap.values
+        ->Array.some(chain => chain.contracts->Array.some(c => c.name === contractName))
+      if isValidContract {
+        let addFn = makeAddFunction(~params, ~contractName)
+        {"add": addFn}->(Utils.magic: {"add": Address.t => unit} => unknown)
+      } else {
+        JsError.throwWithMessage(
+          `Invalid contract name '${prop}' on context.chain. ${EntityFilter.codegenHelpMessage}`,
+        )
+      }
+    }
+  },
+}
+
+let contractRegisterTraps: Utils.Proxy.traps<contractRegisterParams> = {
+  get: (~target as params, ~prop: unknown) => {
+    let prop = prop->(Utils.magic: unknown => string)
+    if params.isResolved {
+      Utils.Error.make(
+        `Impossible to access context.${prop} after the contract register is resolved. Make sure you didn't miss an await in the handler.`,
+      )->ErrorHandling.mkLogAndRaise(
+        ~logger=Ecosystem.getItemLogger(params.item, ~ecosystem=params.config.ecosystem),
+      )
+    }
+    switch prop {
+    | "log" =>
+      Ecosystem.getItemUserLogger(params.item, ~ecosystem=params.config.ecosystem)->(
+        Utils.magic: Envio.logger => unknown
+      )
+
+    | "chain" =>
+      params
+      ->Utils.Proxy.make(contractRegisterChainTraps)
+      ->(Utils.magic: contractRegisterParams => unknown)
+    | _ =>
+      JsError.throwWithMessage(
+        `Invalid context access by '${prop}' property. Use context.chain.ContractName.add(address) to register contracts. ${EntityFilter.codegenHelpMessage}`,
+      )
+    }
+  },
+}
+
+let getContractRegisterContext = (params: contractRegisterParams) => {
+  params
+  ->Utils.Proxy.make(contractRegisterTraps)
+  ->(Utils.magic: contractRegisterParams => Internal.contractRegisterContext)
+}
+
+let getContractRegisterArgs = (params: contractRegisterParams): Internal.contractRegisterArgs => {
+  event: params.item->Ecosystem.getItemEvent(~ecosystem=params.config.ecosystem),
+  context: getContractRegisterContext(params),
+}

package/src/ContractRegisterContext.res.mjs

@@ -0,0 +1,76 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Address from "./Address.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as Ecosystem from "./Ecosystem.res.mjs";
+import * as EntityFilter from "./db/EntityFilter.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+function makeAddFunction(params, contractName) {
+  return contractAddress => {
+    if (params.isResolved) {
+      ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.chain after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
+    }
+    let validatedAddress = params.config.ecosystem.name === "evm" ? (
+        params.config.lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(contractAddress) : Address.Evm.fromAddressOrThrow(contractAddress)
+      ) : contractAddress;
+    params.onRegister(params.item, validatedAddress, contractName);
+  };
+}
+
+let contractRegisterChainTraps_get = (params, prop) => {
+  if (prop === "id") {
+    return params.item.chain;
+  }
+  let isValidContract = ChainMap.values(params.config.chainMap).some(chain => chain.contracts.some(c => c.name === prop));
+  if (isValidContract) {
+    return {
+      add: makeAddFunction(params, prop)
+    };
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Invalid contract name '` + prop + `' on context.chain. ` + EntityFilter.codegenHelpMessage);
+  }
+};
+
+let contractRegisterChainTraps = {
+  get: contractRegisterChainTraps_get
+};
+
+let contractRegisterTraps_get = (params, prop) => {
+  if (params.isResolved) {
+    ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.` + prop + ` after the contract register is resolved. Make sure you didn't miss an await in the handler.`));
+  }
+  switch (prop) {
+    case "chain" :
+      return new Proxy(params, contractRegisterChainTraps);
+    case "log" :
+      return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
+    default:
+      return Stdlib_JsError.throwWithMessage(`Invalid context access by '` + prop + `' property. Use context.chain.ContractName.add(address) to register contracts. ` + EntityFilter.codegenHelpMessage);
+  }
+};
+
+let contractRegisterTraps = {
+  get: contractRegisterTraps_get
+};
+
+function getContractRegisterContext(params) {
+  return new Proxy(params, contractRegisterTraps);
+}
+
+function getContractRegisterArgs(params) {
+  return {
+    event: Ecosystem.getItemEvent(params.item, params.config.ecosystem),
+    context: new Proxy(params, contractRegisterTraps)
+  };
+}
+
+export {
+  makeAddFunction,
+  contractRegisterChainTraps,
+  contractRegisterTraps,
+  getContractRegisterContext,
+  getContractRegisterArgs,
+}
+/* Address Not a pure module */

package/src/Core.res

@@ -8,6 +8,7 @@ type evmHypersyncClientCtor
 type evmRpcClientCtor
 type evmDecoderCtor
 type svmHypersyncClientCtor
+type hyperfuelClientCtor
 
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
@@ -20,6 +21,8 @@ type addon = {
   evmDecoder: evmDecoderCtor,
   @as("SvmHypersyncClient")
   svmHypersyncClient: svmHypersyncClientCtor,
+  @as("HyperfuelClient")
+  hyperfuelClient: hyperfuelClientCtor,
 }
 
 @module("node:module") external createRequire: string => {..} = "createRequire"

package/src/CrossChainState.res

@@ -0,0 +1,269 @@
+// Whole-indexer view over every chain's ChainState: the chain collection plus
+// the run-wide flags derived from it. Owns the cross-chain reads and the
+// batch/threshold transitions that touch every chain. `t` is mutated in place
+// through the transitions below; the type is opaque in the interface.
+
+type t = {
+  chainStates: dict<ChainState.t>,
+  // Chain ids in a stable order, so the cross-chain loops iterate the chains
+  // without allocating a values array on every tick.
+  chainIds: array<int>,
+  // True once every chain has caught up to head/endBlock. Monotonic during a run.
+  mutable isRealtime: bool,
+  mutable isInReorgThreshold: bool,
+  // Indexer-wide caps on concurrent data-source queries, shared across all
+  // chains. The realtime budget applies once every chain is at head.
+  maxBackfillConcurrency: int,
+  maxRealtimeConcurrency: int,
+  // Indexer-wide fetch buffer pool (item count), shared across all chains.
+  targetBufferSize: int,
+}
+
+// The whole-indexer fetch buffer pool, independent of chain count.
+let calculateTargetBufferSize = () =>
+  switch Env.targetBufferSize {
+  | Some(size) => size
+  | None => 100_000
+  }
+
+// The concurrency budget in force for the current phase.
+let maxConcurrency = (crossChainState: t) =>
+  crossChainState.isRealtime
+    ? crossChainState.maxRealtimeConcurrency
+    : crossChainState.maxBackfillConcurrency
+
+let make = (
+  ~chainStates,
+  ~isInReorgThreshold,
+  ~isRealtime,
+  ~maxBackfillConcurrency=Env.maxBackfillConcurrency,
+  ~maxRealtimeConcurrency=Env.maxRealtimeConcurrency,
+  ~targetBufferSize=calculateTargetBufferSize(),
+): t => {
+  let crossChainState = {
+    chainStates,
+    chainIds: chainStates->Dict.valuesToArray->Array.map(cs => (cs->ChainState.chainConfig).id),
+    isRealtime,
+    isInReorgThreshold,
+    maxBackfillConcurrency,
+    maxRealtimeConcurrency,
+    targetBufferSize,
+  }
+  Prometheus.IndexingMaxConcurrency.set(~maxConcurrency=crossChainState->maxConcurrency)
+  Prometheus.IndexingTargetBufferSize.set(~targetBufferSize)
+  crossChainState
+}
+
+// Resolve a chain's state by id. The id always comes from `chainIds`, which is
+// derived from `chainStates`, so the entry is guaranteed present.
+let getChainState = (crossChainState: t, chainId) =>
+  crossChainState.chainStates->Utils.Dict.dangerouslyGetByIntNonOption(chainId)->Option.getUnsafe
+
+// --- Accessors. ---
+
+let chainStates = (crossChainState: t) => crossChainState.chainStates
+let isRealtime = (crossChainState: t) => crossChainState.isRealtime
+let isInReorgThreshold = (crossChainState: t) => crossChainState.isInReorgThreshold
+
+// Partition queries in flight across every chain — the live draw against
+// maxConcurrency.
+let inFlight = (crossChainState: t) => {
+  let total = ref(0)
+  for i in 0 to crossChainState.chainIds->Array.length - 1 {
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    total := total.contents + cs->ChainState.sourceManager->SourceManager.inFlightCount
+  }
+  total.contents
+}
+
+// Ready-to-process items across every chain — the live draw against
+// targetBufferSize, which is a budget of processable events (items stuck behind
+// a gap don't count toward the goal of keeping ~targetBufferSize ready).
+let totalReadyCount = (crossChainState: t) => {
+  let total = ref(0)
+  for i in 0 to crossChainState.chainIds->Array.length - 1 {
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    total := total.contents + cs->ChainState.fetchState->FetchState.bufferReadyCount
+  }
+  total.contents
+}
+
+// --- Derived (pure). ---
+
+let nextItemIsNone = (crossChainState: t): bool =>
+  !Batch.hasReadyItem(
+    crossChainState.chainStates->Dict.valuesToArray->Array.map(ChainState.fetchState),
+  )
+
+let getSafeCheckpointId = (crossChainState: t) => {
+  let result: ref<option<bigint>> = ref(None)
+
+  for i in 0 to crossChainState.chainIds->Array.length - 1 {
+    let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    switch cs->ChainState.safeCheckpointTracking {
+    | None => () // Skip chains with maxReorgDepth = 0
+    | Some(safeCheckpointTracking) =>
+      let safeCheckpointId =
+        safeCheckpointTracking->SafeCheckpointTracking.getSafeCheckpointId(
+          ~sourceBlockNumber=(cs->ChainState.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
+  }
+}
+
+// --- Cross-chain transitions. ---
+
+let createBatch = (
+  crossChainState: t,
+  ~processedCheckpointId,
+  ~batchSizeTarget: int,
+  ~isRollback: bool,
+): Batch.t => {
+  Batch.make(
+    ~isInReorgThreshold=crossChainState.isInReorgThreshold,
+    ~checkpointIdBeforeBatch=processedCheckpointId->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=crossChainState.chainStates->Utils.Dict.mapValues((
+      cs
+    ): Batch.chainBeforeBatch => {
+      fetchState: cs->ChainState.fetchState,
+      progressBlockNumber: cs->ChainState.committedProgressBlockNumber,
+      totalEventsProcessed: cs->ChainState.numEventsProcessed,
+      sourceBlockNumber: (cs->ChainState.fetchState).knownHeight,
+      reorgDetection: cs->ChainState.reorgDetection,
+      chainConfig: cs->ChainState.chainConfig,
+    }),
+    ~batchSizeTarget,
+  )
+}
+
+// Enter the reorg threshold: shrink each chain's buffer by its configured
+// blockLag and flip the flag.
+let enterReorgThreshold = (crossChainState: t) => {
+  Logging.info("Reorg threshold reached")
+  Prometheus.ReorgThreshold.set(~isInReorgThreshold=true)
+
+  for i in 0 to crossChainState.chainIds->Array.length - 1 {
+    crossChainState
+    ->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
+    ->ChainState.enterReorgThreshold
+  }
+
+  crossChainState.isInReorgThreshold = true
+}
+
+// Commit each progressed chain's batch progress, then decide readiness for the
+// whole indexer. A chain is marked caught up only once EVERY chain is caught up
+// (reached endblock or fetched/processed to head) with no processable events
+// left — so no chain flips to ready while another is still backfilling.
+let applyBatchProgress = (crossChainState: t, ~batch: Batch.t) => {
+  let chainIds = crossChainState.chainIds
+
+  let everyChainCaughtUp = ref(true)
+  for i in 0 to chainIds->Array.length - 1 {
+    let cs = crossChainState->getChainState(chainIds->Array.getUnsafe(i))
+    cs->ChainState.applyBatchProgress(~batch)
+    if !(cs->ChainState.hasProcessedToEndblock || cs->ChainState.isProgressAtHead) {
+      everyChainCaughtUp := false
+    }
+  }
+
+  let indexerCaughtUp = crossChainState->nextItemIsNone && everyChainCaughtUp.contents
+
+  let allChainsReady = ref(true)
+  for i in 0 to chainIds->Array.length - 1 {
+    let cs = crossChainState->getChainState(chainIds->Array.getUnsafe(i))
+    if indexerCaughtUp {
+      cs->ChainState.markReady
+    }
+    if !(cs->ChainState.isReady) {
+      allChainsReady := false
+    }
+  }
+
+  if allChainsReady.contents {
+    Prometheus.ProgressReady.setAllReady()
+  }
+
+  let wasRealtime = crossChainState.isRealtime
+  crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady.contents
+  if !wasRealtime && crossChainState.isRealtime {
+    // The realtime budget takes over now that every chain is at head.
+    Prometheus.IndexingMaxConcurrency.set(~maxConcurrency=crossChainState->maxConcurrency)
+  }
+}
+
+// --- Fetch control. ---
+
+// Chains ordered furthest-behind first, so the shared concurrency and buffer
+// pools go to the chains with the most backfill work before the rest.
+let priorityOrder = (crossChainState: t) =>
+  crossChainState.chainStates
+  ->Dict.valuesToArray
+  ->Array.toSorted((a, b) =>
+    Float.compare(
+      a->ChainState.fetchState->FetchState.getProgressPercentage,
+      b->ChainState.fetchState->FetchState.getProgressPercentage,
+    )
+  )
+
+// Dispatch a fetch tick across every chain in priority order, drawing from the
+// shared concurrency and buffer pools. Chains are visited in turn; fetchChain
+// bumps the in-flight count synchronously before it suspends, so a later chain
+// sees the slots an earlier one already claimed and the budget is honored
+// indexer-wide.
+//
+// bufferLimit is each chain's slice of the shared pool: it may grow its buffer
+// into whatever the other chains leave free, so a lone backfilling chain can use
+// the whole pool while head-following chains stay shallow.
+let checkAndFetch = async (
+  crossChainState: t,
+  ~fetchChain: (
+    ~chain: ChainMap.Chain.t,
+    ~concurrencyLimit: int,
+    ~bufferLimit: int,
+  ) => promise<unit>,
+) => {
+  let maxConcurrency = crossChainState->maxConcurrency
+  // Pool is a budget of ready-to-process items, but the cap fed to getNextQuery
+  // is still a buffer position (it tracks the sorted buffer, ready items first),
+  // so add this chain's own buffer size back rather than its ready count. A chain
+  // with a gap therefore gets extra headroom to fetch the not-ready overhang
+  // while still aiming for its share of ~targetBufferSize ready events.
+  let totalReady = crossChainState->totalReadyCount
+  // Track the in-flight total as a running counter (summed once up front, then
+  // adjusted by each chain's delta) instead of re-summing every chain — O(chains)
+  // per tick rather than O(chains^2). fetchChain bumps the chain's count
+  // synchronously, so the delta is observable right after the call.
+  let inFlight = ref(crossChainState->inFlight)
+  let priorityOrdered = crossChainState->priorityOrder
+  let promises = []
+  for i in 0 to priorityOrdered->Array.length - 1 {
+    let cs = priorityOrdered->Array.getUnsafe(i)
+    let chain = ChainMap.Chain.makeUnsafe(~chainId=(cs->ChainState.chainConfig).id)
+    let sourceManager = cs->ChainState.sourceManager
+    let concurrencyLimit = Pervasives.max(0, maxConcurrency - inFlight.contents)
+    let bufferLimit =
+      crossChainState.targetBufferSize -
+      (totalReady -
+      cs->ChainState.fetchState->FetchState.bufferSize)
+    let inFlightBefore = sourceManager->SourceManager.inFlightCount
+    promises->Array.push(fetchChain(~chain, ~concurrencyLimit, ~bufferLimit))
+    inFlight := inFlight.contents + (sourceManager->SourceManager.inFlightCount - inFlightBefore)
+  }
+  let _ = await promises->Promise.all
+}

package/src/CrossChainState.res.mjs

@@ -0,0 +1,197 @@
+// 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 Logging from "./Logging.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
+import * as FetchState from "./FetchState.res.mjs";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
+import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
+import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
+
+function calculateTargetBufferSize() {
+  if (Env.targetBufferSize !== undefined) {
+    return Env.targetBufferSize;
+  } else {
+    return 100000;
+  }
+}
+
+function maxConcurrency(crossChainState) {
+  if (crossChainState.isRealtime) {
+    return crossChainState.maxRealtimeConcurrency;
+  } else {
+    return crossChainState.maxBackfillConcurrency;
+  }
+}
+
+function make(chainStates, isInReorgThreshold, isRealtime, maxBackfillConcurrencyOpt, maxRealtimeConcurrencyOpt, targetBufferSizeOpt) {
+  let maxBackfillConcurrency = maxBackfillConcurrencyOpt !== undefined ? maxBackfillConcurrencyOpt : Env.maxBackfillConcurrency;
+  let maxRealtimeConcurrency = maxRealtimeConcurrencyOpt !== undefined ? maxRealtimeConcurrencyOpt : Env.maxRealtimeConcurrency;
+  let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : (
+      Env.targetBufferSize !== undefined ? Env.targetBufferSize : 100000
+    );
+  let crossChainState = {
+    chainStates: chainStates,
+    chainIds: Object.values(chainStates).map(cs => ChainState.chainConfig(cs).id),
+    isRealtime: isRealtime,
+    isInReorgThreshold: isInReorgThreshold,
+    maxBackfillConcurrency: maxBackfillConcurrency,
+    maxRealtimeConcurrency: maxRealtimeConcurrency,
+    targetBufferSize: targetBufferSize
+  };
+  Prometheus.IndexingMaxConcurrency.set(maxConcurrency(crossChainState));
+  Prometheus.IndexingTargetBufferSize.set(targetBufferSize);
+  return crossChainState;
+}
+
+function chainStates(crossChainState) {
+  return crossChainState.chainStates;
+}
+
+function isRealtime(crossChainState) {
+  return crossChainState.isRealtime;
+}
+
+function isInReorgThreshold(crossChainState) {
+  return crossChainState.isInReorgThreshold;
+}
+
+function inFlight(crossChainState) {
+  let total = 0;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    total = total + SourceManager.inFlightCount(ChainState.sourceManager(cs)) | 0;
+  }
+  return total;
+}
+
+function totalReadyCount(crossChainState) {
+  let total = 0;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    total = total + FetchState.bufferReadyCount(ChainState.fetchState(cs)) | 0;
+  }
+  return total;
+}
+
+function nextItemIsNone(crossChainState) {
+  return !Batch.hasReadyItem(Object.values(crossChainState.chainStates).map(ChainState.fetchState));
+}
+
+function getSafeCheckpointId(crossChainState) {
+  let result;
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    let safeCheckpointTracking = ChainState.safeCheckpointTracking(cs);
+    if (safeCheckpointTracking !== undefined) {
+      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, ChainState.fetchState(cs).knownHeight);
+      let current = result;
+      if (!(current !== undefined && safeCheckpointId >= current)) {
+        result = safeCheckpointId;
+      }
+    }
+  }
+  let id = result;
+  if (id !== undefined && id > 0n) {
+    return id;
+  }
+}
+
+function createBatch(crossChainState, processedCheckpointId, batchSizeTarget, isRollback) {
+  return Batch.make(processedCheckpointId + (
+    isRollback ? 1n : 0n
+  ), Utils.Dict.mapValues(crossChainState.chainStates, cs => ({
+    fetchState: ChainState.fetchState(cs),
+    reorgDetection: ChainState.reorgDetection(cs),
+    progressBlockNumber: ChainState.committedProgressBlockNumber(cs),
+    sourceBlockNumber: ChainState.fetchState(cs).knownHeight,
+    totalEventsProcessed: ChainState.numEventsProcessed(cs),
+    chainConfig: ChainState.chainConfig(cs)
+  })), batchSizeTarget, crossChainState.isInReorgThreshold);
+}
+
+function enterReorgThreshold(crossChainState) {
+  Logging.info("Reorg threshold reached");
+  Prometheus.ReorgThreshold.set(true);
+  for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
+    ChainState.enterReorgThreshold(crossChainState.chainStates[crossChainState.chainIds[i]]);
+  }
+  crossChainState.isInReorgThreshold = true;
+}
+
+function applyBatchProgress(crossChainState, batch) {
+  let chainIds = crossChainState.chainIds;
+  let everyChainCaughtUp = true;
+  for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
+    let cs = crossChainState.chainStates[chainIds[i]];
+    ChainState.applyBatchProgress(cs, batch);
+    if (!(ChainState.hasProcessedToEndblock(cs) || ChainState.isProgressAtHead(cs))) {
+      everyChainCaughtUp = false;
+    }
+  }
+  let indexerCaughtUp = nextItemIsNone(crossChainState) && everyChainCaughtUp;
+  let allChainsReady = true;
+  for (let i$1 = 0, i_finish$1 = chainIds.length; i$1 < i_finish$1; ++i$1) {
+    let cs$1 = crossChainState.chainStates[chainIds[i$1]];
+    if (indexerCaughtUp) {
+      ChainState.markReady(cs$1);
+    }
+    if (!ChainState.isReady(cs$1)) {
+      allChainsReady = false;
+    }
+  }
+  if (allChainsReady) {
+    Prometheus.ProgressReady.setAllReady();
+  }
+  let wasRealtime = crossChainState.isRealtime;
+  crossChainState.isRealtime = crossChainState.isRealtime || allChainsReady;
+  if (!wasRealtime && crossChainState.isRealtime) {
+    return Prometheus.IndexingMaxConcurrency.set(maxConcurrency(crossChainState));
+  }
+}
+
+function priorityOrder(crossChainState) {
+  return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(FetchState.getProgressPercentage(ChainState.fetchState(a)), FetchState.getProgressPercentage(ChainState.fetchState(b))));
+}
+
+async function checkAndFetch(crossChainState, fetchChain) {
+  let maxConcurrency$1 = maxConcurrency(crossChainState);
+  let totalReady = totalReadyCount(crossChainState);
+  let inFlight$1 = inFlight(crossChainState);
+  let priorityOrdered = priorityOrder(crossChainState);
+  let promises = [];
+  for (let i = 0, i_finish = priorityOrdered.length; i < i_finish; ++i) {
+    let cs = priorityOrdered[i];
+    let chain = ChainMap.Chain.makeUnsafe(ChainState.chainConfig(cs).id);
+    let sourceManager = ChainState.sourceManager(cs);
+    let concurrencyLimit = Primitive_int.max(0, maxConcurrency$1 - inFlight$1 | 0);
+    let bufferLimit = crossChainState.targetBufferSize - (totalReady - FetchState.bufferSize(ChainState.fetchState(cs)) | 0) | 0;
+    let inFlightBefore = SourceManager.inFlightCount(sourceManager);
+    promises.push(fetchChain(chain, concurrencyLimit, bufferLimit));
+    inFlight$1 = inFlight$1 + (SourceManager.inFlightCount(sourceManager) - inFlightBefore | 0) | 0;
+  }
+  await Promise.all(promises);
+}
+
+export {
+  calculateTargetBufferSize,
+  make,
+  chainStates,
+  isRealtime,
+  isInReorgThreshold,
+  maxConcurrency,
+  inFlight,
+  nextItemIsNone,
+  getSafeCheckpointId,
+  createBatch,
+  enterReorgThreshold,
+  applyBatchProgress,
+  priorityOrder,
+  checkAndFetch,
+}
+/* Env Not a pure module */