envio 3.0.0-alpha.3 → 3.0.0-alpha.5

package/src/GlobalState.res.mjs

@@ -55,11 +55,11 @@ var WriteThrottlers = {
   make: make
 };
 
-function make$1(indexer, chainManager, isDevelopmentModeOpt, shouldUseTuiOpt) {
+function make$1(ctx, chainManager, isDevelopmentModeOpt, shouldUseTuiOpt) {
   var isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   var shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   return {
-          indexer: indexer,
+          ctx: ctx,
           chainManager: chainManager,
           processedBatches: 0,
           currentlyProcessingBatch: false,
@@ -78,7 +78,7 @@ function getId(self) {
 
 function incrementId(self) {
   return {
-          indexer: self.indexer,
+          ctx: self.ctx,
           chainManager: self.chainManager,
           processedBatches: self.processedBatches,
           currentlyProcessingBatch: self.currentlyProcessingBatch,
@@ -93,7 +93,7 @@ function incrementId(self) {
 
 function setChainManager(self, chainManager) {
   return {
-          indexer: self.indexer,
+          ctx: self.ctx,
           chainManager: chainManager,
           processedBatches: self.processedBatches,
           currentlyProcessingBatch: self.currentlyProcessingBatch,
@@ -138,7 +138,7 @@ function updateChainMetadataTable(cm, persistence, throttler) {
         }));
 }
 
-function updateProgressedChains(chainManager, batch, indexer) {
+function updateProgressedChains(chainManager, batch, ctx) {
   Prometheus.ProgressBatchCount.increment();
   var nextQueueItemIsNone = ChainManager.nextItemIsNone(chainManager);
   var allChainsAtHead = ChainManager.isProgressAtHead(chainManager);
@@ -155,7 +155,7 @@ function updateProgressedChains(chainManager, batch, indexer) {
             }
             var eventItem = Batch.findLastEventItem(batch, chain);
             if (eventItem !== undefined) {
-              var blockTimestamp = indexer.config.ecosystem.getTimestamp(eventItem.event.block);
+              var blockTimestamp = ctx.config.ecosystem.getTimestamp(eventItem.event.block);
               var currentTimeMs = Date.now() | 0;
               var blockTimestampMs = Math.imul(blockTimestamp, 1000);
               var latencyMs = currentTimeMs - blockTimestampMs | 0;
@@ -181,7 +181,7 @@ function updateProgressedChains(chainManager, batch, indexer) {
             cf$1 = cf;
           }
           if (ChainFetcher.hasProcessedToEndblock(cf$1)) {
-            var timestampCaughtUpToHeadOrEndblock = Belt_Option.isSome(cf$1.timestampCaughtUpToHeadOrEndblock) ? cf$1.timestampCaughtUpToHeadOrEndblock : Caml_option.some(new Date());
+            var timestampCaughtUpToHeadOrEndblock = ChainFetcher.isLive(cf$1) ? cf$1.timestampCaughtUpToHeadOrEndblock : Caml_option.some(new Date());
             return {
                     logger: cf$1.logger,
                     fetchState: cf$1.fetchState,
@@ -197,7 +197,7 @@ function updateProgressedChains(chainManager, batch, indexer) {
                     safeCheckpointTracking: cf$1.safeCheckpointTracking
                   };
           }
-          if (!(Belt_Option.isNone(cf$1.timestampCaughtUpToHeadOrEndblock) && cf$1.isProgressAtHead)) {
+          if (!(!ChainFetcher.isLive(cf$1) && cf$1.isProgressAtHead)) {
             return cf$1;
           }
           if (nextQueueItemIsNone && allChainsAtHead) {
@@ -237,7 +237,7 @@ function updateProgressedChains(chainManager, batch, indexer) {
           }
         }));
   var allChainsSyncedAtHead = Belt_Array.every(ChainMap.values(chainFetchers), (function (cf) {
-          return Belt_Option.isSome(cf.timestampCaughtUpToHeadOrEndblock);
+          return ChainFetcher.isLive(cf);
         }));
   if (allChainsSyncedAtHead) {
     Prometheus.setAllChainsSyncedToHead();
@@ -302,7 +302,7 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     safeCheckpointTracking: updatedChainFetcher_safeCheckpointTracking
   };
   var init = state.chainManager;
-  var nextState_indexer = state.indexer;
+  var nextState_ctx = state.ctx;
   var nextState_chainManager = {
     committedCheckpointId: init.committedCheckpointId,
     chainFetchers: ChainMap.set(state.chainManager.chainFetchers, chain, updatedChainFetcher),
@@ -318,7 +318,7 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
   var nextState_keepProcessAlive = state.keepProcessAlive;
   var nextState_id = state.id;
   var nextState = {
-    indexer: nextState_indexer,
+    ctx: nextState_ctx,
     chainManager: nextState_chainManager,
     processedBatches: nextState_processedBatches,
     currentlyProcessingBatch: nextState_currentlyProcessingBatch,
@@ -334,10 +334,10 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
     rollbackWithReorgDetectedBlockNumber = undefined;
   } else {
     var reorgDetected = reorgResult._0;
-    Logging.childInfo(chainFetcher.logger, ReorgDetection.reorgDetectedToLogParams(reorgDetected, state.indexer.config.shouldRollbackOnReorg));
+    Logging.childInfo(chainFetcher.logger, ReorgDetection.reorgDetectedToLogParams(reorgDetected, state.ctx.config.shouldRollbackOnReorg));
     Prometheus.ReorgCount.increment(chain);
     Prometheus.ReorgDetectionBlockNumber.set(reorgDetected.scannedBlock.blockNumber, chain);
-    rollbackWithReorgDetectedBlockNumber = state.indexer.config.shouldRollbackOnReorg ? reorgDetected.scannedBlock.blockNumber : undefined;
+    rollbackWithReorgDetectedBlockNumber = state.ctx.config.shouldRollbackOnReorg ? reorgDetected.scannedBlock.blockNumber : undefined;
   }
   if (rollbackWithReorgDetectedBlockNumber === undefined) {
     return [
@@ -385,7 +385,7 @@ function validatePartitionQueryResponse(state, partitionQueryResponse) {
   var init$2 = incrementId(nextState);
   return [
           {
-            indexer: init$2.indexer,
+            ctx: init$2.ctx,
             chainManager: chainManager,
             processedBatches: init$2.processedBatches,
             currentlyProcessingBatch: init$2.currentlyProcessingBatch,
@@ -437,7 +437,7 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
     Logging.childInfo(updatedChainFetcher_logger, "All events have been fetched");
   }
   var init = state.chainManager;
-  var nextState_indexer = state.indexer;
+  var nextState_ctx = state.ctx;
   var nextState_chainManager = {
     committedCheckpointId: init.committedCheckpointId,
     chainFetchers: ChainMap.set(state.chainManager.chainFetchers, chain, updatedChainFetcher$1),
@@ -453,7 +453,7 @@ function submitPartitionQueryResponse(state, newItems, newItemsWithDcs, knownHei
   var nextState_keepProcessAlive = state.keepProcessAlive;
   var nextState_id = state.id;
   var nextState = {
-    indexer: nextState_indexer,
+    ctx: nextState_ctx,
     chainManager: nextState_chainManager,
     processedBatches: nextState_processedBatches,
     currentlyProcessingBatch: nextState_currentlyProcessingBatch,
@@ -496,7 +496,7 @@ async function processPartitionQueryResponse(state, param, dispatchAction) {
     }
     newItems.push(item);
   }
-  var newItemsWithDcs = itemsWithContractRegister.length !== 0 ? await ChainFetcher.runContractRegistersOrThrow(itemsWithContractRegister, chain, state.indexer.config) : itemsWithContractRegister;
+  var newItemsWithDcs = itemsWithContractRegister.length !== 0 ? await ChainFetcher.runContractRegistersOrThrow(itemsWithContractRegister, chain, state.ctx.config) : itemsWithContractRegister;
   return dispatchAction({
               TAG: "SubmitPartitionQueryResponse",
               newItems: newItems,
@@ -515,7 +515,7 @@ function updateChainFetcher(chainFetcherUpdate, state, chain) {
   var init = state.chainManager;
   return [
           {
-            indexer: state.indexer,
+            ctx: state.ctx,
             chainManager: {
               committedCheckpointId: init.committedCheckpointId,
               chainFetchers: ChainMap.update(state.chainManager.chainFetchers, chain, chainFetcherUpdate),
@@ -556,7 +556,7 @@ function onEnterReorgThreshold(state) {
         }));
   var init = state.chainManager;
   return {
-          indexer: state.indexer,
+          ctx: state.ctx,
           chainManager: {
             committedCheckpointId: init.committedCheckpointId,
             chainFetchers: chainFetchers,
@@ -580,7 +580,7 @@ function actionReducer(state, action) {
       case "StartProcessingBatch" :
           return [
                   {
-                    indexer: state.indexer,
+                    ctx: state.ctx,
                     chainManager: state.chainManager,
                     processedBatches: state.processedBatches,
                     currentlyProcessingBatch: true,
@@ -596,7 +596,7 @@ function actionReducer(state, action) {
       case "StartFindingReorgDepth" :
           return [
                   {
-                    indexer: state.indexer,
+                    ctx: state.ctx,
                     chainManager: state.chainManager,
                     processedBatches: state.processedBatches,
                     currentlyProcessingBatch: state.currentlyProcessingBatch,
@@ -656,12 +656,12 @@ function actionReducer(state, action) {
                     return chainFetcher;
                   }
                 }));
-          var isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.indexer.config.shouldRollbackOnReorg;
+          var isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
           var shouldEnterReorgThreshold = isBelowReorgThreshold && Belt_Array.every(ChainMap.values(updatedChainFetchers), (function (chainFetcher) {
                   return FetchState.isReadyToEnterReorgThreshold(chainFetcher.fetchState);
                 }));
           var init = state.chainManager;
-          var state_indexer = state.indexer;
+          var state_ctx = state.ctx;
           var state_chainManager = {
             committedCheckpointId: init.committedCheckpointId,
             chainFetchers: updatedChainFetchers,
@@ -677,7 +677,7 @@ function actionReducer(state, action) {
           var state_keepProcessAlive = state.keepProcessAlive;
           var state_id = state.id;
           var state$1 = {
-            indexer: state_indexer,
+            ctx: state_ctx,
             chainManager: state_chainManager,
             processedBatches: state_processedBatches,
             currentlyProcessingBatch: state_currentlyProcessingBatch,
@@ -715,9 +715,9 @@ function actionReducer(state, action) {
                   ];
           }
       case "EventBatchProcessed" :
-          var maybePruneEntityHistory = Config.shouldPruneHistory(state.indexer.config, state.chainManager.isInReorgThreshold) ? ["PruneStaleEntityHistory"] : [];
-          var state_indexer$1 = state.indexer;
-          var state_chainManager$1 = updateProgressedChains(state.chainManager, action.batch, state.indexer);
+          var maybePruneEntityHistory = Config.shouldPruneHistory(state.ctx.config, state.chainManager.isInReorgThreshold) ? ["PruneStaleEntityHistory"] : [];
+          var state_ctx$1 = state.ctx;
+          var state_chainManager$1 = updateProgressedChains(state.chainManager, action.batch, state.ctx);
           var state_processedBatches$1 = state.processedBatches + 1 | 0;
           var state_indexerStartTime$1 = state.indexerStartTime;
           var state_writeThrottlers$1 = state.writeThrottlers;
@@ -725,7 +725,7 @@ function actionReducer(state, action) {
           var state_keepProcessAlive$1 = state.keepProcessAlive;
           var state_id$1 = state.id;
           var state$2 = {
-            indexer: state_indexer$1,
+            ctx: state_ctx$1,
             chainManager: state_chainManager$1,
             processedBatches: state_processedBatches$1,
             currentlyProcessingBatch: false,
@@ -750,7 +750,7 @@ function actionReducer(state, action) {
       case "FindReorgDepth" :
           return [
                   {
-                    indexer: state.indexer,
+                    ctx: state.ctx,
                     chainManager: state.chainManager,
                     processedBatches: state.processedBatches,
                     currentlyProcessingBatch: state.currentlyProcessingBatch,
@@ -800,7 +800,7 @@ function actionReducer(state, action) {
           };
           return [
                   {
-                    indexer: state.indexer,
+                    ctx: state.ctx,
                     chainManager: chainManager,
                     processedBatches: state.processedBatches,
                     currentlyProcessingBatch: state.currentlyProcessingBatch,
@@ -826,7 +826,7 @@ function actionReducer(state, action) {
       case "SetRollbackState" :
           return [
                   {
-                    indexer: state.indexer,
+                    ctx: state.ctx,
                     chainManager: action.rollbackedChainManager,
                     processedBatches: state.processedBatches,
                     currentlyProcessingBatch: state.currentlyProcessingBatch,
@@ -862,8 +862,8 @@ function invalidatedActionReducer(state, action) {
             Logging.info("Finished processing batch before rollback, actioning rollback");
             return [
                     {
-                      indexer: state.indexer,
-                      chainManager: updateProgressedChains(state.chainManager, action.batch, state.indexer),
+                      ctx: state.ctx,
+                      chainManager: updateProgressedChains(state.chainManager, action.batch, state.ctx),
                       processedBatches: state.processedBatches + 1 | 0,
                       currentlyProcessingBatch: false,
                       rollbackState: state.rollbackState,
@@ -942,12 +942,12 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
             var match = state.rollbackState;
             var rollbackInMemStore;
             rollbackInMemStore = typeof match !== "object" || match.TAG !== "RollbackReady" ? undefined : match.diffInMemoryStore;
-            var batch = ChainManager.createBatch(state.chainManager, state.indexer.config.batchSize, rollbackInMemStore !== undefined);
+            var batch = ChainManager.createBatch(state.chainManager, state.ctx.config.batchSize, rollbackInMemStore !== undefined);
             var progressedChainsById = batch.progressedChainsById;
             var totalBatchSize = batch.totalBatchSize;
             var isInReorgThreshold = state.chainManager.isInReorgThreshold;
-            var shouldSaveHistory = Config.shouldSaveHistory(state.indexer.config, isInReorgThreshold);
-            var isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.indexer.config.shouldRollbackOnReorg;
+            var shouldSaveHistory = Config.shouldSaveHistory(state.ctx.config, isInReorgThreshold);
+            var isBelowReorgThreshold = !state.chainManager.isInReorgThreshold && state.ctx.config.shouldRollbackOnReorg;
             var shouldEnterReorgThreshold = isBelowReorgThreshold && Belt_Array.every(ChainMap.values(state.chainManager.chainFetchers), (function (chainFetcher) {
                     var chainAfterBatch = progressedChainsById[chainFetcher.fetchState.chainId];
                     var fetchState = chainAfterBatch !== undefined ? chainAfterBatch.fetchState : chainFetcher.fetchState;
@@ -968,11 +968,11 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                   progressedChainsById: progressedChainsById,
                   shouldEnterReorgThreshold: shouldEnterReorgThreshold
                 });
-            var inMemoryStore = Belt_Option.getWithDefault(rollbackInMemStore, InMemoryStore.make(state.indexer.persistence.allEntities, undefined));
+            var inMemoryStore = Belt_Option.getWithDefault(rollbackInMemStore, InMemoryStore.make(state.ctx.persistence.allEntities, undefined));
             InMemoryStore.setBatchDcs(inMemoryStore, batch, shouldSaveHistory);
             var res;
             try {
-              res = await EventProcessing.processEventBatch(batch, inMemoryStore, isInReorgThreshold, state.loadManager, state.indexer, state.chainManager.chainFetchers);
+              res = await EventProcessing.processEventBatch(batch, inMemoryStore, isInReorgThreshold, state.loadManager, state.ctx, state.chainManager.chainFetchers);
             }
             catch (raw_exn){
               var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
@@ -1030,12 +1030,12 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                       });
                   Logging.childInfo(logger, "Started rollback on reorg");
                   Prometheus.RollbackTargetBlockNumber.set(rollbackTargetBlockNumber$1, reorgChain);
-                  var match$3 = await state.indexer.persistence.storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber$1);
+                  var match$3 = await state.ctx.persistence.storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber$1);
                   var rollbackTargetCheckpointId = match$3.length !== 1 ? 0 : match$3[0].id;
                   var eventsProcessedDiffByChain = {};
                   var newProgressBlockNumberPerChain = {};
                   var rollbackedProcessedEvents = 0;
-                  var rollbackProgressDiff = await state.indexer.persistence.storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
+                  var rollbackProgressDiff = await state.ctx.persistence.storage.getRollbackProgressDiff(rollbackTargetCheckpointId);
                   for(var idx = 0 ,idx_finish = rollbackProgressDiff.length; idx < idx_finish; ++idx){
                     var diff = rollbackProgressDiff[idx];
                     var eventsProcessedDiff = Belt_Int.fromString(diff.events_processed_diff);
@@ -1078,7 +1078,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
                                   safeCheckpointTracking: safeCheckpointTracking !== undefined ? SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber) : undefined
                                 };
                         }));
-                  var diff$1 = await Persistence.prepareRollbackDiff(state.indexer.persistence, rollbackTargetCheckpointId, state.chainManager.committedCheckpointId + 1);
+                  var diff$1 = await Persistence.prepareRollbackDiff(state.ctx.persistence, rollbackTargetCheckpointId, state.chainManager.committedCheckpointId + 1);
                   var init = state.chainManager;
                   var chainManager_committedCheckpointId = init.committedCheckpointId;
                   var chainManager_multichain = init.multichain;
@@ -1116,15 +1116,15 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
               if (safeCheckpointId === undefined) {
                 return ;
               }
-              await state.indexer.persistence.storage.pruneStaleCheckpoints(safeCheckpointId);
-              for(var idx = 0 ,idx_finish = state.indexer.persistence.allEntities.length; idx < idx_finish; ++idx){
+              await state.ctx.persistence.storage.pruneStaleCheckpoints(safeCheckpointId);
+              for(var idx = 0 ,idx_finish = state.ctx.persistence.allEntities.length; idx < idx_finish; ++idx){
                 if (idx !== 0) {
                   await Utils.delay(1000);
                 }
-                var entityConfig = state.indexer.persistence.allEntities[idx];
+                var entityConfig = state.ctx.persistence.allEntities[idx];
                 var timeRef = Hrtime.makeTimer();
                 try {
-                  await state.indexer.persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+                  await state.ctx.persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
                 }
                 catch (raw_exn){
                   var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
@@ -1158,10 +1158,10 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
             var writeThrottlers = state.writeThrottlers;
             var chainManager$1 = state.chainManager;
             if (task._0 === "ExitWithSuccess") {
-              updateChainMetadataTable(chainManager$1, state.indexer.persistence, writeThrottlers.chainMetaData);
+              updateChainMetadataTable(chainManager$1, state.ctx.persistence, writeThrottlers.chainMetaData);
               return dispatchAction("SuccessExit");
             }
-            updateChainMetadataTable(chainManager$1, state.indexer.persistence, writeThrottlers.chainMetaData);
+            updateChainMetadataTable(chainManager$1, state.ctx.persistence, writeThrottlers.chainMetaData);
             return ;
         
       }

package/src/GlobalStateManager.res

@@ -0,0 +1,68 @@
+open Belt
+module type State = {
+  type t
+  type action
+  type task
+
+  let taskReducer: (t, task, ~dispatchAction: action => unit) => promise<unit>
+  let actionReducer: (t, action) => (t, array<task>)
+  let invalidatedActionReducer: (t, action) => (t, array<task>)
+  let getId: t => int
+}
+
+module MakeManager = (S: State) => {
+  type t = {mutable state: S.t, onError: exn => unit}
+
+  let make = (
+    state: S.t,
+    ~onError=e => {
+      e->ErrorHandling.make(~msg="Indexer has failed with an unexpected error")->ErrorHandling.log
+      NodeJs.process->NodeJs.exitWithCode(Failure)
+    },
+  ) => {
+    state,
+    onError,
+  }
+
+  let rec dispatchAction = (~stateId=0, self: t, action: S.action) => {
+    try {
+      let reducer = if stateId == self.state->S.getId {
+        S.actionReducer
+      } else {
+        S.invalidatedActionReducer
+      }
+      let (nextState, nextTasks) = reducer(self.state, action)
+      self.state = nextState
+      nextTasks->Array.forEach(task => dispatchTask(self, task))
+    } catch {
+    | e => e->self.onError
+    }
+  }
+  and dispatchTask = (self, task: S.task) => {
+    let stateId = self.state->S.getId
+    Js.Global.setTimeout(() => {
+      if stateId !== self.state->S.getId {
+        Logging.info("Invalidated task discarded")
+      } else {
+        try {
+          S.taskReducer(self.state, task, ~dispatchAction=action =>
+            dispatchAction(~stateId, self, action)
+          )
+          ->Promise.catch(e => {
+            e->self.onError
+            Promise.resolve()
+          })
+          ->ignore
+        } catch {
+        | e => e->self.onError
+        }
+      }
+    }, 0)->ignore
+  }
+
+  let getState = self => self.state
+  let setState = (self: t, state: S.t) => self.state = state
+}
+
+module Manager = MakeManager(GlobalState)
+include Manager

package/src/GlobalStateManager.res.mjs

@@ -0,0 +1,75 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Logging from "./Logging.res.mjs";
+import * as $$Promise from "./bindings/Promise.res.mjs";
+import * as Process from "process";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as GlobalState from "./GlobalState.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+
+function make(state, onErrorOpt) {
+  var onError = onErrorOpt !== undefined ? onErrorOpt : (function (e) {
+        ErrorHandling.log(ErrorHandling.make(e, undefined, "Indexer has failed with an unexpected error"));
+        Process.exit(1);
+      });
+  return {
+          state: state,
+          onError: onError
+        };
+}
+
+function dispatchAction(stateIdOpt, self, action) {
+  var stateId = stateIdOpt !== undefined ? stateIdOpt : 0;
+  try {
+    var reducer = stateId === GlobalState.getId(self.state) ? GlobalState.actionReducer : GlobalState.invalidatedActionReducer;
+    var match = reducer(self.state, action);
+    self.state = match[0];
+    return Belt_Array.forEach(match[1], (function (task) {
+                  dispatchTask(self, task);
+                }));
+  }
+  catch (raw_e){
+    var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+    return self.onError(e);
+  }
+}
+
+function dispatchTask(self, task) {
+  var stateId = GlobalState.getId(self.state);
+  setTimeout((function () {
+          if (stateId !== GlobalState.getId(self.state)) {
+            return Logging.info("Invalidated task discarded");
+          }
+          try {
+            $$Promise.$$catch(GlobalState.taskReducer(self.state, task, (function (action) {
+                        dispatchAction(stateId, self, action);
+                      })), (function (e) {
+                    self.onError(e);
+                    return Promise.resolve();
+                  }));
+            return ;
+          }
+          catch (raw_e){
+            var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+            return self.onError(e);
+          }
+        }), 0);
+}
+
+function getState(self) {
+  return self.state;
+}
+
+function setState(self, state) {
+  self.state = state;
+}
+
+export {
+  make ,
+  dispatchAction ,
+  dispatchTask ,
+  getState ,
+  setState ,
+}
+/* Logging Not a pure module */

package/src/GlobalStateManager.resi

@@ -0,0 +1,7 @@
+type t
+
+let make: (GlobalState.t, ~onError: exn => unit=?) => t
+let dispatchAction: (~stateId: int=?, t, GlobalState.action) => unit
+let dispatchTask: (t, GlobalState.task) => unit
+let getState: t => GlobalState.t
+let setState: (t, GlobalState.t) => unit

package/src/Internal.res

@@ -2,6 +2,47 @@ type eventParams
 type eventBlock
 type eventTransaction
 
+// Shared EVM transaction fields type used by both RPC and HyperSync sources
+// Field names match HyperSyncClient.ResponseTypes.transaction for consistency
+type evmTransactionFields = {
+  from?: Address.t,
+  to?: Address.t,
+  gas?: bigint,
+  gasPrice?: bigint,
+  hash?: string,
+  input?: string,
+  nonce?: bigint,
+  transactionIndex?: int,
+  value?: bigint,
+  // Signature fields - optional for ZKSync EIP-712 compatibility
+  v?: string,
+  r?: string,
+  s?: string,
+  yParity?: string,
+  // EIP-1559 fields
+  maxPriorityFeePerGas?: bigint,
+  maxFeePerGas?: bigint,
+  // EIP-4844 blob fields
+  maxFeePerBlobGas?: bigint,
+  blobVersionedHashes?: array<string>,
+  // Receipt fields (from joined transaction receipts)
+  cumulativeGasUsed?: bigint,
+  effectiveGasPrice?: bigint,
+  gasUsed?: bigint,
+  contractAddress?: string,
+  logsBloom?: string,
+  @as("type")
+  type_?: int,
+  root?: string,
+  status?: int,
+  // L2 specific fields (Optimism, Arbitrum, etc.)
+  l1Fee?: bigint,
+  l1GasPrice?: bigint,
+  l1GasUsed?: bigint,
+  l1FeeScalar?: int,
+  gasUsedForL1?: bigint,
+}
+
 @genType
 type genericEvent<'params, 'block, 'transaction> = {
   params: 'params,
@@ -65,7 +106,6 @@ type chains = dict<chainInfo>
 type loaderReturn
 type handlerContext = private {
   isPreload: bool,
-  chains: chains,
   chain: chainInfo,
 }
 type handlerArgs = {

package/src/LogSelection.res

@@ -84,38 +84,44 @@ let parseEventFiltersOrThrow = {
     }
 
     let parse = (eventFilters: Js.Json.t): array<Internal.topicSelection> => {
-      switch eventFilters {
-      | Array([]) => [%raw(`{}`)]
-      | Array(a) => a
-      | _ => [eventFilters]
-      }->Js.Array2.map(eventFilter => {
-        switch eventFilter {
-        | Object(eventFilter) => {
-            let filterKeys = eventFilter->Js.Dict.keys
-            switch filterKeys {
-            | [] => default
-            | _ => {
-                filterKeys->Js.Array2.forEach(key => {
-                  if params->Js.Array2.includes(key)->not {
-                    // In TS type validation doesn't catch this
-                    // when we have eventFilters as a callback
-                    Js.Exn.raiseError(
-                      `Invalid event filters configuration. The event doesn't have an indexed parameter "${key}" and can't use it for filtering`,
-                    )
+      if eventFilters === Obj.magic(true) {
+        [default]
+      } else if eventFilters === Obj.magic(false) {
+        []
+      } else {
+        switch eventFilters {
+        | Array([]) => [%raw(`{}`)]
+        | Array(a) => a
+        | _ => [eventFilters]
+        }->Js.Array2.map(eventFilter => {
+          switch eventFilter {
+          | Object(eventFilter) => {
+              let filterKeys = eventFilter->Js.Dict.keys
+              switch filterKeys {
+              | [] => default
+              | _ => {
+                  filterKeys->Js.Array2.forEach(key => {
+                    if params->Js.Array2.includes(key)->not {
+                      // In TS type validation doesn't catch this
+                      // when we have eventFilters as a callback
+                      Js.Exn.raiseError(
+                        `Invalid event filters configuration. The event doesn't have an indexed parameter "${key}" and can't use it for filtering`,
+                      )
+                    }
+                  })
+                  {
+                    Internal.topic0,
+                    topic1: topic1(eventFilter),
+                    topic2: topic2(eventFilter),
+                    topic3: topic3(eventFilter),
                   }
-                })
-                {
-                  Internal.topic0,
-                  topic1: topic1(eventFilter),
-                  topic2: topic2(eventFilter),
-                  topic3: topic3(eventFilter),
                 }
               }
             }
+          | _ => Js.Exn.raiseError("Invalid event filters configuration. Expected an object")
           }
-        | _ => Js.Exn.raiseError("Invalid event filters configuration. Expected an object")
-        }
-      })
+        })
+      }
     }
 
     let getEventFiltersOrThrow = switch eventFilters {

package/src/LogSelection.res.mjs

@@ -100,6 +100,12 @@ function parseEventFiltersOrThrow(eventFilters, sighash, params, topic1Opt, topi
     topic3: emptyTopics
   };
   var parse = function (eventFilters) {
+    if (eventFilters === true) {
+      return [$$default];
+    }
+    if (eventFilters === false) {
+      return [];
+    }
     var tmp;
     tmp = !Array.isArray(eventFilters) && (eventFilters === null || typeof eventFilters !== "object") && typeof eventFilters !== "number" && typeof eventFilters !== "string" && typeof eventFilters !== "boolean" ? [eventFilters] : (
         Array.isArray(eventFilters) ? (