envio 3.2.0 → 3.3.0-alpha.0

package/src/ChainFetching.res

@@ -0,0 +1,375 @@
+// Fetch orchestration and query-response handling. Re-enters the loop only
+// through the injected schedule* effects; everything else points at IndexerState
+// (state + transitions) and leaf effect modules.
+
+type partitionQueryResponse = {
+  chain: IndexerState.chain,
+  response: Source.blockRangeFetchResponse,
+  query: FetchState.query,
+}
+
+let runContractRegistersOrThrow = async (
+  ~itemsWithContractRegister: array<Internal.item>,
+  ~config: Config.t,
+) => {
+  let itemsWithDcs = []
+
+  let onRegister = (~item: Internal.item, ~contractAddress, ~contractName) => {
+    let eventItem = item->Internal.castUnsafeEventItem
+    let {blockNumber} = eventItem
+
+    let dc: Internal.indexingAddress = {
+      address: contractAddress,
+      contractName,
+      registrationBlock: blockNumber,
+    }
+
+    switch item->Internal.getItemDcs {
+    | None => {
+        item->Internal.setItemDcs([dc])
+        itemsWithDcs->Array.push(item)
+      }
+    | Some(dcs) => dcs->Array.push(dc)
+    }
+  }
+
+  let promises = []
+  for idx in 0 to itemsWithContractRegister->Array.length - 1 {
+    let item = itemsWithContractRegister->Array.getUnsafe(idx)
+    let eventItem = item->Internal.castUnsafeEventItem
+    let contractRegister = switch eventItem {
+    | {eventConfig: {contractRegister: Some(contractRegister)}} => contractRegister
+    | {eventConfig: {contractRegister: None, name: eventName}} =>
+      // Unexpected case, since we should pass only events with contract register to this function
+      JsError.throwWithMessage("Contract register is not set for event " ++ eventName)
+    }
+
+    let errorMessage = "Event contractRegister failed, please fix the error to keep the indexer running smoothly"
+
+    // Catch sync and async errors
+    try {
+      let params: ContractRegisterContext.contractRegisterParams = {
+        item,
+        onRegister,
+        config,
+        isResolved: false,
+      }
+      let result = contractRegister(ContractRegisterContext.getContractRegisterArgs(params))
+
+      // Even though `contractRegister` always returns a promise,
+      // in the ReScript type, but it might return a non-promise value for TS API.
+      if result->Utils.Promise.isCatchable {
+        promises->Array.push(
+          result
+          ->Promise.thenResolve(r => {
+            params.isResolved = true
+            r
+          })
+          ->Promise.catch(exn => {
+            params.isResolved = true
+            exn->ErrorHandling.mkLogAndRaise(
+              ~msg=errorMessage,
+              ~logger=Ecosystem.getItemLogger(item, ~ecosystem=config.ecosystem),
+            )
+          }),
+        )
+      } else {
+        params.isResolved = true
+      }
+    } catch {
+    | exn =>
+      exn->ErrorHandling.mkLogAndRaise(
+        ~msg=errorMessage,
+        ~logger=Ecosystem.getItemLogger(item, ~ecosystem=config.ecosystem),
+      )
+    }
+  }
+
+  if promises->Utils.Array.notEmpty {
+    let _ = await Promise.all(promises)
+  }
+
+  itemsWithDcs
+}
+
+let rec onQueryResponse = async (
+  state: IndexerState.t,
+  {chain, response, query}: partitionQueryResponse,
+  ~stateId,
+  ~scheduleFetch,
+  ~scheduleProcessing,
+  ~scheduleRollback,
+) =>
+  if state->IndexerState.isStale(~stateId) {
+    ()
+  } else {
+    let chainState = state->IndexerState.getChainState(~chain)
+    let {
+      parsedQueueItems,
+      latestFetchedBlockNumber,
+      latestFetchedBlockTimestamp,
+      stats,
+      knownHeight,
+      blockHashes,
+      fromBlockQueried,
+    } = response
+
+    if knownHeight > (chainState->ChainState.fetchState).knownHeight {
+      Prometheus.SourceHeight.set(
+        ~blockNumber=knownHeight,
+        ~chainId=(chainState->ChainState.chainConfig).id,
+        // The knownHeight from response won't necessarily
+        // belong to the currently active source.
+        // But for simplicity, assume it does.
+        ~sourceName=(chainState->ChainState.sourceManager->SourceManager.getActiveSource).name,
+      )
+    }
+
+    Prometheus.FetchingBlockRange.increment(
+      ~chainId=chain->ChainMap.Chain.toChainId,
+      ~totalTimeElapsed=stats.totalTimeElapsed,
+      ~parsingTimeElapsed=stats.parsingTimeElapsed->Option.getOr(0.),
+      ~numEvents=parsedQueueItems->Array.length,
+      ~blockRangeSize=latestFetchedBlockNumber - fromBlockQueried + 1,
+    )
+
+    let reorgResult = chainState->ChainState.registerReorgGuard(~blockHashes, ~knownHeight)
+
+    let rollbackWithReorgDetectedBlockNumber = switch reorgResult {
+    | ReorgDetected(reorgDetected) => {
+        chainState
+        ->ChainState.logger
+        ->Logging.childInfo(
+          reorgDetected->ReorgDetection.reorgDetectedToLogParams(
+            ~shouldRollbackOnReorg=(state->IndexerState.config).shouldRollbackOnReorg,
+          ),
+        )
+        Prometheus.ReorgCount.increment(~chain)
+        Prometheus.ReorgDetectionBlockNumber.set(
+          ~blockNumber=reorgDetected.scannedBlock.blockNumber,
+          ~chain,
+        )
+        if (state->IndexerState.config).shouldRollbackOnReorg {
+          Some(reorgDetected.scannedBlock.blockNumber)
+        } else {
+          None
+        }
+      }
+    | NoReorg => None
+    }
+
+    switch rollbackWithReorgDetectedBlockNumber {
+    | Some(reorgDetectedBlockNumber) =>
+      // Prepare every chain for the rollback: restore each events-processed
+      // counter (the previous, uncommitted rollback subtracted from all chains,
+      // so undo that before the new rollback subtracts again) and drop pending
+      // queries requested against the about-to-be-invalidated chain state.
+      let eventsProcessedDiffByChain = switch state->IndexerState.rollbackState {
+      | RollbackReady({eventsProcessedDiffByChain}) => Some(eventsProcessedDiffByChain)
+      | _ => None
+      }
+      state
+      ->IndexerState.chainStates
+      ->Utils.Dict.forEach(cs =>
+        cs->ChainState.prepareReorg(
+          ~eventsProcessedDiff=switch eventsProcessedDiffByChain {
+          | Some(byChain) =>
+            byChain->Utils.Dict.dangerouslyGetByIntNonOption((cs->ChainState.chainConfig).id)
+          | None => None
+          },
+        )
+      )
+      state->IndexerState.beginReorg(~chain, ~blockNumber=reorgDetectedBlockNumber)
+      // Advances synchronously to FindingReorgDepth, so a concurrent rollback
+      // kick (eg from the processing loop quiescing) collapses into this one.
+      scheduleRollback()
+    | None =>
+      let itemsWithContractRegister = []
+      let newItems = []
+      for idx in 0 to parsedQueueItems->Array.length - 1 {
+        let item = parsedQueueItems->Array.getUnsafe(idx)
+        let eventItem = item->Internal.castUnsafeEventItem
+        if eventItem.eventConfig.contractRegister !== None {
+          itemsWithContractRegister->Array.push(item)
+        }
+        // TODO: Don't really need to keep it in the queue
+        // when there's no handler (besides raw_events, processed counter, and dcsToStore consuming)
+        newItems->Array.push(item)
+      }
+
+      // Re-check staleness: contract registration is async, so the chain state
+      // may have rolled back by the time we apply the fetched items.
+      let proceed = (~newItemsWithDcs) =>
+        if !(state->IndexerState.isStale(~stateId)) {
+          applyQueryResponse(
+            state,
+            ~chain,
+            ~newItems,
+            ~newItemsWithDcs,
+            ~knownHeight,
+            ~latestFetchedBlock={
+              FetchState.blockNumber: latestFetchedBlockNumber,
+              blockTimestamp: latestFetchedBlockTimestamp,
+            },
+            ~query,
+          )
+          ChainMetadata.stage(state)
+          scheduleFetch()
+          scheduleProcessing()
+        }
+
+      switch itemsWithContractRegister {
+      | [] => proceed(~newItemsWithDcs=[])
+      | _ =>
+        switch await runContractRegistersOrThrow(
+          ~itemsWithContractRegister,
+          ~config=state->IndexerState.config,
+        ) {
+        | exception exn => IndexerState.errorExit(state, exn->ErrorHandling.make)
+        | newItemsWithDcs => proceed(~newItemsWithDcs)
+        }
+      }
+    }
+  }
+
+and applyQueryResponse = (
+  state: IndexerState.t,
+  ~chain,
+  ~newItems,
+  ~newItemsWithDcs,
+  ~knownHeight,
+  ~latestFetchedBlock,
+  ~query,
+) => {
+  let chainState = state->IndexerState.getChainState(~chain)
+  let wasFetchingAtHead = chainState->ChainState.isFetchingAtHead
+
+  chainState->ChainState.handleQueryResult(
+    ~query,
+    ~latestFetchedBlock,
+    ~newItems,
+    ~newItemsWithDcs,
+    ~knownHeight,
+  )
+
+  // In auto-exit mode, set endBlock to the first event's block when events arrive.
+  if state->IndexerState.exitAfterFirstEventBlock && newItems->Array.length > 0 {
+    chainState->ChainState.setEndBlockToFirstEvent(
+      ~blockNumber=newItems->Array.getUnsafe(0)->Internal.getItemBlockNumber,
+    )
+  }
+
+  // Log the backfill→head transition once: this response brought the fetch
+  // frontier to the head. Gated on !isReady so realtime re-catch-ups (a new
+  // block arrives, gets fetched) don't spam the log after the chain is synced.
+  if (
+    !wasFetchingAtHead &&
+    !(chainState->ChainState.isReady) &&
+    chainState->ChainState.isFetchingAtHead
+  ) {
+    chainState->ChainState.logger->Logging.childInfo("All events have been fetched")
+  }
+}
+
+let finishWaitingForNewBlock = (
+  state: IndexerState.t,
+  ~chain,
+  ~knownHeight,
+  ~stateId,
+  ~scheduleFetch,
+  ~scheduleProcessing,
+) =>
+  if state->IndexerState.isStale(~stateId) {
+    ()
+  } else {
+    let chainState = state->IndexerState.getChainState(~chain)
+    chainState->ChainState.updateKnownHeight(~knownHeight)
+
+    let isBelowReorgThreshold =
+      !(state->IndexerState.isInReorgThreshold) &&
+      (state->IndexerState.config).shouldRollbackOnReorg
+    let shouldEnterReorgThreshold =
+      isBelowReorgThreshold &&
+      state
+      ->IndexerState.chainStates
+      ->Dict.valuesToArray
+      ->Array.every(cs => {
+        cs->ChainState.fetchState->FetchState.isReadyToEnterReorgThreshold
+      })
+
+    // Kick processing in case there are block handlers to run.
+    if shouldEnterReorgThreshold {
+      IndexerState.enterReorgThreshold(state)
+    }
+    scheduleFetch()
+    scheduleProcessing()
+  }
+
+let fetchChain = async (
+  state: IndexerState.t,
+  chain,
+  ~concurrencyLimit,
+  ~bufferLimit,
+  ~stateId,
+  ~scheduleFetch,
+  ~scheduleProcessing,
+  ~scheduleRollback,
+) => {
+  let chainState = state->IndexerState.getChainState(~chain)
+  if !(state->IndexerState.isResolvingReorg) && !(state->IndexerState.isStopped) {
+    let fetchState = chainState->ChainState.fetchState
+    let isRealtime = state->IndexerState.isRealtime
+    let sourceManager = chainState->ChainState.sourceManager
+
+    // Only affects the WaitingForNewBlock branch of fetchNext, where
+    // there's nothing to fetch. During backfill any such chain is idle.
+    let reducedPolling = !isRealtime
+
+    // Owns its error boundary: launch doesn't catch, so any failure here (the
+    // query, response handling, or fetchNext itself) must stop the indexer.
+    try {
+      await sourceManager->SourceManager.fetchNext(
+        ~fetchState,
+        ~waitForNewBlock=(~knownHeight) =>
+          sourceManager->SourceManager.waitForNewBlock(~knownHeight, ~isRealtime, ~reducedPolling),
+        ~onNewBlock=(~knownHeight) =>
+          finishWaitingForNewBlock(
+            state,
+            ~chain,
+            ~knownHeight,
+            ~stateId,
+            ~scheduleFetch,
+            ~scheduleProcessing,
+          ),
+        ~executeQuery=async query => {
+          // Caught here (not just by the outer try) so the query promise never
+          // rejects: fetchNext spins a side-chain off it that would otherwise
+          // become an unhandled rejection.
+          try {
+            let response = await sourceManager->SourceManager.executeQuery(
+              ~query,
+              ~knownHeight=fetchState.knownHeight,
+              ~isRealtime,
+            )
+            await onQueryResponse(
+              state,
+              {chain, response, query},
+              ~stateId,
+              ~scheduleFetch,
+              ~scheduleProcessing,
+              ~scheduleRollback,
+            )
+          } catch {
+          | exn => IndexerState.errorExit(state, exn->ErrorHandling.make)
+          }
+        },
+        ~concurrencyLimit,
+        ~bufferLimit,
+        ~stateId,
+      )
+    } catch {
+    | exn =>
+      IndexerState.errorExit(state, exn->ErrorHandling.make(~msg=IndexerState.unexpectedErrorMsg))
+    }
+  }
+}

package/src/ChainFetching.res.mjs

@@ -0,0 +1,206 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Ecosystem from "./Ecosystem.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 IndexerState from "./IndexerState.res.mjs";
+import * as ChainMetadata from "./ChainMetadata.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as ContractRegisterContext from "./ContractRegisterContext.res.mjs";
+
+async function runContractRegistersOrThrow(itemsWithContractRegister, config) {
+  let itemsWithDcs = [];
+  let onRegister = (item, contractAddress, contractName) => {
+    let dc_registrationBlock = item.blockNumber;
+    let dc = {
+      address: contractAddress,
+      contractName: contractName,
+      registrationBlock: dc_registrationBlock
+    };
+    let dcs = item.dcs;
+    if (dcs !== undefined) {
+      dcs.push(dc);
+    } else {
+      item.dcs = [dc];
+      itemsWithDcs.push(item);
+    }
+  };
+  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 {
+      let params = {
+        item: item,
+        onRegister: onRegister,
+        config: config,
+        isResolved: false
+      };
+      let result = contractRegister$1(ContractRegisterContext.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(Ecosystem.getItemLogger(item, config.ecosystem), errorMessage, exn);
+        }));
+      } else {
+        params.isResolved = true;
+      }
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(item, config.ecosystem), errorMessage, exn);
+    }
+  }
+  if (Utils.$$Array.notEmpty(promises)) {
+    await Promise.all(promises);
+  }
+  return itemsWithDcs;
+}
+
+function applyQueryResponse(state, chain, newItems, newItemsWithDcs, knownHeight, latestFetchedBlock, query) {
+  let chainState = IndexerState.getChainState(state, chain);
+  let wasFetchingAtHead = ChainState.isFetchingAtHead(chainState);
+  ChainState.handleQueryResult(chainState, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight);
+  if (IndexerState.exitAfterFirstEventBlock(state) && newItems.length !== 0) {
+    ChainState.setEndBlockToFirstEvent(chainState, newItems[0].blockNumber);
+  }
+  if (!wasFetchingAtHead && !ChainState.isReady(chainState) && ChainState.isFetchingAtHead(chainState)) {
+    return Logging.childInfo(ChainState.logger(chainState), "All events have been fetched");
+  }
+}
+
+async function onQueryResponse(state, param, stateId, scheduleFetch, scheduleProcessing, scheduleRollback) {
+  let query = param.query;
+  let response = param.response;
+  let chain = param.chain;
+  if (IndexerState.isStale(state, stateId)) {
+    return;
+  }
+  let chainState = IndexerState.getChainState(state, chain);
+  let stats = response.stats;
+  let latestFetchedBlockTimestamp = response.latestFetchedBlockTimestamp;
+  let latestFetchedBlockNumber = response.latestFetchedBlockNumber;
+  let parsedQueueItems = response.parsedQueueItems;
+  let knownHeight = response.knownHeight;
+  if (knownHeight > ChainState.fetchState(chainState).knownHeight) {
+    Prometheus.SourceHeight.set(SourceManager.getActiveSource(ChainState.sourceManager(chainState)).name, ChainState.chainConfig(chainState).id, knownHeight);
+  }
+  Prometheus.FetchingBlockRange.increment(chain, stats["total time elapsed (s)"], Stdlib_Option.getOr(stats["parsing time (s)"], 0), parsedQueueItems.length, (latestFetchedBlockNumber - response.fromBlockQueried | 0) + 1 | 0);
+  let reorgResult = ChainState.registerReorgGuard(chainState, response.blockHashes, knownHeight);
+  let rollbackWithReorgDetectedBlockNumber;
+  if (typeof reorgResult !== "object") {
+    rollbackWithReorgDetectedBlockNumber = undefined;
+  } else {
+    let reorgDetected = reorgResult._0;
+    Logging.childInfo(ChainState.logger(chainState), ReorgDetection.reorgDetectedToLogParams(reorgDetected, IndexerState.config(state).shouldRollbackOnReorg));
+    Prometheus.ReorgCount.increment(chain);
+    Prometheus.ReorgDetectionBlockNumber.set(reorgDetected.scannedBlock.blockNumber, chain);
+    rollbackWithReorgDetectedBlockNumber = IndexerState.config(state).shouldRollbackOnReorg ? reorgDetected.scannedBlock.blockNumber : undefined;
+  }
+  if (rollbackWithReorgDetectedBlockNumber !== undefined) {
+    let match = IndexerState.rollbackState(state);
+    let eventsProcessedDiffByChain;
+    eventsProcessedDiffByChain = typeof match !== "object" || match.TAG !== "RollbackReady" ? undefined : match.eventsProcessedDiffByChain;
+    Utils.Dict.forEach(IndexerState.chainStates(state), cs => ChainState.prepareReorg(cs, eventsProcessedDiffByChain !== undefined ? eventsProcessedDiffByChain[ChainState.chainConfig(cs).id] : undefined));
+    IndexerState.beginReorg(state, chain, rollbackWithReorgDetectedBlockNumber);
+    return scheduleRollback();
+  }
+  let itemsWithContractRegister = [];
+  let newItems = [];
+  for (let idx = 0, idx_finish = parsedQueueItems.length; idx < idx_finish; ++idx) {
+    let item = parsedQueueItems[idx];
+    if (item.eventConfig.contractRegister !== undefined) {
+      itemsWithContractRegister.push(item);
+    }
+    newItems.push(item);
+  }
+  let proceed = newItemsWithDcs => {
+    if (!IndexerState.isStale(state, stateId)) {
+      applyQueryResponse(state, chain, newItems, newItemsWithDcs, knownHeight, {
+        blockNumber: latestFetchedBlockNumber,
+        blockTimestamp: latestFetchedBlockTimestamp
+      }, query);
+      ChainMetadata.stage(state);
+      scheduleFetch();
+      return scheduleProcessing();
+    }
+  };
+  if (itemsWithContractRegister.length === 0) {
+    return proceed([]);
+  }
+  let newItemsWithDcs;
+  try {
+    newItemsWithDcs = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state));
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, undefined));
+  }
+  return proceed(newItemsWithDcs);
+}
+
+function finishWaitingForNewBlock(state, chain, knownHeight, stateId, scheduleFetch, scheduleProcessing) {
+  if (IndexerState.isStale(state, stateId)) {
+    return;
+  }
+  let chainState = IndexerState.getChainState(state, chain);
+  ChainState.updateKnownHeight(chainState, knownHeight);
+  let isBelowReorgThreshold = !IndexerState.isInReorgThreshold(state) && IndexerState.config(state).shouldRollbackOnReorg;
+  let shouldEnterReorgThreshold = isBelowReorgThreshold && Object.values(IndexerState.chainStates(state)).every(cs => FetchState.isReadyToEnterReorgThreshold(ChainState.fetchState(cs)));
+  if (shouldEnterReorgThreshold) {
+    IndexerState.enterReorgThreshold(state);
+  }
+  scheduleFetch();
+  scheduleProcessing();
+}
+
+async function fetchChain(state, chain, concurrencyLimit, bufferLimit, stateId, scheduleFetch, scheduleProcessing, scheduleRollback) {
+  let chainState = IndexerState.getChainState(state, chain);
+  if (IndexerState.isResolvingReorg(state) || IndexerState.isStopped(state)) {
+    return;
+  }
+  let fetchState = ChainState.fetchState(chainState);
+  let isRealtime = IndexerState.isRealtime(state);
+  let sourceManager = ChainState.sourceManager(chainState);
+  let reducedPolling = !isRealtime;
+  try {
+    return await SourceManager.fetchNext(sourceManager, fetchState, async query => {
+      try {
+        let response = await SourceManager.executeQuery(sourceManager, query, fetchState.knownHeight, isRealtime);
+        return await onQueryResponse(state, {
+          chain: chain,
+          response: response,
+          query: query
+        }, stateId, scheduleFetch, scheduleProcessing, scheduleRollback);
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, undefined));
+      }
+    }, knownHeight => SourceManager.waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling), knownHeight => finishWaitingForNewBlock(state, chain, knownHeight, stateId, scheduleFetch, scheduleProcessing), concurrencyLimit, bufferLimit, stateId);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, IndexerState.unexpectedErrorMsg));
+  }
+}
+
+export {
+  runContractRegistersOrThrow,
+  onQueryResponse,
+  applyQueryResponse,
+  finishWaitingForNewBlock,
+  fetchChain,
+}
+/* Utils Not a pure module */

package/src/ChainMetadata.res

@@ -0,0 +1,27 @@
+// Stage the per-chain metadata into the in-memory store. It's staged, not
+// written: the next batch write folds the staged diff in.
+let stage = (state: IndexerState.t) => {
+  let chainsData: dict<InternalTable.Chains.metaFields> = Dict.make()
+
+  state
+  ->IndexerState.chainStates
+  ->Dict.valuesToArray
+  ->Array.forEach(cs => {
+    let fetchState = cs->ChainState.fetchState
+    chainsData->Dict.set(
+      (cs->ChainState.chainConfig).id->Int.toString,
+      {
+        firstEventBlockNumber: fetchState.firstEventBlock->Null.fromOption,
+        isHyperSync: (
+          cs->ChainState.sourceManager->SourceManager.getActiveSource
+        ).poweredByHyperSync,
+        latestFetchedBlockNumber: fetchState->FetchState.bufferBlockNumber,
+        timestampCaughtUpToHeadOrEndblock: cs
+        ->ChainState.timestampCaughtUpToHeadOrEndblock
+        ->Null.fromOption,
+      },
+    )
+  })
+
+  state->Writing.setChainMeta(chainsData)
+}

package/src/ChainMetadata.res.mjs

@@ -0,0 +1,27 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Writing from "./Writing.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
+import * as FetchState from "./FetchState.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
+import * as IndexerState from "./IndexerState.res.mjs";
+import * as SourceManager from "./sources/SourceManager.res.mjs";
+
+function stage(state) {
+  let chainsData = {};
+  Object.values(IndexerState.chainStates(state)).forEach(cs => {
+    let fetchState = ChainState.fetchState(cs);
+    chainsData[ChainState.chainConfig(cs).id.toString()] = {
+      first_event_block: Stdlib_Null.fromOption(fetchState.firstEventBlock),
+      buffer_block: FetchState.bufferBlockNumber(fetchState),
+      ready_at: Stdlib_Null.fromOption(ChainState.timestampCaughtUpToHeadOrEndblock(cs)),
+      _is_hyper_sync: SourceManager.getActiveSource(ChainState.sourceManager(cs)).poweredByHyperSync
+    };
+  });
+  Writing.setChainMeta(state, chainsData);
+}
+
+export {
+  stage,
+}
+/* Writing Not a pure module */