envio 3.3.0-alpha.6 → 3.3.0-alpha.8

package/src/HandlerLoader.res

@@ -72,116 +72,12 @@ let autoLoadFromSrcHandlers = async (~handlers: string) => {
   ->Promise.all
 }
 
-// EVM re-runs `parseEventFiltersOrThrow` with the registered `where:` JSON so
-// per-event filters propagate into `getEventFiltersOrThrow` / `filterByAddresses`
-// — which is why `evmEventConfig` has to retain `sighash` and `indexedParams`.
-// `dependsOnAddresses` is routed through `Internal.dependsOnAddresses` so the
-// formula stays in sync with `EventConfigBuilder.build{Evm,Fuel}EventConfig`.
-let applyRegistrations = (~config: Config.t): Config.t => {
-  let newChainMap = config.chainMap->ChainMap.map(chain => {
-    let newContracts = chain.contracts->Array.map(contract => {
-      let newEvents = contract.events->Array.map(
-        ev => {
-          let isWildcard = HandlerRegister.isWildcard(
-            ~contractName=ev.contractName,
-            ~eventName=ev.name,
-          )
-          let handler = HandlerRegister.getHandler(
-            ~contractName=ev.contractName,
-            ~eventName=ev.name,
-          )
-          let contractRegister = HandlerRegister.getContractRegister(
-            ~contractName=ev.contractName,
-            ~eventName=ev.name,
-          )
-          switch config.ecosystem.name {
-          | Fuel =>
-            let fuelEv = ev->(Utils.magic: Internal.eventConfig => Internal.fuelEventConfig)
-
-            ({
-              ...fuelEv,
-              isWildcard,
-              handler,
-              contractRegister,
-              clientAddressFilter: ?EventConfigBuilder.buildAddressFilter([], ~isWildcard),
-              dependsOnAddresses: Internal.dependsOnAddresses(
-                ~isWildcard,
-                ~filterByAddresses=false,
-              ),
-            } :> Internal.eventConfig)
-          | Evm =>
-            let evmEv = ev->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
-            let eventFilters = HandlerRegister.getOnEventWhere(
-              ~contractName=ev.contractName,
-              ~eventName=ev.name,
-            )
-            let indexedParams = evmEv.paramsMetadata->Array.filter(p => p.indexed)
-            let {
-              getEventFiltersOrThrow,
-              filterByAddresses,
-              addressFilterParamGroups,
-            } = LogSelection.parseEventFiltersOrThrow(
-              ~eventFilters,
-              ~sighash=evmEv.sighash,
-              ~params=indexedParams->Array.map(p => p.name),
-              ~contractName=ev.contractName,
-              ~probeChainId=chain.id,
-              ~onEventBlockFilterSchema=config.ecosystem.onEventBlockFilterSchema,
-              ~topic1=?indexedParams
-              ->Array.get(0)
-              ->Option.map(EventConfigBuilder.buildTopicGetter),
-              ~topic2=?indexedParams
-              ->Array.get(1)
-              ->Option.map(EventConfigBuilder.buildTopicGetter),
-              ~topic3=?indexedParams
-              ->Array.get(2)
-              ->Option.map(EventConfigBuilder.buildTopicGetter),
-            )
-
-            ({
-              ...evmEv,
-              isWildcard,
-              handler,
-              contractRegister,
-              getEventFiltersOrThrow,
-              filterByAddresses,
-              clientAddressFilter: ?EventConfigBuilder.buildAddressFilter(
-                addressFilterParamGroups,
-                ~isWildcard,
-              ),
-              dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
-            } :> Internal.eventConfig)
-          | Svm =>
-            let svmEv =
-              ev->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
-            ({
-              ...svmEv,
-              isWildcard,
-              handler,
-              contractRegister,
-              clientAddressFilter: ?EventConfigBuilder.buildAddressFilter(
-                [],
-                ~isWildcard,
-                ~srcAddressExpr="event.programId",
-              ),
-              dependsOnAddresses: Internal.dependsOnAddresses(
-                ~isWildcard,
-                ~filterByAddresses=false,
-              ),
-            } :> Internal.eventConfig)
-          }
-        },
-      )
-      {...contract, events: newEvents}
-    })
-    {...chain, contracts: newContracts}
-  })
-  {...config, chainMap: newChainMap}
-}
-
-// `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) => {
+// `Config` holds only event definitions; handler + per-chain `where`
+// registration state is layered on separately as `onEventRegistration`s by
+// `HandlerRegister.finishRegistration`. This loads the user handler files
+// (populating the global `HandlerRegister` registry as a side effect) and
+// returns the resulting per-chain registrations.
+let registerAllHandlers = async (~config: Config.t): HandlerRegister.registrationsByChainId => {
   HandlerRegister.startRegistration(~ecosystem=config.ecosystem)
 
   // Auto-load all .js files from src/handlers directory
@@ -194,6 +90,5 @@ let registerAllHandlers = async (~config: Config.t) => {
   })
   ->Promise.all
 
-  let registrations = HandlerRegister.finishRegistration()
-  (applyRegistrations(~config), registrations)
+  HandlerRegister.finishRegistration(~config)
 }

package/src/HandlerLoader.res.mjs

@@ -5,16 +5,11 @@ import * as Path from "path";
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Process from "process";
-import * as ChainMap from "./ChainMap.res.mjs";
-import * as Internal from "./Internal.res.mjs";
 import * as Nodemodule from "node:module";
-import * as LogSelection from "./LogSelection.res.mjs";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Promises from "node:fs/promises";
-import * as EventConfigBuilder from "./EventConfigBuilder.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 try {
@@ -61,98 +56,17 @@ async function autoLoadFromSrcHandlers(handlers) {
   })));
 }
 
-function applyRegistrations(config) {
-  let newChainMap = ChainMap.map(config.chainMap, chain => {
-    let newContracts = chain.contracts.map(contract => {
-      let newEvents = contract.events.map(ev => {
-        let isWildcard = HandlerRegister.isWildcard(ev.contractName, ev.name);
-        let handler = HandlerRegister.getHandler(ev.contractName, ev.name);
-        let contractRegister = HandlerRegister.getContractRegister(ev.contractName, ev.name);
-        let match = config.ecosystem.name;
-        switch (match) {
-          case "evm" :
-            let eventFilters = HandlerRegister.getOnEventWhere(ev.contractName, ev.name);
-            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;
-            let newrecord = {...ev};
-            newrecord.getEventFiltersOrThrow = match$1.getEventFiltersOrThrow;
-            newrecord.contractRegister = contractRegister;
-            newrecord.handler = handler;
-            newrecord.clientAddressFilter = EventConfigBuilder.buildAddressFilter(match$1.addressFilterParamGroups, isWildcard, undefined);
-            newrecord.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, filterByAddresses);
-            newrecord.filterByAddresses = filterByAddresses;
-            newrecord.isWildcard = isWildcard;
-            return newrecord;
-          case "fuel" :
-            let newrecord$1 = {...ev};
-            newrecord$1.contractRegister = contractRegister;
-            newrecord$1.handler = handler;
-            newrecord$1.clientAddressFilter = EventConfigBuilder.buildAddressFilter([], isWildcard, undefined);
-            newrecord$1.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, false);
-            newrecord$1.isWildcard = isWildcard;
-            return newrecord$1;
-          case "svm" :
-            let newrecord$2 = {...ev};
-            newrecord$2.contractRegister = contractRegister;
-            newrecord$2.handler = handler;
-            newrecord$2.clientAddressFilter = EventConfigBuilder.buildAddressFilter([], isWildcard, "event.programId");
-            newrecord$2.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, false);
-            newrecord$2.isWildcard = isWildcard;
-            return newrecord$2;
-        }
-      });
-      return {
-        name: contract.name,
-        abi: contract.abi,
-        addresses: contract.addresses,
-        events: newEvents,
-        startBlock: contract.startBlock
-      };
-    });
-    let newrecord = {...chain};
-    newrecord.contracts = newContracts;
-    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);
   await autoLoadFromSrcHandlers(config.handlers);
   await Promise.all(config.contractHandlers.map(param => registerContractHandlers(param.name, param.handler)));
-  let registrations = HandlerRegister.finishRegistration();
-  return [
-    applyRegistrations(config),
-    registrations
-  ];
+  return HandlerRegister.finishRegistration(config);
 }
 
 export {
   toImportUrl,
   registerContractHandlers,
   autoLoadFromSrcHandlers,
-  applyRegistrations,
   registerAllHandlers,
 }
 /*  Not a pure module */

package/src/HandlerRegister.res

@@ -10,18 +10,30 @@ let empty = {
   eventOptions: None,
 }
 
-type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
+// Per-chain onEventRegistrations built from the event definitions in
+// `Config.t` plus whatever handler/contractRegister/eventOptions got
+// registered for them, and the onBlock registrations collected during
+// registration.
+type chainRegistrations = {
+  onEventRegistrations: array<Internal.onEventRegistration>,
+  onBlockRegistrations: array<Internal.onBlockRegistration>,
+}
+
+// The finished registration state returned by `finishRegistration`.
+type registrationsByChainId = dict<chainRegistrations>
+
+type pendingRegistrations = {onBlockByChainId: dict<array<Internal.onBlockRegistration>>}
 
 type activeRegistration = {
   ecosystem: Ecosystem.t,
-  registrations: registrations,
+  registrations: pendingRegistrations,
   mutable finished: bool,
 }
 
 // Stashed on `globalThis` so a duplicate envio module instance — e.g. when the
 // CLI's `bin.mjs` resolves envio from one path but the user's handlers resolve
 // it from `node_modules/envio` — shares one registry. Without this, each copy
-// keeps its own dict and `applyRegistrations` reads empty state.
+// keeps its own dict and `buildOnEventRegistrations` reads empty state.
 //
 // Version-gated: the record shapes below can evolve between envio versions,
 // so the guard uses strict full-version equality. On mismatch we throw with
@@ -119,11 +131,202 @@ let startRegistration = (~ecosystem) => {
   }
 }
 
-let finishRegistration = () => {
+// Enrich one event definition into its (event, chain) registration using
+// whatever handler/contractRegister/where the user registered for it. Shared
+// by chain startup (`buildOnEventRegistrations`), `simulate`, and test
+// helpers so the three stay in sync instead of re-deriving the per-ecosystem
+// dispatch each place.
+let buildOnEventRegistration = (
+  ~config: Config.t,
+  ~chainId: int,
+  ~eventConfig: Internal.eventConfig,
+  ~startBlock=?,
+): Internal.onEventRegistration => {
+  let contractName = eventConfig.contractName
+  let eventName = eventConfig.name
+  let t = get(~contractName, ~eventName)
+  let isWildcard = t.eventOptions->Option.flatMap(v => v.wildcard)->Option.getOr(false)
+  let handler = t.handler
+  let contractRegister = t.contractRegister
+
+  switch config.ecosystem.name {
+  | Fuel =>
+    (EventConfigBuilder.buildFuelOnEventRegistration(
+      ~eventConfig=eventConfig->(Utils.magic: Internal.eventConfig => Internal.fuelEventConfig),
+      ~isWildcard,
+      ~handler,
+      ~contractRegister,
+      ~startBlock?,
+    ) :> Internal.onEventRegistration)
+  | Svm =>
+    (EventConfigBuilder.buildSvmOnEventRegistration(
+      ~eventConfig=eventConfig->(
+        Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig
+      ),
+      ~isWildcard,
+      ~handler,
+      ~contractRegister,
+      ~startBlock?,
+    ) :> Internal.onEventRegistration)
+  | Evm =>
+    (EventConfigBuilder.buildEvmOnEventRegistration(
+      ~eventConfig=eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig),
+      ~isWildcard,
+      ~handler,
+      ~contractRegister,
+      ~eventFilters=t.eventOptions->Option.flatMap(v => v.where),
+      ~probeChainId=chainId,
+      ~onEventBlockFilterSchema=config.ecosystem.onEventBlockFilterSchema,
+      ~startBlock?,
+    ) :> Internal.onEventRegistration)
+  }
+}
+
+// Enrich a chain's static event definitions with the registered
+// handler/contractRegister/where (validating them along the way) to produce
+// the onEventRegistrations ChainState indexes off. Runs once per chain when
+// registration finishes, so a bad `where`/duplicate event throws during
+// startup with a stack trace pointing here instead of surfacing later from
+// inside ChainState's construction. Events without a handler/contractRegister
+// get added to `notRegisteredEventsByContract` (event names grouped by
+// contract name) so the caller can report them once for the whole indexer
+// instead of per chain.
+let buildOnEventRegistrations = (
+  ~chainConfig: Config.chain,
+  ~config: Config.t,
+  ~notRegisteredEventsByContract: dict<Utils.Set.t<string>>,
+): array<Internal.onEventRegistration> => {
+  // We don't need the router itself, but only validation logic,
+  // since now event router is created for selection of events
+  // and validation doesn't work correctly in routers.
+  // Ideally to split it into two different parts.
+  let eventRouter = EventRouter.empty()
+
+  let onEventRegistrations: array<Internal.onEventRegistration> = []
+
+  chainConfig.contracts->Array.forEach(contract => {
+    let contractName = contract.name
+
+    contract.events->Array.forEach(eventConfig => {
+      let eventName = eventConfig.name
+
+      let onEventRegistration = buildOnEventRegistration(
+        ~config,
+        ~chainId=chainConfig.id,
+        ~eventConfig,
+        ~startBlock=?contract.startBlock,
+      )
+      let {isWildcard, handler, contractRegister} = onEventRegistration
+
+      // Should validate the events
+      eventRouter->EventRouter.addOrThrow(
+        eventConfig.id,
+        (),
+        ~contractName,
+        ~chain=ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id),
+        ~eventName,
+        ~isWildcard,
+      )
+
+      // Filter out events without a handler/contractRegister so they aren't
+      // fetched or dispatched (unless raw events are enabled).
+      let shouldBeIncluded = if config.enableRawEvents {
+        true
+      } else {
+        let isRegistered = contractRegister->Option.isSome || handler->Option.isSome
+        if !isRegistered {
+          let eventNames = switch notRegisteredEventsByContract->Utils.Dict.dangerouslyGetNonOption(
+            contractName,
+          ) {
+          | Some(set) => set
+          | None => {
+              let set = Utils.Set.make()
+              notRegisteredEventsByContract->Dict.set(contractName, set)
+              set
+            }
+          }
+          eventNames->Utils.Set.add(eventName)->ignore
+        }
+        isRegistered
+      }
+
+      // Check if event has Static([]) filters (from a dynamic where
+      // callback returning `false` / SkipAll for this chain).
+      // If so, skip it entirely - it should never be fetched
+      let shouldSkip = try {
+        let getEventFiltersOrThrow = (
+          onEventRegistration->(
+            Utils.magic: Internal.onEventRegistration => Internal.evmOnEventRegistration
+          )
+        ).getEventFiltersOrThrow
+
+        // Check for non-evm chains
+        if (
+          getEventFiltersOrThrow->(Utils.magic: (ChainMap.Chain.t => Internal.eventFilters) => bool)
+        ) {
+          switch getEventFiltersOrThrow(ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)) {
+          | Static([]) => true
+          | _ => false
+          }
+        } else {
+          false
+        }
+      } catch {
+      // Can throw when filter is invalid
+      // Don't skip an event in this case. Let it throw in a better place - source code
+      | _ => false
+      }
+
+      if shouldBeIncluded && !shouldSkip {
+        onEventRegistrations->Array.push(onEventRegistration)
+      }
+    })
+  })
+
+  onEventRegistrations
+}
+
+let finishRegistration = (~config: Config.t): registrationsByChainId => {
   switch activeRegistration.contents {
   | Some(r) => {
       r.finished = true
-      r.registrations
+      let notRegisteredEventsByContract: dict<Utils.Set.t<string>> = Dict.make()
+      let registrationsByChainId: registrationsByChainId = Dict.make()
+      config.chainMap
+      ->ChainMap.values
+      ->Array.forEach(chainConfig => {
+        let key = chainConfig.id->Int.toString
+        registrationsByChainId->Dict.set(
+          key,
+          {
+            onEventRegistrations: buildOnEventRegistrations(
+              ~chainConfig,
+              ~config,
+              ~notRegisteredEventsByContract,
+            ),
+            onBlockRegistrations: r.registrations.onBlockByChainId
+            ->Utils.Dict.dangerouslyGetNonOption(key)
+            ->Option.getOr([]),
+          },
+        )
+      })
+
+      // Reported once for the whole indexer (a shared contract on multiple
+      // chains would otherwise repeat the same message per chain).
+      let notRegisteredEntries = notRegisteredEventsByContract->Dict.toArray
+      if notRegisteredEntries->Utils.Array.notEmpty {
+        let groups =
+          notRegisteredEntries
+          ->Array.map(((contractName, eventNames)) =>
+            `${contractName} (${eventNames->Utils.Set.toArray->Array.joinUnsafe(", ")})`
+          )
+          ->Array.joinUnsafe(", ")
+        Logging.getLogger()->Logging.childInfo(
+          `Events without a handler, skipped for indexing: ${groups}`,
+        )
+      }
+
+      registrationsByChainId
     }
   | None =>
     JsError.throwWithMessage(
@@ -178,7 +381,7 @@ let registerOnBlock = (
           interval,
           chainId,
           handler,
-        }: Internal.onBlockConfig
+        }: Internal.onBlockRegistration
       ),
     )
   })

package/src/HandlerRegister.res.mjs

@@ -2,9 +2,13 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as EventRouter from "./sources/EventRouter.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as EventConfigBuilder from "./EventConfigBuilder.res.mjs";
 
 let version = Utils.EnvioPackage.value.version;
 
@@ -88,14 +92,94 @@ function startRegistration(ecosystem) {
   };
 }
 
-function finishRegistration() {
+function buildOnEventRegistration(config, chainId, eventConfig, startBlock) {
+  let contractName = eventConfig.contractName;
+  let eventName = eventConfig.name;
+  let t = get(contractName, eventName);
+  let isWildcard = Stdlib_Option.getOr(Stdlib_Option.flatMap(t.eventOptions, v => v.wildcard), false);
+  let handler = t.handler;
+  let contractRegister = t.contractRegister;
+  let match = config.ecosystem.name;
+  switch (match) {
+    case "evm" :
+      return EventConfigBuilder.buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, Stdlib_Option.flatMap(t.eventOptions, v => v.where), chainId, config.ecosystem.onEventBlockFilterSchema, startBlock);
+    case "fuel" :
+      return EventConfigBuilder.buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
+    case "svm" :
+      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
+  }
+}
+
+function buildOnEventRegistrations(chainConfig, config, notRegisteredEventsByContract) {
+  let eventRouter = EventRouter.empty();
+  let onEventRegistrations = [];
+  chainConfig.contracts.forEach(contract => {
+    let contractName = contract.name;
+    contract.events.forEach(eventConfig => {
+      let eventName = eventConfig.name;
+      let onEventRegistration = buildOnEventRegistration(config, chainConfig.id, eventConfig, contract.startBlock);
+      EventRouter.addOrThrow(eventRouter, eventConfig.id, undefined, contractName, onEventRegistration.isWildcard, eventName, ChainMap.Chain.makeUnsafe(chainConfig.id));
+      let shouldBeIncluded;
+      if (config.enableRawEvents) {
+        shouldBeIncluded = true;
+      } else {
+        let isRegistered = Stdlib_Option.isSome(onEventRegistration.contractRegister) || Stdlib_Option.isSome(onEventRegistration.handler);
+        if (!isRegistered) {
+          let set = notRegisteredEventsByContract[contractName];
+          let eventNames;
+          if (set !== undefined) {
+            eventNames = Primitive_option.valFromOption(set);
+          } else {
+            let set$1 = new Set();
+            notRegisteredEventsByContract[contractName] = set$1;
+            eventNames = set$1;
+          }
+          eventNames.add(eventName);
+        }
+        shouldBeIncluded = isRegistered;
+      }
+      let shouldSkip;
+      try {
+        let getEventFiltersOrThrow = onEventRegistration.getEventFiltersOrThrow;
+        if (getEventFiltersOrThrow) {
+          let match = getEventFiltersOrThrow(ChainMap.Chain.makeUnsafe(chainConfig.id));
+          shouldSkip = match.TAG === "Static" ? match._0.length === 0 : false;
+        } else {
+          shouldSkip = false;
+        }
+      } catch (exn) {
+        shouldSkip = false;
+      }
+      if (shouldBeIncluded && !shouldSkip) {
+        onEventRegistrations.push(onEventRegistration);
+        return;
+      }
+    });
+  });
+  return onEventRegistrations;
+}
+
+function finishRegistration(config) {
   let r = activeRegistration.contents;
-  if (r !== undefined) {
-    r.finished = true;
-    return r.registrations;
-  } else {
+  if (r === undefined) {
     return Stdlib_JsError.throwWithMessage("The indexer has not started registering handlers, so can't finish it.");
   }
+  r.finished = true;
+  let notRegisteredEventsByContract = {};
+  let registrationsByChainId = {};
+  ChainMap.values(config.chainMap).forEach(chainConfig => {
+    let key = chainConfig.id.toString();
+    registrationsByChainId[key] = {
+      onEventRegistrations: buildOnEventRegistrations(chainConfig, config, notRegisteredEventsByContract),
+      onBlockRegistrations: Stdlib_Option.getOr(r.registrations.onBlockByChainId[key], [])
+    };
+  });
+  let notRegisteredEntries = Object.entries(notRegisteredEventsByContract);
+  if (Utils.$$Array.notEmpty(notRegisteredEntries)) {
+    let groups = notRegisteredEntries.map(param => param[0] + ` (` + Array.from(param[1]).join(", ") + `)`).join(", ");
+    Logging.childInfo(Logging.getLogger(), `Events without a handler, skipped for indexing: ` + groups);
+  }
+  return registrationsByChainId;
 }
 
 function isPendingRegistration() {
@@ -282,6 +366,7 @@ export {
   isPendingRegistration,
   finishRegistration,
   throwIfFinishedRegistration,
+  buildOnEventRegistration,
   setHandler,
   setContractRegister,
   getHandler,

package/src/HandlerRegister.resi

@@ -1,10 +1,21 @@
-type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
+type chainRegistrations = {
+  onEventRegistrations: array<Internal.onEventRegistration>,
+  onBlockRegistrations: array<Internal.onBlockRegistration>,
+}
+type registrationsByChainId = dict<chainRegistrations>
 
 let startRegistration: (~ecosystem: Ecosystem.t) => unit
 let isPendingRegistration: unit => bool
-let finishRegistration: unit => registrations
+let finishRegistration: (~config: Config.t) => registrationsByChainId
 let throwIfFinishedRegistration: (~methodName: string) => unit
 
+let buildOnEventRegistration: (
+  ~config: Config.t,
+  ~chainId: int,
+  ~eventConfig: Internal.eventConfig,
+  ~startBlock: int=?,
+) => Internal.onEventRegistration
+
 let setHandler: (
   ~contractName: string,
   ~eventName: string,

package/src/IndexerState.res

@@ -188,7 +188,7 @@ let makeFromDbState = (
   ~config: Config.t,
   ~persistence: Persistence.t,
   ~initialState: Persistence.initialState,
-  ~registrations,
+  ~registrationsByChainId,
   ~isDevelopmentMode=false,
   ~shouldUseTui=false,
   ~exitAfterFirstEventBlock=false,
@@ -234,7 +234,7 @@ let makeFromDbState = (
         ~isInReorgThreshold,
         ~isRealtime,
         ~config,
-        ~registrations,
+        ~registrationsByChainId,
         ~reducedPollingInterval?,
       ),
     )
@@ -362,7 +362,10 @@ let clearRollback = (state: t) => state.rollbackState = NoRollback
 let invalidateInflight = (state: t) => state.epoch = state.epoch + 1
 
 let applyBatchProgress = (state: t, ~batch: Batch.t) =>
-  state.crossChainState->CrossChainState.applyBatchProgress(~batch)
+  state.crossChainState->CrossChainState.applyBatchProgress(
+    ~batch,
+    ~blockTimestampName=state.config.ecosystem.blockTimestampName,
+  )
 
 // Processing-loop mutex. Guards ProcessEventBatch re-entry so only one
 // processing loop runs at a time.