envio 3.3.0-alpha.5 → 3.3.0-alpha.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.3.0-alpha.5",
+  "version": "3.3.0-alpha.6",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -69,10 +69,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.3.0-alpha.5",
-    "envio-linux-x64-musl": "3.3.0-alpha.5",
-    "envio-linux-arm64": "3.3.0-alpha.5",
-    "envio-darwin-x64": "3.3.0-alpha.5",
-    "envio-darwin-arm64": "3.3.0-alpha.5"
+    "envio-linux-x64": "3.3.0-alpha.6",
+    "envio-linux-x64-musl": "3.3.0-alpha.6",
+    "envio-linux-arm64": "3.3.0-alpha.6",
+    "envio-darwin-x64": "3.3.0-alpha.6",
+    "envio-darwin-arm64": "3.3.0-alpha.6"
   }
 }

package/src/BatchProcessing.res

@@ -127,6 +127,11 @@ and processNextBatch = async (state: IndexerState.t, ~scheduleFetch): unit => {
     | Ok() =>
       state->IndexerState.recordProcessedBatch
 
+      switch state->IndexerState.simulateDeadInputTracker {
+      | Some(tracker) => tracker->SimulateDeadInputTracker.recordProcessed(~batch)
+      | None => ()
+      }
+
       if state->IndexerState.isResolvingReorg {
         // A reorg landed while this batch was processing. Apply its progress so
         // the rollback diff is computed against up-to-date chain progress, but

package/src/BatchProcessing.res.mjs

@@ -10,8 +10,10 @@ import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as ExitOnCaughtUp from "./ExitOnCaughtUp.res.mjs";
 import * as EventProcessing from "./EventProcessing.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as PruneStaleHistory from "./PruneStaleHistory.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
 function yieldTick() {
   return new Promise((resolve, param) => {
@@ -55,6 +57,10 @@ async function processNextBatch(state, scheduleFetch) {
     return IndexerState.errorExit(state, errHandler._0);
   }
   IndexerState.recordProcessedBatch(state);
+  let tracker = IndexerState.simulateDeadInputTracker(state);
+  if (tracker !== undefined) {
+    SimulateDeadInputTracker.recordProcessed(Primitive_option.valFromOption(tracker), batch);
+  }
   if (IndexerState.isResolvingReorg(state)) {
     return IndexerState.applyBatchProgress(state, batch);
   }

package/src/ExitOnCaughtUp.res

@@ -4,7 +4,15 @@ let run = async (state: IndexerState.t) => {
   ChainMetadata.stage(state)
   await state->Writing.flush
   if !(state->IndexerState.isStopped) && !(state->IndexerState.isResolvingReorg) {
-    Logging.info("Exiting with success")
-    NodeJs.process->NodeJs.exitWithCode(Success)
+    // A simulate run fails here when a provided item never reached a handler —
+    // dead test code. The tracker is None (a no-op) off the simulate path.
+    switch state
+    ->IndexerState.simulateDeadInputTracker
+    ->Option.flatMap(SimulateDeadInputTracker.failureMessage) {
+    | None =>
+      Logging.info("Exiting with success")
+      NodeJs.process->NodeJs.exitWithCode(Success)
+    | Some(message) => state->IndexerState.errorExit(ErrorHandling.make(Utils.Error.make(message)))
+    }
   }
 }

package/src/ExitOnCaughtUp.res.mjs

@@ -5,11 +5,20 @@ import * as Writing from "./Writing.res.mjs";
 import * as Process from "process";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ChainMetadata from "./ChainMetadata.res.mjs";
+import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
 async function run(state) {
   ChainMetadata.stage(state);
   await Writing.flush(state);
-  if (!IndexerState.isStopped(state) && !IndexerState.isResolvingReorg(state)) {
+  if (IndexerState.isStopped(state) || IndexerState.isResolvingReorg(state)) {
+    return;
+  }
+  let message = Stdlib_Option.flatMap(IndexerState.simulateDeadInputTracker(state), SimulateDeadInputTracker.failureMessage);
+  if (message !== undefined) {
+    return IndexerState.errorExit(state, ErrorHandling.make(new Error(message), undefined, undefined));
+  } else {
     Logging.info("Exiting with success");
     Process.exit(0);
     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 = (
@@ -169,6 +171,7 @@ let make = (
     onError,
     isStopped: false,
     epoch: 0,
+    simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
   }
 }
 
@@ -400,6 +403,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. ---
 

package/src/IndexerState.res.mjs

@@ -18,6 +18,7 @@ import * as CrossChainState from "./CrossChainState.res.mjs";
 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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as SimulateDeadInputTracker from "./SimulateDeadInputTracker.res.mjs";
 
 function make() {
   let intervalMillis = Env.ThrottleWrites.pruneStaleDataIntervalMillis;
@@ -91,7 +92,8 @@ function make$2(config, persistence, chainStates, isInReorgThreshold, isRealtime
     exitAfterFirstEventBlock: exitAfterFirstEventBlock,
     onError: onError,
     isStopped: false,
-    epoch: 0
+    epoch: 0,
+    simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config)
   };
 }
 
@@ -348,6 +350,10 @@ function pruneStaleEntityHistoryThrottler(state) {
   return state.writeThrottlers.pruneStaleEntityHistory;
 }
 
+function simulateDeadInputTracker(state) {
+  return state.simulateDeadInputTracker;
+}
+
 function queueProcessedBatch(state, batch) {
   state.processedBatches.push(batch);
   let checkpointId = Utils.$$Array.last(batch.checkpointIds);
@@ -527,6 +533,7 @@ export {
   isStopped,
   epoch,
   pruneStaleEntityHistoryThrottler,
+  simulateDeadInputTracker,
   queueProcessedBatch,
   drainBatchRun,
   takeRollback,

package/src/IndexerState.resi

@@ -107,6 +107,7 @@ let exitAfterFirstEventBlock: t => bool
 let isStopped: t => bool
 let epoch: t => int
 let pruneStaleEntityHistoryThrottler: t => Throttler.t
+let simulateDeadInputTracker: t => option<SimulateDeadInputTracker.t>
 
 // Store domain operations.
 let queueProcessedBatch: (t, ~batch: Batch.t) => unit

package/src/SimulateDeadInputTracker.res

@@ -0,0 +1,85 @@
+// Lives on IndexerState and is fed each processed batch, so ChainState and the
+// fetch loop carry no simulate-specific state.
+
+// Match a provided item to a processed one by its (chain, block, logIndex)
+// coordinate rather than object identity, so matching survives any copy or
+// transform of the item between the source and the batch.
+let itemKey = (item: Internal.item): string =>
+  switch item {
+  | Internal.Event({chain, blockNumber, logIndex}) =>
+    `${chain
+      ->ChainMap.Chain.toChainId
+      ->Int.toString}:${blockNumber->Int.toString}:${logIndex->Int.toString}`
+  | _ => "" // non-event items are never a provided simulate input
+  }
+
+// `index` is the item's position in its chain's `simulate` array, reported back
+// so a user finds it without echoing its fields.
+type entry = {chainId: int, index: int, key: string}
+
+type t = {mutable unprocessed: array<entry>}
+
+let makeFromConfig = (config: Config.t): option<t> => {
+  let entries =
+    config.chainMap
+    ->ChainMap.values
+    ->Array.flatMap(chainConfig =>
+      switch chainConfig.sourceConfig {
+      | Config.CustomSources(sources) =>
+        sources->Array.flatMap(source =>
+          source.simulateItems
+          ->Option.getOr([])
+          ->Array.mapWithIndex(
+            (item, index) => {
+              chainId: chainConfig.id,
+              index,
+              key: itemKey(item),
+            },
+          )
+        )
+      | _ => []
+      }
+    )
+  switch entries {
+  | [] => None
+  | _ => Some({unprocessed: entries})
+  }
+}
+
+let recordProcessed = (t: t, ~batch: Batch.t) => {
+  let processedKeys = batch.items->Array.map(itemKey)->Utils.Set.fromArray
+  t.unprocessed = t.unprocessed->Array.filter(entry => !(processedKeys->Utils.Set.has(entry.key)))
+}
+
+// Unrouted item indices grouped by chain, in the order chains were first seen.
+let unroutedByChain = (t: t): array<(int, array<int>)> => {
+  let indicesByChain = Dict.make()
+  let chainOrder = []
+  t.unprocessed->Array.forEach(entry => {
+    let key = entry.chainId->Int.toString
+    if indicesByChain->Dict.get(key)->Option.isNone {
+      chainOrder->Array.push(entry.chainId)->ignore
+    }
+    indicesByChain->Utils.Dict.push(key, entry.index)
+  })
+  chainOrder->Array.map(chainId => (chainId, indicesByChain->Dict.getUnsafe(chainId->Int.toString)))
+}
+
+let failureMessage = (t: t): option<string> =>
+  switch t->unroutedByChain {
+  | [] => None
+  | byChain =>
+    let count = byChain->Array.reduce(0, (acc, (_chainId, indices)) => acc + indices->Array.length)
+    let itemWord = count === 1 ? "item" : "items"
+    let lines =
+      byChain
+      ->Array.map(((chainId, indices)) =>
+        `  - chain ${chainId->Int.toString}: ${indices
+          ->Array.map(index => index->Int.toString)
+          ->Array.join(", ")}`
+      )
+      ->Array.join("\n")
+    Some(
+      `simulate: ${count->Int.toString} ${itemWord} you passed to simulate never reached a handler, so nothing ran for them. Each was filtered out before the handler — usually a non-wildcard srcAddress that isn't indexed for the contract, or a where/block filter that excluded the event. Unrouted items, by index in each chain's simulate array:\n${lines}`,
+    )
+  }

package/src/SimulateDeadInputTracker.res.mjs

@@ -0,0 +1,73 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function itemKey(item) {
+  if (item.kind === 0) {
+    return item.chain.toString() + `:` + item.blockNumber.toString() + `:` + item.logIndex.toString();
+  } else {
+    return "";
+  }
+}
+
+function makeFromConfig(config) {
+  let entries = ChainMap.values(config.chainMap).flatMap(chainConfig => {
+    let sources = chainConfig.sourceConfig;
+    if (sources.TAG === "CustomSources") {
+      return sources._0.flatMap(source => Stdlib_Option.getOr(source.simulateItems, []).map((item, index) => ({
+        chainId: chainConfig.id,
+        index: index,
+        key: itemKey(item)
+      })));
+    } else {
+      return [];
+    }
+  });
+  if (entries.length !== 0) {
+    return {
+      unprocessed: entries
+    };
+  }
+}
+
+function recordProcessed(t, batch) {
+  let processedKeys = new Set(batch.items.map(itemKey));
+  t.unprocessed = t.unprocessed.filter(entry => !processedKeys.has(entry.key));
+}
+
+function unroutedByChain(t) {
+  let indicesByChain = {};
+  let chainOrder = [];
+  t.unprocessed.forEach(entry => {
+    let key = entry.chainId.toString();
+    if (Stdlib_Option.isNone(indicesByChain[key])) {
+      chainOrder.push(entry.chainId);
+    }
+    Utils.Dict.push(indicesByChain, key, entry.index);
+  });
+  return chainOrder.map(chainId => [
+    chainId,
+    indicesByChain[chainId.toString()]
+  ]);
+}
+
+function failureMessage(t) {
+  let byChain = unroutedByChain(t);
+  if (byChain.length === 0) {
+    return;
+  }
+  let count = Stdlib_Array.reduce(byChain, 0, (acc, param) => acc + param[1].length | 0);
+  let itemWord = count === 1 ? "item" : "items";
+  let lines = byChain.map(param => `  - chain ` + param[0].toString() + `: ` + param[1].map(index => index.toString()).join(", ")).join("\n");
+  return `simulate: ` + count.toString() + ` ` + itemWord + ` you passed to simulate never reached a handler, so nothing ran for them. Each was filtered out before the handler — usually a non-wildcard srcAddress that isn't indexed for the contract, or a where/block filter that excluded the event. Unrouted items, by index in each chain's simulate array:\n` + lines;
+}
+
+export {
+  makeFromConfig,
+  recordProcessed,
+  failureMessage,
+}
+/* Utils Not a pure module */

package/src/SimulateDeadInputTracker.resi

@@ -0,0 +1,12 @@
+type t
+
+// Builds a tracker from the run's config, seeded with every item each simulate
+// source provided. None when no chain has a simulate source.
+let makeFromConfig: Config.t => option<t>
+
+// Drop the batch's items from the not-yet-routed set, matched by event coordinate.
+let recordProcessed: (t, ~batch: Batch.t) => unit
+
+// The error to fail the run with when items never reached a handler, listing them
+// by chain and index within that chain's `simulate` array. None when all routed.
+let failureMessage: t => option<string>

package/src/SimulateItems.res

@@ -231,46 +231,6 @@ let deriveSrcAddress = (
   }
 }
 
-// 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,
 > => {
@@ -281,8 +241,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
   let currentLogIndex = ref(0)
 
   let items = []
+  // Coordinate "block:logIndex" -> the index of the first item that claimed it,
+  // used to reject two items resolving to the same (block, logIndex).
+  let seenCoordinates = Dict.make()
 
-  simulateItems->Array.forEach(rawJson => {
+  simulateItems->Array.forEachWithIndex((rawJson, itemIndex) => {
     let raw = rawJson->(Utils.magic: JSON.t => rawSimulateItem)
 
     switch (raw->getContract, raw->getEvent) {
@@ -306,8 +269,14 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
       }
       let params = paramsJson->S.convertOrThrow(eventConfig.simulateParamsSchema)
 
+      // An explicit logIndex advances the auto-increment counter past itself, so a
+      // later item that omits logIndex picks up after it instead of colliding.
       let logIndex = switch item.logIndex {
-      | Some(li) => li
+      | Some(li) =>
+        if li >= currentLogIndex.contents {
+          currentLogIndex := li + 1
+        }
+        li
       | None =>
         let li = currentLogIndex.contents
         currentLogIndex := li + 1
@@ -345,6 +314,18 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
       // Update currentBlock for subsequent items
       currentBlock := blockNumber
 
+      // A simulate item must land on a distinct (block, logIndex): event ordering
+      // and the dead-input tracker both key on it. Catch explicit duplicates and
+      // explicit-vs-auto-increment collisions here, naming both offending indices.
+      let coordinate = `${blockNumber->Int.toString}:${logIndex->Int.toString}`
+      switch seenCoordinates->Dict.get(coordinate) {
+      | Some(firstIndex) =>
+        JsError.throwWithMessage(
+          `simulate: items at index ${firstIndex->Int.toString} and ${itemIndex->Int.toString} on chain ${chainId->Int.toString} both resolve to block ${blockNumber->Int.toString}, logIndex ${logIndex->Int.toString}. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`,
+        )
+      | None => seenCoordinates->Dict.set(coordinate, itemIndex)
+      }
+
       items
       ->Array.push(
         Internal.Event({

package/src/SimulateItems.res.mjs

@@ -165,34 +165,6 @@ function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig) {
   }
 }
 
-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;
@@ -204,7 +176,8 @@ function parse(simulateItems, config, chainConfig) {
     contents: 0
   };
   let items = [];
-  simulateItems.forEach(rawJson => {
+  let seenCoordinates = {};
+  simulateItems.forEach((rawJson, itemIndex) => {
     let match = rawJson.contract;
     let match$1 = rawJson.event;
     if (match === undefined) {
@@ -221,6 +194,9 @@ function parse(simulateItems, config, chainConfig) {
     let li = rawJson.logIndex;
     let logIndex;
     if (li !== undefined) {
+      if (li >= currentLogIndex.contents) {
+        currentLogIndex.contents = li + 1 | 0;
+      }
       logIndex = li;
     } else {
       let li$1 = currentLogIndex.contents;
@@ -272,6 +248,13 @@ function parse(simulateItems, config, chainConfig) {
         break;
     }
     currentBlock.contents = blockNumber;
+    let coordinate = blockNumber.toString() + `:` + logIndex.toString();
+    let firstIndex = seenCoordinates[coordinate];
+    if (firstIndex !== undefined) {
+      Stdlib_JsError.throwWithMessage(`simulate: items at index ` + firstIndex.toString() + ` and ` + itemIndex.toString() + ` on chain ` + chainId.toString() + ` both resolve to block ` + blockNumber.toString() + `, logIndex ` + logIndex.toString() + `. Give each item a distinct logIndex (or omit logIndex so they auto-increment).`);
+    } else {
+      seenCoordinates[coordinate] = itemIndex;
+    }
     items.push({
       kind: 0,
       eventConfig: eventConfig,
@@ -360,7 +343,6 @@ export {
   dummySrcAddress,
   firstContractAddress,
   deriveSrcAddress,
-  validateSrcAddresses,
   parse,
   patchConfig,
 }

package/src/TestIndexer.res

@@ -667,11 +667,7 @@ let makeCreateTestIndexer = (~config: Config.t, ~workerPath: string): (
             Int.compare(aId, bId)
           })
 
-          // 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.
+          // Parse and validate the block ranges upfront before starting any workers.
           let chainEntries = sortedChainKeys->Array.map(chainIdStr => {
             let rawChainConfig = rawChains->Dict.getUnsafe(chainIdStr)
             let chainId = switch chainIdStr->Int.fromString {
@@ -868,26 +864,6 @@ let initTestWorker = () => {
     }
 
     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
@@ -900,8 +876,8 @@ let initTestWorker = () => {
     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
+      // in `Main.FatalError` (already logged), a setup throw (e.g. an invalid
+      // simulate item) 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

package/src/TestIndexer.res.mjs

@@ -586,11 +586,9 @@ function initTestWorker() {
     Process.exit(1);
     return;
   }
-  let initialState = workerData.initialState;
   let simulate = workerData.simulate;
   let endBlock = workerData.endBlock;
-  let chainId = workerData.chainId;
-  let chainIdStr = chainId.toString();
+  let chainIdStr = workerData.chainId.toString();
   let exitAfterFirstEventBlock = Stdlib_Option.isNone(endBlock);
   let resolvedChainDict = {};
   resolvedChainDict["startBlock"] = workerData.startBlock;
@@ -605,7 +603,7 @@ function initTestWorker() {
   let processConfig = {
     chains: resolvedChainsDict
   };
-  let proxy = TestIndexerProxyStorage.make(parentPort, initialState);
+  let proxy = TestIndexerProxyStorage.make(parentPort, workerData.initialState);
   let storage = TestIndexerProxyStorage.makeStorage(proxy);
   let config = Config.loadWithoutRegistrations();
   let persistence = Persistence.make(config.userEntities, config.allEnums, storage);
@@ -615,11 +613,6 @@ function initTestWorker() {
     Logging.setLogLevel("silent");
   }
   let patchConfig = (config, _registrations) => {
-    if (simulate !== undefined) {
-      let chainConfig = ChainMap.get(config.chainMap, ChainMap.Chain.makeUnsafe(chainId));
-      let indexingAddresses = Stdlib_Option.mapOr(initialState.chains.find(c => c.id === chainId), [], c => c.indexingAddresses);
-      SimulateItems.validateSrcAddresses(simulate, config, chainConfig, indexingAddresses);
-    }
     let config$1 = SimulateItems.patchConfig(config, processConfig);
     if (exitAfterFirstEventBlock) {
       return {

package/src/sources/EvmChain.res

@@ -32,7 +32,7 @@ let getSyncConfig = (
     intervalCeiling: Env.Configurable.SyncConfig.intervalCeiling->Option.getOr(
       intervalCeiling->Option.getOr(10_000),
     ),
-    backoffMillis: backoffMillis->Option.getOr(5000),
+    backoffMillis: backoffMillis->Option.getOr(2000),
     queryTimeoutMillis,
     fallbackStallTimeout: fallbackStallTimeout->Option.getOr(queryTimeoutMillis / 2),
     pollingInterval: pollingInterval->Option.getOr(1000),

package/src/sources/EvmChain.res.mjs

@@ -13,7 +13,7 @@ function getSyncConfig(param) {
     backoffMultiplicative: Stdlib_Option.getOr(Env.Configurable.SyncConfig.backoffMultiplicative, Stdlib_Option.getOr(param.backoffMultiplicative, 0.8)),
     accelerationAdditive: Stdlib_Option.getOr(Env.Configurable.SyncConfig.accelerationAdditive, Stdlib_Option.getOr(param.accelerationAdditive, 500)),
     intervalCeiling: Stdlib_Option.getOr(Env.Configurable.SyncConfig.intervalCeiling, Stdlib_Option.getOr(param.intervalCeiling, 10000)),
-    backoffMillis: Stdlib_Option.getOr(param.backoffMillis, 5000),
+    backoffMillis: Stdlib_Option.getOr(param.backoffMillis, 2000),
     queryTimeoutMillis: queryTimeoutMillis,
     fallbackStallTimeout: Stdlib_Option.getOr(param.fallbackStallTimeout, queryTimeoutMillis / 2 | 0),
     pollingInterval: Stdlib_Option.getOr(param.pollingInterval, 1000)