envio 3.3.0-alpha.0 → 3.3.0-alpha.10

package/src/HandlerRegister.res.mjs

@@ -2,35 +2,18 @@
 
 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;
@@ -53,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.");
@@ -71,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) {
@@ -88,51 +67,37 @@ function startRegistration(ecosystem) {
   };
 }
 
-function finishRegistration() {
-  let r = activeRegistration.contents;
-  if (r !== undefined) {
-    r.finished = true;
-    return r.registrations;
-  } else {
-    return Stdlib_JsError.throwWithMessage("The indexer has not started registering handlers, so can't finish it.");
-  }
-}
-
-function isPendingRegistration() {
-  let r = activeRegistration.contents;
-  if (r !== undefined) {
-    return !r.finished;
-  } else {
-    return false;
+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 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 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, 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 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) {
@@ -143,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);
 }
@@ -171,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;
     }
@@ -195,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) {
@@ -219,76 +191,256 @@ 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,
   finishRegistration,
   throwIfFinishedRegistration,
+  buildOnEventRegistration,
   setHandler,
   setContractRegister,
   getHandler,
   getContractRegister,
-  getOnEventWhere,
   isWildcard,
   hasRegistration,
+  blockRangeSchema,
+  defaultBlockRange,
   registerOnBlock,
 }
-/* existing Not a pure module */
+/* blockRangeSchema Not a pure module */

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 startRegistration: (~config: Config.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,
@@ -24,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/IndexerLoop.res

@@ -19,12 +19,11 @@ let start = (state: IndexerState.t) => {
     launch(state, () =>
       state
       ->IndexerState.crossChainState
-      ->CrossChainState.checkAndFetch(~fetchChain=(~chain, ~concurrencyLimit, ~bufferLimit) =>
+      ->CrossChainState.checkAndFetch(~dispatchChain=(~chain, ~action) =>
         ChainFetching.fetchChain(
           state,
           chain,
-          ~concurrencyLimit,
-          ~bufferLimit,
+          ~action,
           ~stateId=state->IndexerState.epoch,
           ~scheduleFetch,
           ~scheduleProcessing,

package/src/IndexerLoop.res.mjs

@@ -15,7 +15,7 @@ function launch(state, work) {
 
 function start(state) {
   let scheduleFetch = () => {
-    let work = () => CrossChainState.checkAndFetch(IndexerState.crossChainState(state), (chain, concurrencyLimit, bufferLimit) => ChainFetching.fetchChain(state, chain, concurrencyLimit, bufferLimit, IndexerState.epoch(state), scheduleFetch, scheduleProcessing, scheduleRollback));
+    let work = () => CrossChainState.checkAndFetch(IndexerState.crossChainState(state), (chain, action) => ChainFetching.fetchChain(state, chain, action, IndexerState.epoch(state), scheduleFetch, scheduleProcessing, scheduleRollback));
     if (!IndexerState.isStopped(state)) {
       work();
       return;

package/src/IndexerState.res

@@ -108,6 +108,8 @@ type t = {
   // waitForNewBlock waiter is bound to the old, pre-realtime source). A fetch
   // response or waiter carrying an older epoch than this is discarded.
   mutable epoch: int,
+  // None off the simulate path.
+  simulateDeadInputTracker: option<SimulateDeadInputTracker.t>,
 }
 
 let make = (
@@ -116,8 +118,6 @@ let make = (
   ~chainStates: dict<ChainState.t>,
   ~isInReorgThreshold: bool,
   ~isRealtime: bool,
-  ~maxBackfillConcurrency=Env.maxBackfillConcurrency,
-  ~maxRealtimeConcurrency=Env.maxRealtimeConcurrency,
   ~targetBufferSize=CrossChainState.calculateTargetBufferSize(),
   ~committedCheckpointId=Internal.initialCheckpointId,
   ~isDevelopmentMode=false,
@@ -160,8 +160,6 @@ let make = (
       ~chainStates,
       ~isInReorgThreshold,
       ~isRealtime,
-      ~maxBackfillConcurrency,
-      ~maxRealtimeConcurrency,
       ~targetBufferSize,
     ),
     indexerStartTime: Date.make(),
@@ -173,6 +171,7 @@ let make = (
     onError,
     isStopped: false,
     epoch: 0,
+    simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
   }
 }
 
@@ -189,13 +188,11 @@ let makeFromDbState = (
   ~config: Config.t,
   ~persistence: Persistence.t,
   ~initialState: Persistence.initialState,
-  ~registrations,
+  ~registrationsByChainId,
   ~isDevelopmentMode=false,
   ~shouldUseTui=false,
   ~exitAfterFirstEventBlock=false,
   ~reducedPollingInterval=?,
-  ~maxBackfillConcurrency=Env.maxBackfillConcurrency,
-  ~maxRealtimeConcurrency=Env.maxRealtimeConcurrency,
   ~targetBufferSize=CrossChainState.calculateTargetBufferSize(),
   ~onError,
 ) => {
@@ -237,7 +234,7 @@ let makeFromDbState = (
         ~isInReorgThreshold,
         ~isRealtime,
         ~config,
-        ~registrations,
+        ~registrationsByChainId,
         ~reducedPollingInterval?,
       ),
     )
@@ -269,8 +266,6 @@ let makeFromDbState = (
     ~chainStates,
     ~isInReorgThreshold,
     ~isRealtime,
-    ~maxBackfillConcurrency,
-    ~maxRealtimeConcurrency,
     ~targetBufferSize,
     ~committedCheckpointId=initialState.checkpointId,
     ~isDevelopmentMode,
@@ -367,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.
@@ -408,6 +406,7 @@ let exitAfterFirstEventBlock = (state: t) => state.exitAfterFirstEventBlock
 let isStopped = (state: t) => state.isStopped
 let epoch = (state: t) => state.epoch
 let pruneStaleEntityHistoryThrottler = (state: t) => state.writeThrottlers.pruneStaleEntityHistory
+let simulateDeadInputTracker = (state: t) => state.simulateDeadInputTracker
 
 // --- Store domain operations. ---