envio 3.3.1 → 3.4.0

package/src/HandlerRegister.res.mjs

@@ -4,7 +4,6 @@ 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";
@@ -13,27 +12,12 @@ 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 eventRegistrations = EnvioGlobal.value.eventRegistrations;
-
 function getKey(contractName, eventName) {
   return contractName + "." + eventName;
 }
 
-function get(contractName, eventName) {
-  let existing = eventRegistrations[getKey(contractName, eventName)];
-  if (existing !== undefined) {
-    return existing;
-  } else {
-    return {
-      handler: undefined,
-      contractRegister: undefined,
-      eventOptions: undefined
-    };
-  }
-}
-
-function set(contractName, eventName, registration) {
-  eventRegistrations[getKey(contractName, eventName)] = registration;
+function resetOnEventRegistrations() {
+  EnvioGlobal.value.activeRegistration = undefined;
 }
 
 let preRegistered = EnvioGlobal.value.preRegistered;
@@ -53,27 +37,28 @@ function withRegistration(fn) {
 }
 
 function startRegistration(config) {
+  let match = EnvioGlobal.value.activeRegistration;
+  if (match !== undefined) {
+    return;
+  }
   let r = {
     config: config,
     registrationsByChainId: {},
     finished: false
   };
   EnvioGlobal.value.activeRegistration = Primitive_option.some(r);
-  while (preRegistered.length !== 0) {
-    let fn = preRegistered.pop();
-    if (fn !== undefined) {
-      fn(r);
-    }
-  };
+  let queued = preRegistered.slice();
+  preRegistered.splice(0, preRegistered.length);
+  queued.forEach(fn => fn(r));
 }
 
-function getPendingChainRegistrations(r, chainId) {
+function getChainRegistrations(r, chainId) {
   let key = chainId.toString();
-  let pending = r.registrationsByChainId[key];
-  if (pending !== undefined) {
-    return pending;
+  let existing = r.registrationsByChainId[key];
+  if (existing !== undefined) {
+    return existing;
   }
-  let fresh_onEventRegistrations = {};
+  let fresh_onEventRegistrations = [];
   let fresh_onBlockRegistrations = [];
   let fresh = {
     onEventRegistrations: fresh_onEventRegistrations,
@@ -95,164 +80,221 @@ function buildOnEventRegistrationWith(config, chainId, eventConfig, isWildcard,
   }
 }
 
-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 sameEventAndFilter(a, b, config) {
+  if (a.eventConfig.contractName !== b.eventConfig.contractName || a.eventConfig.name !== b.eventConfig.name || a.isWildcard !== b.isWildcard) {
+    return false;
+  }
+  let match = config.ecosystem.name;
+  switch (match) {
+    case "evm" :
+      return Primitive_object.equal(a.resolvedWhere, b.resolvedWhere);
+    case "fuel" :
+    case "svm" :
+      return true;
+  }
 }
 
-function getHandler(contractName, eventName) {
-  return get(contractName, eventName).handler;
+function mergeRegistrations(resolved, config) {
+  let merged = {
+    contents: []
+  };
+  resolved.forEach(reg => {
+    if (Stdlib_Option.isSome(reg.handler)) {
+      let i = merged.contents.findIndex(m => {
+        if (Stdlib_Option.isNone(m.handler) && Stdlib_Option.isSome(m.contractRegister)) {
+          return sameEventAndFilter(m, reg, config);
+        } else {
+          return false;
+        }
+      });
+      if (i === -1) {
+        merged.contents = merged.contents.concat([reg]);
+        return;
+      }
+      let target = merged.contents[i];
+      let newrecord = {...reg};
+      merged.contents = merged.contents.filter((param, j) => j !== i).concat([(newrecord.contractRegister = target.contractRegister, newrecord)]);
+      return;
+    }
+    let i$1 = merged.contents.findIndex(m => {
+      if (Stdlib_Option.isSome(m.handler) && Stdlib_Option.isNone(m.contractRegister)) {
+        return sameEventAndFilter(m, reg, config);
+      } else {
+        return false;
+      }
+    });
+    if (i$1 === -1) {
+      merged.contents = merged.contents.concat([reg]);
+      return;
+    }
+    let target$1 = merged.contents[i$1];
+    let next = merged.contents.slice();
+    let newrecord$1 = {...target$1};
+    newrecord$1.contractRegister = reg.contractRegister;
+    next[i$1] = newrecord$1;
+    merged.contents = next;
+  });
+  return merged.contents;
 }
 
-function getContractRegister(contractName, eventName) {
-  return get(contractName, eventName).contractRegister;
+function isDroppedByWhere(config, reg) {
+  if (config.ecosystem.name === "evm") {
+    return Utils.$$Array.isEmpty(reg.resolvedWhere.topicSelections);
+  } else {
+    return false;
+  }
 }
 
-function isWildcard(contractName, eventName) {
-  return Stdlib_Option.getOr(Stdlib_Option.flatMap(get(contractName, eventName).eventOptions, value => value.wildcard), false);
+function addOnEventRegistration(registration, contractName, eventName, handler, contractRegister, eventOptions) {
+  let isWildcard = Stdlib_Option.getOr(Stdlib_Option.flatMap(eventOptions, v => v.wildcard), false);
+  let where = Stdlib_Option.flatMap(eventOptions, v => v.where);
+  ChainMap.values(registration.config.chainMap).forEach(chainConfig => {
+    let contract = chainConfig.contracts.find(c => c.name === contractName);
+    if (contract === undefined) {
+      return;
+    }
+    let eventConfig = contract.events.find(e => e.name === eventName);
+    if (eventConfig === undefined) {
+      return;
+    }
+    let reg = buildOnEventRegistrationWith(registration.config, chainConfig.id, eventConfig, isWildcard, handler, contractRegister, where, contract.startBlock);
+    getChainRegistrations(registration, chainConfig.id).onEventRegistrations.push(reg);
+  });
 }
 
-function hasRegistration(contractName, eventName) {
-  let r = get(contractName, eventName);
-  if (Stdlib_Option.isSome(r.handler)) {
-    return true;
+function setHandler(contractName, eventName, handler, eventOptions) {
+  withRegistration(registration => {
+    let eventOptions$1 = Stdlib_Option.map(eventOptions, v => v);
+    addOnEventRegistration(registration, contractName, eventName, handler, undefined, eventOptions$1);
+  });
+}
+
+function setContractRegister(contractName, eventName, contractRegister, eventOptions) {
+  withRegistration(registration => {
+    let eventOptions$1 = Stdlib_Option.map(eventOptions, v => v);
+    addOnEventRegistration(registration, contractName, eventName, undefined, contractRegister, eventOptions$1);
+  });
+}
+
+function storedOnEventRegistrations(r, chainId) {
+  let chainRegs = r.registrationsByChainId[chainId.toString()];
+  if (chainRegs !== undefined) {
+    return chainRegs.onEventRegistrations;
   } else {
-    return Stdlib_Option.isSome(r.contractRegister);
+    return [];
   }
 }
 
-function raiseDuplicateRegistration(contractName, eventName, msg, logger) {
-  let fullMsg = msg + " for " + contractName + "." + eventName;
-  Logging.childError(Logging.createChildFrom(logger, {
-    contractName: contractName,
-    eventName: eventName
-  }), fullMsg);
-  return Stdlib_JsError.throwWithMessage(fullMsg);
+function isWildcard(contractName, eventName) {
+  let r = EnvioGlobal.value.activeRegistration;
+  if (r !== undefined) {
+    return Object.values(r.registrationsByChainId).some(chainRegs => chainRegs.onEventRegistrations.some(reg => {
+      if (reg.eventConfig.contractName === contractName && reg.eventConfig.name === eventName) {
+        return reg.isWildcard;
+      } else {
+        return false;
+      }
+    }));
+  } else {
+    return false;
+  }
 }
 
-function eventOptionsMatch(existing, incoming) {
-  if (existing !== undefined) {
-    if (incoming !== undefined) {
-      return existing.wildcard === incoming.wildcard;
+function getSimulateOnEventRegistrations(config, chainId, eventConfig) {
+  let r = EnvioGlobal.value.activeRegistration;
+  let stored = r !== undefined ? storedOnEventRegistrations(r, chainId) : [];
+  let matching = mergeRegistrations(stored, config).filter(reg => {
+    if (reg.eventConfig.contractName === eventConfig.contractName) {
+      return reg.eventConfig.name === eventConfig.name;
     } else {
       return false;
     }
+  });
+  if (Utils.$$Array.notEmpty(matching)) {
+    return matching;
   } else {
-    return incoming === undefined;
+    return [buildOnEventRegistrationWith(config, chainId, eventConfig, false, undefined, undefined, undefined, undefined)];
   }
 }
 
-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);
+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 chainId = chainConfig.id;
+    let key = chainId.toString();
+    let builtRegs = mergeRegistrations(storedOnEventRegistrations(r, chainId), config);
+    let registeredKeys = new Set();
+    builtRegs.forEach(reg => {
+      registeredKeys.add(getKey(reg.eventConfig.contractName, reg.eventConfig.name));
+    });
+    let rawEventRegs = [];
     chainConfig.contracts.forEach(contract => {
-      if (contract.name !== contractName) {
-        return;
-      }
-      let eventConfig = contract.events.find(e => e.name === eventName);
-      if (eventConfig === undefined) {
+      contract.events.forEach(eventConfig => {
+        if (registeredKeys.has(getKey(contract.name, eventConfig.name))) {
+          return;
+        }
+        if (config.enableRawEvents) {
+          rawEventRegs.push(buildOnEventRegistrationWith(config, chainId, eventConfig, false, undefined, undefined, undefined, contract.startBlock));
+          return;
+        }
+        let set = notRegisteredEventsByContract[contract.name];
+        let eventNames;
+        if (set !== undefined) {
+          eventNames = Primitive_option.valFromOption(set);
+        } else {
+          let set$1 = new Set();
+          notRegisteredEventsByContract[contract.name] = set$1;
+          eventNames = set$1;
+        }
+        eventNames.add(eventConfig.name);
+      });
+    });
+    let onEventRegistrations = [];
+    builtRegs.concat(rawEventRegs).forEach(reg => {
+      if (isDroppedByWhere(config, reg)) {
         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;
+      let newrecord = {...reg};
+      onEventRegistrations.push((newrecord.index = onEventRegistrations.length, newrecord));
     });
+    let chainRegs = r.registrationsByChainId[key];
+    registrationsByChainId[key] = {
+      onEventRegistrations: onEventRegistrations,
+      onBlockRegistrations: chainRegs !== undefined ? chainRegs.onBlockRegistrations.slice() : []
+    };
   });
+  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 setEventOptions(contractName, eventName, eventOptions, loggerOpt) {
-  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  if (eventOptions === undefined) {
-    return;
-  }
-  let t = get(contractName, eventName);
-  let existingValue = t.eventOptions;
-  if (existingValue !== undefined) {
-    if (!eventOptionsMatch(existingValue, eventOptions)) {
-      return raiseDuplicateRegistration(contractName, eventName, "Cannot register handler with different options. Make sure all handlers for the same event use identical options (wildcard, where)", logger);
-    } else {
-      return;
-    }
+function isPendingRegistration() {
+  let r = EnvioGlobal.value.activeRegistration;
+  if (r !== undefined) {
+    return !r.finished;
   } else {
-    return set(contractName, eventName, {
-      handler: t.handler,
-      contractRegister: t.contractRegister,
-      eventOptions: eventOptions
-    });
+    return false;
   }
 }
 
-function setHandler(contractName, eventName, handler, eventOptions, loggerOpt) {
-  let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(registration => {
-    let t = get(contractName, eventName);
-    let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
-    let prevHandler = t.handler;
-    if (prevHandler !== undefined) {
-      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);
-      }
-    } 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
-      });
-    }
-    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 => {
-    let t = get(contractName, eventName);
-    let incomingEventOptions = Stdlib_Option.map(eventOptions, v => v);
-    let prevContractRegister = t.contractRegister;
-    if (prevContractRegister !== undefined) {
-      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);
-      }
-    } 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
-      });
-    }
-    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);
-  });
+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.`);
+  }
 }
 
 let blockRangeSchema = S$RescriptSchema.strict(S$RescriptSchema.object(s => ({
@@ -330,9 +372,9 @@ function registerOnBlock(name, where, handler, getChainsObject) {
       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,
+      let chainRegs = getChainRegistrations(registration, chainId);
+      chainRegs.onBlockRegistrations.push({
+        index: chainRegs.onBlockRegistrations.length,
         name: name,
         chainId: chainId,
         startBlock: range._gte,
@@ -347,99 +389,17 @@ function registerOnBlock(name, where, handler, getChainsObject) {
   });
 }
 
-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) {
-          return;
-        }
-        let newrecord = {...registration$1};
-        onEventRegistrations.push((newrecord.index = onEventRegistrations.length, newrecord));
-      });
-    });
-    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,
+  resetOnEventRegistrations,
   isPendingRegistration,
   finishRegistration,
   throwIfFinishedRegistration,
-  buildOnEventRegistration,
   setHandler,
   setContractRegister,
-  getHandler,
-  getContractRegister,
   isWildcard,
-  hasRegistration,
+  isDroppedByWhere,
+  getSimulateOnEventRegistrations,
   blockRangeSchema,
   defaultBlockRange,
   registerOnBlock,

package/src/HandlerRegister.resi

@@ -5,38 +5,30 @@ type chainRegistrations = {
 type registrationsByChainId = dict<chainRegistrations>
 
 let startRegistration: (~config: Config.t) => unit
+let resetOnEventRegistrations: unit => unit
 let isPendingRegistration: unit => bool
 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,
   Internal.genericHandler<Internal.genericHandlerArgs<'event, Internal.handlerContext>>,
   ~eventOptions: option<Internal.eventOptions<'where>>,
-  ~logger: Pino.t=?,
 ) => unit
 let setContractRegister: (
   ~contractName: string,
   ~eventName: string,
   Internal.genericContractRegister<Internal.genericContractRegisterArgs<'event, 'context>>,
   ~eventOptions: option<Internal.eventOptions<'where>>,
-  ~logger: Pino.t=?,
 ) => unit
-let getHandler: (~contractName: string, ~eventName: string) => option<Internal.handler>
-let getContractRegister: (
-  ~contractName: string,
-  ~eventName: string,
-) => option<Internal.contractRegister>
 let isWildcard: (~contractName: string, ~eventName: string) => bool
-let hasRegistration: (~contractName: string, ~eventName: string) => bool
+let isDroppedByWhere: (~config: Config.t, Internal.onEventRegistration) => bool
+let getSimulateOnEventRegistrations: (
+  ~config: Config.t,
+  ~chainId: int,
+  ~eventConfig: Internal.eventConfig,
+) => array<Internal.onEventRegistration>
 
 type blockRange = {
   _gte: option<int>,

package/src/IndexerState.res

@@ -115,6 +115,11 @@ type t = {
   exitAfterFirstEventBlock: bool,
   // The single fatal-error handler.
   onError: ErrorHandling.t => unit,
+  // Invoked once when the indexer catches up and would otherwise exit the
+  // process. `None` keeps the production behavior (exit the process); the
+  // in-process test runner injects a callback that resolves its run promise
+  // instead, so a caught-up run doesn't kill the test process.
+  onExit: option<unit => unit>,
   // Set once on any fatal error. Every loop checks it to stop iterating and
   // every launch skips when it's set, so a single failure quiesces the indexer.
   mutable isStopped: bool,
@@ -149,6 +154,7 @@ let make = (
   ~shouldUseTui=false,
   ~exitAfterFirstEventBlock=false,
   ~onError: ErrorHandling.t => unit,
+  ~onExit=?,
 ) => {
   let chainMetaThrottler = {
     let intervalMillis = Env.ThrottleWrites.chainMetadataIntervalMillis
@@ -194,6 +200,7 @@ let make = (
     keepProcessAlive: isDevelopmentMode || shouldUseTui,
     exitAfterFirstEventBlock,
     onError,
+    onExit,
     isStopped: false,
     epoch: 0,
     simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
@@ -229,6 +236,7 @@ let makeFromDbState = (
   ~reducedPollingInterval=?,
   ~targetBufferSize=CrossChainState.calculateTargetBufferSize(),
   ~onError,
+  ~onExit=?,
 ) => {
   let isInReorgThreshold = if initialState.cleanRun {
     false
@@ -280,6 +288,7 @@ let makeFromDbState = (
     ~shouldUseTui,
     ~exitAfterFirstEventBlock,
     ~onError,
+    ~onExit?,
   )
   initialState.cache->Utils.Dict.forEach(({effectName, count, scope}) => {
     state.effectState->EffectState.setUnregisteredCacheCount(~effectName, ~scope, ~count)
@@ -415,6 +424,7 @@ let indexerStartTime = (state: t) => state.indexerStartTime
 let loadManager = (state: t) => state.loadManager
 let keepProcessAlive = (state: t) => state.keepProcessAlive
 let exitAfterFirstEventBlock = (state: t) => state.exitAfterFirstEventBlock
+let onExit = (state: t) => state.onExit
 let isStopped = (state: t) => state.isStopped
 let epoch = (state: t) => state.epoch
 let lastPrunedAtMillis = (state: t) => state.lastPrunedAtMillis