envio 3.3.0-alpha.2 → 3.3.0-alpha.4

package/src/Prometheus.res

@@ -212,7 +212,7 @@ module PreloadHandler = {
 
   type operationRef = {
     mutable pendingCount: int,
-    timerRef: Hrtime.timeRef,
+    timerRef: Performance.timeRef,
   }
   let operations: dict<operationRef> = Dict.make()
 
@@ -227,11 +227,11 @@ module PreloadHandler = {
         key,
         {
           pendingCount: 1,
-          timerRef: Hrtime.makeTimer(),
+          timerRef: Performance.now(),
         },
       )
     }
-    Hrtime.makeTimer()
+    Performance.now()
   }
 
   let endOperation = (timerRef, ~contract, ~event) => {
@@ -242,13 +242,13 @@ module PreloadHandler = {
     if operationRef.pendingCount === 0 {
       timeCounter->SafeCounter.handleFloat(
         ~labels,
-        ~value=operationRef.timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+        ~value=operationRef.timerRef->Performance.secondsSince,
       )
       operations->Utils.Dict.deleteInPlace(key)
     }
     sumTimeCounter->SafeCounter.handleFloat(
       ~labels,
-      ~value=timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+      ~value=timerRef->Performance.secondsSince,
     )
     count->SafeCounter.increment(~labels)
   }
@@ -764,7 +764,7 @@ module StorageLoad = {
 
   type operationRef = {
     mutable pendingCount: int,
-    timerRef: Hrtime.timeRef,
+    timerRef: Performance.timeRef,
   }
   let operations = Dict.make()
 
@@ -780,12 +780,12 @@ module StorageLoad = {
         (
           {
             pendingCount: 1,
-            timerRef: Hrtime.makeTimer(),
+            timerRef: Performance.now(),
           }: operationRef
         ),
       )
     }
-    Hrtime.makeTimer()
+    Performance.now()
   }
 
   let endOperation = (timerRef, ~storage, ~operation, ~whereSize, ~size) => {
@@ -796,13 +796,13 @@ module StorageLoad = {
     if operationRef.pendingCount === 0 {
       timeCounter->SafeCounter.handleFloat(
         ~labels,
-        ~value=operationRef.timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+        ~value=operationRef.timerRef->Performance.secondsSince,
       )
       operations->Utils.Dict.deleteInPlace(key)
     }
     sumTimeCounter->SafeCounter.handleFloat(
       ~labels,
-      ~value=timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
+      ~value=timerRef->Performance.secondsSince,
     )
     counter->SafeCounter.increment(~labels)
     whereSizeCounter->SafeCounter.handleInt(~labels, ~value=whereSize)

package/src/Prometheus.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as PromClient from "./bindings/PromClient.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -290,10 +290,10 @@ function startOperation(contract, event) {
   } else {
     operations[key] = {
       pendingCount: 1,
-      timerRef: Hrtime.makeTimer()
+      timerRef: Performance.now()
     };
   }
-  return Hrtime.makeTimer();
+  return Performance.now();
 }
 
 function endOperation(timerRef, contract, event) {
@@ -305,10 +305,10 @@ function endOperation(timerRef, contract, event) {
   let operationRef = operations[key];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleFloat(timeCounter$1, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    handleFloat(timeCounter$1, labels, Performance.secondsSince(operationRef.timerRef));
     Utils.Dict.deleteInPlace(operations, key);
   }
-  handleFloat(sumTimeCounter, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  handleFloat(sumTimeCounter, labels, Performance.secondsSince(timerRef));
   increment(count$1, labels);
 }
 
@@ -775,10 +775,10 @@ function startOperation$1(storage, operation) {
   } else {
     operations$1[key] = {
       pendingCount: 1,
-      timerRef: Hrtime.makeTimer()
+      timerRef: Performance.now()
     };
   }
-  return Hrtime.makeTimer();
+  return Performance.now();
 }
 
 function endOperation$1(timerRef, storage, operation, whereSize, size) {
@@ -790,10 +790,10 @@ function endOperation$1(timerRef, storage, operation, whereSize, size) {
   let operationRef = operations$1[key];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleFloat(timeCounter$7, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    handleFloat(timeCounter$7, labels, Performance.secondsSince(operationRef.timerRef));
     Utils.Dict.deleteInPlace(operations$1, key);
   }
-  handleFloat(sumTimeCounter$3, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  handleFloat(sumTimeCounter$3, labels, Performance.secondsSince(timerRef));
   increment(counter$8, labels);
   handleInt(whereSizeCounter, labels, whereSize);
   handleInt(sizeCounter$1, labels, size);

package/src/PruneStaleHistory.res

@@ -14,7 +14,7 @@ let runPrune = async (state: IndexerState.t) => {
         await Utils.delay(1000)
       }
       let entityConfig = persistence.allEntities->Array.getUnsafe(idx)
-      let timeRef = Hrtime.makeTimer()
+      let timeRef = Performance.now()
       try {
         let () = await persistence.storage.pruneStaleEntityHistory(
           ~entityName=entityConfig.name,
@@ -34,7 +34,7 @@ let runPrune = async (state: IndexerState.t) => {
         )
       }
       Prometheus.RollbackHistoryPrune.increment(
-        ~timeSeconds=Hrtime.timeSince(timeRef)->Hrtime.toSecondsFloat,
+        ~timeSeconds=Performance.secondsSince(timeRef),
         ~entityName=entityConfig.name,
       )
     }

package/src/PruneStaleHistory.res.mjs

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -21,7 +21,7 @@ async function runPrune(state) {
       await Utils.delay(1000);
     }
     let entityConfig = persistence.allEntities[idx];
-    let timeRef = Hrtime.makeTimer();
+    let timeRef = Performance.now();
     try {
       await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
     } catch (raw_exn) {
@@ -31,7 +31,7 @@ async function runPrune(state) {
         safeCheckpointId: safeCheckpointId
       }), `Failed to prune stale entity history`, exn);
     }
-    Prometheus.RollbackHistoryPrune.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef)), entityConfig.name);
+    Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
   }
 }
 

package/src/Rollback.res

@@ -94,7 +94,7 @@ and executeRollback = async (
   ~scheduleFetch,
   ~scheduleProcessing,
 ) => {
-  let startTime = Hrtime.makeTimer()
+  let startTime = Performance.now()
 
   let chainState = state->IndexerState.getChainState(~chain=reorgChain)
 
@@ -194,7 +194,7 @@ and executeRollback = async (
     "targetCheckpointId": rollbackTargetCheckpointId,
   })
   Prometheus.RollbackSuccess.increment(
-    ~timeSeconds=Hrtime.timeSince(startTime)->Hrtime.toSecondsFloat,
+    ~timeSeconds=Performance.secondsSince(startTime),
     ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
   )
 

package/src/Rollback.res.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
@@ -32,7 +32,7 @@ async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime)
 }
 
 async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
-  let startTime = Hrtime.makeTimer();
+  let startTime = Performance.now();
   let chainState = IndexerState.getChainState(state, reorgChain);
   let logger = Logging.createChildFrom(ChainState.logger(chainState), {
     action: "Rollback",
@@ -70,7 +70,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     beforeCheckpointId: IndexerState.committedCheckpointId(state),
     targetCheckpointId: rollbackTargetCheckpointId
   });
-  Prometheus.RollbackSuccess.increment(Hrtime.toSecondsFloat(Hrtime.timeSince(startTime)), rollbackedProcessedEvents);
+  Prometheus.RollbackSuccess.increment(Performance.secondsSince(startTime), rollbackedProcessedEvents);
   IndexerState.completeRollback(state, eventsProcessedDiffByChain);
   scheduleFetch();
   return scheduleProcessing();

package/src/SimulateItems.res

@@ -195,6 +195,82 @@ let findEventConfig = (~config: Config.t, ~contractName: string, ~eventName: str
   found.contents
 }
 
+let dummySrcAddress = Address.unsafeFromString("0x0000000000000000000000000000000000000000")
+
+// First address configured for `contractName` on the simulated chain. Only the
+// simulated chain is consulted — a contract's address on another chain has no
+// meaning here.
+let firstContractAddress = (~chainConfig: Config.chain, ~contractName: string): option<
+  Address.t,
+> => {
+  let found = ref(None)
+  chainConfig.contracts->Array.forEach(contract => {
+    if found.contents->Option.isNone && contract.name === contractName {
+      found := contract.addresses->Array.get(0)
+    }
+  })
+  found.contents
+}
+
+let deriveSrcAddress = (
+  ~providedSrcAddress: option<Address.t>,
+  ~eventConfig: Internal.eventConfig,
+  ~chainConfig: Config.chain,
+): Address.t => {
+  switch providedSrcAddress {
+  | Some(addr) => addr
+  | None =>
+    if eventConfig.isWildcard {
+      dummySrcAddress
+    } else {
+      switch firstContractAddress(~chainConfig, ~contractName=eventConfig.contractName) {
+      | Some(addr) => addr
+      | None => dummySrcAddress
+      }
+    }
+  }
+}
+
+// A non-wildcard event is gated by `clientAddressFilter` on srcAddress ownership,
+// so a simulate item whose srcAddress isn't indexed on this chain would be
+// silently dropped (handler never runs). Fail loudly instead.
+//
+// `config` must already have handler registrations applied, otherwise an event
+// made wildcard purely through `indexer.onEvent({ wildcard: true })` reads back
+// as non-wildcard and gets wrongly rejected.
+let validateSrcAddresses = (
+  ~simulateItems: array<JSON.t>,
+  ~config: Config.t,
+  ~chainConfig: Config.chain,
+  ~indexingAddresses: array<Internal.indexingAddress>,
+): unit => {
+  let known = Utils.Set.make()
+  indexingAddresses->Array.forEach(ia => known->Utils.Set.add(ia.address->Address.toString)->ignore)
+  simulateItems->Array.forEach(rawJson => {
+    let raw = rawJson->(Utils.magic: JSON.t => rawSimulateItem)
+    switch (raw->getContract, raw->getEvent) {
+    | (Some(contractName), Some(eventName)) =>
+      switch findEventConfig(~config, ~contractName, ~eventName) {
+      | Some(eventConfig) if !eventConfig.isWildcard =>
+        let item = rawJson->(Utils.magic: JSON.t => Envio.evmSimulateItem)
+        let srcAddress = deriveSrcAddress(
+          ~providedSrcAddress=item.srcAddress,
+          ~eventConfig,
+          ~chainConfig,
+        )
+        if !(known->Utils.Set.has(srcAddress->Address.toString)) {
+          JsError.throwWithMessage(
+            `simulate: ${contractName}.${eventName} resolved to address ${srcAddress->Address.toString}, which isn't indexed on chain ${chainConfig.id->Int.toString}. ` ++
+            `Provide a "srcAddress" configured or registered for ${contractName} on this chain, or use a wildcard event.`,
+          )
+        }
+      | _ => ()
+      }
+    | _ => ()
+    }
+  })
+}
+
 let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Config.chain): array<
   Internal.item,
 > => {
@@ -238,21 +314,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
         li
       }
 
-      let srcAddress = switch item.srcAddress {
-      | Some(addr) => addr
-      | None =>
-        // Use first address from contract config
-        let addr = ref(Address.unsafeFromString("0x0000000000000000000000000000000000000000"))
-        chainConfig.contracts->Array.forEach(contract => {
-          if contract.name === contractName {
-            switch contract.addresses->Array.get(0) {
-            | Some(a) => addr := a
-            | None => ()
-            }
-          }
-        })
-        addr.contents
-      }
+      let srcAddress = deriveSrcAddress(
+        ~providedSrcAddress=item.srcAddress,
+        ~eventConfig,
+        ~chainConfig,
+      )
 
       let rawItem = rawJson->(Utils.magic: JSON.t => {..})
       let blockJson: option<JSON.t> =

package/src/SimulateItems.res.mjs

@@ -135,6 +135,64 @@ function findEventConfig(config, contractName, eventName) {
   return found.contents;
 }
 
+let dummySrcAddress = "0x0000000000000000000000000000000000000000";
+
+function firstContractAddress(chainConfig, contractName) {
+  let found = {
+    contents: undefined
+  };
+  chainConfig.contracts.forEach(contract => {
+    if (Stdlib_Option.isNone(found.contents) && contract.name === contractName) {
+      found.contents = contract.addresses[0];
+      return;
+    }
+  });
+  return found.contents;
+}
+
+function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig) {
+  if (providedSrcAddress !== undefined) {
+    return Primitive_option.valFromOption(providedSrcAddress);
+  }
+  if (eventConfig.isWildcard) {
+    return dummySrcAddress;
+  }
+  let addr = firstContractAddress(chainConfig, eventConfig.contractName);
+  if (addr !== undefined) {
+    return Primitive_option.valFromOption(addr);
+  } else {
+    return dummySrcAddress;
+  }
+}
+
+function validateSrcAddresses(simulateItems, config, chainConfig, indexingAddresses) {
+  let known = new Set();
+  indexingAddresses.forEach(ia => {
+    known.add(ia.address);
+  });
+  simulateItems.forEach(rawJson => {
+    let match = rawJson.contract;
+    let match$1 = rawJson.event;
+    if (match === undefined) {
+      return;
+    }
+    if (match$1 === undefined) {
+      return;
+    }
+    let eventConfig = findEventConfig(config, match, match$1);
+    if (eventConfig === undefined) {
+      return;
+    }
+    if (eventConfig.isWildcard) {
+      return;
+    }
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig);
+    if (!known.has(srcAddress)) {
+      return Stdlib_JsError.throwWithMessage(`simulate: ` + match + `.` + match$1 + ` resolved to address ` + srcAddress + `, which isn't indexed on chain ` + chainConfig.id.toString() + `. ` + (`Provide a "srcAddress" configured or registered for ` + match + ` on this chain, or use a wildcard event.`));
+    }
+  });
+}
+
 function parse(simulateItems, config, chainConfig) {
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
@@ -169,26 +227,7 @@ function parse(simulateItems, config, chainConfig) {
       currentLogIndex.contents = li$1 + 1 | 0;
       logIndex = li$1;
     }
-    let addr = rawJson.srcAddress;
-    let srcAddress;
-    if (addr !== undefined) {
-      srcAddress = Primitive_option.valFromOption(addr);
-    } else {
-      let addr$1 = {
-        contents: "0x0000000000000000000000000000000000000000"
-      };
-      chainConfig.contracts.forEach(contract => {
-        if (contract.name !== match) {
-          return;
-        }
-        let a = contract.addresses[0];
-        if (a !== undefined) {
-          addr$1.contents = Primitive_option.valFromOption(a);
-          return;
-        }
-      });
-      srcAddress = addr$1.contents;
-    }
+    let srcAddress = deriveSrcAddress(rawJson.srcAddress, eventConfig, chainConfig);
     let blockJson = rawJson.block;
     let blockJson$1 = (blockJson == null) ? undefined : Primitive_option.some(blockJson);
     let transactionJson = rawJson.transaction;
@@ -318,6 +357,10 @@ export {
   fuelSimulateTransactionSchema,
   parseFuelSimulateTransaction,
   findEventConfig,
+  dummySrcAddress,
+  firstContractAddress,
+  deriveSrcAddress,
+  validateSrcAddresses,
   parse,
   patchConfig,
 }

package/src/TestIndexer.res

@@ -43,6 +43,33 @@ let toIndexingAddress = (dc: InternalTable.EnvioAddresses.t): Internal.indexingA
   registrationBlock: dc.registrationBlock,
 }
 
+// All indexing addresses (config-seeded + dynamically registered) grouped by
+// chain id string, derived from the envio_addresses entities.
+let getIndexingAddressesByChain = (state: testIndexerState): dict<
+  array<Internal.indexingAddress>,
+> => {
+  let byChain = Dict.make()
+  switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
+  | Some(dcDict) =>
+    dcDict
+    ->Dict.valuesToArray
+    ->Array.forEach(entity => {
+      let dc = entity->castToEnvioAddresses
+      let chainIdStr = dc.chainId->Int.toString
+      let contracts = switch byChain->Dict.get(chainIdStr) {
+      | Some(arr) => arr
+      | None =>
+        let arr = []
+        byChain->Dict.set(chainIdStr, arr)
+        arr
+      }
+      contracts->Array.push(dc->toIndexingAddress)->ignore
+    })
+  | None => ()
+  }
+  byChain
+}
+
 let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFilter.t): JSON.t => {
   // Loads for non-entity tables (e.g. effect caches `envio_effect_<name>`) reach
   // here too. TestIndexer never persists those, so there's nothing to return —
@@ -566,22 +593,10 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
                   `Cannot access ${contract.name}.addresses while indexer.process() is running. ` ++ "Wait for process() to complete before reading contract addresses.",
                 )
               }
-              let addresses = []
-              switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-              | Some(dcDict) =>
-                dcDict
-                ->Dict.valuesToArray
-                ->Array.forEach(
-                  entity => {
-                    let dc = entity->castToEnvioAddresses
-                    if dc.contractName === contract.name && dc.chainId === chainConfig.id {
-                      addresses->Array.push(dc->Config.EnvioAddresses.getAddress)->ignore
-                    }
-                  },
-                )
-              | None => ()
-              }
-              addresses
+              getIndexingAddressesByChain(state)
+              ->Dict.get(chainConfig.id->Int.toString)
+              ->Option.getOr([])
+              ->Array.filterMap(ia => ia.contractName === contract.name ? Some(ia.address) : None)
             },
           },
         )
@@ -652,7 +667,11 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             Int.compare(aId, bId)
           })
 
-          // Parse and validate all chain configs upfront before starting any workers
+          // Parse and validate the block ranges upfront before starting any
+          // workers. srcAddress validation can't run here: it depends on which
+          // events are wildcard, and `config` reflects config.yaml only —
+          // handler-level `wildcard: true` takes effect only once registrations
+          // are applied.
           let chainEntries = sortedChainKeys->Array.map(chainIdStr => {
             let rawChainConfig = rawChains->Dict.getUnsafe(chainIdStr)
             let chainId = switch chainIdStr->Int.fromString {
@@ -684,26 +703,9 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             let chains: dict<chainConfig> = Dict.make()
             chains->Dict.set(chainIdStr, processChainConfig)
 
-            // Extract dynamic contracts from state.entities for each chain
-            let indexingAddressesByChain: dict<array<Internal.indexingAddress>> = Dict.make()
-            switch state.entities->Dict.get(InternalTable.EnvioAddresses.name) {
-            | Some(dcDict) =>
-              dcDict
-              ->Dict.valuesToArray
-              ->Array.forEach(entity => {
-                let dc = entity->castToEnvioAddresses
-                let dcChainIdStr = dc.chainId->Int.toString
-                let contracts = switch indexingAddressesByChain->Dict.get(dcChainIdStr) {
-                | Some(arr) => arr
-                | None =>
-                  let arr = []
-                  indexingAddressesByChain->Dict.set(dcChainIdStr, arr)
-                  arr
-                }
-                contracts->Array.push(dc->toIndexingAddress)->ignore
-              })
-            | None => ()
-            }
+            // Rebuilt per chain so workers see contracts registered by earlier
+            // chains in the same process() call.
+            let indexingAddressesByChain = getIndexingAddressesByChain(state)
 
             let initialState = makeInitialState(
               ~config,
@@ -865,7 +867,27 @@ let initTestWorker = () => {
     | Some(_) => ()
     }
 
-    let patchConfig = (config, _registrations) => {
+    let patchConfig = (config: Config.t, _registrations) => {
+      // `config` here has handler registrations applied, so `isWildcard`
+      // reflects `indexer.onEvent({ wildcard: true })` — which the main thread
+      // can't see. Validate srcAddresses against it before patching in the
+      // simulate source.
+      switch simulate {
+      | Some(simulateItems) =>
+        let chainConfig = config.chainMap->ChainMap.get(ChainMap.Chain.makeUnsafe(~chainId))
+        let indexingAddresses =
+          initialState.chains
+          ->Array.find(c => c.id == chainId)
+          ->Option.mapOr([], c => c.indexingAddresses)
+        SimulateItems.validateSrcAddresses(
+          ~simulateItems,
+          ~config,
+          ~chainConfig,
+          ~indexingAddresses,
+        )
+      | None => ()
+      }
+
       let config = SimulateItems.patchConfig(~config, ~processConfig)
 
       // In auto-exit mode, set batchSize=1 to process one block checkpoint at a time
@@ -875,7 +897,23 @@ let initTestWorker = () => {
         config
       }
     }
-    Main.start(~persistence, ~isTest=true, ~patchConfig, ~exitAfterFirstEventBlock)->ignore
+    Main.start(~persistence, ~isTest=true, ~patchConfig, ~exitAfterFirstEventBlock)
+    ->Promise.catch(exn => {
+      // `Main.start` rejects on any fatal error: a runtime failure arrives wrapped
+      // in `Main.FatalError` (already logged), a setup throw (e.g. patchConfig's
+      // srcAddress validation) arrives raw. The parent only learns of failures
+      // through the worker `error` event, which fires on an *uncaught* exception.
+      // Throwing synchronously in this catch would just reject the catch's own
+      // promise (swallowed by `ignore`); `setImmediate` re-throws outside the
+      // promise chain so it becomes uncaught and reaches the parent.
+      let toThrow = switch exn {
+      | Main.FatalError(inner) => inner
+      | _ => exn->Utils.prettifyExn
+      }
+      NodeJs.setImmediate(() => throw(toThrow))
+      Promise.resolve()
+    })
+    ->ignore
   | None =>
     Logging.error("TestIndexerWorker: No worker data provided")
     NodeJs.process->NodeJs.exitWithCode(Failure)