envio 3.0.2 → 3.1.0-rc.1

package/src/FetchState.res

@@ -1485,15 +1485,6 @@ let getNextQuery = (
   }
 }
 
-let getTimestampAt = (fetchState: t, ~index) => {
-  switch fetchState.buffer->Belt.Array.get(index) {
-  | Some(Event({timestamp})) => timestamp
-  | Some(Block(_)) =>
-    JsError.throwWithMessage("Block handlers are not supported for ordered multichain mode.")
-  | None => (fetchState->bufferBlock).blockTimestamp
-  }
-}
-
 let hasReadyItem = ({buffer} as fetchState: t) => {
   switch buffer->Belt.Array.get(0) {
   | Some(item) => item->Internal.getItemBlockNumber <= fetchState->bufferBlockNumber
@@ -1739,10 +1730,7 @@ let rollback = (fetchState: t, ~targetBlockNumber) => {
   let addressesToRemove = Utils.Set.make()
   let indexingAddresses = Dict.make()
 
-  fetchState.indexingAddresses
-  ->Dict.keysToArray
-  ->Array.forEach(address => {
-    let indexingContract = fetchState.indexingAddresses->Dict.getUnsafe(address)
+  fetchState.indexingAddresses->Utils.Dict.forEachWithKey((indexingContract, address) => {
     if indexingContract.registrationBlock > targetBlockNumber {
       let _ = addressesToRemove->Utils.Set.add(address->Address.unsafeFromString)
     } else {
@@ -1965,8 +1953,7 @@ let sortForUnorderedBatch = {
   }
 }
 
-// Ordered multichain mode can't skip blocks, even if there are no items.
-let getUnorderedMultichainProgressBlockNumberAt = ({buffer} as fetchState: t, ~index) => {
+let getProgressBlockNumberAt = ({buffer} as fetchState: t, ~index) => {
   let bufferBlockNumber = fetchState->bufferBlockNumber
   switch buffer->Belt.Array.get(index) {
   | Some(item) if bufferBlockNumber >= item->Internal.getItemBlockNumber =>

package/src/FetchState.res.mjs

@@ -1174,19 +1174,6 @@ function getNextQuery(fetchState, concurrencyLimit) {
   };
 }
 
-function getTimestampAt(fetchState, index) {
-  let match = Belt_Array.get(fetchState.buffer, index);
-  if (match !== undefined) {
-    if (match.kind === 0) {
-      return match.timestamp;
-    } else {
-      return Stdlib_JsError.throwWithMessage("Block handlers are not supported for ordered multichain mode.");
-    }
-  } else {
-    return bufferBlock(fetchState).blockTimestamp;
-  }
-}
-
 function hasReadyItem(fetchState) {
   let item = Belt_Array.get(fetchState.buffer, 0);
   if (item !== undefined) {
@@ -1373,8 +1360,7 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
 function rollback(fetchState, targetBlockNumber) {
   let addressesToRemove = new Set();
   let indexingAddresses = {};
-  Object.keys(fetchState.indexingAddresses).forEach(address => {
-    let indexingContract = fetchState.indexingAddresses[address];
+  Utils.Dict.forEachWithKey(fetchState.indexingAddresses, (indexingContract, address) => {
     if (indexingContract.registrationBlock > targetBlockNumber) {
       addressesToRemove.add(address);
     } else {
@@ -1590,7 +1576,7 @@ function sortForUnorderedBatch(fetchStates, batchSizeTarget) {
   return copied;
 }
 
-function getUnorderedMultichainProgressBlockNumberAt(fetchState, index) {
+function getProgressBlockNumberAt(fetchState, index) {
   let bufferBlockNumber$1 = bufferBlockNumber(fetchState);
   let item = Belt_Array.get(fetchState.buffer, index);
   if (item !== undefined && bufferBlockNumber$1 >= item.blockNumber) {
@@ -1631,7 +1617,6 @@ export {
   startFetchingQueries,
   pushQueriesForRange,
   getNextQuery,
-  getTimestampAt,
   hasReadyItem,
   getReadyItemsCount,
   make$1 as make,
@@ -1642,7 +1627,7 @@ export {
   isActivelyIndexing,
   isReadyToEnterReorgThreshold,
   sortForUnorderedBatch,
-  getUnorderedMultichainProgressBlockNumberAt,
+  getProgressBlockNumberAt,
   updateKnownHeight,
 }
 /* Utils Not a pure module */

package/src/GlobalState.res

@@ -4,7 +4,7 @@ type rollbackState =
   | ReorgDetected({chain: chain, blockNumber: int})
   | FindingReorgDepth
   | FoundReorgDepth({chain: chain, rollbackTargetBlockNumber: int})
-  | RollbackReady({diffInMemoryStore: InMemoryStore.t, eventsProcessedDiffByChain: dict<float>})
+  | RollbackReady({eventsProcessedDiffByChain: dict<float>})
 
 module WriteThrottlers = {
   type t = {
@@ -132,7 +132,6 @@ type action =
   | SuccessExit
   | ErrorExit(ErrorHandling.t)
   | SetRollbackState({
-      diffInMemoryStore: InMemoryStore.t,
       rollbackedChainManager: ChainManager.t,
       eventsProcessedDiffByChain: dict<float>,
     })
@@ -331,10 +330,6 @@ let updateProgressedChains = (chainManager: ChainManager.t, ~batch: Batch.t, ~ct
 
   {
     ...chainManager,
-    committedCheckpointId: switch batch.checkpointIds->Utils.Array.last {
-    | Some(checkpointId) => checkpointId
-    | None => chainManager.committedCheckpointId
-    },
     chainFetchers,
     isRealtime: chainManager.isRealtime || allChainsReady.contents,
   }
@@ -350,7 +345,7 @@ let validatePartitionQueryResponse = (
     latestFetchedBlockNumber,
     stats,
     knownHeight,
-    reorgGuard,
+    blockHashes,
     fromBlockQueried,
   } = response
 
@@ -374,7 +369,7 @@ let validatePartitionQueryResponse = (
   )
 
   let (updatedReorgDetection, reorgResult: ReorgDetection.reorgResult) =
-    chainFetcher.reorgDetection->ReorgDetection.registerReorgGuard(~reorgGuard, ~knownHeight)
+    chainFetcher.reorgDetection->ReorgDetection.registerReorgGuard(~blockHashes, ~knownHeight)
 
   let updatedChainFetcher = {
     ...chainFetcher,
@@ -764,12 +759,11 @@ let actionReducer = (state: t, action: action) => {
       },
       [NextQuery(CheckAllChains)],
     )
-  | SetRollbackState({diffInMemoryStore, rollbackedChainManager, eventsProcessedDiffByChain}) => (
+  | SetRollbackState({rollbackedChainManager, eventsProcessedDiffByChain}) => (
       {
         ...state,
         rollbackState: RollbackReady({
-          diffInMemoryStore,
-          eventsProcessedDiffByChain,
+          eventsProcessedDiffByChain: eventsProcessedDiffByChain,
         }),
         chainManager: rollbackedChainManager,
       },
@@ -823,14 +817,9 @@ let checkAndFetchForChain = (
       let {fetchState} = chainFetcher
       let isRealtime = state.chainManager.isRealtime
 
-      // Reduce polling when there's nothing useful to fetch right now:
-      //   - this chain has caught up but others are still backfilling, or
-      //   - we're about to enter the reorg threshold (rollback mode only).
-      let reducedPolling =
-        (chainFetcher->ChainFetcher.isReady && !isRealtime) ||
-          (state.ctx.config.shouldRollbackOnReorg &&
-          !state.chainManager.isInReorgThreshold &&
-          fetchState->FetchState.isReadyToEnterReorgThreshold)
+      // Only affects the WaitingForNewBlock branch of fetchNext, where
+      // there's nothing to fetch. During backfill any such chain is idle.
+      let reducedPolling = !isRealtime
 
       await chainFetcher.sourceManager->SourceManager.fetchNext(
         ~fetchState,
@@ -951,23 +940,21 @@ let injectedTaskReducer = (
       }
     | ProcessEventBatch =>
       if !state.currentlyProcessingBatch && !isPreparingRollback(state) {
-        //In the case of a rollback, use the provided in memory store
-        //With rolled back values
-        let rollbackInMemStore = switch state.rollbackState {
-        | RollbackReady({diffInMemoryStore}) => Some(diffInMemoryStore)
-        | _ => None
+        let isRollbackBatch = switch state.rollbackState {
+        | RollbackReady(_) => true
+        | _ => false
         }
 
         let batch =
           state.chainManager->ChainManager.createBatch(
+            ~committedCheckpointId=state.ctx.inMemoryStore.committedCheckpointId,
             ~batchSizeTarget=state.ctx.config.batchSize,
-            ~isRollback=rollbackInMemStore !== None,
+            ~isRollback=isRollbackBatch,
           )
 
         let progressedChainsById = batch.progressedChainsById
 
         let isInReorgThreshold = state.chainManager.isInReorgThreshold
-        let shouldSaveHistory = state.ctx.config->Config.shouldSaveHistory(~isInReorgThreshold)
 
         let isBelowReorgThreshold =
           !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg
@@ -1007,12 +994,8 @@ let injectedTaskReducer = (
           dispatchAction(StartProcessingBatch)
           dispatchAction(UpdateQueues({progressedChainsById, shouldEnterReorgThreshold}))
 
-          let inMemoryStore =
-            rollbackInMemStore->Option.getOr(
-              InMemoryStore.make(~entities=state.ctx.persistence.allEntities),
-            )
-
-          inMemoryStore->InMemoryStore.setBatchDcs(~batch, ~shouldSaveHistory)
+          let inMemoryStore = state.ctx.inMemoryStore
+          inMemoryStore->InMemoryStore.setBatchDcs(~batch)
 
           switch await EventProcessing.processEventBatch(
             ~batch,
@@ -1049,6 +1032,11 @@ let injectedTaskReducer = (
           dispatchAction(StartFindingReorgDepth)
           let rollbackTargetBlockNumber = await chainFetcher->getLastKnownValidBlock(
             ~reorgBlockNumber,
+            ~isRealtime=state.chainManager.isRealtime,
+          )
+
+          chainFetcher.sourceManager->SourceManager.onReorg(
+            ~rollbackTargetBlock=rollbackTargetBlockNumber,
           )
 
           dispatchAction(FindReorgDepth({chain, rollbackTargetBlockNumber}))
@@ -1189,10 +1177,10 @@ let injectedTaskReducer = (
           }
         })
 
-        // Construct in Memory store with rollback diff
-        let diff = await state.ctx.persistence->Persistence.prepareRollbackDiff(
+        let diff = await state.ctx.inMemoryStore->InMemoryStore.prepareRollbackDiff(
+          ~persistence=state.ctx.persistence,
           ~rollbackTargetCheckpointId,
-          ~rollbackDiffCheckpointId=state.chainManager.committedCheckpointId->BigInt.add(1n),
+          ~rollbackDiffCheckpointId=state.ctx.inMemoryStore.committedCheckpointId->BigInt.add(1n),
         )
 
         let chainManager = {
@@ -1207,7 +1195,7 @@ let injectedTaskReducer = (
             "upserted": diff["setEntities"],
           },
           "rollbackedEvents": rollbackedProcessedEvents.contents,
-          "beforeCheckpointId": state.chainManager.committedCheckpointId,
+          "beforeCheckpointId": state.ctx.inMemoryStore.committedCheckpointId,
           "targetCheckpointId": rollbackTargetCheckpointId,
         })
         Prometheus.RollbackSuccess.increment(
@@ -1217,7 +1205,6 @@ let injectedTaskReducer = (
 
         dispatchAction(
           SetRollbackState({
-            diffInMemoryStore: diff["inMemStore"],
             rollbackedChainManager: chainManager,
             eventsProcessedDiffByChain,
           }),
@@ -1229,6 +1216,6 @@ let injectedTaskReducer = (
 let taskReducer = injectedTaskReducer(
   ~waitForNewBlock=SourceManager.waitForNewBlock,
   ~executeQuery=SourceManager.executeQuery,
-  ~getLastKnownValidBlock=(chainFetcher, ~reorgBlockNumber) =>
-    chainFetcher->ChainFetcher.getLastKnownValidBlock(~reorgBlockNumber),
+  ~getLastKnownValidBlock=(chainFetcher, ~reorgBlockNumber, ~isRealtime) =>
+    chainFetcher->ChainFetcher.getLastKnownValidBlock(~reorgBlockNumber, ~isRealtime),
 )

package/src/GlobalState.res.mjs

@@ -14,7 +14,6 @@ import * as FetchState from "./FetchState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
 import * as LoadManager from "./LoadManager.res.mjs";
-import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as ChainManager from "./ChainManager.res.mjs";
@@ -244,11 +243,8 @@ function updateProgressedChains(chainManager, batch, ctx) {
   if (allChainsReady.contents) {
     Prometheus.ProgressReady.setAllReady();
   }
-  let checkpointId = Utils.$$Array.last(batch.checkpointIds);
   return {
-    committedCheckpointId: checkpointId !== undefined ? checkpointId : chainManager.committedCheckpointId,
     chainFetchers: chainFetchers,
-    multichain: chainManager.multichain,
     isInReorgThreshold: chainManager.isInReorgThreshold,
     isRealtime: chainManager.isRealtime || allChainsReady.contents
   };
@@ -264,7 +260,7 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     Prometheus.SourceHeight.set(SourceManager.getActiveSource(chainFetcher.sourceManager).name, chainFetcher.chainConfig.id, knownHeight);
   }
   Prometheus.FetchingBlockRange.increment(chain, stats["total time elapsed (s)"], Belt_Option.getWithDefault(stats["parsing time (s)"], 0), response.parsedQueueItems.length, (response.latestFetchedBlockNumber - response.fromBlockQueried | 0) + 1 | 0);
-  let match = ReorgDetection.registerReorgGuard(chainFetcher.reorgDetection, response.reorgGuard, knownHeight);
+  let match = ReorgDetection.registerReorgGuard(chainFetcher.reorgDetection, response.blockHashes, knownHeight);
   let reorgResult = match[1];
   let updatedChainFetcher_logger = chainFetcher.logger;
   let updatedChainFetcher_fetchState = chainFetcher.fetchState;
@@ -291,9 +287,7 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
   let init = state.chainManager;
   let nextState_ctx = state.ctx;
   let nextState_chainManager = {
-    committedCheckpointId: init.committedCheckpointId,
     chainFetchers: ChainMap.set(state.chainManager.chainFetchers, chain, updatedChainFetcher),
-    multichain: init.multichain,
     isInReorgThreshold: init.isInReorgThreshold,
     isRealtime: init.isRealtime
   };
@@ -346,7 +340,6 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     let eventsProcessedDiffByChain = match$1.eventsProcessedDiffByChain;
     let init$1 = state.chainManager;
     chainManager = {
-      committedCheckpointId: init$1.committedCheckpointId,
       chainFetchers: ChainMap.mapWithKey(state.chainManager.chainFetchers, (c, chainFetcher) => {
         let eventsProcessedDiff = eventsProcessedDiffByChain[c];
         if (eventsProcessedDiff !== undefined) {
@@ -366,7 +359,6 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
           return chainFetcher;
         }
       }),
-      multichain: init$1.multichain,
       isInReorgThreshold: init$1.isInReorgThreshold,
       isRealtime: init$1.isRealtime
     };
@@ -375,7 +367,6 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     {
       ctx: nextState_ctx,
       chainManager: {
-        committedCheckpointId: chainManager.committedCheckpointId,
         chainFetchers: ChainMap.map(chainManager.chainFetchers, chainFetcher => ({
           logger: chainFetcher.logger,
           fetchState: FetchState.resetPendingQueries(chainFetcher.fetchState),
@@ -388,7 +379,6 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
           reorgDetection: chainFetcher.reorgDetection,
           safeCheckpointTracking: chainFetcher.safeCheckpointTracking
         })),
-        multichain: chainManager.multichain,
         isInReorgThreshold: chainManager.isInReorgThreshold,
         isRealtime: chainManager.isRealtime
       },
@@ -489,9 +479,7 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
   let init$2 = state.chainManager;
   let nextState_ctx = state.ctx;
   let nextState_chainManager = {
-    committedCheckpointId: init$2.committedCheckpointId,
     chainFetchers: ChainMap.set(state.chainManager.chainFetchers, chain, updatedChainFetcher$1),
-    multichain: init$2.multichain,
     isInReorgThreshold: init$2.isInReorgThreshold,
     isRealtime: init$2.isRealtime
   };
@@ -569,9 +557,7 @@ function updateChainFetcher(chainFetcherUpdate, state, chain) {
     {
       ctx: state.ctx,
       chainManager: {
-        committedCheckpointId: init.committedCheckpointId,
         chainFetchers: ChainMap.update(state.chainManager.chainFetchers, chain, chainFetcherUpdate),
-        multichain: init.multichain,
         isInReorgThreshold: init.isInReorgThreshold,
         isRealtime: init.isRealtime
       },
@@ -608,9 +594,7 @@ function onEnterReorgThreshold(state) {
   return {
     ctx: state.ctx,
     chainManager: {
-      committedCheckpointId: init.committedCheckpointId,
       chainFetchers: chainFetchers,
-      multichain: init.multichain,
       isInReorgThreshold: true,
       isRealtime: init.isRealtime
     },
@@ -712,9 +696,7 @@ function actionReducer(state, action) {
         let init = state.chainManager;
         let state_ctx = state.ctx;
         let state_chainManager = {
-          committedCheckpointId: init.committedCheckpointId,
           chainFetchers: updatedChainFetchers,
-          multichain: init.multichain,
           isInReorgThreshold: init.isInReorgThreshold,
           isRealtime: init.isRealtime
         };
@@ -853,14 +835,10 @@ function actionReducer(state, action) {
           };
         });
         let init$1 = state.chainManager;
-        let chainManager_committedCheckpointId = init$1.committedCheckpointId;
-        let chainManager_multichain = init$1.multichain;
         let chainManager_isInReorgThreshold = init$1.isInReorgThreshold;
         let chainManager_isRealtime = init$1.isRealtime;
         let chainManager = {
-          committedCheckpointId: chainManager_committedCheckpointId,
           chainFetchers: chainFetchers,
-          multichain: chainManager_multichain,
           isInReorgThreshold: chainManager_isInReorgThreshold,
           isRealtime: chainManager_isRealtime
         };
@@ -899,7 +877,6 @@ function actionReducer(state, action) {
             currentlyProcessingBatch: state.currentlyProcessingBatch,
             rollbackState: {
               TAG: "RollbackReady",
-              diffInMemoryStore: action.diffInMemoryStore,
               eventsProcessedDiffByChain: action.eventsProcessedDiffByChain
             },
             indexerStartTime: state.indexerStartTime,
@@ -967,7 +944,7 @@ function checkAndFetchForChain(waitForNewBlock, executeQuery, state, dispatchAct
     }
     let fetchState = chainFetcher.fetchState;
     let isRealtime = state.chainManager.isRealtime;
-    let reducedPolling = ChainFetcher.isReady(chainFetcher) && !isRealtime || state.ctx.config.shouldRollbackOnReorg && !state.chainManager.isInReorgThreshold && FetchState.isReadyToEnterReorgThreshold(fetchState);
+    let reducedPolling = !isRealtime;
     return await SourceManager.fetchNext(chainFetcher.sourceManager, fetchState, async query => {
       try {
         let response = await executeQuery(chainFetcher.sourceManager, query, fetchState.knownHeight, isRealtime);
@@ -1003,12 +980,11 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
             return;
           }
           let match = state.rollbackState;
-          let rollbackInMemStore;
-          rollbackInMemStore = typeof match !== "object" || match.TAG !== "RollbackReady" ? undefined : match.diffInMemoryStore;
-          let batch = ChainManager.createBatch(state.chainManager, state.ctx.config.batchSize, rollbackInMemStore !== undefined);
+          let isRollbackBatch;
+          isRollbackBatch = typeof match !== "object" ? false : match.TAG === "RollbackReady";
+          let batch = ChainManager.createBatch(state.chainManager, state.ctx.inMemoryStore.committedCheckpointId, state.ctx.config.batchSize, isRollbackBatch);
           let progressedChainsById = batch.progressedChainsById;
           let isInReorgThreshold = state.chainManager.isInReorgThreshold;
-          let shouldSaveHistory = Config.shouldSaveHistory(state.ctx.config, isInReorgThreshold);
           let isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
           let shouldEnterReorgThreshold = isBelowReorgThreshold && ChainMap.values(state.chainManager.chainFetchers).every(chainFetcher => {
             let chainAfterBatch = progressedChainsById[chainFetcher.fetchState.chainId];
@@ -1036,8 +1012,8 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
             progressedChainsById: progressedChainsById,
             shouldEnterReorgThreshold: shouldEnterReorgThreshold
           });
-          let inMemoryStore = Stdlib_Option.getOr(rollbackInMemStore, InMemoryStore.make(state.ctx.persistence.allEntities, undefined));
-          InMemoryStore.setBatchDcs(inMemoryStore, batch, shouldSaveHistory);
+          let inMemoryStore = state.ctx.inMemoryStore;
+          InMemoryStore.setBatchDcs(inMemoryStore, batch);
           let res;
           try {
             res = await EventProcessing.processEventBatch(batch, inMemoryStore, isInReorgThreshold, state.loadManager, state.ctx, state.chainManager.chainFetchers);
@@ -1075,7 +1051,8 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
               let chain = match$1.chain;
               let chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
               dispatchAction("StartFindingReorgDepth");
-              let rollbackTargetBlockNumber = await getLastKnownValidBlock(chainFetcher, match$1.blockNumber);
+              let rollbackTargetBlockNumber = await getLastKnownValidBlock(chainFetcher, match$1.blockNumber, state.chainManager.isRealtime);
+              SourceManager.onReorg(chainFetcher.sourceManager, rollbackTargetBlockNumber);
               return dispatchAction({
                 TAG: "FindReorgDepth",
                 chain: chain,
@@ -1152,16 +1129,12 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                   safeCheckpointTracking: safeCheckpointTracking !== undefined ? SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber) : undefined
                 };
               });
-              let diff$1 = await Persistence.prepareRollbackDiff(state.ctx.persistence, rollbackTargetCheckpointId, state.chainManager.committedCheckpointId + 1n);
+              let diff$1 = await InMemoryStore.prepareRollbackDiff(state.ctx.inMemoryStore, state.ctx.persistence, rollbackTargetCheckpointId, state.ctx.inMemoryStore.committedCheckpointId + 1n);
               let init = state.chainManager;
-              let chainManager_committedCheckpointId = init.committedCheckpointId;
-              let chainManager_multichain = init.multichain;
               let chainManager_isInReorgThreshold = init.isInReorgThreshold;
               let chainManager_isRealtime = init.isRealtime;
               let chainManager = {
-                committedCheckpointId: chainManager_committedCheckpointId,
                 chainFetchers: chainFetchers,
-                multichain: chainManager_multichain,
                 isInReorgThreshold: chainManager_isInReorgThreshold,
                 isRealtime: chainManager_isRealtime
               };
@@ -1172,13 +1145,12 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                   upserted: diff$1.setEntities
                 },
                 rollbackedEvents: rollbackedProcessedEvents,
-                beforeCheckpointId: state.chainManager.committedCheckpointId,
+                beforeCheckpointId: state.ctx.inMemoryStore.committedCheckpointId,
                 targetCheckpointId: rollbackTargetCheckpointId
               });
               Prometheus.RollbackSuccess.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(startTime)), rollbackedProcessedEvents);
               return dispatchAction({
                 TAG: "SetRollbackState",
-                diffInMemoryStore: diff$1.inMemStore,
                 rollbackedChainManager: chainManager,
                 eventsProcessedDiffByChain: eventsProcessedDiffByChain
               });
@@ -1246,7 +1218,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
   };
 }
 
-let taskReducer = injectedTaskReducer(SourceManager.waitForNewBlock, SourceManager.executeQuery, (chainFetcher, reorgBlockNumber) => ChainFetcher.getLastKnownValidBlock(chainFetcher, reorgBlockNumber, undefined));
+let taskReducer = injectedTaskReducer(SourceManager.waitForNewBlock, SourceManager.executeQuery, ChainFetcher.getLastKnownValidBlock);
 
 export {
   WriteThrottlers,

package/src/HandlerLoader.res

@@ -114,20 +114,21 @@ let applyRegistrations = (~config: Config.t): Config.t => {
               ~contractName=ev.contractName,
               ~eventName=ev.name,
             )
+            let indexedParams = evmEv.paramsMetadata->Array.filter(p => p.indexed)
             let {getEventFiltersOrThrow, filterByAddresses} = LogSelection.parseEventFiltersOrThrow(
               ~eventFilters,
               ~sighash=evmEv.sighash,
-              ~params=evmEv.indexedParams->Array.map(p => p.name),
+              ~params=indexedParams->Array.map(p => p.name),
               ~contractName=ev.contractName,
               ~probeChainId=chain.id,
               ~onEventBlockFilterSchema=config.ecosystem.onEventBlockFilterSchema,
-              ~topic1=?evmEv.indexedParams
+              ~topic1=?indexedParams
               ->Array.get(0)
               ->Option.map(EventConfigBuilder.buildTopicGetter),
-              ~topic2=?evmEv.indexedParams
+              ~topic2=?indexedParams
               ->Array.get(1)
               ->Option.map(EventConfigBuilder.buildTopicGetter),
-              ~topic3=?evmEv.indexedParams
+              ~topic3=?indexedParams
               ->Array.get(2)
               ->Option.map(EventConfigBuilder.buildTopicGetter),
             )
@@ -156,7 +157,7 @@ let applyRegistrations = (~config: Config.t): Config.t => {
 // `Config` never reads `HandlerRegister`. The only way to get a config that
 // reflects registration state is through the returned value here.
 let registerAllHandlers = async (~config: Config.t) => {
-  HandlerRegister.startRegistration(~ecosystem=config.ecosystem, ~multichain=config.multichain)
+  HandlerRegister.startRegistration(~ecosystem=config.ecosystem)
 
   // Auto-load all .js files from src/handlers directory
   await autoLoadFromSrcHandlers(~handlers=config.handlers)

package/src/HandlerLoader.res.mjs

@@ -72,7 +72,8 @@ function applyRegistrations(config) {
         switch (match) {
           case "evm" :
             let eventFilters = HandlerRegister.getOnEventWhere(ev.contractName, ev.name);
-            let match$1 = LogSelection.parseEventFiltersOrThrow(eventFilters, ev.sighash, ev.indexedParams.map(p => p.name), ev.contractName, chain.id, config.ecosystem.onEventBlockFilterSchema, Stdlib_Option.map(ev.indexedParams[0], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(ev.indexedParams[1], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(ev.indexedParams[2], EventConfigBuilder.buildTopicGetter));
+            let indexedParams = ev.paramsMetadata.filter(p => p.indexed);
+            let match$1 = LogSelection.parseEventFiltersOrThrow(eventFilters, ev.sighash, indexedParams.map(p => p.name), ev.contractName, chain.id, config.ecosystem.onEventBlockFilterSchema, Stdlib_Option.map(indexedParams[0], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(indexedParams[1], EventConfigBuilder.buildTopicGetter), Stdlib_Option.map(indexedParams[2], EventConfigBuilder.buildTopicGetter));
             let filterByAddresses = match$1.filterByAddresses;
             return {
               id: ev.id,
@@ -87,11 +88,11 @@ function applyRegistrations(config) {
               simulateParamsSchema: ev.simulateParamsSchema,
               startBlock: ev.startBlock,
               getEventFiltersOrThrow: match$1.getEventFiltersOrThrow,
-              convertHyperSyncEventArgs: ev.convertHyperSyncEventArgs,
               selectedBlockFields: ev.selectedBlockFields,
               selectedTransactionFields: ev.selectedTransactionFields,
               sighash: ev.sighash,
-              indexedParams: ev.indexedParams
+              topicCount: ev.topicCount,
+              paramsMetadata: ev.paramsMetadata
             };
           case "fuel" :
             return {
@@ -117,21 +118,38 @@ function applyRegistrations(config) {
         abi: contract.abi,
         addresses: contract.addresses,
         events: newEvents,
-        startBlock: contract.startBlock,
-        eventSignatures: contract.eventSignatures
+        startBlock: contract.startBlock
       };
     });
     let newrecord = {...chain};
     newrecord.contracts = newContracts;
     return newrecord;
   });
-  let newrecord = {...config};
-  newrecord.chainMap = newChainMap;
-  return newrecord;
+  return {
+    name: config.name,
+    description: config.description,
+    handlers: config.handlers,
+    contractHandlers: config.contractHandlers,
+    shouldRollbackOnReorg: config.shouldRollbackOnReorg,
+    shouldSaveFullHistory: config.shouldSaveFullHistory,
+    storage: config.storage,
+    chainMap: newChainMap,
+    defaultChain: config.defaultChain,
+    ecosystem: config.ecosystem,
+    enableRawEvents: config.enableRawEvents,
+    maxAddrInPartition: config.maxAddrInPartition,
+    batchSize: config.batchSize,
+    lowercaseAddresses: config.lowercaseAddresses,
+    isDev: config.isDev,
+    userEntitiesByName: config.userEntitiesByName,
+    userEntities: config.userEntities,
+    allEntities: config.allEntities,
+    allEnums: config.allEnums
+  };
 }
 
 async function registerAllHandlers(config) {
-  HandlerRegister.startRegistration(config.ecosystem, config.multichain);
+  HandlerRegister.startRegistration(config.ecosystem);
   await autoLoadFromSrcHandlers(config.handlers);
   await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
   let registrations = HandlerRegister.finishRegistration();

package/src/HandlerRegister.res

@@ -14,7 +14,6 @@ type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
 
 type activeRegistration = {
   ecosystem: Ecosystem.t,
-  multichain: Internal.multichain,
   registrations: registrations,
   mutable finished: bool,
 }
@@ -102,10 +101,9 @@ let withRegistration = (fn: activeRegistration => unit) => {
   }
 }
 
-let startRegistration = (~ecosystem, ~multichain) => {
+let startRegistration = (~ecosystem) => {
   let r = {
     ecosystem,
-    multichain,
     registrations: {
       onBlockByChainId: Dict.make(),
     },
@@ -163,15 +161,6 @@ let registerOnBlock = (
   ~handler: Internal.onBlockArgs => promise<unit>,
 ) => {
   withRegistration(registration => {
-    // We need to get timestamp for ordered multichain mode
-    switch registration.multichain {
-    | Unordered => ()
-    | Ordered =>
-      JsError.throwWithMessage(
-        "Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.",
-      )
-    }
-
     let onBlockByChainId = registration.registrations.onBlockByChainId
     let key = chainId->Belt.Int.toString
     let index =

package/src/HandlerRegister.res.mjs

@@ -71,10 +71,9 @@ function withRegistration(fn) {
   }
 }
 
-function startRegistration(ecosystem, multichain) {
+function startRegistration(ecosystem) {
   let r = {
     ecosystem: ecosystem,
-    multichain: multichain,
     registrations: {
       onBlockByChainId: {}
     },
@@ -121,10 +120,6 @@ function throwIfFinishedRegistration(methodName) {
 
 function registerOnBlock(name, chainId, interval, startBlock, endBlock, handler) {
   withRegistration(registration => {
-    let match = registration.multichain;
-    if (match === "ordered") {
-      Stdlib_JsError.throwWithMessage("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.");
-    }
     let onBlockByChainId = registration.registrations.onBlockByChainId;
     let key = String(chainId);
     let index = Belt_Option.mapWithDefault(onBlockByChainId[key], 0, configs => configs.length);

package/src/HandlerRegister.resi

@@ -1,6 +1,6 @@
 type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
 
-let startRegistration: (~ecosystem: Ecosystem.t, ~multichain: Internal.multichain) => unit
+let startRegistration: (~ecosystem: Ecosystem.t) => unit
 let isPendingRegistration: unit => bool
 let finishRegistration: unit => registrations
 let throwIfFinishedRegistration: (~methodName: string) => unit