envio 3.6.1 → 3.7.0

package/src/ChainFetching.res

@@ -11,17 +11,17 @@ type partitionQueryResponse = {
 let runContractRegistersOrThrow = async (
   ~itemsWithContractRegister: array<Internal.item>,
   ~config: Config.t,
+  ~chainState: ChainState.t,
   ~transactionStore: option<TransactionStore.t>,
-  ~blockStore: option<BlockStore.t>,
 ) => {
   // contractRegister handlers can read event.transaction and event.block, so
   // materialise the selected fields onto the payloads before running them. All
-  // items belong to the chain being fetched, hence its single page stores.
+  // items belong to the chain being fetched: transactions come from its
+  // response page, blocks from the chain store the page was merged into.
   await ChainState.materializePageItems(
     ~items=itemsWithContractRegister,
     ~transactionStore,
-    ~blockStore,
-    ~ecosystem=config.ecosystem.name,
+    ~blockStore=chainState->ChainState.blockStore,
   )
 
   let registrations: array<AddressStore.registration> = []
@@ -111,10 +111,8 @@ let rec onQueryResponse = async (
       transactionStore,
       blockStore,
       latestFetchedBlockNumber,
-      latestFetchedBlockTimestamp,
       stats,
       knownHeight,
-      blockHashes,
       fromBlockQueried,
     } = response
 
@@ -150,7 +148,7 @@ let rec onQueryResponse = async (
       })
     }
 
-    let reorgResult = chainState->ChainState.registerReorgGuard(~blockHashes, ~knownHeight)
+    let reorgResult = chainState->ChainState.registerReorgGuard(~blockStore, ~knownHeight)
 
     let rollbackWithReorgDetectedBlockNumber = switch reorgResult {
     | ReorgDetected(reorgDetected) => {
@@ -158,13 +156,17 @@ let rec onQueryResponse = async (
         ->ChainState.logger
         ->Logging.childInfo(
           reorgDetected->ReorgDetection.reorgDetectedToLogParams(
-            ~shouldRollbackOnReorg=(state->IndexerState.config).shouldRollbackOnReorg,
+            ~shouldRollbackOnReorg=chainState->ChainState.shouldRollbackOnReorg,
           ),
         )
         chainState->ChainState.recordReorgDetected(
           ~blockNumber=reorgDetected.scannedBlock.blockNumber,
         )
-        if (state->IndexerState.config).shouldRollbackOnReorg {
+
+        // Must agree with the `reportOnly` flag registerReorgGuard passed to
+        // the merge: a discarded page (rollback mode) needs the rollback to
+        // actually happen, or the stale stored hash re-reports forever.
+        if chainState->ChainState.shouldRollbackOnReorg {
           Some(reorgDetected.scannedBlock.blockNumber)
         } else {
           None
@@ -224,13 +226,9 @@ let rec onQueryResponse = async (
             ~newItems,
             ~newRegistrations,
             ~knownHeight,
-            ~latestFetchedBlock={
-              FetchState.blockNumber: latestFetchedBlockNumber,
-              blockTimestamp: latestFetchedBlockTimestamp,
-            },
+            ~latestFetchedBlock=latestFetchedBlockNumber,
             ~query,
             ~transactionStore,
-            ~blockStore,
           )
           ChainMetadata.stage(state)
           scheduleFetch()
@@ -243,8 +241,8 @@ let rec onQueryResponse = async (
         switch await runContractRegistersOrThrow(
           ~itemsWithContractRegister,
           ~config=state->IndexerState.config,
+          ~chainState,
           ~transactionStore,
-          ~blockStore,
         ) {
         | exception exn => IndexerState.errorExit(state, exn->ErrorHandling.make)
         | newRegistrations => proceed(~newRegistrations)
@@ -262,7 +260,6 @@ and applyQueryResponse = (
   ~latestFetchedBlock,
   ~query,
   ~transactionStore,
-  ~blockStore,
 ) => {
   let chainState = state->IndexerState.getChainState(~chainId)
   let wasFetchingAtHead = chainState->ChainState.isFetchingAtHead
@@ -274,7 +271,6 @@ and applyQueryResponse = (
     ~newRegistrations,
     ~knownHeight,
     ~transactionStore,
-    ~blockStore,
   )
 
   // In auto-exit mode, set endBlock to the first event's block when events arrive.

package/src/ChainFetching.res.mjs

@@ -16,8 +16,8 @@ import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as ContractRegisterContext from "./ContractRegisterContext.res.mjs";
 
-async function runContractRegistersOrThrow(itemsWithContractRegister, config, transactionStore, blockStore) {
-  await ChainState.materializePageItems(itemsWithContractRegister, transactionStore, blockStore, config.ecosystem.name);
+async function runContractRegistersOrThrow(itemsWithContractRegister, config, chainState, transactionStore) {
+  await ChainState.materializePageItems(itemsWithContractRegister, transactionStore, ChainState.blockStore(chainState));
   let registrations = [];
   let onRegister = (item, contractAddress, contractName) => {
     registrations.push({
@@ -63,10 +63,10 @@ async function runContractRegistersOrThrow(itemsWithContractRegister, config, tr
   return registrations;
 }
 
-function applyQueryResponse(state, chainId, newItems, newRegistrations, knownHeight, latestFetchedBlock, query, transactionStore, blockStore) {
+function applyQueryResponse(state, chainId, newItems, newRegistrations, knownHeight, latestFetchedBlock, query, transactionStore) {
   let chainState = IndexerState.getChainState(state, chainId);
   let wasFetchingAtHead = ChainState.isFetchingAtHead(chainState);
-  ChainState.handleQueryResult(chainState, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, transactionStore, blockStore);
+  ChainState.handleQueryResult(chainState, query, newItems, newRegistrations, latestFetchedBlock, knownHeight, transactionStore);
   if (IndexerState.exitAfterFirstEventBlock(state) && newItems.length !== 0) {
     ChainState.setEndBlockToFirstEvent(chainState, newItems[0].blockNumber);
   }
@@ -84,10 +84,8 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   }
   let chainState = IndexerState.getChainState(state, chainId);
   let stats = response.stats;
-  let latestFetchedBlockTimestamp = response.latestFetchedBlockTimestamp;
   let latestFetchedBlockNumber = response.latestFetchedBlockNumber;
   let fromBlockQueried = response.fromBlockQueried;
-  let blockStore = response.blockStore;
   let transactionStore = response.transactionStore;
   let parsedQueueItems = response.parsedQueueItems;
   let knownHeight = response.knownHeight;
@@ -119,15 +117,15 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
       numContractRegisterEvents: numContractRegisterEvents
     });
   }
-  let reorgResult = ChainState.registerReorgGuard(chainState, response.blockHashes, knownHeight);
+  let reorgResult = ChainState.registerReorgGuard(chainState, response.blockStore, knownHeight);
   let rollbackWithReorgDetectedBlockNumber;
   if (typeof reorgResult !== "object") {
     rollbackWithReorgDetectedBlockNumber = undefined;
   } else {
     let reorgDetected = reorgResult._0;
-    Logging.childInfo(ChainState.logger(chainState), ReorgDetection.reorgDetectedToLogParams(reorgDetected, IndexerState.config(state).shouldRollbackOnReorg));
+    Logging.childInfo(ChainState.logger(chainState), ReorgDetection.reorgDetectedToLogParams(reorgDetected, ChainState.shouldRollbackOnReorg(chainState)));
     ChainState.recordReorgDetected(chainState, reorgDetected.scannedBlock.blockNumber);
-    rollbackWithReorgDetectedBlockNumber = IndexerState.config(state).shouldRollbackOnReorg ? reorgDetected.scannedBlock.blockNumber : undefined;
+    rollbackWithReorgDetectedBlockNumber = ChainState.shouldRollbackOnReorg(chainState) ? reorgDetected.scannedBlock.blockNumber : undefined;
   }
   if (rollbackWithReorgDetectedBlockNumber !== undefined) {
     let match = IndexerState.rollbackState(state);
@@ -146,10 +144,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   }
   let proceed = newRegistrations => {
     if (!IndexerState.isStale(state, stateId)) {
-      applyQueryResponse(state, chainId, parsedQueueItems, newRegistrations, knownHeight, {
-        blockNumber: latestFetchedBlockNumber,
-        blockTimestamp: latestFetchedBlockTimestamp
-      }, query, transactionStore, blockStore);
+      applyQueryResponse(state, chainId, parsedQueueItems, newRegistrations, knownHeight, latestFetchedBlockNumber, query, transactionStore);
       ChainMetadata.stage(state);
       scheduleFetch();
       return scheduleProcessing();
@@ -160,7 +155,7 @@ async function onQueryResponse(state, param, stateId, scheduleFetch, schedulePro
   }
   let newRegistrations;
   try {
-    newRegistrations = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), transactionStore, blockStore);
+    newRegistrations = await runContractRegistersOrThrow(itemsWithContractRegister, IndexerState.config(state), chainState, transactionStore);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     return IndexerState.errorExit(state, ErrorHandling.make(exn, undefined, undefined));