envio 3.3.2 → 3.5.0-alpha.0

package/src/HandlerRegister.res

@@ -1,19 +1,7 @@
-type eventRegistration = {
-  handler: option<Internal.handler>,
-  contractRegister: option<Internal.contractRegister>,
-  eventOptions: option<Internal.eventOptions<JSON.t>>,
-}
-
-let empty = {
-  handler: None,
-  contractRegister: None,
-  eventOptions: None,
-}
-
-// 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.
+// Per-chain onEvent + onBlock registrations. Used both as the live registration
+// store (`activeRegistration`, where onEvent regs are raw: registration order,
+// unmerged, unindexed, `where:false` ones kept) and as the finished output of
+// `finishRegistration` (merged, backfilled, indexed).
 type chainRegistrations = {
   onEventRegistrations: array<Internal.onEventRegistration>,
   onBlockRegistrations: array<Internal.onBlockRegistration>,
@@ -22,38 +10,24 @@ type chainRegistrations = {
 // The finished registration state returned by `finishRegistration`.
 type registrationsByChainId = dict<chainRegistrations>
 
-// Incrementally built during registration: every `indexer.onEvent` /
-// `.contractRegister` call resolves its `where` per chain right away and
-// stores the resulting registration here, keyed by "Contract.Event", so
-// invalid configuration throws at the user's registration call site.
-type pendingChainRegistrations = {
-  onEventRegistrations: dict<Internal.onEventRegistration>,
-  onBlockRegistrations: array<Internal.onBlockRegistration>,
-}
-
+// The one registration, resolved once and reused. Handlers register into it at
+// `onEvent`/`onBlock` call time (resolving for every chain in `config`, which is
+// the full chain set), and it persists in `EnvioGlobal` across the many
+// `finishRegistration` calls a single isolate makes (handler modules are
+// import-cached and register only once). `finishRegistration` reads it and
+// builds a fresh per-config output, never mutating the store.
 type activeRegistration = {
   config: Config.t,
-  registrationsByChainId: dict<pendingChainRegistrations>,
+  registrationsByChainId: dict<chainRegistrations>,
   mutable finished: bool,
 }
 
-// Registration state lives in the process-wide `EnvioGlobal` record (shared
-// across duplicate envio module instances); the slots are opaque there, so
-// cast them to the real types once here.
-let eventRegistrations =
-  EnvioGlobal.value.eventRegistrations->(Utils.magic: dict<unknown> => dict<eventRegistration>)
-
 let getKey = (~contractName, ~eventName) => contractName ++ "." ++ eventName
 
-let get = (~contractName, ~eventName) => {
-  switch eventRegistrations->Utils.Dict.dangerouslyGetNonOption(getKey(~contractName, ~eventName)) {
-  | Some(existing) => existing
-  | None => empty
-  }
-}
-
-let set = (~contractName, ~eventName, registration) => {
-  eventRegistrations->Dict.set(getKey(~contractName, ~eventName), registration)
+// Test-only: reset to fresh-import state so a new registration cycle starts
+// empty (production starts each isolate empty and registers once).
+let resetOnEventRegistrations = () => {
+  EnvioGlobal.value.activeRegistration = None
 }
 
 let getActiveRegistration = () =>
@@ -85,29 +59,36 @@ let withRegistration = (fn: activeRegistration => unit) => {
   }
 }
 
+// Idempotent: handlers register once (import-cached), so the first call builds
+// the registration and every later call reuses it. `config` must be the full
+// chain set — registrations resolve for all its chains here, and
+// `finishRegistration` later narrows to whatever config it's given.
 let startRegistration = (~config: Config.t) => {
-  let r = {
-    config,
-    registrationsByChainId: Dict.make(),
-    finished: false,
-  }
-  EnvioGlobal.value.activeRegistration = Some(r->(Utils.magic: activeRegistration => unknown))
-  while preRegistered->Array.length > 0 {
-    // Loop + cleanup in one go
-    switch preRegistered->Array.pop {
-    | Some(fn) => fn(r)
-    | None => ()
+  switch getActiveRegistration() {
+  | Some(_) => ()
+  | None =>
+    let r = {
+      config,
+      registrationsByChainId: Dict.make(),
+      finished: false,
     }
+    EnvioGlobal.value.activeRegistration = Some(r->(Utils.magic: activeRegistration => unknown))
+    // Replay pre-registered callbacks in source (FIFO) order, then clear. For
+    // multiple handlers on one event this replay order is the dispatch order, so
+    // it must not reverse (which `Array.pop` would).
+    let queued = preRegistered->Array.copy
+    preRegistered->Array.splice(~start=0, ~remove=preRegistered->Array.length, ~insert=[])
+    queued->Array.forEach(fn => fn(r))
   }
 }
 
-let getPendingChainRegistrations = (r: activeRegistration, ~chainId: int) => {
+let getChainRegistrations = (r: activeRegistration, ~chainId: int): chainRegistrations => {
   let key = chainId->Int.toString
   switch r.registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(key) {
-  | Some(pending) => pending
+  | Some(existing) => existing
   | None =>
-    let fresh = {
-      onEventRegistrations: Dict.make(),
+    let fresh: chainRegistrations = {
+      onEventRegistrations: [],
       onBlockRegistrations: [],
     }
     r.registrationsByChainId->Dict.set(key, fresh)
@@ -158,268 +139,367 @@ let buildOnEventRegistrationWith = (
   }
 }
 
-// Enrich one event definition into its (event, chain) registration using
-// whatever handler/contractRegister/where the user registered for it. Shared
-// by the incremental per-chain sync below, `simulate`, and test helpers so
-// they 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 t = get(~contractName=eventConfig.contractName, ~eventName=eventConfig.name)
-  buildOnEventRegistrationWith(
-    ~config,
-    ~chainId,
-    ~eventConfig,
-    ~isWildcard=t.eventOptions->Option.flatMap(v => v.wildcard)->Option.getOr(false),
-    ~handler=t.handler,
-    ~contractRegister=t.contractRegister,
-    ~where=t.eventOptions->Option.flatMap(v => v.where),
-    ~startBlock?,
-  )
-}
-
-let getHandler = (~contractName, ~eventName) => get(~contractName, ~eventName).handler
-
-let getContractRegister = (~contractName, ~eventName) =>
-  get(~contractName, ~eventName).contractRegister
-
-let isWildcard = (~contractName, ~eventName) =>
-  get(~contractName, ~eventName).eventOptions
-  ->Option.flatMap(value => value.wildcard)
-  ->Option.getOr(false)
-
-let hasRegistration = (~contractName, ~eventName) => {
-  let r = get(~contractName, ~eventName)
-  r.handler->Option.isSome || r.contractRegister->Option.isSome
-}
-
-type eventNamespace = {contractName: string, eventName: string}
-
-let raiseDuplicateRegistration = (~contractName, ~eventName, ~msg, ~logger) => {
-  let fullMsg = msg ++ " for " ++ contractName ++ "." ++ eventName
-  Logging.createChildFrom(~logger, ~params={contractName, eventName})->Logging.childError(fullMsg)
-  JsError.throwWithMessage(fullMsg)
-}
-
-// `where` equality is checked per chain on the resolved structure (see
-// `syncOnEventRegistrations`), so registration options only need to agree on
-// `wildcard` here — two callbacks that resolve to identical filters count as
-// identical options even when the function references differ.
-let eventOptionsMatch = (
-  existing: option<Internal.eventOptions<JSON.t>>,
-  incoming: option<Internal.eventOptions<JSON.t>>,
-) => {
-  switch (existing, incoming) {
-  | (None, None) => true
-  | (Some(a), Some(b)) => a.wildcard === b.wildcard
-  | _ => false
-  }
-}
-
 let getResolvedWhere = (reg: Internal.onEventRegistration) =>
   (
     reg->(Utils.magic: Internal.onEventRegistration => Internal.evmOnEventRegistration)
   ).resolvedWhere
 
-// Resolve the registration for every configured chain that defines the event
-// and store it in the pending per-chain registry. When the chain already
-// holds a registration for this event, the resolved `where` structures must
-// deep-compare equal (`Values` by hex arrays, `ContractAddresses` by contract
-// name, plus `startBlock`) — otherwise it's a conflicting duplicate
-// registration. Both live registrations and `preRegistered` callbacks
-// replayed by `startRegistration` run through this single code path.
-let syncOnEventRegistrations = (
-  r: activeRegistration,
-  ~contractName,
-  ~eventName,
-  ~where: option<JSON.t>,
-  ~duplicateMsg,
-  ~logger,
-) => {
-  let config = r.config
-  let t = get(~contractName, ~eventName)
-  let isWildcard = t.eventOptions->Option.flatMap(v => v.wildcard)->Option.getOr(false)
-  let key = getKey(~contractName, ~eventName)
+// Two chain registrations target the same fetched log when they share the
+// event, the wildcard flag, and (on EVM) the resolved `where` — a handler and
+// a contractRegister that agree on all three can be merged into one
+// registration (so one item per log runs both). `where` is compared on the
+// resolved structure (`Values` by hex arrays, `ContractAddresses` by contract
+// name, plus `startBlock`); differing filters stay separate registrations.
+let sameEventAndFilter = (
+  a: Internal.onEventRegistration,
+  b: Internal.onEventRegistration,
+  ~config: Config.t,
+) =>
+  a.eventConfig.contractName === b.eventConfig.contractName &&
+  a.eventConfig.name === b.eventConfig.name &&
+  a.isWildcard === b.isWildcard &&
+  switch config.ecosystem.name {
+  | Evm => getResolvedWhere(a) == getResolvedWhere(b)
+  | Fuel | Svm => true
+  }
 
-  config.chainMap
-  ->ChainMap.values
-  ->Array.forEach(chainConfig => {
-    chainConfig.contracts->Array.forEach(contract => {
-      if contract.name === contractName {
-        switch contract.events->Array.find(e => e.name === eventName) {
-        | None => ()
-        | Some(eventConfig) =>
-          let newRegistration = buildOnEventRegistrationWith(
-            ~config,
-            ~chainId=chainConfig.id,
-            ~eventConfig,
-            ~isWildcard,
-            ~handler=t.handler,
-            ~contractRegister=t.contractRegister,
-            ~where,
-            ~startBlock=?contract.startBlock,
-          )
-          let pending = r->getPendingChainRegistrations(~chainId=chainConfig.id)
-          switch pending.onEventRegistrations->Utils.Dict.dangerouslyGetNonOption(key) {
-          | Some(existing) if config.ecosystem.name === Evm =>
-            if !(existing->getResolvedWhere == newRegistration->getResolvedWhere) {
-              raiseDuplicateRegistration(~contractName, ~eventName, ~msg=duplicateMsg, ~logger)
-            }
-          | _ => ()
-          }
-          pending.onEventRegistrations->Dict.set(key, newRegistration)
-        }
+// Merge each contractRegister into a matching handler registration (either
+// registration order; the merged registration takes the handler's slot so
+// dispatch order follows handler registration order). Two handlers (or two
+// contractRegisters) for one event never merge. Operates on the raw per-chain
+// registrations stored at `onEvent` time; shared by `finishRegistration` and
+// simulate so both see the same registrations.
+let mergeRegistrations = (resolved: array<Internal.onEventRegistration>, ~config: Config.t): array<
+  Internal.onEventRegistration,
+> => {
+  let merged: ref<array<Internal.onEventRegistration>> = ref([])
+  resolved->Array.forEach((reg: Internal.onEventRegistration) => {
+    if reg.handler->Option.isSome {
+      // A handler absorbs a matching contractRegister-only registration,
+      // dropping it and taking its own (handler) slot.
+      switch merged.contents->Array.findIndex(m =>
+        m.handler->Option.isNone &&
+        m.contractRegister->Option.isSome &&
+        sameEventAndFilter(m, reg, ~config)
+      ) {
+      | -1 => merged := merged.contents->Array.concat([reg])
+      | i =>
+        let target = merged.contents->Array.getUnsafe(i)
+        merged :=
+          merged.contents
+          ->Array.filterWithIndex((_, j) => j !== i)
+          ->Array.concat([{...reg, contractRegister: target.contractRegister}])
       }
-    })
+    } else {
+      // A contractRegister merges into a matching handler registration,
+      // keeping the handler's slot.
+      switch merged.contents->Array.findIndex(m =>
+        m.handler->Option.isSome &&
+        m.contractRegister->Option.isNone &&
+        sameEventAndFilter(m, reg, ~config)
+      ) {
+      | -1 => merged := merged.contents->Array.concat([reg])
+      | i =>
+        let target = merged.contents->Array.getUnsafe(i)
+        let next = merged.contents->Array.copy
+        next->Array.setUnsafe(i, {...target, contractRegister: reg.contractRegister})
+        merged := next
+      }
+    }
   })
+  merged.contents
 }
 
-let setEventOptions = (~contractName, ~eventName, ~eventOptions, ~logger=Logging.getLogger()) => {
-  switch eventOptions {
-  | Some(value) =>
-    let value = value->(Utils.magic: Internal.eventOptions<'where> => Internal.eventOptions<JSON.t>)
-    let t = get(~contractName, ~eventName)
-    switch t.eventOptions {
-    | None => set(~contractName, ~eventName, {...t, eventOptions: Some(value)})
-    | Some(existingValue) =>
-      if !eventOptionsMatch(Some(existingValue), Some(value)) {
-        raiseDuplicateRegistration(
-          ~contractName,
-          ~eventName,
-          ~msg="Cannot register handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)",
-          ~logger,
+// A `where` that resolved to no topic selections (`false` for this chain)
+// should never be fetched or dispatched here — drop it. Only meaningful on EVM.
+let isDroppedByWhere = (~config: Config.t, reg: Internal.onEventRegistration) =>
+  config.ecosystem.name === Evm && (reg->getResolvedWhere).topicSelections->Utils.Array.isEmpty
+
+// Resolve one `onEvent`/`contractRegister` call into a registration for every
+// chain in the config (the full chain set) and store it in registration order.
+// Building runs the user's `where` callback here — once per chain — so a broken
+// filter throws at the call site. A chain that doesn't define the event is
+// skipped.
+let addOnEventRegistration = (
+  registration: activeRegistration,
+  ~contractName,
+  ~eventName,
+  ~handler: option<Internal.handler>,
+  ~contractRegister: option<Internal.contractRegister>,
+  ~eventOptions: option<Internal.eventOptions<JSON.t>>,
+) => {
+  let isWildcard = eventOptions->Option.flatMap(v => v.wildcard)->Option.getOr(false)
+  let where = eventOptions->Option.flatMap(v => v.where)
+  registration.config.chainMap
+  ->ChainMap.values
+  ->Array.forEach(chainConfig =>
+    switch chainConfig.contracts->Array.find(c => c.name === contractName) {
+    | None => ()
+    | Some(contract) =>
+      switch contract.events->Array.find(e => e.name === eventName) {
+      | None => ()
+      | Some(eventConfig) =>
+        let reg = buildOnEventRegistrationWith(
+          ~config=registration.config,
+          ~chainId=chainConfig.id,
+          ~eventConfig,
+          ~isWildcard,
+          ~handler,
+          ~contractRegister,
+          ~where,
+          ~startBlock=?contract.startBlock,
         )
+        (registration->getChainRegistrations(~chainId=chainConfig.id)).onEventRegistrations
+        ->Array.push(reg)
+        ->ignore
       }
     }
-  | None => ()
-  }
+  )
 }
 
-let setHandler = (
-  ~contractName,
-  ~eventName,
-  handler,
-  ~eventOptions,
-  ~logger=Logging.getLogger(),
-) => {
+let setHandler = (~contractName, ~eventName, handler, ~eventOptions) => {
   withRegistration(registration => {
-    let t = get(~contractName, ~eventName)
     let newHandler = handler->(Utils.magic: Internal.genericHandler<'args> => Internal.handler)
-    let incomingEventOptions =
+    let eventOptions =
       eventOptions->Option.map(v =>
         v->(Utils.magic: Internal.eventOptions<'where> => Internal.eventOptions<JSON.t>)
       )
-    switch t.handler {
-    | None =>
-      setEventOptions(~contractName, ~eventName, ~eventOptions, ~logger)
-      let t = get(~contractName, ~eventName)
-      set(
-        ~contractName,
-        ~eventName,
-        {
-          ...t,
-          handler: Some(newHandler),
-        },
-      )
-    | Some(prevHandler) =>
-      if eventOptionsMatch(t.eventOptions, incomingEventOptions) {
-        let composedHandler: Internal.handler = async args => {
-          await prevHandler(args)
-          await newHandler(args)
-        }
-        set(
-          ~contractName,
-          ~eventName,
-          {
-            ...t,
-            handler: Some(composedHandler),
-          },
-        )
-      } else {
-        raiseDuplicateRegistration(
-          ~contractName,
-          ~eventName,
-          ~msg="Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)",
-          ~logger,
-        )
-      }
-    }
-    registration->syncOnEventRegistrations(
+    registration->addOnEventRegistration(
       ~contractName,
       ~eventName,
-      ~where=incomingEventOptions->Option.flatMap(v => v.where),
-      ~duplicateMsg="Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)",
-      ~logger,
+      ~handler=Some(newHandler),
+      ~contractRegister=None,
+      ~eventOptions,
     )
   })
 }
 
-let setContractRegister = (
-  ~contractName,
-  ~eventName,
-  contractRegister,
-  ~eventOptions,
-  ~logger=Logging.getLogger(),
-) => {
+let setContractRegister = (~contractName, ~eventName, contractRegister, ~eventOptions) => {
   withRegistration(registration => {
-    let t = get(~contractName, ~eventName)
     let newContractRegister =
       contractRegister->(
         Utils.magic: Internal.genericContractRegister<
           Internal.genericContractRegisterArgs<'event, 'context>,
         > => Internal.contractRegister
       )
-    let incomingEventOptions =
+    let eventOptions =
       eventOptions->Option.map(v =>
         v->(Utils.magic: Internal.eventOptions<'where> => Internal.eventOptions<JSON.t>)
       )
-    switch t.contractRegister {
-    | None =>
-      setEventOptions(~contractName, ~eventName, ~eventOptions, ~logger)
-      let t = get(~contractName, ~eventName)
-      set(
-        ~contractName,
-        ~eventName,
-        {
-          ...t,
-          contractRegister: Some(newContractRegister),
-        },
+    registration->addOnEventRegistration(
+      ~contractName,
+      ~eventName,
+      ~handler=None,
+      ~contractRegister=Some(newContractRegister),
+      ~eventOptions,
+    )
+  })
+}
+
+// Raw onEvent registrations stored for a chain (empty if the chain has none).
+let storedOnEventRegistrations = (r: activeRegistration, ~chainId: int): array<
+  Internal.onEventRegistration,
+> =>
+  switch r.registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(chainId->Int.toString) {
+  | Some(chainRegs) => chainRegs.onEventRegistrations
+  | None => []
+  }
+
+// True when any registration for the event is a wildcard. Used by simulate to
+// decide whether a src address needs deriving.
+let isWildcard = (~contractName, ~eventName) =>
+  switch getActiveRegistration() {
+  | Some(r) =>
+    r.registrationsByChainId
+    ->Dict.valuesToArray
+    ->Array.some(chainRegs =>
+      chainRegs.onEventRegistrations->Array.some(reg =>
+        reg.eventConfig.contractName === contractName &&
+        reg.eventConfig.name === eventName &&
+        reg.isWildcard
       )
-    | Some(prevContractRegister) =>
-      if eventOptionsMatch(t.eventOptions, incomingEventOptions) {
-        let composedContractRegister: Internal.contractRegister = async args => {
-          await prevContractRegister(args)
-          await newContractRegister(args)
-        }
-        set(
-          ~contractName,
-          ~eventName,
+    )
+  | None => false
+  }
+
+// Every registration for one event on a chain, so simulate fans a simulated
+// event out to each the way real routing does. Falls back to a bare
+// registration when the event has no handler/contractRegister, so a simulated
+// item still produces an item to run.
+let getSimulateOnEventRegistrations = (
+  ~config: Config.t,
+  ~chainId: int,
+  ~eventConfig: Internal.eventConfig,
+): array<Internal.onEventRegistration> => {
+  let stored = switch getActiveRegistration() {
+  | Some(r) => r->storedOnEventRegistrations(~chainId)
+  | None => []
+  }
+  let matching =
+    mergeRegistrations(stored, ~config)->Array.filter(reg =>
+      reg.eventConfig.contractName === eventConfig.contractName &&
+        reg.eventConfig.name === eventConfig.name
+    )
+  if matching->Utils.Array.notEmpty {
+    matching
+  } else {
+    [
+      buildOnEventRegistrationWith(
+        ~config,
+        ~chainId,
+        ~eventConfig,
+        ~isWildcard=false,
+        ~handler=None,
+        ~contractRegister=None,
+        ~where=None,
+      ),
+    ]
+  }
+}
+
+let finishRegistration = (~config: Config.t): registrationsByChainId => {
+  switch getActiveRegistration() {
+  | Some(r) => {
+      r.finished = true
+      let notRegisteredEventsByContract: dict<Utils.Set.t<string>> = Dict.make()
+      let registrationsByChainId: registrationsByChainId = Dict.make()
+      config.chainMap
+      ->ChainMap.values
+      ->Array.forEach(chainConfig => {
+        let chainId = chainConfig.id
+        let key = chainId->Int.toString
+
+        let builtRegs = mergeRegistrations(r->storedOnEventRegistrations(~chainId), ~config)
+        let registeredKeys = Utils.Set.make()
+        builtRegs->Array.forEach(reg =>
+          registeredKeys
+          ->Utils.Set.add(
+            getKey(~contractName=reg.eventConfig.contractName, ~eventName=reg.eventConfig.name),
+          )
+          ->ignore
+        )
+
+        // Events with no handler/contractRegister aren't fetched or dispatched
+        // unless raw events are enabled, in which case a bare registration is
+        // added to fetch them. Otherwise they're reported once below. Keyed on
+        // the resolved registrations (before the where-empty drop) so a
+        // `where: false` event still counts as registered — its handler opted
+        // out of this chain, so it gets no raw-event registration either.
+        let rawEventRegs = []
+        chainConfig.contracts->Array.forEach(contract => {
+          contract.events->Array.forEach(
+            eventConfig => {
+              if (
+                !(
+                  registeredKeys->Utils.Set.has(
+                    getKey(~contractName=contract.name, ~eventName=eventConfig.name),
+                  )
+                )
+              ) {
+                if config.enableRawEvents {
+                  rawEventRegs
+                  ->Array.push(
+                    buildOnEventRegistrationWith(
+                      ~config,
+                      ~chainId,
+                      ~eventConfig,
+                      ~isWildcard=false,
+                      ~handler=None,
+                      ~contractRegister=None,
+                      ~where=None,
+                      ~startBlock=?contract.startBlock,
+                    ),
+                  )
+                  ->ignore
+                } else {
+                  let eventNames = switch notRegisteredEventsByContract->Utils.Dict.dangerouslyGetNonOption(
+                    contract.name,
+                  ) {
+                  | Some(set) => set
+                  | None => {
+                      let set = Utils.Set.make()
+                      notRegisteredEventsByContract->Dict.set(contract.name, set)
+                      set
+                    }
+                  }
+                  eventNames->Utils.Set.add(eventConfig.name)->ignore
+                }
+              }
+            },
+          )
+        })
+
+        // Drop registrations whose `where` opts out of this chain, then assign
+        // each survivor its chain-scoped index by position.
+        let onEventRegistrations: array<Internal.onEventRegistration> = []
+        builtRegs
+        ->Array.concat(rawEventRegs)
+        ->Array.forEach(reg => {
+          if !isDroppedByWhere(~config, reg) {
+            onEventRegistrations
+            ->Array.push({...reg, index: onEventRegistrations->Array.length})
+            ->ignore
+          }
+        })
+
+        registrationsByChainId->Dict.set(
+          key,
           {
-            ...t,
-            contractRegister: Some(composedContractRegister),
+            onEventRegistrations,
+            // Copy so a consumer appending to the output (e.g. simulate source
+            // registration) never mutates the persistent store.
+            onBlockRegistrations: switch r.registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(
+              key,
+            ) {
+            | Some(chainRegs) => chainRegs.onBlockRegistrations->Array.copy
+            | None => []
+            },
           },
         )
-      } else {
-        raiseDuplicateRegistration(
-          ~contractName,
-          ~eventName,
-          ~msg="Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, where)",
-          ~logger,
+      })
+
+      // 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
     }
-    registration->syncOnEventRegistrations(
-      ~contractName,
-      ~eventName,
-      ~where=incomingEventOptions->Option.flatMap(v => v.where),
-      ~duplicateMsg="Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, where)",
-      ~logger,
+  | None =>
+    JsError.throwWithMessage(
+      "The indexer has not started registering handlers, so can't finish it.",
     )
-  })
+  }
+}
+
+let isPendingRegistration = () => {
+  switch getActiveRegistration() {
+  | Some(r) => !r.finished
+  | None => false
+  }
+}
+
+// Early guard called from `indexer.onEvent` / `.contractRegister` / `.onBlock` /
+// `.onSlot` so the user sees a method-specific error at the call site, instead
+// of hitting the generic `withRegistration` throw deep inside `setHandler` etc.
+let throwIfFinishedRegistration = (~methodName) => {
+  switch getActiveRegistration() {
+  | Some({finished: true}) =>
+    JsError.throwWithMessage(
+      `Cannot call \`indexer.${methodName}\` after the indexer has started. Make sure all handlers are registered at the top level of your handler module.`,
+    )
+  | _ => ()
+  }
 }
 
 // Shape of the user-returned `{_gte?, _lte?, _every?}` filter chunk after
@@ -557,12 +637,12 @@ let registerOnBlock = (
           }
         | None => ()
         }
-        let pending = registration->getPendingChainRegistrations(~chainId)
-        pending.onBlockRegistrations
+        let chainRegs = registration->getChainRegistrations(~chainId)
+        chainRegs.onBlockRegistrations
         ->Array.push(
           (
             {
-              index: pending.onBlockRegistrations->Array.length,
+              index: chainRegs.onBlockRegistrations->Array.length,
               name,
               startBlock: range._gte,
               endBlock: range._lte,
@@ -587,160 +667,3 @@ let registerOnBlock = (
     }
   })
 }
-
-let finishRegistration = (~config: Config.t): registrationsByChainId => {
-  switch getActiveRegistration() {
-  | Some(r) => {
-      r.finished = true
-      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
-        let pending = r.registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(key)
-
-        // 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 registration =
-                pending->Option.flatMap(
-                  pending =>
-                    pending.onEventRegistrations->Utils.Dict.dangerouslyGetNonOption(
-                      getKey(~contractName, ~eventName),
-                    ),
-                )
-
-              // Should validate the events
-              eventRouter->EventRouter.addOrThrow(
-                eventConfig.id,
-                (),
-                ~contractName,
-                ~chain=ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id),
-                ~eventName,
-                ~isWildcard=switch registration {
-                | Some(registration) => registration.isWildcard
-                | None => isWildcard(~contractName, ~eventName)
-                },
-              )
-
-              let registration = switch registration {
-              | Some(_) as registration => registration
-              | None =>
-                // No entry in the incremental store, but the persistent dict
-                // may still hold a handler: handler modules are import-cached,
-                // so a repeated registration cycle in the same process (tests
-                // restarting the indexer) never re-runs the `indexer.onEvent`
-                // calls. Rebuild from the dict in that case. Events without a
-                // handler/contractRegister aren't fetched or dispatched
-                // (unless raw events are enabled).
-                if hasRegistration(~contractName, ~eventName) || config.enableRawEvents {
-                  Some(
-                    buildOnEventRegistration(
-                      ~config,
-                      ~chainId=chainConfig.id,
-                      ~eventConfig,
-                      ~startBlock=?contract.startBlock,
-                    ),
-                  )
-                } else {
-                  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
-                  None
-                }
-              }
-
-              switch registration {
-              | Some(registration) =>
-                // A `where` that resolved to no topic selections (`false` for
-                // this chain) drops the chain's registration entirely — the
-                // event should never be fetched here.
-                let isDroppedByWhere =
-                  config.ecosystem.name === Evm &&
-                    (registration->getResolvedWhere).topicSelections->Utils.Array.isEmpty
-                if !isDroppedByWhere {
-                  onEventRegistrations
-                  ->Array.push({...registration, index: onEventRegistrations->Array.length})
-                  ->ignore
-                }
-              | None => ()
-              }
-            },
-          )
-        })
-
-        registrationsByChainId->Dict.set(
-          key,
-          {
-            onEventRegistrations,
-            onBlockRegistrations: switch pending {
-            | Some(pending) => pending.onBlockRegistrations
-            | None => []
-            },
-          },
-        )
-      })
-
-      // 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(
-      "The indexer has not started registering handlers, so can't finish it.",
-    )
-  }
-}
-
-let isPendingRegistration = () => {
-  switch getActiveRegistration() {
-  | Some(r) => !r.finished
-  | None => false
-  }
-}
-
-// Early guard called from `indexer.onEvent` / `.contractRegister` / `.onBlock` /
-// `.onSlot` so the user sees a method-specific error at the call site, instead
-// of hitting the generic `withRegistration` throw deep inside `setHandler` etc.
-let throwIfFinishedRegistration = (~methodName) => {
-  switch getActiveRegistration() {
-  | Some({finished: true}) =>
-    JsError.throwWithMessage(
-      `Cannot call \`indexer.${methodName}\` after the indexer has started. Make sure all handlers are registered at the top level of your handler module.`,
-    )
-  | _ => ()
-  }
-}