envio 3.2.1 → 3.3.0-alpha.0

package/src/sources/HyperSyncSource.res.mjs

@@ -135,7 +135,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
       blockNumber: block.number,
       blockHash: block.hash,
       logIndex: logIndex,
-      event: {
+      payload: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
         params: params,

package/src/sources/RpcSource.res

@@ -1200,7 +1200,7 @@ let make = (
                   blockHash: block->getBlockHash,
                   chain,
                   logIndex: log.logIndex,
-                  event: {
+                  payload: {
                     contractName: eventConfig.contractName,
                     eventName: eventConfig.name,
                     chainId: chain->ChainMap.Chain.toChainId,
@@ -1209,7 +1209,7 @@ let make = (
                     block,
                     srcAddress: routedAddress,
                     logIndex: log.logIndex,
-                  }->Internal.fromGenericEvent,
+                  }->Evm.fromPayload,
                 })
               }
             )(),

package/src/sources/RpcSource.res.mjs

@@ -1131,7 +1131,7 @@ function make(param) {
           blockNumber: block.number,
           blockHash: block.hash,
           logIndex: log.logIndex,
-          event: {
+          payload: {
             contractName: eventConfig.contractName,
             eventName: eventConfig.name,
             params: decoded$1,

package/src/sources/SourceManager.res

@@ -11,16 +11,12 @@ type sourceState = {
   mutable lastFailedAt: option<float>,
 }
 
-// Ideally the ChainFetcher name suits this better
-// But currently the ChainFetcher module is immutable
-// and handles both processing and fetching.
-// So this module is to encapsulate the fetching logic only
+// Encapsulates the fetching logic for a chain's sources.
 // with a mutable state for easier reasoning and testing.
 type t = {
   sourcesState: array<sourceState>,
   mutable statusStart: Hrtime.timeRef,
   mutable status: sourceManagerStatus,
-  maxPartitionConcurrency: int,
   newBlockStallTimeout: int,
   newBlockStallTimeoutRealtime: int,
   stalledPollingInterval: int,
@@ -46,6 +42,10 @@ type t = {
 
 let getActiveSource = sourceManager => sourceManager.activeSource
 
+// Partition queries currently in flight on this chain's sources. Summed across
+// chains by CrossChainState to enforce the indexer-wide concurrency budget.
+let inFlightCount = sourceManager => sourceManager.fetchingPartitionsCount
+
 let getRateLimitTimeMs = sourceManager =>
   sourceManager.committedRateLimitTimeMs +.
   switch sourceManager.activeRateLimitStartMs {
@@ -151,7 +151,6 @@ let makeGetHeightRetryInterval = (
 
 let make = (
   ~sources: array<Source.t>,
-  ~maxPartitionConcurrency,
   ~isRealtime,
   ~newBlockStallTimeout=60_000,
   ~newBlockStallTimeoutRealtime=20_000,
@@ -172,16 +171,11 @@ let make = (
   | None =>
     JsError.throwWithMessage("Invalid configuration, no data-source for historical sync provided")
   }
-  Prometheus.IndexingMaxConcurrency.set(
-    ~maxConcurrency=maxPartitionConcurrency,
-    ~chainId=initialActiveSource.chain->ChainMap.Chain.toChainId,
-  )
   Prometheus.IndexingConcurrency.set(
     ~concurrency=0,
     ~chainId=initialActiveSource.chain->ChainMap.Chain.toChainId,
   )
   {
-    maxPartitionConcurrency,
     sourcesState: sources->Array.map(source => {
       source,
       knownHeight: 0,
@@ -229,15 +223,11 @@ let fetchNext = async (
   ~executeQuery,
   ~waitForNewBlock,
   ~onNewBlock,
+  ~concurrencyLimit,
+  ~bufferLimit,
   ~stateId,
 ) => {
-  let {maxPartitionConcurrency} = sourceManager
-
-  let nextQuery = fetchState->FetchState.getNextQuery(
-    ~concurrencyLimit={
-      maxPartitionConcurrency - sourceManager.fetchingPartitionsCount
-    },
-  )
+  let nextQuery = fetchState->FetchState.getNextQuery(~concurrencyLimit, ~bufferLimit)
 
   switch nextQuery {
   | ReachedMaxConcurrency

package/src/sources/SourceManager.res.mjs

@@ -18,6 +18,10 @@ function getActiveSource(sourceManager) {
   return sourceManager.activeSource;
 }
 
+function inFlightCount(sourceManager) {
+  return sourceManager.fetchingPartitionsCount;
+}
+
 function getRateLimitTimeMs(sourceManager) {
   let startMs = sourceManager.activeRateLimitStartMs;
   return sourceManager.committedRateLimitTimeMs + (
@@ -115,7 +119,7 @@ function makeGetHeightRetryInterval(initialRetryInterval, backoffMultiplicative,
   };
 }
 
-function make(sources, maxPartitionConcurrency, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeoutRealtimeOpt, stalledPollingIntervalOpt, reducedPollingIntervalOpt, recoveryTimeoutOpt, getHeightRetryIntervalOpt) {
+function make(sources, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeoutRealtimeOpt, stalledPollingIntervalOpt, reducedPollingIntervalOpt, recoveryTimeoutOpt, getHeightRetryIntervalOpt) {
   let newBlockStallTimeout = newBlockStallTimeoutOpt !== undefined ? newBlockStallTimeoutOpt : 60000;
   let newBlockStallTimeoutRealtime = newBlockStallTimeoutRealtimeOpt !== undefined ? newBlockStallTimeoutRealtimeOpt : 20000;
   let stalledPollingInterval = stalledPollingIntervalOpt !== undefined ? stalledPollingIntervalOpt : 5000;
@@ -125,7 +129,6 @@ function make(sources, maxPartitionConcurrency, isRealtime, newBlockStallTimeout
   let hasRealtime = sources.some(s => s.sourceFor === "Realtime");
   let source = sources.find(source => getSourceRole(source.sourceFor, isRealtime, hasRealtime) === "Primary");
   let initialActiveSource = source !== undefined ? source : Stdlib_JsError.throwWithMessage("Invalid configuration, no data-source for historical sync provided");
-  Prometheus.IndexingMaxConcurrency.set(maxPartitionConcurrency, initialActiveSource.chain);
   Prometheus.IndexingConcurrency.set(0, initialActiveSource.chain);
   return {
     sourcesState: sources.map(source => ({
@@ -138,7 +141,6 @@ function make(sources, maxPartitionConcurrency, isRealtime, newBlockStallTimeout
     })),
     statusStart: Hrtime.makeTimer(),
     status: "Idle",
-    maxPartitionConcurrency: maxPartitionConcurrency,
     newBlockStallTimeout: newBlockStallTimeout,
     newBlockStallTimeoutRealtime: newBlockStallTimeoutRealtime,
     stalledPollingInterval: stalledPollingInterval,
@@ -175,8 +177,8 @@ function trackNewStatus(sourceManager, newStatus) {
   sourceManager.status = newStatus;
 }
 
-async function fetchNext(sourceManager, fetchState, executeQuery, waitForNewBlock, onNewBlock, stateId) {
-  let nextQuery = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0);
+async function fetchNext(sourceManager, fetchState, executeQuery, waitForNewBlock, onNewBlock, concurrencyLimit, bufferLimit, stateId) {
+  let nextQuery = FetchState.getNextQuery(fetchState, concurrencyLimit, bufferLimit);
   if (typeof nextQuery !== "object") {
     switch (nextQuery) {
       case "WaitingForNewBlock" :
@@ -680,6 +682,7 @@ export {
   getSourceRole,
   make,
   getActiveSource,
+  inFlightCount,
   onReorg,
   fetchNext,
   waitForNewBlock,

package/src/sources/SourceManager.resi

@@ -10,7 +10,6 @@ let getSourceRole: (
 
 let make: (
   ~sources: array<Source.t>,
-  ~maxPartitionConcurrency: int,
   ~isRealtime: bool,
   ~newBlockStallTimeout: int=?,
   ~newBlockStallTimeoutRealtime: int=?,
@@ -22,6 +21,8 @@ let make: (
 
 let getActiveSource: t => Source.t
 
+let inFlightCount: t => int
+
 let onReorg: (t, ~rollbackTargetBlock: int) => unit
 
 let fetchNext: (
@@ -30,6 +31,8 @@ let fetchNext: (
   ~executeQuery: FetchState.query => promise<unit>,
   ~waitForNewBlock: (~knownHeight: int) => promise<int>,
   ~onNewBlock: (~knownHeight: int) => unit,
+  ~concurrencyLimit: int,
+  ~bufferLimit: int,
   ~stateId: int,
 ) => promise<unit>
 

package/src/sources/Svm.res

@@ -4,7 +4,7 @@ let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.time
   }`)
 
-let ecosystem: Ecosystem.t = {
+let make = (~logger: Pino.t): Ecosystem.t => {
   name: Svm,
   blockFields: ["slot"],
   transactionFields: [],
@@ -19,6 +19,23 @@ let ecosystem: Ecosystem.t = {
   // SVM has no event handlers, so there is no `onEvent` `where` value to
   // parse. The schema is a no-op object that always surfaces `None`.
   onEventBlockFilterSchema: S.object(_ => None),
+  logger,
+  toEvent: eventItem => eventItem.payload->Internal.payloadToEvent,
+  toEventLogger: eventItem => {
+    let instruction =
+      eventItem.payload->(Utils.magic: Internal.eventPayload => Envio.svmInstruction)
+    Logging.createChildFrom(
+      ~logger,
+      ~params={
+        "program": eventItem.eventConfig.contractName,
+        "instruction": eventItem.eventConfig.name,
+        "chainId": eventItem.chain->ChainMap.Chain.toChainId,
+        "slot": eventItem.blockNumber,
+        "programId": instruction.programId,
+      },
+    )
+  },
+  toRawEvent: _ => JsError.throwWithMessage("Raw events are not supported for SVM"),
 }
 
 module GetFinalizedSlot = {

package/src/sources/Svm.res.mjs

@@ -4,6 +4,7 @@ import * as Rpc from "./Rpc.res.mjs";
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
+import * as Logging from "../Logging.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -14,26 +15,33 @@ let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.time
   });
 
-let ecosystem_blockFields = ["slot"];
-
-let ecosystem_transactionFields = [];
-
-let ecosystem_onBlockFilterSchema = S$RescriptSchema.object(s => s.f("slot", S$RescriptSchema.option(S$RescriptSchema.unknown)));
-
-let ecosystem_onEventBlockFilterSchema = S$RescriptSchema.object(param => {});
-
-let ecosystem = {
-  name: "svm",
-  blockFields: ecosystem_blockFields,
-  transactionFields: ecosystem_transactionFields,
-  blockNumberName: "height",
-  blockTimestampName: "time",
-  blockHashName: "hash",
-  cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
-  onBlockMethodName: "onSlot",
-  onBlockFilterSchema: ecosystem_onBlockFilterSchema,
-  onEventBlockFilterSchema: ecosystem_onEventBlockFilterSchema
-};
+function make(logger) {
+  return {
+    name: "svm",
+    blockFields: ["slot"],
+    transactionFields: [],
+    blockNumberName: "height",
+    blockTimestampName: "time",
+    blockHashName: "hash",
+    cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
+    onBlockMethodName: "onSlot",
+    onBlockFilterSchema: S$RescriptSchema.object(s => s.f("slot", S$RescriptSchema.option(S$RescriptSchema.unknown))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(param => {}),
+    logger: logger,
+    toEvent: eventItem => eventItem.payload,
+    toEventLogger: eventItem => {
+      let instruction = eventItem.payload;
+      return Logging.createChildFrom(logger, {
+        program: eventItem.eventConfig.contractName,
+        instruction: eventItem.eventConfig.name,
+        chainId: eventItem.chain,
+        slot: eventItem.blockNumber,
+        programId: instruction.programId
+      });
+    },
+    toRawEvent: param => Stdlib_JsError.throwWithMessage("Raw events are not supported for SVM")
+  };
+}
 
 let route = Rpc.makeRpcRoute("getSlot", S$RescriptSchema.tuple(s => {
   s.tag(0, {
@@ -72,8 +80,8 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
 
 export {
   cleanUpRawEventFieldsInPlace,
-  ecosystem,
+  make,
   GetFinalizedSlot,
   makeRPCSource,
 }
-/* ecosystem Not a pure module */
+/* route Not a pure module */

package/src/sources/SvmHyperSyncSource.res

@@ -510,7 +510,7 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
             blockNumber: instr.slot,
             blockHash: "",
             logIndex: synthLogIndex(instr),
-            event: payload->(Utils.magic: Envio.svmInstruction => Internal.event),
+            payload: payload->(Utils.magic: Envio.svmInstruction => Internal.eventPayload),
           }),
         )
         ->ignore

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -420,7 +420,7 @@ function make(param) {
           blockNumber: instr.slot,
           blockHash: "",
           logIndex: synthLogIndex(instr),
-          event: payload
+          payload: payload
         });
       }
     });

package/src/tui/Tui.res

@@ -134,11 +134,11 @@ module App = {
   @react.component
   let make = (~getState) => {
     let stdoutColumns = Hooks.useStdoutColumns()
-    // GlobalState is mutated in place — passing the same ref to useState
+    // IndexerState is mutated in place — passing the same ref to useState
     // would bail out via Object.is and skip the re-render. Tick a counter
     // instead and read state freshly from getState() on every render.
     let (tick, setTick) = React.useState(() => 0)
-    let state: GlobalState.t = getState()
+    let state: IndexerState.t = getState()
 
     React.useEffect(() => {
       let intervalId = setInterval(() => {
@@ -153,18 +153,22 @@ module App = {
     }, [getState])
 
     let chains =
-      state.chainManager.chainFetchers
-      ->ChainMap.values
-      ->Array.map(cf => {
-        let {numEventsProcessed, fetchState} = cf
+      state
+      ->IndexerState.chainStates
+      ->Dict.valuesToArray
+      ->Array.map(cs => {
+        let numEventsProcessed = cs->ChainState.numEventsProcessed
+        let fetchState = cs->ChainState.fetchState
+        let committedProgressBlockNumber = cs->ChainState.committedProgressBlockNumber
+        let timestampCaughtUpToHeadOrEndblock = cs->ChainState.timestampCaughtUpToHeadOrEndblock
+        let sourceManager = cs->ChainState.sourceManager
         let latestFetchedBlockNumber = Pervasives.max(fetchState->FetchState.bufferBlockNumber, 0)
-        let hasProcessedToEndblock = cf->ChainFetcher.hasProcessedToEndblock
-        let knownHeight =
-          cf->ChainFetcher.hasProcessedToEndblock
-            ? cf.fetchState.endBlock->Option.getOr(cf.fetchState.knownHeight)
-            : cf.fetchState.knownHeight
+        let hasProcessedToEndblock = cs->ChainState.hasProcessedToEndblock
+        let knownHeight = hasProcessedToEndblock
+          ? fetchState.endBlock->Option.getOr(fetchState.knownHeight)
+          : fetchState.knownHeight
 
-        let firstEventBlock = cf.fetchState.firstEventBlock
+        let firstEventBlock = fetchState.firstEventBlock
         let progress: TuiData.progress = if hasProcessedToEndblock {
           // If the endblock has been reached then set the progress to synced.
           // if there's chains that have no events in the block range start->end,
@@ -172,25 +176,25 @@ module App = {
           // This ensures TUI still displays synced in this case
           Synced({
             firstEventBlockNumber: firstEventBlock->Option.getOr(0),
-            latestProcessedBlock: cf.committedProgressBlockNumber,
-            timestampCaughtUpToHeadOrEndblock: cf.timestampCaughtUpToHeadOrEndblock->Option.getOr(
+            latestProcessedBlock: committedProgressBlockNumber,
+            timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock->Option.getOr(
               Date.now()->Date.fromTime,
             ),
             numEventsProcessed,
           })
         } else {
-          switch (firstEventBlock, cf.timestampCaughtUpToHeadOrEndblock) {
+          switch (firstEventBlock, timestampCaughtUpToHeadOrEndblock) {
           | (Some(firstEventBlockNumber), Some(timestampCaughtUpToHeadOrEndblock)) =>
             Synced({
               firstEventBlockNumber,
-              latestProcessedBlock: cf.committedProgressBlockNumber,
+              latestProcessedBlock: committedProgressBlockNumber,
               timestampCaughtUpToHeadOrEndblock,
               numEventsProcessed,
             })
           | (Some(firstEventBlockNumber), None) =>
             Syncing({
               firstEventBlockNumber,
-              latestProcessedBlock: cf.committedProgressBlockNumber,
+              latestProcessedBlock: committedProgressBlockNumber,
               numEventsProcessed,
             })
           | (None, _) => SearchingForEvents
@@ -203,25 +207,23 @@ module App = {
             knownHeight,
             latestFetchedBlockNumber,
             eventsProcessed: numEventsProcessed,
-            chainId: cf.chainConfig.id->Int.toString,
-            progressBlock: cf.committedProgressBlockNumber < cf.fetchState.startBlock
-              ? Some(cf.fetchState.startBlock)
-              : Some(cf.committedProgressBlockNumber),
+            chainId: (cs->ChainState.chainConfig).id->Int.toString,
+            progressBlock: committedProgressBlockNumber < fetchState.startBlock
+              ? Some(fetchState.startBlock)
+              : Some(committedProgressBlockNumber),
             bufferBlock: Some(latestFetchedBlockNumber),
-            sourceBlock: Some(cf.fetchState.knownHeight),
-            firstEventBlockNumber: cf.fetchState.firstEventBlock,
-            startBlock: cf.fetchState.startBlock,
-            endBlock: cf.fetchState.endBlock,
-            poweredByHyperSync: (
-              cf.sourceManager->SourceManager.getActiveSource
-            ).poweredByHyperSync,
-            blockUnit: switch state.ctx.config.ecosystem.name {
+            sourceBlock: Some(fetchState.knownHeight),
+            firstEventBlockNumber: fetchState.firstEventBlock,
+            startBlock: fetchState.startBlock,
+            endBlock: fetchState.endBlock,
+            poweredByHyperSync: (sourceManager->SourceManager.getActiveSource).poweredByHyperSync,
+            blockUnit: switch (state->IndexerState.config).ecosystem.name {
             | Svm => "Slot"
             | Evm | Fuel => "Block"
             },
-            rateLimitTimeMs: cf.sourceManager->SourceManager.getRateLimitTimeMs,
-            isRateLimited: cf.sourceManager->SourceManager.isRateLimited,
-            rateLimitResetInMs: cf.sourceManager->SourceManager.getRateLimitResetInMs,
+            rateLimitTimeMs: sourceManager->SourceManager.getRateLimitTimeMs,
+            isRateLimited: sourceManager->SourceManager.isRateLimited,
+            rateLimitResetInMs: sourceManager->SourceManager.getRateLimitResetInMs,
           }: TuiData.chain
         )
       })
@@ -269,7 +271,7 @@ module App = {
         totalEventsProcessed
         eventsPerSecond={SyncETA.isIndexerFullySynced(chains) ? None : eventsPerSecond}
       />
-      <SyncETA chains indexerStartTime=state.indexerStartTime />
+      <SyncETA chains indexerStartTime={state->IndexerState.indexerStartTime} />
       {
         let maxRateLimitTimeMs =
           chains->Array.reduce(0., (acc, chain) => Pervasives.max(acc, chain.rateLimitTimeMs))
@@ -315,7 +317,7 @@ module App = {
           }
         }
       </Box>
-      {if state.ctx.config.isDev {
+      {if (state->IndexerState.config).isDev {
         <Box flexDirection={Row}>
           <Text> {"Dev Console: "->React.string} </Text>
           <Text color={Info} underline=true> {`${Env.envioAppUrl}/console`->React.string} </Text>
@@ -323,7 +325,7 @@ module App = {
       } else {
         React.null
       }}
-      {switch (state.ctx.config.storage.clickhouse, Env.ClickHouse.host()) {
+      {switch ((state->IndexerState.config).storage.clickhouse, Env.ClickHouse.host()) {
       | (true, Some(host)) =>
         <Box flexDirection={Row}>
           <Text> {"ClickHouse: "->React.string} </Text>
@@ -331,7 +333,7 @@ module App = {
         </Box>
       | _ => React.null
       }}
-      <Messages config=state.ctx.config />
+      <Messages config={state->IndexerState.config} />
     </Box>
   }
 }

package/src/tui/Tui.res.mjs

@@ -6,10 +6,10 @@ import * as Ink$1 from "ink";
 import * as React from "react";
 import * as SyncETA from "./components/SyncETA.res.mjs";
 import * as TuiData from "./components/TuiData.res.mjs";
-import * as ChainMap from "../ChainMap.res.mjs";
 import * as Messages from "./components/Messages.res.mjs";
+import * as ChainState from "../ChainState.res.mjs";
 import * as FetchState from "../FetchState.res.mjs";
-import * as ChainFetcher from "../ChainFetcher.res.mjs";
+import * as IndexerState from "../IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import InkBigText from "ink-big-text";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
@@ -207,47 +207,47 @@ function Tui$App(props) {
       clearInterval(intervalId);
     };
   }, [getState]);
-  let chains = ChainMap.values(state.chainManager.chainFetchers).map(cf => {
-    let numEventsProcessed = cf.numEventsProcessed;
-    let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(cf.fetchState), 0);
-    let hasProcessedToEndblock = ChainFetcher.hasProcessedToEndblock(cf);
-    let knownHeight = ChainFetcher.hasProcessedToEndblock(cf) ? Stdlib_Option.getOr(cf.fetchState.endBlock, cf.fetchState.knownHeight) : cf.fetchState.knownHeight;
-    let firstEventBlock = cf.fetchState.firstEventBlock;
-    let progress;
-    if (hasProcessedToEndblock) {
-      progress = {
+  let chains = Object.values(IndexerState.chainStates(state)).map(cs => {
+    let numEventsProcessed = ChainState.numEventsProcessed(cs);
+    let fetchState = ChainState.fetchState(cs);
+    let committedProgressBlockNumber = ChainState.committedProgressBlockNumber(cs);
+    let timestampCaughtUpToHeadOrEndblock = ChainState.timestampCaughtUpToHeadOrEndblock(cs);
+    let sourceManager = ChainState.sourceManager(cs);
+    let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(fetchState), 0);
+    let hasProcessedToEndblock = ChainState.hasProcessedToEndblock(cs);
+    let knownHeight = hasProcessedToEndblock ? Stdlib_Option.getOr(fetchState.endBlock, fetchState.knownHeight) : fetchState.knownHeight;
+    let firstEventBlock = fetchState.firstEventBlock;
+    let progress = hasProcessedToEndblock ? ({
         TAG: "Synced",
         _0: {
           firstEventBlockNumber: Stdlib_Option.getOr(firstEventBlock, 0),
-          latestProcessedBlock: cf.committedProgressBlockNumber,
+          latestProcessedBlock: committedProgressBlockNumber,
           numEventsProcessed: numEventsProcessed,
-          timestampCaughtUpToHeadOrEndblock: Stdlib_Option.getOr(cf.timestampCaughtUpToHeadOrEndblock, new Date(Date.now()))
+          timestampCaughtUpToHeadOrEndblock: Stdlib_Option.getOr(timestampCaughtUpToHeadOrEndblock, new Date(Date.now()))
         }
-      };
-    } else {
-      let match = cf.timestampCaughtUpToHeadOrEndblock;
-      progress = firstEventBlock !== undefined ? (
-          match !== undefined ? ({
-              TAG: "Synced",
-              _0: {
-                firstEventBlockNumber: firstEventBlock,
-                latestProcessedBlock: cf.committedProgressBlockNumber,
-                numEventsProcessed: numEventsProcessed,
-                timestampCaughtUpToHeadOrEndblock: match
-              }
-            }) : ({
-              TAG: "Syncing",
-              _0: {
-                firstEventBlockNumber: firstEventBlock,
-                latestProcessedBlock: cf.committedProgressBlockNumber,
-                numEventsProcessed: numEventsProcessed
-              }
-            })
-        ) : "SearchingForEvents";
-    }
-    let match$1 = state.ctx.config.ecosystem.name;
+      }) : (
+        firstEventBlock !== undefined ? (
+            timestampCaughtUpToHeadOrEndblock !== undefined ? ({
+                TAG: "Synced",
+                _0: {
+                  firstEventBlockNumber: firstEventBlock,
+                  latestProcessedBlock: committedProgressBlockNumber,
+                  numEventsProcessed: numEventsProcessed,
+                  timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock
+                }
+              }) : ({
+                TAG: "Syncing",
+                _0: {
+                  firstEventBlockNumber: firstEventBlock,
+                  latestProcessedBlock: committedProgressBlockNumber,
+                  numEventsProcessed: numEventsProcessed
+                }
+              })
+          ) : "SearchingForEvents"
+      );
+    let match = IndexerState.config(state).ecosystem.name;
     let tmp;
-    switch (match$1) {
+    switch (match) {
       case "evm" :
       case "fuel" :
         tmp = "Block";
@@ -257,22 +257,22 @@ function Tui$App(props) {
         break;
     }
     return {
-      chainId: cf.chainConfig.id.toString(),
+      chainId: ChainState.chainConfig(cs).id.toString(),
       eventsProcessed: numEventsProcessed,
-      progressBlock: cf.committedProgressBlockNumber < cf.fetchState.startBlock ? cf.fetchState.startBlock : cf.committedProgressBlockNumber,
+      progressBlock: committedProgressBlockNumber < fetchState.startBlock ? fetchState.startBlock : committedProgressBlockNumber,
       bufferBlock: latestFetchedBlockNumber,
-      sourceBlock: cf.fetchState.knownHeight,
-      startBlock: cf.fetchState.startBlock,
-      endBlock: cf.fetchState.endBlock,
-      firstEventBlockNumber: cf.fetchState.firstEventBlock,
-      poweredByHyperSync: SourceManager.getActiveSource(cf.sourceManager).poweredByHyperSync,
+      sourceBlock: fetchState.knownHeight,
+      startBlock: fetchState.startBlock,
+      endBlock: fetchState.endBlock,
+      firstEventBlockNumber: fetchState.firstEventBlock,
+      poweredByHyperSync: SourceManager.getActiveSource(sourceManager).poweredByHyperSync,
       progress: progress,
       latestFetchedBlockNumber: latestFetchedBlockNumber,
       knownHeight: knownHeight,
       blockUnit: tmp,
-      rateLimitTimeMs: SourceManager.getRateLimitTimeMs(cf.sourceManager),
-      isRateLimited: SourceManager.isRateLimited(cf.sourceManager),
-      rateLimitResetInMs: SourceManager.getRateLimitResetInMs(cf.sourceManager)
+      rateLimitTimeMs: SourceManager.getRateLimitTimeMs(sourceManager),
+      isRateLimited: SourceManager.isRateLimited(sourceManager),
+      rateLimitResetInMs: SourceManager.getRateLimitResetInMs(sourceManager)
     };
   });
   let totalEventsProcessed = Stdlib_Array.reduce(chains, 0, (acc, chain) => acc + chain.eventsProcessed);
@@ -329,7 +329,7 @@ function Tui$App(props) {
     tmp = null;
   }
   let defaultPassword = "testing";
-  let match$1 = state.ctx.config.storage.clickhouse;
+  let match$1 = IndexerState.config(state).storage.clickhouse;
   let match$2 = Env.ClickHouse.host();
   return JsxRuntime.jsxs(Ink$1.Box, {
     children: [
@@ -362,7 +362,7 @@ function Tui$App(props) {
       }),
       JsxRuntime.jsx(SyncETA.make, {
         chains: chains,
-        indexerStartTime: state.indexerStartTime
+        indexerStartTime: IndexerState.indexerStartTime(state)
       }),
       tmp,
       JsxRuntime.jsx(Ink.Newline.make, {}),
@@ -383,7 +383,7 @@ function Tui$App(props) {
         ],
         flexDirection: "row"
       }),
-      state.ctx.config.isDev ? JsxRuntime.jsxs(Ink$1.Box, {
+      IndexerState.config(state).isDev ? JsxRuntime.jsxs(Ink$1.Box, {
           children: [
             JsxRuntime.jsx(Ink$1.Text, {
               children: "Dev Console: "
@@ -410,7 +410,7 @@ function Tui$App(props) {
           flexDirection: "row"
         }) : null,
       JsxRuntime.jsx(Messages.make, {
-        config: state.ctx.config
+        config: IndexerState.config(state)
       })
     ],
     flexDirection: "column"