envio 3.3.0-alpha.1 → 3.3.0-alpha.3

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
 import * as EventRouter from "./EventRouter.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -166,7 +166,7 @@ function parseDecoded(d) {
   };
 }
 
-function toSvmInstruction(instr, programName, instructionName, transaction, logs, block) {
+function toSvmInstruction(instr, programName, instructionName, logs, block) {
   return {
     programName: programName,
     instructionName: instructionName,
@@ -180,40 +180,15 @@ function toSvmInstruction(instr, programName, instructionName, transaction, logs
     d4: instr.d4,
     d8: instr.d8,
     params: Stdlib_Option.map(instr.decoded, parseDecoded),
-    transaction: transaction,
     logs: logs,
     block: block
   };
 }
 
-function toSvmTransaction(tx) {
-  return {
-    signatures: tx.signatures,
-    feePayer: Stdlib_Option.map(tx.feePayer, prim => prim),
-    success: tx.success,
-    err: tx.err,
-    fee: Stdlib_Option.map(tx.fee, prim => BigInt(prim)),
-    computeUnitsConsumed: Stdlib_Option.map(tx.computeUnitsConsumed, prim => BigInt(prim)),
-    accountKeys: tx.accountKeys,
-    recentBlockhash: tx.recentBlockhash,
-    version: tx.version
-  };
-}
-
-function toSvmTokenBalance(tb) {
-  return {
-    account: Stdlib_Option.map(tb.account, prim => prim),
-    mint: Stdlib_Option.map(tb.mint, prim => prim),
-    owner: Stdlib_Option.map(tb.owner, prim => prim),
-    preAmount: tb.preAmount,
-    postAmount: tb.postAmount
-  };
-}
-
-function probeRouter(router, programId, instr, byteLengthsDesc, contractAddress, indexingAddresses) {
+function probeRouter(router, programId, instr, byteLengthsDesc, contractAddress, contractNameByAddress) {
   let probe = dN => {
     let tag = EventRouter.getSvmEventId(programId, dN);
-    return EventRouter.get(router, tag, contractAddress, instr.slot, indexingAddresses);
+    return EventRouter.get(router, tag, contractAddress, contractNameByAddress);
   };
   let result = Stdlib_Array.reduce(byteLengthsDesc, undefined, (acc, len) => {
     if (acc !== undefined) {
@@ -247,6 +222,32 @@ function probeRouter(router, programId, instr, byteLengthsDesc, contractAddress,
   }
 }
 
+function toQueryTxField(field) {
+  switch (field) {
+    case "signatures" :
+      return "signatures";
+    case "feePayer" :
+      return "fee_payer";
+    case "success" :
+      return "success";
+    case "err" :
+      return "err";
+    case "fee" :
+      return "fee";
+    case "computeUnitsConsumed" :
+      return "compute_units_consumed";
+    case "accountKeys" :
+      return "account_keys";
+    case "recentBlockhash" :
+      return "recent_blockhash";
+    case "version" :
+      return "version";
+    case "transactionIndex" :
+    case "tokenBalances" :
+      return;
+  }
+}
+
 function make(param) {
   let eventConfigs = param.eventConfigs;
   let chain = param.chain;
@@ -259,31 +260,44 @@ function make(param) {
   match[1].forEach(o => {
     orderingByProgram[o.programId] = o.byteLengthsDesc;
   });
-  let needsTransactions = eventConfigs.some(cfg => cfg.includeTransaction);
   let needsLogs = eventConfigs.some(cfg => cfg.includeLogs);
-  let needsTokenBalances = eventConfigs.some(cfg => cfg.includeTokenBalances);
-  let getItemsOrThrow = async (fromBlock, toBlock, param, indexingAddresses, knownHeight, param$1, param$2, retry, logger) => {
-    let totalTimeRef = Hrtime.makeTimer();
-    let pageFetchRef = Hrtime.makeTimer();
+  let selectedTxFields = new Set();
+  eventConfigs.forEach(cfg => {
+    cfg.selectedTransactionFields.forEach(field => {
+      selectedTxFields.add(field);
+    });
+  });
+  let needsTokenBalances = selectedTxFields.has("tokenBalances");
+  let fields = [
+    "slot",
+    "transaction_index"
+  ];
+  Array.from(selectedTxFields).forEach(field => {
+    let queryField = toQueryTxField(field);
+    if (queryField !== undefined) {
+      fields.push(queryField);
+      return;
+    }
+  });
+  let needsTransactions = Array.from(selectedTxFields).some(field => {
+    switch (field) {
+      case "transactionIndex" :
+      case "tokenBalances" :
+        return false;
+      default:
+        return true;
+    }
+  });
+  let getItemsOrThrow = async (fromBlock, toBlock, param, contractNameByAddress, knownHeight, param$1, param$2, retry, logger) => {
+    let totalTimeRef = Performance.now();
+    let pageFetchRef = Performance.now();
     let instructionSelections = buildInstructionSelections(eventConfigs);
     let fields_block = [
       "slot",
       "blockhash",
       "block_time"
     ];
-    let fields_transaction = needsTransactions ? [
-        "slot",
-        "transaction_index",
-        "signatures",
-        "fee_payer",
-        "success",
-        "err",
-        "fee",
-        "compute_units_consumed",
-        "account_keys",
-        "recent_blockhash",
-        "version"
-      ] : undefined;
+    let fields_transaction = needsTransactions ? fields : undefined;
     let fields_log = needsLogs ? [
         "slot",
         "transaction_index",
@@ -300,7 +314,7 @@ function make(param) {
         "pre_amount",
         "post_amount"
       ] : undefined;
-    let fields = {
+    let fields$1 = {
       block: fields_block,
       transaction: fields_transaction,
       log: fields_log,
@@ -308,7 +322,7 @@ function make(param) {
     };
     let query_toSlot = Stdlib_Option.map(toBlock, toBlock => toBlock + 1 | 0);
     let query_instructions = instructionSelections;
-    let query_fields = fields;
+    let query_fields = fields$1;
     let query = {
       fromSlot: fromBlock,
       toSlot: query_toSlot,
@@ -316,9 +330,9 @@ function make(param) {
       fields: query_fields
     };
     Prometheus.SourceRequestCount.increment(name, chain, "getInstructions");
-    let resp;
+    let match;
     try {
-      resp = await client.get(query);
+      match = await client.get(query);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {
@@ -336,8 +350,9 @@ function make(param) {
         Error: new Error()
       };
     }
-    let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(pageFetchRef));
-    let parsingRef = Hrtime.makeTimer();
+    let resp = match[0];
+    let pageFetchTime = Performance.secondsSince(pageFetchRef);
+    let parsingRef = Performance.now();
     let blockTimeBySlot = {};
     resp.data.blocks.forEach(b => {
       let t = b.blockTime;
@@ -346,11 +361,6 @@ function make(param) {
         return;
       }
     });
-    let txByKey = {};
-    resp.data.transactions.forEach(tx => {
-      let key = tx.slot.toString() + ":" + tx.transactionIndex.toString();
-      txByKey[key] = tx;
-    });
     let logsByKey = {};
     resp.data.logs.forEach(log => {
       let match = log.transactionIndex;
@@ -369,37 +379,13 @@ function make(param) {
         logsByKey[key] = [log];
       }
     });
-    let tokenBalancesByTx = {};
-    if (needsTokenBalances) {
-      resp.data.tokenBalances.forEach(tb => {
-        let txIdx = tb.transactionIndex;
-        if (txIdx === undefined) {
-          return;
-        }
-        let key = tb.slot.toString() + ":" + txIdx.toString();
-        let existing = tokenBalancesByTx[key];
-        if (existing !== undefined) {
-          existing.push(tb);
-        } else {
-          tokenBalancesByTx[key] = [tb];
-        }
-      });
-    }
     let parsedQueueItems = [];
     resp.data.instructions.forEach(instr => {
       let programId = instr.programId;
       let byteLengths = Stdlib_Option.getOr(orderingByProgram[instr.programId], []);
       let contractAddress = instr.programId;
-      let maybeConfig = probeRouter(eventRouter, programId, instr, byteLengths, contractAddress, indexingAddresses);
+      let maybeConfig = probeRouter(eventRouter, programId, instr, byteLengths, contractAddress, contractNameByAddress);
       if (maybeConfig !== undefined) {
-        let txKey = instr.slot.toString() + ":" + instr.transactionIndex.toString();
-        let maybeTx = Stdlib_Option.map(txByKey[txKey], toSvmTransaction);
-        let maybeTx$1 = maybeConfig.includeTokenBalances ? Stdlib_Option.map(maybeTx, tx => {
-            let maybeBalances = Stdlib_Option.map(tokenBalancesByTx[txKey], bals => bals.map(toSvmTokenBalance));
-            let newrecord = {...tx};
-            newrecord.tokenBalances = maybeBalances;
-            return newrecord;
-          }) : maybeTx;
         let logKey = instr.slot.toString() + ":" + instr.transactionIndex.toString() + ":" + serializeInstructionAddress(instr.instructionAddress);
         let maybeLogs = Stdlib_Option.map(logsByKey[logKey], logs => logs.map(log => ({
           kind: Stdlib_Option.getOr(log.kind, ""),
@@ -407,7 +393,7 @@ function make(param) {
         })));
         let slotKey = instr.slot.toString();
         let blockTime = blockTimeBySlot[slotKey];
-        let payload = toSvmInstruction(instr, maybeConfig.contractName, maybeConfig.name, maybeConfig.includeTransaction ? maybeTx$1 : undefined, maybeConfig.includeLogs ? maybeLogs : undefined, {
+        let payload = toSvmInstruction(instr, maybeConfig.contractName, maybeConfig.name, maybeConfig.includeLogs ? maybeLogs : undefined, {
           slot: instr.slot,
           time: Stdlib_Option.getOr(blockTime, 0),
           hash: ""
@@ -420,22 +406,24 @@ function make(param) {
           blockNumber: instr.slot,
           blockHash: "",
           logIndex: synthLogIndex(instr),
+          transactionIndex: instr.transactionIndex,
           payload: payload
         });
       }
     });
-    let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingRef));
+    let parsingTimeElapsed = Performance.secondsSince(parsingRef);
     let highestSlot = resp.nextSlot - 1 | 0;
     let latestBlockTime = Stdlib_Option.getOr(blockTimeBySlot[highestSlot.toString()], 0);
     let blockHashes = resp.data.blocks.map(b => ({
       blockHash: b.blockhash,
       blockNumber: b.slot
     }));
-    let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
+    let totalTimeElapsed = Performance.secondsSince(totalTimeRef);
     return {
       knownHeight: knownHeight,
       blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
+      transactionStore: Primitive_option.some(match[1]),
       fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: highestSlot,
       latestFetchedBlockTimestamp: latestBlockTime,
@@ -469,7 +457,8 @@ function make(param) {
         maxNumBlocks: query_maxNumBlocks
       };
       Prometheus.SourceRequestCount.increment(name, chain, "getBlockHashes");
-      let resp = await client.get(query);
+      let match = await client.get(query);
+      let resp = match[0];
       resp.data.blocks.forEach(b => {
         blockDatas.push({
           blockHash: b.blockhash,
@@ -531,9 +520,9 @@ function make(param) {
     pollingInterval: 1000,
     getBlockHashes: getBlockHashes,
     getHeightOrThrow: async () => {
-      let timer = Hrtime.makeTimer();
+      let timer = Performance.now();
       let h = await client.getHeight();
-      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timer));
+      let seconds = Performance.secondsSince(timer);
       Prometheus.SourceRequestCount.increment(name, chain, "getHeight");
       Prometheus.SourceRequestCount.addSeconds(name, chain, "getHeight", seconds);
       return h;
@@ -549,9 +538,8 @@ export {
   buildProgramSchemas,
   parseDecoded,
   toSvmInstruction,
-  toSvmTransaction,
-  toSvmTokenBalance,
   probeRouter,
+  toQueryTxField,
   make,
 }
 /* Prometheus Not a pure module */

package/src/sources/TransactionStore.res

@@ -0,0 +1,128 @@
+// Binding to the Rust `TransactionStore` napi class. Transactions are kept in
+// Rust as raw structs (their large fields never enter JS until read) keyed by
+// (blockNumber, transactionIndex). One store lives per chain on `ChainState`;
+// each fetch response contributes a page that is merged in. At batch
+// preparation the selected fields are materialised in bulk, off the JS thread,
+// in columnar form and zipped into plain JS objects on the main thread.
+type t
+
+@send external classNew: Core.transactionStoreCtor => t = "new"
+let make = (): t => Core.getAddon().transactionStore->classNew
+
+// Field-name → bit-index map from an ordered field-name array. The index is the
+// field code shared with the Rust store (`EvmTxField`/`SvmTxField`).
+let fieldCodes = (fields: array<string>): dict<int> => {
+  let codes = Dict.make()
+  fields->Array.forEachWithIndex((name, i) => codes->Dict.set(name, i))
+  codes
+}
+
+let pow2: int => float = %raw(`c => Math.pow(2, c)`)
+
+// Union of an ecosystem's selected transaction fields as a bitmask float (bit
+// `code` set ⇔ selected). Built arithmetically to dodge 32-bit JS bitwise ops.
+let mask = (eventConfigs: array<Internal.eventConfig>, ~codes: dict<int>): float => {
+  let selected = Utils.Set.make()
+  eventConfigs->Array.forEach(eventConfig =>
+    eventConfig.selectedTransactionFields->Utils.Set.forEach(name =>
+      switch codes->Utils.Dict.dangerouslyGetNonOption(name) {
+      | Some(code) => selected->Utils.Set.add(code)->ignore
+      | None => ()
+      }
+    )
+  )
+  selected->Utils.Set.toArray->Array.reduce(0., (mask, code) => mask +. pow2(code))
+}
+
+// Build an ecosystem's mask function from its ordered field-name array. The
+// field codes are derived once and closed over.
+let makeMaskFn = (fields: array<string>): (array<Internal.eventConfig> => float) => {
+  let codes = fieldCodes(fields)
+  eventConfigs => eventConfigs->mask(~codes)
+}
+
+// Drain another store (a fetch-response page) into this one.
+@send external merge: (t, t) => unit = "merge"
+
+// Bulk-materialise the fields selected by `mask` (one bit per field code) for
+// the given transactions, off the JS thread. Result is aligned with the input.
+@send
+external materialize: (
+  t,
+  ~blockNumbers: array<int>,
+  ~transactionIndices: array<int>,
+  ~mask: float,
+) => promise<array<Internal.eventTransaction>> = "materialize"
+
+// Drop transactions for blocks at or below the given block (already processed).
+@send external prune: (t, int) => unit = "prune"
+
+// Drop transactions for blocks above the given block (rolled back).
+@send external rollback: (t, int) => unit = "rollback"
+
+// Materialise the mask-selected fields for the store-backed items and write the
+// resulting transaction onto each item's payload. Items that already carry an
+// inline transaction (RPC/simulate/Fuel) are skipped. Store-backed items always
+// get a transaction object — the selected fields, or `{}` when the chain
+// selected none — so `event.transaction` is never `undefined` (matching the
+// inline sources). Deduped per (blockNumber, transactionIndex).
+let materializeItems = async (store: t, ~items: array<Internal.item>, ~mask: float) => {
+  if mask == 0. {
+    // No fields selected: there's nothing to decode and no reason to group by
+    // key, but each store-backed item still gets an empty transaction object so
+    // `event.transaction` is never undefined (matching the inline sources).
+    items->Array.forEach(item =>
+      switch item {
+      | Internal.Event(_) =>
+        let payload = (item->Internal.castUnsafeEventItem).payload
+        switch payload->Internal.getPayloadTransaction->Nullable.toOption {
+        | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
+        | None => payload->Internal.setPayloadTransaction(%raw(`{}`))
+        }
+      | Internal.Block(_) => ()
+      }
+    )
+  } else {
+    // Store-backed items arrive in (block, logIndex) order, and a transaction's
+    // logs are contiguous within a block, so events sharing a (blockNumber,
+    // transactionIndex) are adjacent. Group them by extending the current run
+    // rather than hashing a string key per item. A key recurring non-adjacently
+    // just splits into two groups (one redundant decode) — never incorrect.
+    let blockNumbers = []
+    let transactionIndices = []
+    let payloadGroups = []
+
+    items->Array.forEach(item =>
+      switch item {
+      | Internal.Event(_) =>
+        let eventItem = item->Internal.castUnsafeEventItem
+        switch eventItem.payload->Internal.getPayloadTransaction->Nullable.toOption {
+        | Some(_) => () // RPC/simulate/Fuel carry the transaction inline.
+        | None =>
+          let {blockNumber, transactionIndex} = eventItem
+          let last = payloadGroups->Array.length - 1
+          if (
+            last >= 0 &&
+            blockNumbers->Array.getUnsafe(last) == blockNumber &&
+            transactionIndices->Array.getUnsafe(last) == transactionIndex
+          ) {
+            payloadGroups->Array.getUnsafe(last)->Array.push(eventItem.payload)
+          } else {
+            blockNumbers->Array.push(blockNumber)
+            transactionIndices->Array.push(transactionIndex)
+            payloadGroups->Array.push([eventItem.payload])
+          }
+        }
+      | Internal.Block(_) => ()
+      }
+    )
+
+    if payloadGroups->Utils.Array.notEmpty {
+      let txs = await store->materialize(~blockNumbers, ~transactionIndices, ~mask)
+      payloadGroups->Array.forEachWithIndex((payloads, i) => {
+        let tx = txs->Array.getUnsafe(i)
+        payloads->Array.forEach(payload => payload->Internal.setPayloadTransaction(tx))
+      })
+    }
+  }
+}

package/src/sources/TransactionStore.res.mjs

@@ -0,0 +1,97 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as Utils from "../Utils.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+
+function make() {
+  return Core.getAddon().TransactionStore.new();
+}
+
+function fieldCodes(fields) {
+  let codes = {};
+  fields.forEach((name, i) => {
+    codes[name] = i;
+  });
+  return codes;
+}
+
+let pow2 = (c => Math.pow(2, c));
+
+function mask(eventConfigs, codes) {
+  let selected = new Set();
+  eventConfigs.forEach(eventConfig => {
+    eventConfig.selectedTransactionFields.forEach(name => {
+      let code = codes[name];
+      if (code !== undefined) {
+        selected.add(code);
+        return;
+      }
+    });
+  });
+  return Stdlib_Array.reduce(Array.from(selected), 0, (mask, code) => mask + pow2(code));
+}
+
+function makeMaskFn(fields) {
+  let codes = fieldCodes(fields);
+  return eventConfigs => mask(eventConfigs, codes);
+}
+
+async function materializeItems(store, items, mask) {
+  if (mask === 0) {
+    items.forEach(item => {
+      if (item.kind !== 0) {
+        return;
+      }
+      let payload = item.payload;
+      let match = payload.transaction;
+      if (match == null) {
+        payload.transaction = {};
+        return;
+      }
+    });
+    return;
+  }
+  let blockNumbers = [];
+  let transactionIndices = [];
+  let payloadGroups = [];
+  items.forEach(item => {
+    if (item.kind !== 0) {
+      return;
+    }
+    let match = item.payload.transaction;
+    if (!(match == null)) {
+      return;
+    }
+    let transactionIndex = item.transactionIndex;
+    let blockNumber = item.blockNumber;
+    let last = payloadGroups.length - 1 | 0;
+    if (last >= 0 && blockNumbers[last] === blockNumber && transactionIndices[last] === transactionIndex) {
+      payloadGroups[last].push(item.payload);
+    } else {
+      blockNumbers.push(blockNumber);
+      transactionIndices.push(transactionIndex);
+      payloadGroups.push([item.payload]);
+    }
+  });
+  if (!Utils.$$Array.notEmpty(payloadGroups)) {
+    return;
+  }
+  let txs = await store.materialize(blockNumbers, transactionIndices, mask);
+  payloadGroups.forEach((payloads, i) => {
+    let tx = txs[i];
+    payloads.forEach(payload => {
+      payload.transaction = tx;
+    });
+  });
+}
+
+export {
+  make,
+  fieldCodes,
+  pow2,
+  mask,
+  makeMaskFn,
+  materializeItems,
+}
+/* Core Not a pure module */

package/src/tui/Tui.res

@@ -157,18 +157,15 @@ module App = {
       ->IndexerState.chainStates
       ->Dict.valuesToArray
       ->Array.map(cs => {
-        let numEventsProcessed = cs->ChainState.numEventsProcessed
-        let fetchState = cs->ChainState.fetchState
+        let data = cs->ChainState.toChainData
+        let numEventsProcessed = data.numEventsProcessed
         let committedProgressBlockNumber = cs->ChainState.committedProgressBlockNumber
-        let timestampCaughtUpToHeadOrEndblock = cs->ChainState.timestampCaughtUpToHeadOrEndblock
+        let timestampCaughtUpToHeadOrEndblock = data.timestampCaughtUpToHeadOrEndblock
         let sourceManager = cs->ChainState.sourceManager
-        let latestFetchedBlockNumber = Pervasives.max(fetchState->FetchState.bufferBlockNumber, 0)
+        let latestFetchedBlockNumber = data.latestFetchedBlockNumber
         let hasProcessedToEndblock = cs->ChainState.hasProcessedToEndblock
-        let knownHeight = hasProcessedToEndblock
-          ? fetchState.endBlock->Option.getOr(fetchState.knownHeight)
-          : fetchState.knownHeight
 
-        let firstEventBlock = fetchState.firstEventBlock
+        let firstEventBlock = data.firstEventBlockNumber
         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,
@@ -204,19 +201,19 @@ module App = {
         (
           {
             progress,
-            knownHeight,
+            knownHeight: data.knownHeight,
             latestFetchedBlockNumber,
             eventsProcessed: numEventsProcessed,
             chainId: (cs->ChainState.chainConfig).id->Int.toString,
-            progressBlock: committedProgressBlockNumber < fetchState.startBlock
-              ? Some(fetchState.startBlock)
+            progressBlock: committedProgressBlockNumber < data.startBlock
+              ? Some(data.startBlock)
               : Some(committedProgressBlockNumber),
             bufferBlock: Some(latestFetchedBlockNumber),
-            sourceBlock: Some(fetchState.knownHeight),
-            firstEventBlockNumber: fetchState.firstEventBlock,
-            startBlock: fetchState.startBlock,
-            endBlock: fetchState.endBlock,
-            poweredByHyperSync: (sourceManager->SourceManager.getActiveSource).poweredByHyperSync,
+            sourceBlock: Some(cs->ChainState.knownHeight),
+            firstEventBlockNumber: firstEventBlock,
+            startBlock: data.startBlock,
+            endBlock: data.endBlock,
+            poweredByHyperSync: data.poweredByHyperSync,
             blockUnit: switch (state->IndexerState.config).ecosystem.name {
             | Svm => "Slot"
             | Evm | Fuel => "Block"

package/src/tui/Tui.res.mjs

@@ -8,7 +8,6 @@ import * as SyncETA from "./components/SyncETA.res.mjs";
 import * as TuiData from "./components/TuiData.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 IndexerState from "../IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import InkBigText from "ink-big-text";
@@ -208,15 +207,14 @@ function Tui$App(props) {
     };
   }, [getState]);
   let chains = Object.values(IndexerState.chainStates(state)).map(cs => {
-    let numEventsProcessed = ChainState.numEventsProcessed(cs);
-    let fetchState = ChainState.fetchState(cs);
+    let data = ChainState.toChainData(cs);
+    let numEventsProcessed = data.numEventsProcessed;
     let committedProgressBlockNumber = ChainState.committedProgressBlockNumber(cs);
-    let timestampCaughtUpToHeadOrEndblock = ChainState.timestampCaughtUpToHeadOrEndblock(cs);
+    let timestampCaughtUpToHeadOrEndblock = data.timestampCaughtUpToHeadOrEndblock;
     let sourceManager = ChainState.sourceManager(cs);
-    let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(fetchState), 0);
+    let latestFetchedBlockNumber = data.latestFetchedBlockNumber;
     let hasProcessedToEndblock = ChainState.hasProcessedToEndblock(cs);
-    let knownHeight = hasProcessedToEndblock ? Stdlib_Option.getOr(fetchState.endBlock, fetchState.knownHeight) : fetchState.knownHeight;
-    let firstEventBlock = fetchState.firstEventBlock;
+    let firstEventBlock = data.firstEventBlockNumber;
     let progress = hasProcessedToEndblock ? ({
         TAG: "Synced",
         _0: {
@@ -259,16 +257,16 @@ function Tui$App(props) {
     return {
       chainId: ChainState.chainConfig(cs).id.toString(),
       eventsProcessed: numEventsProcessed,
-      progressBlock: committedProgressBlockNumber < fetchState.startBlock ? fetchState.startBlock : committedProgressBlockNumber,
+      progressBlock: committedProgressBlockNumber < data.startBlock ? data.startBlock : committedProgressBlockNumber,
       bufferBlock: latestFetchedBlockNumber,
-      sourceBlock: fetchState.knownHeight,
-      startBlock: fetchState.startBlock,
-      endBlock: fetchState.endBlock,
-      firstEventBlockNumber: fetchState.firstEventBlock,
-      poweredByHyperSync: SourceManager.getActiveSource(sourceManager).poweredByHyperSync,
+      sourceBlock: ChainState.knownHeight(cs),
+      startBlock: data.startBlock,
+      endBlock: data.endBlock,
+      firstEventBlockNumber: firstEventBlock,
+      poweredByHyperSync: data.poweredByHyperSync,
       progress: progress,
       latestFetchedBlockNumber: latestFetchedBlockNumber,
-      knownHeight: knownHeight,
+      knownHeight: data.currentBlockHeight,
       blockUnit: tmp,
       rateLimitTimeMs: SourceManager.getRateLimitTimeMs(sourceManager),
       isRateLimited: SourceManager.isRateLimited(sourceManager),