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

package/src/HandlerRegister.res.mjs

@@ -3,38 +3,17 @@
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
+import * as EnvioGlobal from "./EnvioGlobal.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 S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as EventConfigBuilder from "./EventConfigBuilder.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-let version = Utils.EnvioPackage.value.version;
-
-let existing = globalThis.__envioRegistry;
-
-let registry;
-
-if (existing == null) {
-  let fresh_eventRegistrations = {};
-  let fresh_activeRegistration = {
-    contents: undefined
-  };
-  let fresh_preRegistered = [];
-  let fresh = {
-    version: version,
-    eventRegistrations: fresh_eventRegistrations,
-    activeRegistration: fresh_activeRegistration,
-    preRegistered: fresh_preRegistered
-  };
-  globalThis.__envioRegistry = fresh;
-  registry = fresh;
-} else {
-  registry = existing.version === version ? existing : Stdlib_JsError.throwWithMessage(`Multiple incompatible envio versions loaded in the same process: ` + existing.version + ` and ` + version + `. Deduplicate the 'envio' dependency in your project.`);
-}
-
-let eventRegistrations = registry.eventRegistrations;
+let eventRegistrations = EnvioGlobal.value.eventRegistrations;
 
 function getKey(contractName, eventName) {
   return contractName + "." + eventName;
@@ -57,12 +36,10 @@ function set(contractName, eventName, registration) {
   eventRegistrations[getKey(contractName, eventName)] = registration;
 }
 
-let activeRegistration = registry.activeRegistration;
-
-let preRegistered = registry.preRegistered;
+let preRegistered = EnvioGlobal.value.preRegistered;
 
 function withRegistration(fn) {
-  let r = activeRegistration.contents;
+  let r = EnvioGlobal.value.activeRegistration;
   if (r !== undefined) {
     if (r.finished) {
       return Stdlib_JsError.throwWithMessage("The indexer finished initializing, so no more handlers can be registered. Make sure the handlers are registered on the top level of the file.");
@@ -75,15 +52,13 @@ function withRegistration(fn) {
   }
 }
 
-function startRegistration(ecosystem) {
+function startRegistration(config) {
   let r = {
-    ecosystem: ecosystem,
-    registrations: {
-      onBlockByChainId: {}
-    },
+    config: config,
+    registrationsByChainId: {},
     finished: false
   };
-  activeRegistration.contents = r;
+  EnvioGlobal.value.activeRegistration = Primitive_option.some(r);
   while (preRegistered.length !== 0) {
     let fn = preRegistered.pop();
     if (fn !== undefined) {
@@ -92,17 +67,27 @@ function startRegistration(ecosystem) {
   };
 }
 
-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;
+function getPendingChainRegistrations(r, chainId) {
+  let key = chainId.toString();
+  let pending = r.registrationsByChainId[key];
+  if (pending !== undefined) {
+    return pending;
+  }
+  let fresh_onEventRegistrations = {};
+  let fresh_onBlockRegistrations = [];
+  let fresh = {
+    onEventRegistrations: fresh_onEventRegistrations,
+    onBlockRegistrations: fresh_onBlockRegistrations
+  };
+  r.registrationsByChainId[key] = fresh;
+  return fresh;
+}
+
+function buildOnEventRegistrationWith(config, chainId, eventConfig, isWildcard, handler, contractRegister, where, startBlock) {
   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);
+      return EventConfigBuilder.buildEvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, chainId, config.ecosystem.onEventBlockFilterSchema, startBlock);
     case "fuel" :
       return EventConfigBuilder.buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
     case "svm" :
@@ -110,113 +95,9 @@ function buildOnEventRegistration(config, chainId, eventConfig, 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) {
-    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() {
-  let r = activeRegistration.contents;
-  if (r !== undefined) {
-    return !r.finished;
-  } else {
-    return false;
-  }
-}
-
-function throwIfFinishedRegistration(methodName) {
-  let match = activeRegistration.contents;
-  if (match === undefined) {
-    return;
-  }
-  let match$1 = match.finished;
-  if (match$1) {
-    return Stdlib_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.`);
-  }
-}
-
-function registerOnBlock(name, chainId, interval, startBlock, endBlock, handler) {
-  withRegistration(registration => {
-    let onBlockByChainId = registration.registrations.onBlockByChainId;
-    let key = chainId.toString();
-    let index = Stdlib_Option.mapOr(onBlockByChainId[key], 0, configs => configs.length);
-    Utils.Dict.push(onBlockByChainId, key, {
-      index: index,
-      name: name,
-      chainId: chainId,
-      startBlock: startBlock,
-      endBlock: endBlock,
-      interval: interval,
-      handler: handler
-    });
-  });
+function buildOnEventRegistration(config, chainId, eventConfig, startBlock) {
+  let t = get(eventConfig.contractName, eventConfig.name);
+  return buildOnEventRegistrationWith(config, chainId, eventConfig, Stdlib_Option.getOr(Stdlib_Option.flatMap(t.eventOptions, v => v.wildcard), false), t.handler, t.contractRegister, Stdlib_Option.flatMap(t.eventOptions, v => v.where), startBlock);
 }
 
 function getHandler(contractName, eventName) {
@@ -227,10 +108,6 @@ function getContractRegister(contractName, eventName) {
   return get(contractName, eventName).contractRegister;
 }
 
-function getOnEventWhere(contractName, eventName) {
-  return Stdlib_Option.flatMap(get(contractName, eventName).eventOptions, value => value.where);
-}
-
 function isWildcard(contractName, eventName) {
   return Stdlib_Option.getOr(Stdlib_Option.flatMap(get(contractName, eventName).eventOptions, value => value.wildcard), false);
 }
@@ -255,22 +132,8 @@ function raiseDuplicateRegistration(contractName, eventName, msg, logger) {
 
 function eventOptionsMatch(existing, incoming) {
   if (existing !== undefined) {
-    if (incoming !== undefined && existing.wildcard === incoming.wildcard) {
-      let a = existing.where;
-      let b = incoming.where;
-      if (a !== undefined) {
-        if (b !== undefined) {
-          if (typeof a === "function" || typeof b === "function") {
-            return a === b;
-          } else {
-            return Primitive_object.equal(a, b);
-          }
-        } else {
-          return false;
-        }
-      } else {
-        return b === undefined;
-      }
+    if (incoming !== undefined) {
+      return existing.wildcard === incoming.wildcard;
     } else {
       return false;
     }
@@ -279,6 +142,31 @@ function eventOptionsMatch(existing, incoming) {
   }
 }
 
+function syncOnEventRegistrations(r, contractName, eventName, where, duplicateMsg, logger) {
+  let config = r.config;
+  let t = get(contractName, eventName);
+  let isWildcard = Stdlib_Option.getOr(Stdlib_Option.flatMap(t.eventOptions, v => v.wildcard), false);
+  let key = getKey(contractName, eventName);
+  ChainMap.values(config.chainMap).forEach(chainConfig => {
+    chainConfig.contracts.forEach(contract => {
+      if (contract.name !== contractName) {
+        return;
+      }
+      let eventConfig = contract.events.find(e => e.name === eventName);
+      if (eventConfig === undefined) {
+        return;
+      }
+      let newRegistration = buildOnEventRegistrationWith(config, chainConfig.id, eventConfig, isWildcard, t.handler, t.contractRegister, where, contract.startBlock);
+      let pending = getPendingChainRegistrations(r, chainConfig.id);
+      let existing = pending.onEventRegistrations[key];
+      if (existing !== undefined && config.ecosystem.name === "evm" && !Primitive_object.equal(existing.resolvedWhere, newRegistration.resolvedWhere)) {
+        raiseDuplicateRegistration(contractName, eventName, duplicateMsg, logger);
+      }
+      pending.onEventRegistrations[key] = newRegistration;
+    });
+  });
+}
+
 function setEventOptions(contractName, eventName, eventOptions, loggerOpt) {
   let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
   if (eventOptions === undefined) {
@@ -303,64 +191,242 @@ function setEventOptions(contractName, eventName, eventOptions, loggerOpt) {
 
 function setHandler(contractName, eventName, handler, eventOptions, loggerOpt) {
   let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(_registration => {
+  withRegistration(registration => {
     let t = get(contractName, eventName);
+    let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
     let prevHandler = t.handler;
     if (prevHandler !== undefined) {
-      let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
-      if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
-        return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
+      if (eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
+        let composedHandler = async args => {
+          await prevHandler(args);
+          return await handler(args);
+        };
+        set(contractName, eventName, {
+          handler: composedHandler,
+          contractRegister: t.contractRegister,
+          eventOptions: t.eventOptions
+        });
+      } else {
+        raiseDuplicateRegistration(contractName, eventName, "Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
       }
-      let composedHandler = async args => {
-        await prevHandler(args);
-        return await handler(args);
-      };
-      return set(contractName, eventName, {
-        handler: composedHandler,
-        contractRegister: t.contractRegister,
-        eventOptions: t.eventOptions
+    } else {
+      setEventOptions(contractName, eventName, eventOptions, logger);
+      let t$1 = get(contractName, eventName);
+      set(contractName, eventName, {
+        handler: handler,
+        contractRegister: t$1.contractRegister,
+        eventOptions: t$1.eventOptions
       });
     }
-    setEventOptions(contractName, eventName, eventOptions, logger);
-    let t$1 = get(contractName, eventName);
-    set(contractName, eventName, {
-      handler: handler,
-      contractRegister: t$1.contractRegister,
-      eventOptions: t$1.eventOptions
-    });
+    syncOnEventRegistrations(registration, contractName, eventName, Stdlib_Option.flatMap(incomingEventOptions, v => v.where), "Cannot register a second handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
   });
 }
 
 function setContractRegister(contractName, eventName, contractRegister, eventOptions, loggerOpt) {
   let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(_registration => {
+  withRegistration(registration => {
     let t = get(contractName, eventName);
+    let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
     let prevContractRegister = t.contractRegister;
     if (prevContractRegister !== undefined) {
-      let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
-      if (!eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
-        return raiseDuplicateRegistration(contractName, eventName, "Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
+      if (eventOptionsMatch(t.eventOptions, incomingEventOptions)) {
+        let composedContractRegister = async args => {
+          await prevContractRegister(args);
+          return await contractRegister(args);
+        };
+        set(contractName, eventName, {
+          handler: t.handler,
+          contractRegister: composedContractRegister,
+          eventOptions: t.eventOptions
+        });
+      } else {
+        raiseDuplicateRegistration(contractName, eventName, "Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
       }
-      let composedContractRegister = async args => {
-        await prevContractRegister(args);
-        return await contractRegister(args);
-      };
-      return set(contractName, eventName, {
-        handler: t.handler,
-        contractRegister: composedContractRegister,
-        eventOptions: t.eventOptions
+    } else {
+      setEventOptions(contractName, eventName, eventOptions, logger);
+      let t$1 = get(contractName, eventName);
+      set(contractName, eventName, {
+        handler: t$1.handler,
+        contractRegister: contractRegister,
+        eventOptions: t$1.eventOptions
       });
     }
-    setEventOptions(contractName, eventName, eventOptions, logger);
-    let t$1 = get(contractName, eventName);
-    set(contractName, eventName, {
-      handler: t$1.handler,
-      contractRegister: contractRegister,
-      eventOptions: t$1.eventOptions
+    syncOnEventRegistrations(registration, contractName, eventName, Stdlib_Option.flatMap(incomingEventOptions, v => v.where), "Cannot register a second contractRegister with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
+  });
+}
+
+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))
+})));
+
+let defaultBlockRange = {
+  _gte: undefined,
+  _lte: undefined,
+  _every: 1
+};
+
+function 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;
+  }
+}
+
+function registerOnBlock(name, where, handler, getChainsObject) {
+  withRegistration(registration => {
+    let config = registration.config;
+    let ecosystem = config.ecosystem;
+    let chainsDict = getChainsObject(config);
+    let logger = Logging.createChild({
+      onBlock: name
     });
+    let where$1 = where === undefined || where === null ? undefined : (
+        typeof where === "function" ? where : Stdlib_JsError.throwWithMessage(`\`indexer.` + ecosystem.onBlockMethodName + `("` + name + `")\` expected \`where\` to be a function or omitted, but got ` + typeof where + `.`)
+      );
+    let matchedAny = {
+      contents: false
+    };
+    ChainMap.values(config.chainMap).forEach(chainConfig => {
+      let chainId = chainConfig.id;
+      let chainObj = chainsDict[chainId.toString()];
+      let result = where$1 !== undefined ? where$1({
+          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;
+      if (Stdlib_Option.getOr(range._gte, chainConfig.startBlock) < chainConfig.startBlock) {
+        Stdlib_JsError.throwWithMessage(`The start block for onBlock handler "` + name + `" is less than the chain start block (` + chainConfig.startBlock.toString() + `). This is not supported yet.`);
+      }
+      let chainEndBlock = chainConfig.endBlock;
+      if (chainEndBlock !== undefined && Stdlib_Option.getOr(range._lte, chainEndBlock) > chainEndBlock) {
+        Stdlib_JsError.throwWithMessage(`The end block for onBlock handler "` + name + `" is greater than the chain end block (` + chainEndBlock.toString() + `). This is not supported yet.`);
+      }
+      let pending = getPendingChainRegistrations(registration, chainId);
+      pending.onBlockRegistrations.push({
+        index: pending.onBlockRegistrations.length,
+        name: name,
+        chainId: chainId,
+        startBlock: range._gte,
+        endBlock: range._lte,
+        interval: range._every,
+        handler: handler
+      });
+    });
+    if (!matchedAny.contents) {
+      return Logging.childWarn(logger, `\`indexer.` + ecosystem.onBlockMethodName + `\` matched 0 chains. Check the \`where\` predicate.`);
+    }
   });
 }
 
+function finishRegistration(config) {
+  let r = EnvioGlobal.value.activeRegistration;
+  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();
+    let pending = r.registrationsByChainId[key];
+    let eventRouter = EventRouter.empty();
+    let onEventRegistrations = [];
+    chainConfig.contracts.forEach(contract => {
+      let contractName = contract.name;
+      contract.events.forEach(eventConfig => {
+        let eventName = eventConfig.name;
+        let registration = Stdlib_Option.flatMap(pending, pending => pending.onEventRegistrations[getKey(contractName, eventName)]);
+        EventRouter.addOrThrow(eventRouter, eventConfig.id, undefined, contractName, registration !== undefined ? registration.isWildcard : isWildcard(contractName, eventName), eventName, ChainMap.Chain.makeUnsafe(chainConfig.id));
+        let registration$1;
+        if (registration !== undefined) {
+          registration$1 = registration;
+        } else if (hasRegistration(contractName, eventName) || config.enableRawEvents) {
+          registration$1 = buildOnEventRegistration(config, chainConfig.id, eventConfig, contract.startBlock);
+        } else {
+          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);
+          registration$1 = undefined;
+        }
+        if (registration$1 === undefined) {
+          return;
+        }
+        let isDroppedByWhere = config.ecosystem.name === "evm" && Utils.$$Array.isEmpty(registration$1.resolvedWhere.topicSelections);
+        if (!isDroppedByWhere) {
+          onEventRegistrations.push(registration$1);
+          return;
+        }
+      });
+    });
+    registrationsByChainId[key] = {
+      onEventRegistrations: onEventRegistrations,
+      onBlockRegistrations: pending !== undefined ? pending.onBlockRegistrations : []
+    };
+  });
+  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() {
+  let r = EnvioGlobal.value.activeRegistration;
+  if (r !== undefined) {
+    return !r.finished;
+  } else {
+    return false;
+  }
+}
+
+function throwIfFinishedRegistration(methodName) {
+  let match = EnvioGlobal.value.activeRegistration;
+  if (match === undefined) {
+    return;
+  }
+  let match$1 = match.finished;
+  if (match$1) {
+    return Stdlib_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.`);
+  }
+}
+
 export {
   startRegistration,
   isPendingRegistration,
@@ -371,9 +437,10 @@ export {
   setContractRegister,
   getHandler,
   getContractRegister,
-  getOnEventWhere,
   isWildcard,
   hasRegistration,
+  blockRangeSchema,
+  defaultBlockRange,
   registerOnBlock,
 }
-/* existing Not a pure module */
+/* blockRangeSchema Not a pure module */

package/src/HandlerRegister.resi

@@ -4,7 +4,7 @@ type chainRegistrations = {
 }
 type registrationsByChainId = dict<chainRegistrations>
 
-let startRegistration: (~ecosystem: Ecosystem.t) => unit
+let startRegistration: (~config: Config.t) => unit
 let isPendingRegistration: unit => bool
 let finishRegistration: (~config: Config.t) => registrationsByChainId
 let throwIfFinishedRegistration: (~methodName: string) => unit
@@ -35,15 +35,20 @@ let getContractRegister: (
   ~contractName: string,
   ~eventName: string,
 ) => option<Internal.contractRegister>
-let getOnEventWhere: (~contractName: string, ~eventName: string) => option<JSON.t>
 let isWildcard: (~contractName: string, ~eventName: string) => bool
 let hasRegistration: (~contractName: string, ~eventName: string) => bool
 
+type blockRange = {
+  _gte: option<int>,
+  _lte: option<int>,
+  _every: int,
+}
+let blockRangeSchema: S.t<blockRange>
+let defaultBlockRange: blockRange
+
 let registerOnBlock: (
   ~name: string,
-  ~chainId: int,
-  ~interval: int,
-  ~startBlock: option<int>,
-  ~endBlock: option<int>,
+  ~where: unknown,
   ~handler: Internal.onBlockArgs => promise<unit>,
+  ~getChainsObject: Config.t => dict<unknown>,
 ) => unit

package/src/Internal.res

@@ -459,15 +459,34 @@ type topicSelection = {
   topic3: array<EvmTypes.Hex.t>,
 }
 
+// A single topic position of a resolved `where`: either static pre-encoded
+// values, or a marker for "the currently registered addresses of this
+// contract", expanded to topic values when a source query is built.
+type topicFilter =
+  | Values(array<EvmTypes.Hex.t>)
+  | ContractAddresses({contractName: string})
+
+type resolvedTopicSelection = {
+  topic0: array<EvmTypes.Hex.t>,
+  topic1: topicFilter,
+  topic2: topicFilter,
+  topic3: topicFilter,
+}
+
+// The registered `where` fully resolved at registration time for one chain.
+// `topicSelections` is in disjunctive normal form (outer array is OR);
+// an empty array means the `where` returned `false` for this chain.
+type resolvedWhere = {
+  topicSelections: array<resolvedTopicSelection>,
+  startBlock: option<int>,
+}
+
 // Per-event, per-invocation arguments passed to a `where` callback. The
 // concrete `chain` shape (which contract key it exposes) is generated per
 // event in user-project codegen — here it's an open record so codegen'd
 // types subtype-coerce into it cleanly.
 type onEventWhereArgs<'chain> = {chain: 'chain}
 
-type eventFilters =
-  Static(array<topicSelection>) | Dynamic(array<Address.t> => array<topicSelection>)
-
 type evmEventConfig = {
   ...eventConfig,
   selectedBlockFields: Utils.Set.t<evmBlockField>,
@@ -557,7 +576,7 @@ type onEventRegistration = {
 
 type evmOnEventRegistration = {
   ...onEventRegistration,
-  getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
+  resolvedWhere: resolvedWhere,
 }
 
 // Fuel and SVM registrations add no ecosystem-specific fetch state (their