envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -1,9 +1,8 @@
 // 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 +165,7 @@ function parseDecoded(d) {
   };
 }
 
-function toSvmInstruction(instr, programName, instructionName, transaction, logs, block) {
+function toSvmInstruction(instr, programName, instructionName, logs) {
   return {
     programName: programName,
     instructionName: instructionName,
@@ -180,40 +179,14 @@ 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
+    logs: logs
   };
 }
 
-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,43 +220,109 @@ 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 toQueryBlockField(field) {
+  switch (field) {
+    case "height" :
+      return "block_height";
+    case "parentSlot" :
+      return "parent_slot";
+    case "parentHash" :
+      return "parent_blockhash";
+    default:
+      return;
+  }
+}
+
 function make(param) {
-  let eventConfigs = param.eventConfigs;
+  let onEventRegistrations = param.onEventRegistrations;
   let chain = param.chain;
-  let name = "SvmHyperSync";
+  let eventConfigs = onEventRegistrations.map(reg => reg.eventConfig);
   let programSchemas = buildProgramSchemas(eventConfigs);
   let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, programSchemas.length !== 0 ? programSchemas : undefined);
-  let match = EventRouter.fromSvmEventConfigsOrThrow(eventConfigs, chain);
+  let match = EventRouter.fromSvmEventConfigsOrThrow(onEventRegistrations, chain);
   let eventRouter = match[0];
   let orderingByProgram = {};
   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 fields$1 = [
+    "slot",
+    "blockhash",
+    "block_time"
+  ];
+  let selected = new Set();
+  eventConfigs.forEach(cfg => {
+    cfg.selectedBlockFields.forEach(field => {
+      selected.add(field);
+    });
+  });
+  selected.forEach(field => {
+    let queryField = toQueryBlockField(field);
+    if (queryField !== undefined) {
+      fields$1.push(queryField);
+      return;
+    }
+  });
+  let getItemsOrThrow = async (fromBlock, toBlock, param, contractNameByAddress, knownHeight, param$1, param$2, itemsTarget, 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_block = fields$1;
+    let fields_transaction = needsTransactions ? fields : undefined;
     let fields_log = needsLogs ? [
         "slot",
         "transaction_index",
@@ -300,7 +339,7 @@ function make(param) {
         "pre_amount",
         "post_amount"
       ] : undefined;
-    let fields = {
+    let fields$2 = {
       block: fields_block,
       transaction: fields_transaction,
       log: fields_log,
@@ -308,17 +347,18 @@ 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$2;
+    let query_maxNumInstructions = itemsTarget;
     let query = {
       fromSlot: fromBlock,
       toSlot: query_toSlot,
       instructions: query_instructions,
-      fields: query_fields
+      fields: query_fields,
+      maxNumInstructions: query_maxNumInstructions
     };
-    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 +376,13 @@ 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 requestStats = [{
+        method: "getInstructions",
+        seconds: pageFetchTime
+      }];
+    let parsingRef = Performance.now();
     let blockTimeBySlot = {};
     resp.data.blocks.forEach(b => {
       let t = b.blockTime;
@@ -346,11 +391,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,73 +409,45 @@ 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 eventConfig = maybeConfig.eventConfig;
         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, ""),
           message: Stdlib_Option.getOr(log.message, "")
         })));
-        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, {
-          slot: instr.slot,
-          time: Stdlib_Option.getOr(blockTime, 0),
-          hash: ""
-        });
+        let payload = toSvmInstruction(instr, eventConfig.contractName, eventConfig.name, eventConfig.includeLogs ? maybeLogs : undefined);
         parsedQueueItems.push({
           kind: 0,
-          eventConfig: maybeConfig,
-          timestamp: Stdlib_Option.getOr(blockTime, 0),
+          onEventRegistration: maybeConfig,
           chain: chain,
           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]),
+      blockStore: Primitive_option.some(match[2]),
       fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: highestSlot,
       latestFetchedBlockTimestamp: latestBlockTime,
@@ -443,11 +455,13 @@ function make(param) {
         "total time elapsed (s)": totalTimeElapsed,
         "parsing time (s)": parsingTimeElapsed,
         "page fetch time (s)": pageFetchTime
-      }
+      },
+      requestStats: requestStats
     };
   };
   let queryBlockDataRange = async (fromSlot, toSlot) => {
     let blockDatas = [];
+    let requestStats = [];
     let fromRef = fromSlot;
     let keepGoing = true;
     while (keepGoing) {
@@ -468,8 +482,13 @@ function make(param) {
         fields: query_fields,
         maxNumBlocks: query_maxNumBlocks
       };
-      Prometheus.SourceRequestCount.increment(name, chain, "getBlockHashes");
-      let resp = await client.get(query);
+      let timerRef = Performance.now();
+      let match = await client.get(query);
+      let resp = match[0];
+      requestStats.push({
+        method: "getBlockHashes",
+        seconds: Performance.secondsSince(timerRef)
+      });
       resp.data.blocks.forEach(b => {
         blockDatas.push({
           blockHash: b.blockhash,
@@ -483,14 +502,20 @@ function make(param) {
         fromRef = resp.nextSlot;
       }
     };
-    return blockDatas;
+    return [
+      blockDatas,
+      requestStats
+    ];
   };
   let getBlockHashes = async (blockNumbers, param) => {
     let firstSlot = blockNumbers[0];
     if (firstSlot === undefined) {
       return {
-        TAG: "Ok",
-        _0: []
+        result: {
+          TAG: "Ok",
+          _0: []
+        },
+        requestStats: []
       };
     }
     try {
@@ -510,33 +535,43 @@ function make(param) {
         }
         requested.add(slot);
       });
-      let blockDatas = await queryBlockDataRange(minSlot.contents, maxSlot.contents);
+      let match = await queryBlockDataRange(minSlot.contents, maxSlot.contents);
       return {
-        TAG: "Ok",
-        _0: blockDatas.filter(data => requested.delete(data.blockNumber))
+        result: {
+          TAG: "Ok",
+          _0: match[0].filter(data => requested.delete(data.blockNumber))
+        },
+        requestStats: match[1]
       };
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       return {
-        TAG: "Error",
-        _0: exn
+        result: {
+          TAG: "Error",
+          _0: exn
+        },
+        requestStats: []
       };
     }
   };
   return {
-    name: name,
+    name: "SvmHyperSync",
     sourceFor: "Sync",
     chain: chain,
     poweredByHyperSync: true,
     pollingInterval: 1000,
     getBlockHashes: getBlockHashes,
     getHeightOrThrow: async () => {
-      let timer = Hrtime.makeTimer();
-      let h = await client.getHeight();
-      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timer));
-      Prometheus.SourceRequestCount.increment(name, chain, "getHeight");
-      Prometheus.SourceRequestCount.addSeconds(name, chain, "getHeight", seconds);
-      return h;
+      let timer = Performance.now();
+      let height = await client.getHeight();
+      let seconds = Performance.secondsSince(timer);
+      return {
+        height: height,
+        requestStats: [{
+            method: "getHeight",
+            seconds: seconds
+          }]
+      };
     },
     getItemsOrThrow: getItemsOrThrow
   };
@@ -549,9 +584,9 @@ export {
   buildProgramSchemas,
   parseDecoded,
   toSvmInstruction,
-  toSvmTransaction,
-  toSvmTokenBalance,
   probeRouter,
+  toQueryTxField,
+  toQueryBlockField,
   make,
 }
-/* Prometheus Not a pure module */
+/* EventRouter Not a pure module */

package/src/sources/TransactionStore.res

@@ -0,0 +1,49 @@
+// 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 newEvm: (Core.transactionStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
+@send external newSvm: Core.transactionStoreCtor => t = "newSvm"
+@send external newFuel: Core.transactionStoreCtor => t = "newFuel"
+
+// The store's ecosystem is fixed here, from the chain's config. EVM carries the
+// chain's address-checksumming setting; SVM/Fuel need no extra data.
+let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
+  let ctor = Core.getAddon().transactionStore
+  switch ecosystem {
+  | Evm => ctor->newEvm(~shouldChecksum)
+  | Svm => ctor->newSvm
+  | Fuel => ctor->newFuel
+  }
+}
+
+// One event's selected transaction fields → store selection bitmask, built from
+// the ecosystem's ordered field-name array (the bit index is the field code
+// shared with the Rust store, `EvmTxField`/`SvmTxField`).
+let makeMaskFn = FieldMask.makeMaskFn
+let orMask = FieldMask.orMask
+let fieldCodes = FieldMask.fieldCodes
+
+// Drain another store (a fetch-response page) into this one.
+@send external merge: (t, t) => unit = "merge"
+
+// Bulk-materialise transactions off the JS thread, one row per
+// (blockNumbers[i], transactionIndices[i]) key, decoding only the fields set in
+// that row's own masks[i]. Result is aligned with the input.
+@send
+external materialize: (
+  t,
+  ~blockNumbers: array<int>,
+  ~transactionIndices: array<int>,
+  ~masks: array<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"

package/src/sources/TransactionStore.res.mjs

@@ -0,0 +1,30 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as FieldMask from "./FieldMask.res.mjs";
+
+function make(ecosystem, shouldChecksum) {
+  let ctor = Core.getAddon().TransactionStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum);
+    case "fuel" :
+      return ctor.newFuel();
+    case "svm" :
+      return ctor.newSvm();
+  }
+}
+
+let makeMaskFn = FieldMask.makeMaskFn;
+
+let orMask = FieldMask.orMask;
+
+let fieldCodes = FieldMask.fieldCodes;
+
+export {
+  make,
+  makeMaskFn,
+  orMask,
+  fieldCodes,
+}
+/* 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),