envio 3.3.0-alpha.8 → 3.3.0-alpha.9

package/src/Main.res

@@ -39,40 +39,24 @@ let stateSchema = S.union([
   })),
 ])
 
-// Shape of the user-returned `{_gte?, _lte?, _every?}` filter chunk after
-// the ecosystem-specific wrapper is stripped. Shared across all ecosystems —
-// the outer `block.number` / `block.height` / `slot` unwrap lives on each
-// ecosystem's `onBlockFilterSchema`, and the inner range fields are the
-// same everywhere.
-type blockRange = {
-  _gte: option<int>,
-  _lte: option<int>,
-  _every: int,
-}
-
-// `S.strict` rejects unknown fields so typos like `_gt` / `_evry` surface
-// with a readable schema error pointing at the offending key, instead of
-// silently registering a broken filter. `_every` defaults to 1 inside the
-// schema so the caller always sees a plain `int`, and `intMin(1)` rejects
-// zero/negative strides — `(blockNumber - startBlock) % 0` would crash and
-// any negative stride would never match.
-let blockRangeSchema: S.t<blockRange> = S.object(s => {
-  _gte: s.field("_gte", S.option(S.int)),
-  _lte: s.field("_lte", S.option(S.int)),
-  _every: s.field("_every", S.option(S.int->S.intMin(1))->S.Option.getOr(1)),
-})->S.strict
-
-let defaultBlockRange: blockRange = {_gte: None, _lte: None, _every: 1}
-
-let indexerStateRef: ref<option<IndexerState.t>> = ref(None)
+// Runtime 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 here.
+let getIndexerState = () =>
+  EnvioGlobal.value.indexerState->(Utils.magic: option<unknown> => option<IndexerState.t>)
+let setIndexerState = (state: IndexerState.t) =>
+  EnvioGlobal.value.indexerState = Some(state->(Utils.magic: IndexerState.t => unknown))
 
 // Persistence is set by Main.start before handler modules load, so that
 // the exported indexer value can lazily expose DB state (startBlock,
 // endBlock, isRealtime, dynamic contract addresses) once it's ready.
-let globalPersistenceRef: ref<option<Persistence.t>> = ref(None)
+let getGlobalPersistence = () =>
+  EnvioGlobal.value.persistence->(Utils.magic: option<unknown> => option<Persistence.t>)
+let setGlobalPersistence = (persistence: Persistence.t) =>
+  EnvioGlobal.value.persistence = Some(persistence->(Utils.magic: Persistence.t => unknown))
 
 let getInitialChainState = (~chainId: int): option<Persistence.initialChainState> => {
-  switch globalPersistenceRef.contents {
+  switch getGlobalPersistence() {
   | Some(persistence) =>
     switch persistence.storageStatus {
     | Ready(initialState) => initialState.chains->Array.find(c => c.id === chainId)
@@ -130,7 +114,7 @@ let buildChainsObject = (~config: Config.t) => {
       {
         enumerable: true,
         get: () => {
-          switch indexerStateRef.contents {
+          switch getIndexerState() {
           | Some(state) => state->IndexerState.isRealtime
           // Before the global state is available (eg during handler
           // module load after resume), derive from persistence: every chain
@@ -164,7 +148,7 @@ let buildChainsObject = (~config: Config.t) => {
         {
           enumerable: true,
           get: () => {
-            switch indexerStateRef.contents {
+            switch getIndexerState() {
             | Some(state) => {
                 let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
                 let chainState = state->IndexerState.getChainState(~chain)
@@ -345,121 +329,24 @@ let getGlobalIndexer = (): 'indexer => {
     let _ = RollbackCommit.register(callback->(Utils.magic: 'a => RollbackCommit.callback))
   }
 
-  // Two-stage parse: first the ecosystem-specific outer schema unwraps the
-  // wrapper (`block.number` / `block.height` / `slot`) and surfaces the
-  // inner chunk as raw `unknown`; then the shared `blockRangeSchema`
-  // validates the `{_gte?, _lte?, _every?}` fields. Keeping the inner
-  // validation in one place means typos and shape mismatches surface with
-  // the same user-friendly error regardless of ecosystem.
-  let extractRange = (filter: unknown, ~name, ~ecosystem: Ecosystem.t): blockRange =>
-    try {
-      switch filter->S.parseOrThrow(ecosystem.onBlockFilterSchema) {
-      | None => defaultBlockRange
-      | Some(inner) => inner->S.parseOrThrow(blockRangeSchema)
-      }
-    } catch {
-    | S.Raised(exn) =>
-      JsError.throwWithMessage(
-        `\`indexer.${ecosystem.onBlockMethodName}("${name}")\` \`where\` returned an invalid filter: ${exn
-          ->Utils.prettifyExn
-          ->(Utils.magic: exn => string)}`,
-      )
-    }
-
-  // `where` is evaluated once per configured chain at registration time.
-  // Decoded ranges/stride feed directly into `HandlerRegister.registerOnBlock`
-  // so the fetcher's `(blockNumber - handlerStartBlock) % interval === 0`
-  // math at `FetchState.res:619` stays untouched.
   let onBlockFn = (rawOptions: 'a, handler: 'b) => {
     HandlerRegister.throwIfFinishedRegistration(~methodName="onBlock")
-    let config = Config.load()
-    let ecosystem = config.ecosystem
     let raw =
       rawOptions->(
         Utils.magic: 'a => {
           "name": string,
-          "where": option<Envio.onBlockWhereArgs<unknown> => unknown>,
+          "where": unknown,
         }
       )
-    let typedHandler = handler->(Utils.magic: 'b => Internal.onBlockArgs => promise<unit>)
-    let (chains, _) = buildChainsObject(~config)
-    let chainsDict = chains->(Utils.magic: {..} => dict<unknown>)
-    let name = raw["name"]
-    let logger = Logging.createChild(~params={"onBlock": name})
-
-    // `where` must be a function (unlike onEvent, which also accepts a static
-    // value). A static value would have to be evaluated against every chain
-    // independently, which has no useful semantic for block handlers.
-    // Normalize undefined/null to None up front so the per-chain loop below
-    // can't accidentally call `null` as a predicate (ReScript treats a JS
-    // `null` value as `Some(null)` when the field is typed as option).
-    let where = switch raw["where"]->(Utils.magic: option<'a> => unknown) {
-    | w if w === %raw(`undefined`) || w === %raw(`null`) => None
-    | w if typeof(w) === #function => Some(raw["where"]->Option.getUnsafe)
-    | w =>
-      JsError.throwWithMessage(
-        `\`indexer.${ecosystem.onBlockMethodName}("${name}")\` expected \`where\` to be a function or omitted, but got ${(typeof(
-            w,
-          ) :> string)}.`,
-      )
-    }
-
-    let matchedAny = ref(false)
-
-    config.chainMap
-    ->ChainMap.values
-    ->Array.forEach(chainConfig => {
-      let chainId = chainConfig.id
-      let chainObj = chainsDict->Dict.getUnsafe(chainId->Int.toString)
-
-      // Predicate returns `true` → match with no filter; `false` → skip;
-      // any plain object → structured filter. `undefined`/`null` returns
-      // are rejected — the TS type excludes `void`, so a missing return is
-      // a user bug we surface early rather than silently match-all.
-      let result = switch where {
-      | None => %raw(`true`)
-      | Some(predicate) => predicate({chain: chainObj})
-      }
-
-      let (shouldRegister, range) = if result === %raw(`true`) {
-        (true, defaultBlockRange)
-      } else if result === %raw(`false`) {
-        (false, defaultBlockRange)
-      } else if typeof(result) === #object && !(result->Array.isArray) && result !== %raw(`null`) {
-        (true, extractRange(result, ~name, ~ecosystem))
-      } else {
-        // Reject numbers, strings, functions, arrays, undefined, null —
-        // anything that isn't bool or a plain object would silently
-        // misregister.
-        JsError.throwWithMessage(
-          `\`indexer.${ecosystem.onBlockMethodName}("${name}")\` \`where\` predicate returned an invalid value of type ${(typeof(
-              result,
-            ) :> string)}. Expected boolean or a filter object.`,
-        )
-      }
-
-      if shouldRegister {
-        matchedAny := true
-        HandlerRegister.registerOnBlock(
-          ~name,
-          ~chainId,
-          ~interval=range._every,
-          ~startBlock=range._gte,
-          ~endBlock=range._lte,
-          ~handler=typedHandler,
-        )
-      }
-    })
-
-    // Catches misconfigured `where` predicates that return `false` for every
-    // configured chain — the handler would otherwise never fire with no hint.
-    // Includes the ecosystem-specific method name so SVM users see "onSlot"
-    // and don't get confused looking for a "Block handler" they never wrote.
-    if !matchedAny.contents {
-      logger->Logging.childWarn(
-        `\`indexer.${ecosystem.onBlockMethodName}\` matched 0 chains. Check the \`where\` predicate.`,
-      )
-    }
+    HandlerRegister.registerOnBlock(
+      ~name=raw["name"],
+      ~where=raw["where"],
+      ~handler=handler->(Utils.magic: 'b => Internal.onBlockArgs => promise<unit>),
+      ~getChainsObject=config => {
+        let (chains, _) = buildChainsObject(~config)
+        chains->(Utils.magic: {..} => dict<unknown>)
+      },
+    )
   }
 
   // Ecosystem-specific surface: EVM/Fuel expose event + block handlers; SVM
@@ -506,8 +393,7 @@ let getGlobalIndexer = (): 'indexer => {
   let get = (~prop: string) =>
     switch prop {
     | "name" => Config.load().name->(Utils.magic: string => unknown)
-    | "description" =>
-      Config.load().description->(Utils.magic: option<string> => unknown)
+    | "description" => Config.load().description->(Utils.magic: option<string> => unknown)
     | "chainIds" => {
         let (_, chainIds) = buildChainsObject(~config=Config.load())
         chainIds->(Utils.magic: array<int> => unknown)
@@ -616,7 +502,7 @@ let startServer = (~getState, ~persistence: Persistence.t, ~isDevelopmentMode: b
   app->get("/metrics", (_req, res) => {
     res->set("Content-Type", PromClient.defaultRegister->PromClient.getContentType)
     let _ =
-      Metrics.collect(~state=indexerStateRef.contents)->Promise.thenResolve(metrics =>
+      Metrics.collect(~state=getIndexerState())->Promise.thenResolve(metrics =>
         res->endWithData(metrics)
       )
   })
@@ -709,7 +595,7 @@ let start = async (
   | Some(p) => p
   | None => PgStorage.makePersistenceFromConfig(~config)
   }
-  globalPersistenceRef := Some(persistence)
+  setGlobalPersistence(persistence)
   await persistence->Persistence.init(
     ~reset,
     ~chainConfigs=config.chainMap->ChainMap.values,
@@ -756,7 +642,7 @@ let start = async (
 
   if !isTest {
     startServer(~persistence, ~isDevelopmentMode, ~getState=() =>
-      switch indexerStateRef.contents {
+      switch getIndexerState() {
       | None => Initializing({})
       | Some(state) => {
           let chains =
@@ -786,7 +672,7 @@ let start = async (
   if shouldUseTui {
     let _rerender = Tui.start(~getState=() => state)
   }
-  indexerStateRef := Some(state)
+  setIndexerState(state)
   state->IndexerLoop.start
   await runUntilFatalError
 }

package/src/Main.res.mjs

@@ -13,6 +13,7 @@ import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 import * as IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as PromClient from "prom-client";
@@ -61,28 +62,24 @@ let stateSchema = S$RescriptSchema.union([
   }))
 ]);
 
-let blockRangeSchema = S$RescriptSchema.strict(S$RescriptSchema.object(s => ({
-  _gte: s.f("_gte", S$RescriptSchema.option(S$RescriptSchema.int)),
-  _lte: s.f("_lte", S$RescriptSchema.option(S$RescriptSchema.int)),
-  _every: s.f("_every", S$RescriptSchema.Option.getOr(S$RescriptSchema.option(S$RescriptSchema.intMin(S$RescriptSchema.int, 1, undefined)), 1))
-})));
+function getIndexerState() {
+  return EnvioGlobal.value.indexerState;
+}
 
-let defaultBlockRange = {
-  _gte: undefined,
-  _lte: undefined,
-  _every: 1
-};
+function setIndexerState(state) {
+  EnvioGlobal.value.indexerState = Primitive_option.some(state);
+}
 
-let indexerStateRef = {
-  contents: undefined
-};
+function getGlobalPersistence() {
+  return EnvioGlobal.value.persistence;
+}
 
-let globalPersistenceRef = {
-  contents: undefined
-};
+function setGlobalPersistence(persistence) {
+  EnvioGlobal.value.persistence = Primitive_option.some(persistence);
+}
 
 function getInitialChainState(chainId) {
-  let persistence = globalPersistenceRef.contents;
+  let persistence = EnvioGlobal.value.persistence;
   if (persistence === undefined) {
     return;
   }
@@ -134,7 +131,7 @@ function buildChainsObject(config) {
     }), "isRealtime", {
       enumerable: true,
       get: () => {
-        let state = indexerStateRef.contents;
+        let state = EnvioGlobal.value.indexerState;
         if (state !== undefined) {
           return IndexerState.isRealtime(Primitive_option.valFromOption(state));
         } else if (Env.updateSyncTimeOnRestart) {
@@ -162,7 +159,7 @@ function buildChainsObject(config) {
       }), "addresses", {
         enumerable: true,
         get: () => {
-          let state = indexerStateRef.contents;
+          let state = EnvioGlobal.value.indexerState;
           if (state !== undefined) {
             let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
             let chainState = IndexerState.getChainState(Primitive_option.valFromOption(state), chain);
@@ -278,69 +275,9 @@ function getGlobalIndexer() {
     HandlerRegister.throwIfFinishedRegistration("~internalAndWillBeRemovedSoon_onRollbackCommit");
     RollbackCommit.register(callback);
   };
-  let extractRange = (filter, name, ecosystem) => {
-    try {
-      let inner = S$RescriptSchema.parseOrThrow(filter, ecosystem.onBlockFilterSchema);
-      if (inner !== undefined) {
-        return S$RescriptSchema.parseOrThrow(Primitive_option.valFromOption(inner), blockRangeSchema);
-      } else {
-        return defaultBlockRange;
-      }
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      if (exn.RE_EXN_ID === S$RescriptSchema.Raised) {
-        return Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` \`where\` returned an invalid filter: ` + Utils.prettifyExn(exn._1));
-      }
-      throw exn;
-    }
-  };
   let onBlockFn = (rawOptions, handler) => {
     HandlerRegister.throwIfFinishedRegistration("onBlock");
-    let config = Config.load();
-    let ecosystem = config.ecosystem;
-    let match = buildChainsObject(config);
-    let chains = match[0];
-    let name = rawOptions.name;
-    let logger = Logging.createChild({
-      onBlock: name
-    });
-    let w = rawOptions.where;
-    let where = w === undefined || w === null ? undefined : (
-        typeof w === "function" ? rawOptions.where : Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` expected \`where\` to be a function or omitted, but got ` + typeof w + `.`)
-      );
-    let matchedAny = {
-      contents: false
-    };
-    ChainMap.values(config.chainMap).forEach(chainConfig => {
-      let chainId = chainConfig.id;
-      let chainObj = chains[chainId.toString()];
-      let result = where !== undefined ? where({
-          chain: chainObj
-        }) : true;
-      let match = result === true ? [
-          true,
-          defaultBlockRange
-        ] : (
-          result === false ? [
-              false,
-              defaultBlockRange
-            ] : (
-              typeof result === "object" && !Array.isArray(result) && result !== null ? [
-                  true,
-                  extractRange(result, name, ecosystem)
-                ] : Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` \`where\` predicate returned an invalid value of type ` + typeof result + `. Expected boolean or a filter object.`)
-            )
-        );
-      if (!match[0]) {
-        return;
-      }
-      let range = match[1];
-      matchedAny.contents = true;
-      HandlerRegister.registerOnBlock(name, chainId, range._every, range._gte, range._lte, handler);
-    });
-    if (!matchedAny.contents) {
-      return Logging.childWarn(logger, `\`indexer.` + ecosystem.onBlockMethodName + `\` matched 0 chains. Check the \`where\` predicate.`);
-    }
+    HandlerRegister.registerOnBlock(rawOptions.name, rawOptions.where, handler, config => buildChainsObject(config)[0]);
   };
   let keysMemo = {
     contents: undefined
@@ -478,7 +415,7 @@ function startServer(getState, persistence, isDevelopmentMode) {
   });
   app.get("/metrics", (_req, res) => {
     res.set("Content-Type", PromClient.register.contentType);
-    Metrics.collect(indexerStateRef.contents).then(metrics => res.end(metrics));
+    Metrics.collect(EnvioGlobal.value.indexerState).then(metrics => res.end(metrics));
   });
   app.get("/metrics/runtime", (_req, res) => {
     res.set("Content-Type", runtimeRegistry.contentType);
@@ -529,7 +466,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let config = Config.load();
   let isDevelopmentMode = !isTest && config.isDev;
   let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
-  globalPersistenceRef.contents = persistence$1;
+  EnvioGlobal.value.persistence = Primitive_option.some(persistence$1);
   await Persistence.init(persistence$1, ChainMap.values(config.chainMap), Config.stripSensitiveData(Config.getPublicConfigJson()), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset);
   let registrationsByChainId = await HandlerLoader.registerAllHandlers(config);
   let config$1 = isTest ? ({
@@ -573,7 +510,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   Prometheus.RollbackEnabled.set(config$2.shouldRollbackOnReorg);
   if (!isTest) {
     startServer(() => {
-      let state = indexerStateRef.contents;
+      let state = EnvioGlobal.value.indexerState;
       if (state === undefined) {
         return {
           status: "initializing"
@@ -595,7 +532,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   if (shouldUseTui) {
     Tui.start(() => state);
   }
-  indexerStateRef.contents = Primitive_option.some(state);
+  EnvioGlobal.value.indexerState = Primitive_option.some(state);
   IndexerLoop.start(state);
   return await runUntilFatalError;
 }
@@ -603,10 +540,10 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
 export {
   chainDataSchema,
   stateSchema,
-  blockRangeSchema,
-  defaultBlockRange,
-  indexerStateRef,
-  globalPersistenceRef,
+  getIndexerState,
+  setIndexerState,
+  getGlobalPersistence,
+  setGlobalPersistence,
   getInitialChainState,
   buildChainsObject,
   getGlobalIndexer,

package/src/RollbackCommit.res

@@ -6,7 +6,10 @@
 type args = {chainId: int, rollbackToBlock: int}
 type callback = args => promise<unit>
 
-let callbacks: array<callback> = []
+// Lives in the process-wide `EnvioGlobal` record so callbacks registered
+// through a duplicate envio module instance still fire.
+let callbacks =
+  EnvioGlobal.value.rollbackCommitCallbacks->(Utils.magic: array<unknown> => array<callback>)
 
 let register = (callback: callback) => {
   callbacks->Array.push(callback)

package/src/RollbackCommit.res.mjs

@@ -1,8 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 
-let callbacks = [];
+let callbacks = EnvioGlobal.value.rollbackCommitCallbacks;
 
 function register(callback) {
   callbacks.push(callback);
@@ -32,4 +33,4 @@ export {
   register,
   fire,
 }
-/* No side effect */
+/* EnvioGlobal Not a pure module */

package/src/SimulateItems.res

@@ -336,7 +336,7 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
       | None => seenCoordinates->Dict.set(coordinate, itemIndex)
       }
 
-      // Build a real registration the same way `HandlerRegister.buildOnEventRegistrations`
+      // Build a real registration the same way `HandlerRegister.finishRegistration`
       // does at startup (not a stub), so the address filter and `where`
       // behave identically to real indexing — the dead-input tracker relies
       // on `clientAddressFilter` actually gating unrouted items.

package/src/sources/Evm.res

@@ -90,8 +90,11 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // range chunk is validated by `eventBlockRangeSchema` in
   // `LogSelection.res` which rejects `_lte`/`_every` (use `onBlock` for
   // stride- and endBlock-based block handlers).
+  // `S.strict` on the inner object rejects unknown `block` fields (e.g. a
+  // `numbre` typo or `block: {timestamp: ...}`) instead of silently
+  // ignoring them.
   onEventBlockFilterSchema: S.object(s =>
-    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))))
+    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))->S.strict))
   ),
   logger,
   // The payload carries `transaction` by batch prep (HyperSync) or inline

package/src/sources/Evm.res.mjs

@@ -58,7 +58,7 @@ function make(logger) {
     cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
-    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown)))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {

package/src/sources/Fuel.res

@@ -35,8 +35,10 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // Analogous to EVM, but keyed by `block.height` instead of
   // `block.number`. See `Evm.res` for the rationale on the two-stage
   // parse and the `_lte`/`_every` rejection.
+  // `S.strict` on the inner object rejects unknown `block` fields — including
+  // `block.number`, which is EVM-only; Fuel filters by `block.height`.
   onEventBlockFilterSchema: S.object(s =>
-    s.field("block", S.option(S.object(s2 => s2.field("height", S.unknown))))
+    s.field("block", S.option(S.object(s2 => s2.field("height", S.unknown))->S.strict))
   ),
   logger,
   toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),

package/src/sources/Fuel.res.mjs

@@ -19,7 +19,7 @@ function make(logger) {
     cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown))))),
-    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown))))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown)))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {

package/src/sources/HyperSyncSource.res

@@ -7,13 +7,12 @@ type selectionConfig = {
   fieldSelection: HyperSyncClient.QueryTypes.fieldSelection,
 }
 
-let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
+let getSelectionConfig = (selection: FetchState.selection) => {
   let capitalizedBlockFields = Utils.Set.make()
   let capitalizedTransactionFields = Utils.Set.make()
 
-  let staticTopicSelectionsByContract = Dict.make()
-  let dynamicEventFiltersByContract = Dict.make()
-  let dynamicWildcardEventFiltersByContract = Dict.make()
+  let topicSelectionsByContract = Dict.make()
+  let wildcardTopicSelectionsByContract = Dict.make()
   let noAddressesTopicSelections = []
   let contractNames = Utils.Set.make()
 
@@ -24,7 +23,7 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
       reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
     let contractName = eventConfig.contractName
     let {selectedBlockFields, selectedTransactionFields} = eventConfig
-    let {dependsOnAddresses, getEventFiltersOrThrow, isWildcard} = reg
+    let {dependsOnAddresses, resolvedWhere, isWildcard} = reg
     selectedBlockFields
     ->Utils.Set.toArray
     ->Array.forEach(name =>
@@ -44,24 +43,16 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
       }
     })
 
-    let eventFilters = getEventFiltersOrThrow(chain)
     if dependsOnAddresses {
       let _ = contractNames->Utils.Set.add(contractName)
-      switch eventFilters {
-      | Static(topicSelections) =>
-        staticTopicSelectionsByContract->Utils.Dict.pushMany(contractName, topicSelections)
-      | Dynamic(fn) =>
-        (
-          isWildcard ? dynamicWildcardEventFiltersByContract : dynamicEventFiltersByContract
-        )->Utils.Dict.push(contractName, fn)
-      }
+
+      (
+        isWildcard ? wildcardTopicSelectionsByContract : topicSelectionsByContract
+      )->Utils.Dict.pushMany(contractName, resolvedWhere.topicSelections)
     } else {
       noAddressesTopicSelections
       ->Array.pushMany(
-        switch eventFilters {
-        | Static(s) => s
-        | Dynamic(fn) => fn([])
-        },
+        resolvedWhere.topicSelections->LogSelection.materializeTopicSelections(~addresses=[]),
       )
       ->ignore
     }
@@ -92,27 +83,26 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
       | None
       | Some([]) => ()
       | Some(addresses) =>
-        switch staticTopicSelectionsByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
+        switch topicSelectionsByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
         | None => ()
         | Some(topicSelections) =>
-          logSelections->Array.push(LogSelection.make(~addresses, ~topicSelections))
-        }
-        switch dynamicEventFiltersByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-        | None => ()
-        | Some(fns) =>
           logSelections->Array.push(
-            LogSelection.make(~addresses, ~topicSelections=fns->Array.flatMap(fn => fn(addresses))),
+            LogSelection.make(
+              ~addresses,
+              ~topicSelections=topicSelections->LogSelection.materializeTopicSelections(~addresses),
+            ),
           )
         }
-        switch dynamicWildcardEventFiltersByContract->Utils.Dict.dangerouslyGetNonOption(
-          contractName,
-        ) {
+        // Wildcard events that filter an indexed param by registered addresses:
+        // the addresses fold into the topics, so the query itself stays
+        // address-unbound.
+        switch wildcardTopicSelectionsByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
         | None => ()
-        | Some(fns) =>
+        | Some(topicSelections) =>
           logSelections->Array.push(
             LogSelection.make(
               ~addresses=[],
-              ~topicSelections=fns->Array.flatMap(fn => fn(addresses)),
+              ~topicSelections=topicSelections->LogSelection.materializeTopicSelections(~addresses),
             ),
           )
         }
@@ -127,8 +117,7 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
   }
 }
 
-let memoGetSelectionConfig = (~chain) =>
-  Utils.WeakMap.memoize(selection => selection->getSelectionConfig(~chain))
+let memoGetSelectionConfig = () => Utils.WeakMap.memoize(getSelectionConfig)
 
 // Surfaced by HyperSyncClient.getHeight (Rust) when HyperSync rejects the API
 // token. The corrupted-token test feeds the real server error through this
@@ -164,7 +153,7 @@ let make = (
 ): t => {
   let name = "HyperSync"
 
-  let getSelectionConfig = memoGetSelectionConfig(~chain)
+  let getSelectionConfig = memoGetSelectionConfig()
 
   let apiToken = switch apiToken {
   | Some(token) => token