envio 3.2.1 → 3.3.0-alpha.1

package/src/Main.res

@@ -79,7 +79,7 @@ let blockRangeSchema: S.t<blockRange> = S.object(s => {
 
 let defaultBlockRange: blockRange = {_gte: None, _lte: None, _every: 1}
 
-let globalGsManagerRef: ref<option<GlobalStateManager.t>> = ref(None)
+let indexerStateRef: ref<option<IndexerState.t>> = ref(None)
 
 // Persistence is set by Main.start before handler modules load, so that
 // the exported indexer value can lazily expose DB state (startBlock,
@@ -145,12 +145,12 @@ let buildChainsObject = (~config: Config.t) => {
       {
         enumerable: true,
         get: () => {
-          switch globalGsManagerRef.contents {
-          | Some(gsManager) => (gsManager->GlobalStateManager.getState).chainManager.isRealtime
-          // Before the GlobalStateManager is available (eg during handler
+          switch indexerStateRef.contents {
+          | Some(state) => state->IndexerState.isRealtime
+          // Before the global state is available (eg during handler
           // module load after resume), derive from persistence: every chain
           // must have previously caught up to head or endBlock. Mirror the
-          // ChainManager.makeFromDbState path: updateSyncTimeOnRestart wipes
+          // IndexerState.makeFromDbState path: updateSyncTimeOnRestart wipes
           // the saved timestamps so a restart re-enters backfill.
           | None if Env.updateSyncTimeOnRestart => false
           | None =>
@@ -179,12 +179,11 @@ let buildChainsObject = (~config: Config.t) => {
         {
           enumerable: true,
           get: () => {
-            switch globalGsManagerRef.contents {
-            | Some(gsManager) => {
-                let state = gsManager->GlobalStateManager.getState
+            switch indexerStateRef.contents {
+            | Some(state) => {
                 let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
-                let chainFetcher = state.chainManager.chainFetchers->ChainMap.get(chain)
-                let indexingAddresses = chainFetcher.fetchState.indexingAddresses
+                let chainState = state->IndexerState.getChainState(~chain)
+                let indexingAddresses = (chainState->ChainState.fetchState).indexingAddresses
 
                 // Collect all addresses for this contract name from indexingAddresses
                 let addresses = []
@@ -197,7 +196,7 @@ let buildChainsObject = (~config: Config.t) => {
                 }
                 addresses
               }
-            // Before the GlobalStateManager is available (eg during handler
+            // Before the global state is available (eg during handler
             // module load after resume), combine static addresses from config
             // with dynamic contracts persisted in the database.
             | None =>
@@ -586,7 +585,7 @@ let getGlobalIndexer = (): 'indexer => {
   Utils.Proxy.make(Utils.Object.createNullObject(), traps)->(Utils.magic: {..} => 'indexer)
 }
 
-let startServer = (~getState, ~ctx: Ctx.t, ~isDevelopmentMode: bool) => {
+let startServer = (~getState, ~persistence: Persistence.t, ~isDevelopmentMode: bool) => {
   open Express
 
   let app = make()
@@ -629,7 +628,7 @@ let startServer = (~getState, ~ctx: Ctx.t, ~isDevelopmentMode: bool) => {
 
   app->post("/console/syncCache", (_req, res) => {
     if isDevelopmentMode {
-      (ctx.persistence->Persistence.getInitializedStorageOrThrow).dumpEffectCache()
+      (persistence->Persistence.getInitializedStorageOrThrow).dumpEffectCache()
       ->Promise.thenResolve(_ => res->json(Boolean(true)))
       ->Promise.ignore
     } else {
@@ -757,112 +756,88 @@ let start = async (
   | Some(patchConfig) => patchConfig(config, registrations)
   | None => config
   }
-  // The single fatal-error handler, shared by the store, ErrorExit, and the
-  // manager's catch.
+  // The single fatal-error handler, invoked once via IndexerState.errorExit.
   let onError = (errHandler: ErrorHandling.t) => {
     errHandler->ErrorHandling.log
-    NodeJs.process->NodeJs.exitWithCode(Failure)
-  }
-  let ctx = {
-    Ctx.registrations,
-    config,
-    persistence,
-    inMemoryStore: InMemoryStore.make(
-      ~entities=persistence.allEntities,
-      ~committedCheckpointId=(persistence->Persistence.getInitializedState).checkpointId,
-      ~persistence,
-      ~config,
-      ~onError=exn => onError(exn->ErrorHandling.make(~msg="Failed writing batch to the database")),
-    ),
+    if isTest {
+      // The TestIndexer runs the indexer in a worker thread and reads the
+      // failure off the worker 'error' event. Re-throw the original error
+      // outside the promise chain on the next tick so the test sees its real
+      // message instead of a generic non-zero exit code.
+      NodeJs.setImmediate(() => errHandler->ErrorHandling.raiseExn)
+    } else {
+      NodeJs.process->NodeJs.exitWithCode(Failure)
+    }
   }
-
   let envioVersion = Utils.EnvioPackage.value.version
   Prometheus.Info.set(~version=envioVersion)
   Prometheus.ProcessStartTimeSeconds.set()
-  Prometheus.RollbackEnabled.set(~enabled=ctx.config.shouldRollbackOnReorg)
+  Prometheus.RollbackEnabled.set(~enabled=config.shouldRollbackOnReorg)
 
   if !isTest {
-    startServer(~ctx, ~isDevelopmentMode, ~getState=() =>
-      switch globalGsManagerRef.contents {
+    startServer(~persistence, ~isDevelopmentMode, ~getState=() =>
+      switch indexerStateRef.contents {
       | None => Initializing({})
-      | Some(gsManager) => {
-          let state = gsManager->GlobalStateManager.getState
+      | Some(state) => {
           let chains =
-            state.chainManager.chainFetchers
-            ->ChainMap.values
-            ->Array.map(cf => {
-              let {fetchState} = cf
+            state
+            ->IndexerState.chainStates
+            ->Dict.valuesToArray
+            ->Array.map(cs => {
+              let fetchState = cs->ChainState.fetchState
               let latestFetchedBlockNumber = Pervasives.max(
                 FetchState.bufferBlockNumber(fetchState),
                 0,
               )
               let knownHeight =
-                cf->ChainFetcher.hasProcessedToEndblock
-                  ? cf.fetchState.endBlock->Option.getOr(cf.fetchState.knownHeight)
-                  : cf.fetchState.knownHeight
+                cs->ChainState.hasProcessedToEndblock
+                  ? fetchState.endBlock->Option.getOr(fetchState.knownHeight)
+                  : fetchState.knownHeight
 
               {
-                chainId: cf.chainConfig.id->Int.toFloat,
+                chainId: (cs->ChainState.chainConfig).id->Int.toFloat,
                 poweredByHyperSync: (
-                  cf.sourceManager->SourceManager.getActiveSource
+                  cs->ChainState.sourceManager->SourceManager.getActiveSource
                 ).poweredByHyperSync,
                 latestFetchedBlockNumber,
                 knownHeight,
                 numBatchesFetched: 0,
-                startBlock: cf.fetchState.startBlock,
-                endBlock: cf.fetchState.endBlock,
-                firstEventBlockNumber: cf.fetchState.firstEventBlock,
-                latestProcessedBlock: cf.committedProgressBlockNumber === -1
+                startBlock: fetchState.startBlock,
+                endBlock: fetchState.endBlock,
+                firstEventBlockNumber: fetchState.firstEventBlock,
+                latestProcessedBlock: cs->ChainState.committedProgressBlockNumber === -1
                   ? None
-                  : Some(cf.committedProgressBlockNumber),
-                timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
-                numEventsProcessed: cf.numEventsProcessed,
-                numAddresses: cf.fetchState->FetchState.numAddresses,
+                  : Some(cs->ChainState.committedProgressBlockNumber),
+                timestampCaughtUpToHeadOrEndblock: cs->ChainState.timestampCaughtUpToHeadOrEndblock,
+                numEventsProcessed: cs->ChainState.numEventsProcessed,
+                numAddresses: fetchState->FetchState.numAddresses,
               }
             })
           Active({
             envioVersion,
             chains,
-            indexerStartTime: state.indexerStartTime,
+            indexerStartTime: state->IndexerState.indexerStartTime,
             isPreRegisteringDynamicContracts: false,
-            rollbackOnReorg: ctx.config.shouldRollbackOnReorg,
+            rollbackOnReorg: config.shouldRollbackOnReorg,
           })
         }
       }
     )
   }
 
-  let chainManager = ChainManager.makeFromDbState(
-    ~initialState=ctx.persistence->Persistence.getInitializedState,
-    ~config=ctx.config,
-    ~registrations=ctx.registrations,
-  )
-  let globalState = GlobalState.make(
-    ~ctx,
-    ~chainManager,
+  let state = IndexerState.makeFromDbState(
+    ~config,
+    ~persistence,
+    ~initialState=persistence->Persistence.getInitializedState,
+    ~registrations,
     ~isDevelopmentMode,
     ~shouldUseTui,
     ~exitAfterFirstEventBlock,
     ~onError,
   )
-  let gsManager =
-    globalState->GlobalStateManager.make(
-      ~reducers=GlobalState.makeReducers(
-        ~markBatchProcessed=MarkBatchProcessedAdapter.make(~inMemoryStore=ctx.inMemoryStore),
-      ),
-      ~onError=exn =>
-        onError(exn->ErrorHandling.make(~msg="Indexer has failed with an unexpected error")),
-    )
   if shouldUseTui {
-    let _rerender = Tui.start(~getState=() => gsManager->GlobalStateManager.getState)
+    let _rerender = Tui.start(~getState=() => state)
   }
-  globalGsManagerRef := Some(gsManager)
-  gsManager->GlobalStateManager.dispatchTask(NextQuery(CheckAllChains))
-  /*
-    NOTE:
-      This `ProcessEventBatch` dispatch shouldn't be necessary but we are adding for safety, it should immediately return doing 
-      nothing since there is no events on the queues.
- */
-
-  gsManager->GlobalStateManager.dispatchTask(ProcessEventBatch)
+  indexerStateRef := Some(state)
+  state->IndexerLoop.start
 }

package/src/Main.res.mjs

@@ -10,17 +10,16 @@ import Express from "express";
 import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.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 GlobalState from "./GlobalState.res.mjs";
+import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as PromClient from "prom-client";
 import Yargs from "yargs/yargs";
-import * as ChainFetcher from "./ChainFetcher.res.mjs";
-import * as ChainManager from "./ChainManager.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as HandlerLoader from "./HandlerLoader.res.mjs";
-import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -30,9 +29,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as GlobalStateManager from "./GlobalStateManager.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-import * as MarkBatchProcessedAdapter from "./adapters/MarkBatchProcessedAdapter.res.mjs";
 
 let chainDataSchema = S$RescriptSchema.schema(s => ({
   chainId: s.m(S$RescriptSchema.float),
@@ -78,7 +75,7 @@ let defaultBlockRange = {
   _every: 1
 };
 
-let globalGsManagerRef = {
+let indexerStateRef = {
   contents: undefined
 };
 
@@ -139,9 +136,9 @@ function buildChainsObject(config) {
     }), "isRealtime", {
       enumerable: true,
       get: () => {
-        let gsManager = globalGsManagerRef.contents;
-        if (gsManager !== undefined) {
-          return GlobalStateManager.getState(Primitive_option.valFromOption(gsManager)).chainManager.isRealtime;
+        let state = indexerStateRef.contents;
+        if (state !== undefined) {
+          return IndexerState.isRealtime(Primitive_option.valFromOption(state));
         } else if (Env.updateSyncTimeOnRestart) {
           return false;
         } else {
@@ -167,12 +164,11 @@ function buildChainsObject(config) {
       }), "addresses", {
         enumerable: true,
         get: () => {
-          let gsManager = globalGsManagerRef.contents;
-          if (gsManager !== undefined) {
-            let state = GlobalStateManager.getState(Primitive_option.valFromOption(gsManager));
+          let state = indexerStateRef.contents;
+          if (state !== undefined) {
             let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
-            let chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
-            let indexingAddresses = chainFetcher.fetchState.indexingAddresses;
+            let chainState = IndexerState.getChainState(Primitive_option.valFromOption(state), chain);
+            let indexingAddresses = ChainState.fetchState(chainState).indexingAddresses;
             let addresses = [];
             let values = Object.values(indexingAddresses);
             for (let idx = 0, idx_finish = values.length; idx < idx_finish; ++idx) {
@@ -183,12 +179,12 @@ function buildChainsObject(config) {
             }
             return addresses;
           }
-          let chainState = getInitialChainState(chainConfig.id);
-          if (chainState === undefined) {
+          let chainState$1 = getInitialChainState(chainConfig.id);
+          if (chainState$1 === undefined) {
             return contract.addresses;
           }
           let addresses$1 = contract.addresses.slice();
-          chainState.indexingAddresses.forEach(dc => {
+          chainState$1.indexingAddresses.forEach(dc => {
             if (dc.contractName === contract.name) {
               addresses$1.push(dc.address);
               return;
@@ -450,7 +446,7 @@ function getGlobalIndexer() {
   return new Proxy(Object.create(null), traps);
 }
 
-function startServer(getState, ctx, isDevelopmentMode) {
+function startServer(getState, persistence, isDevelopmentMode) {
   let app = Express();
   let consoleCorsMiddleware = (req, res, next) => {
     let origin = req.headers["origin"];
@@ -480,7 +476,7 @@ function startServer(getState, ctx, isDevelopmentMode) {
   });
   app.post("/console/syncCache", (_req, res) => {
     if (isDevelopmentMode) {
-      Persistence.getInitializedStorageOrThrow(ctx.persistence).dumpEffectCache().then(() => {
+      Persistence.getInitializedStorageOrThrow(persistence).dumpEffectCache().then(() => {
         res.json(true);
       });
     } else {
@@ -571,14 +567,11 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let config$2 = patchConfig !== undefined ? patchConfig(config$1, registrations) : config$1;
   let onError = errHandler => {
     ErrorHandling.log(errHandler);
-    Process.exit(1);
-  };
-  let ctx_inMemoryStore = InMemoryStore.make(persistence$1.allEntities, Persistence.getInitializedState(persistence$1).checkpointId, persistence$1, config$2, exn => onError(ErrorHandling.make(exn, undefined, "Failed writing batch to the database")));
-  let ctx = {
-    registrations: registrations,
-    config: config$2,
-    persistence: persistence$1,
-    inMemoryStore: ctx_inMemoryStore
+    if (isTest) {
+      setImmediate(() => ErrorHandling.raiseExn(errHandler));
+    } else {
+      Process.exit(1);
+    }
   };
   let envioVersion = Utils.EnvioPackage.value.version;
   Prometheus.Info.set(envioVersion);
@@ -586,53 +579,48 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   Prometheus.RollbackEnabled.set(config$2.shouldRollbackOnReorg);
   if (!isTest) {
     startServer(() => {
-      let gsManager = globalGsManagerRef.contents;
-      if (gsManager === undefined) {
+      let state = indexerStateRef.contents;
+      if (state === undefined) {
         return {
           status: "initializing"
         };
       }
-      let state = GlobalStateManager.getState(Primitive_option.valFromOption(gsManager));
-      let chains = ChainMap.values(state.chainManager.chainFetchers).map(cf => {
-        let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(cf.fetchState), 0);
-        let knownHeight = ChainFetcher.hasProcessedToEndblock(cf) ? Stdlib_Option.getOr(cf.fetchState.endBlock, cf.fetchState.knownHeight) : cf.fetchState.knownHeight;
+      let state$1 = Primitive_option.valFromOption(state);
+      let chains = Object.values(IndexerState.chainStates(state$1)).map(cs => {
+        let fetchState = ChainState.fetchState(cs);
+        let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(fetchState), 0);
+        let knownHeight = ChainState.hasProcessedToEndblock(cs) ? Stdlib_Option.getOr(fetchState.endBlock, fetchState.knownHeight) : fetchState.knownHeight;
         return {
-          chainId: cf.chainConfig.id,
-          poweredByHyperSync: SourceManager.getActiveSource(cf.sourceManager).poweredByHyperSync,
-          firstEventBlockNumber: cf.fetchState.firstEventBlock,
-          latestProcessedBlock: cf.committedProgressBlockNumber === -1 ? undefined : cf.committedProgressBlockNumber,
-          timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock,
-          numEventsProcessed: cf.numEventsProcessed,
+          chainId: ChainState.chainConfig(cs).id,
+          poweredByHyperSync: SourceManager.getActiveSource(ChainState.sourceManager(cs)).poweredByHyperSync,
+          firstEventBlockNumber: fetchState.firstEventBlock,
+          latestProcessedBlock: ChainState.committedProgressBlockNumber(cs) === -1 ? undefined : ChainState.committedProgressBlockNumber(cs),
+          timestampCaughtUpToHeadOrEndblock: ChainState.timestampCaughtUpToHeadOrEndblock(cs),
+          numEventsProcessed: ChainState.numEventsProcessed(cs),
           latestFetchedBlockNumber: latestFetchedBlockNumber,
           currentBlockHeight: knownHeight,
           numBatchesFetched: 0,
-          startBlock: cf.fetchState.startBlock,
-          endBlock: cf.fetchState.endBlock,
-          numAddresses: FetchState.numAddresses(cf.fetchState)
+          startBlock: fetchState.startBlock,
+          endBlock: fetchState.endBlock,
+          numAddresses: FetchState.numAddresses(fetchState)
         };
       });
       return {
         status: "active",
         envioVersion: envioVersion,
         chains: chains,
-        indexerStartTime: state.indexerStartTime,
+        indexerStartTime: IndexerState.indexerStartTime(state$1),
         isPreRegisteringDynamicContracts: false,
         rollbackOnReorg: config$2.shouldRollbackOnReorg
       };
-    }, ctx, isDevelopmentMode);
+    }, persistence$1, isDevelopmentMode);
   }
-  let chainManager = ChainManager.makeFromDbState(Persistence.getInitializedState(persistence$1), config$2, registrations, undefined);
-  let globalState = GlobalState.make(ctx, chainManager, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError);
-  let gsManager = GlobalStateManager.make(globalState, GlobalState.makeReducers(undefined, undefined, undefined, MarkBatchProcessedAdapter.make(ctx_inMemoryStore)), exn => onError(ErrorHandling.make(exn, undefined, "Indexer has failed with an unexpected error")));
+  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrations, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
   if (shouldUseTui) {
-    Tui.start(() => GlobalStateManager.getState(gsManager));
+    Tui.start(() => state);
   }
-  globalGsManagerRef.contents = Primitive_option.some(gsManager);
-  GlobalStateManager.dispatchTask(gsManager, {
-    TAG: "NextQuery",
-    _0: "CheckAllChains"
-  });
-  return GlobalStateManager.dispatchTask(gsManager, "ProcessEventBatch");
+  indexerStateRef.contents = Primitive_option.some(state);
+  return IndexerLoop.start(state);
 }
 
 export {
@@ -640,7 +628,7 @@ export {
   stateSchema,
   blockRangeSchema,
   defaultBlockRange,
-  globalGsManagerRef,
+  indexerStateRef,
   globalPersistenceRef,
   getInitialChainState,
   buildChainsObject,

package/src/PgStorage.res

@@ -308,7 +308,12 @@ let rec makeFilterCondition = (
         }),
       )
     }
-  let serializeParamOrThrow = (~queryField: Table.queryField, ~fieldName, ~fieldValue: unknown, ~isArray) => {
+  let serializeParamOrThrow = (
+    ~queryField: Table.queryField,
+    ~fieldName,
+    ~fieldValue: unknown,
+    ~isArray,
+  ) => {
     let param = try fieldValue->S.reverseConvertToJsonOrThrow(
       isArray ? queryField.arrayFieldSchema : queryField.fieldSchema,
     ) catch {
@@ -815,74 +820,6 @@ let executeSet = (
   }
 }
 
-let convertFieldsToJson = (fields: option<dict<unknown>>) => {
-  switch fields {
-  | None => %raw(`{}`)
-  | Some(fields) =>
-    // Convert bigint fields to string. There are no fields with nested
-    // bigints, so iterating only the top level is safe.
-    fields
-    ->Utils.Dict.mapValues(value =>
-      typeof(value) === #bigint
-        ? value
-          ->(Utils.magic: unknown => bigint)
-          ->BigInt.toString
-          ->(Utils.magic: string => unknown)
-        : value
-    )
-    ->(Utils.magic: dict<unknown> => JSON.t)
-  }
-}
-
-let makeRawEvent = (
-  eventItem: Internal.eventItem,
-  ~config: Config.t,
-): InternalTable.RawEvents.t => {
-  let {event, eventConfig, chain, blockNumber, blockHash, timestamp: blockTimestamp} = eventItem
-  let {block, transaction, params, logIndex, srcAddress} = event->Internal.toGenericEvent
-  let chainId = chain->ChainMap.Chain.toChainId
-  let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
-  let blockFields =
-    block
-    ->(Utils.magic: Internal.eventBlock => option<dict<unknown>>)
-    ->convertFieldsToJson
-  let transactionFields =
-    transaction
-    ->(Utils.magic: Internal.eventTransaction => option<dict<unknown>>)
-    ->convertFieldsToJson
-
-  blockFields->config.ecosystem.cleanUpRawEventFieldsInPlace
-
-  // Serialize to unknown, because serializing to Js.Json.t fails for Bytes Fuel type, since it has unknown schema
-  let params =
-    params
-    ->S.reverseConvertOrThrow(eventConfig.paramsRawEventSchema)
-    ->(Utils.magic: unknown => JSON.t)
-  let params = if params === %raw(`null`) {
-    // Should probably make the params field nullable
-    // But this is currently needed to make events
-    // with empty params work
-    %raw(`"null"`)
-  } else {
-    params
-  }
-
-  {
-    chainId,
-    eventId,
-    eventName: eventConfig.name,
-    contractName: eventConfig.contractName,
-    blockNumber,
-    logIndex,
-    srcAddress,
-    blockHash,
-    blockTimestamp,
-    blockFields,
-    transactionFields,
-    params,
-  }
-}
-
 let rec writeBatch = async (
   sql,
   ~batch: Batch.t,
@@ -906,7 +843,7 @@ let rec writeBatch = async (
     let rawEvents = if config.enableRawEvents {
       let rows = batch.items->Array.filterMap(item =>
         switch item {
-        | Internal.Event(_) => Some(item->Internal.castUnsafeEventItem->makeRawEvent(~config))
+        | Internal.Event(_) => Some(config.ecosystem.toRawEvent(item->Internal.castUnsafeEventItem))
         | Internal.Block(_) => None
         }
       )
@@ -1493,7 +1430,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
         numEventsProcessed: 0.,
         firstEventBlockNumber: None,
         timestampCaughtUpToHeadOrEndblock: None,
-        indexingAddresses: ChainFetcher.configAddresses(chainConfig),
+        indexingAddresses: ChainState.configAddresses(chainConfig),
         sourceBlockNumber: 0,
       }),
       checkpointId: InternalTable.Checkpoints.initialCheckpointId,

package/src/PgStorage.res.mjs

@@ -13,10 +13,9 @@ import * as Schema from "./db/Schema.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import Postgres from "postgres";
-import * as EventUtils from "./EventUtils.res.mjs";
+import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
-import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as InternalTable from "./db/InternalTable.res.mjs";
@@ -608,47 +607,6 @@ function executeSet(sql, items, dbFunction) {
   }
 }
 
-function convertFieldsToJson(fields) {
-  if (fields !== undefined) {
-    return Utils.Dict.mapValues(fields, value => {
-      if (typeof value === "bigint") {
-        return value.toString();
-      } else {
-        return value;
-      }
-    });
-  } else {
-    return {};
-  }
-}
-
-function makeRawEvent(eventItem, config) {
-  let event = eventItem.event;
-  let blockNumber = eventItem.blockNumber;
-  let eventConfig = eventItem.eventConfig;
-  let logIndex = event.logIndex;
-  let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
-  let blockFields = convertFieldsToJson(event.block);
-  let transactionFields = convertFieldsToJson(event.transaction);
-  config.ecosystem.cleanUpRawEventFieldsInPlace(blockFields);
-  let params = S$RescriptSchema.reverseConvertOrThrow(event.params, eventConfig.paramsRawEventSchema);
-  let params$1 = params === null ? "null" : params;
-  return {
-    chain_id: eventItem.chain,
-    event_id: eventId,
-    event_name: eventConfig.name,
-    contract_name: eventConfig.contractName,
-    block_number: blockNumber,
-    log_index: logIndex,
-    src_address: event.srcAddress,
-    block_hash: eventItem.blockHash,
-    block_timestamp: eventItem.timestamp,
-    block_fields: blockFields,
-    transaction_fields: transactionFields,
-    params: params$1
-  };
-}
-
 async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, updatedEntities, sinkPromise, chainMetaData, escapeTables) {
   try {
     let shouldSaveHistory = Config.shouldSaveHistory(config, isInReorgThreshold);
@@ -659,7 +617,7 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     if (config.enableRawEvents) {
       let rows = Stdlib_Array.filterMap(batch.items, item => {
         if (item.kind === 0) {
-          return makeRawEvent(item, config);
+          return config.ecosystem.toRawEvent(item);
         }
       });
       if (escapeTables !== undefined && Primitive_option.valFromOption(escapeTables).has(InternalTable.RawEvents.table)) {
@@ -1004,7 +962,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
         numEventsProcessed: 0,
         firstEventBlockNumber: undefined,
         timestampCaughtUpToHeadOrEndblock: undefined,
-        indexingAddresses: ChainFetcher.configAddresses(chainConfig),
+        indexingAddresses: ChainState.configAddresses(chainConfig),
         sourceBlockNumber: 0
       })),
       checkpointId: InternalTable.Checkpoints.initialCheckpointId,
@@ -1275,8 +1233,6 @@ export {
   deleteByIdsOrThrow,
   makeInsertDeleteUpdatesQuery,
   executeSet,
-  convertFieldsToJson,
-  makeRawEvent,
   writeBatch,
   makeGetRollbackRestoredEntitiesQuery,
   makeGetRollbackRemovedIdsQuery,

package/src/Prometheus.res

@@ -351,18 +351,6 @@ module IndexingAddresses = {
   }
 }
 
-module IndexingMaxConcurrency = {
-  let gauge = SafeGauge.makeOrThrow(
-    ~name="envio_indexing_max_concurrency",
-    ~help="The maximum number of concurrent queries to the chain data-source.",
-    ~labelSchema=chainIdLabelsSchema,
-  )
-
-  let set = (~maxConcurrency, ~chainId) => {
-    gauge->SafeGauge.handleInt(~labels=chainId, ~value=maxConcurrency)
-  }
-}
-
 module IndexingConcurrency = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_indexing_concurrency",
@@ -426,7 +414,7 @@ module IndexingBufferSize = {
 module IndexingTargetBufferSize = {
   let gauge = PromClient.Gauge.makeGauge({
     "name": "envio_indexing_target_buffer_size",
-    "help": "The target buffer size per chain for indexing. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target.",
+    "help": "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target.",
   })
 
   let set = (~targetBufferSize) => {