envio 3.3.0-alpha.1 → 3.3.0-alpha.10

package/src/RawEvent.res.mjs

@@ -18,10 +18,10 @@ function convertFieldsToJson(fields) {
   }
 }
 
-function make(eventItem, block, transaction, params, srcAddress, cleanUpRawEventFieldsInPlace) {
+function make(eventItem, block, transaction, params, srcAddress, blockHash, blockTimestamp, cleanUpRawEventFieldsInPlace) {
   let logIndex = eventItem.logIndex;
   let blockNumber = eventItem.blockNumber;
-  let eventConfig = eventItem.eventConfig;
+  let eventConfig = eventItem.onEventRegistration.eventConfig;
   let eventId = EventUtils.packEventIndex(blockNumber, logIndex);
   let blockFields = convertFieldsToJson(block);
   let transactionFields = convertFieldsToJson(transaction);
@@ -36,8 +36,8 @@ function make(eventItem, block, transaction, params, srcAddress, cleanUpRawEvent
     block_number: blockNumber,
     log_index: logIndex,
     src_address: srcAddress,
-    block_hash: eventItem.blockHash,
-    block_timestamp: eventItem.timestamp,
+    block_hash: blockHash,
+    block_timestamp: blockTimestamp,
     block_fields: blockFields,
     transaction_fields: transactionFields,
     params: params$2

package/src/Rollback.res

@@ -18,7 +18,7 @@ let getLastKnownValidBlock = async (
     ->ChainState.reorgDetection
     ->ReorgDetection.getThresholdBlockNumbersBelowBlock(
       ~blockNumber=reorgBlockNumber,
-      ~knownHeight=(chainState->ChainState.fetchState).knownHeight,
+      ~knownHeight=chainState->ChainState.knownHeight,
     )
 
   switch scannedBlockNumbers {
@@ -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";
@@ -18,7 +18,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime) {
-  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.fetchState(chainState).knownHeight);
+  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.knownHeight(chainState));
   if (scannedBlockNumbers.length === 0) {
     return ChainState.getHighestBlockBelowThreshold(chainState);
   }
@@ -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/RollbackCommit.res

@@ -6,7 +6,10 @@
 type args = {chainId: int, rollbackToBlock: int}
 type callback = args => promise<unit>
 
-let callbacks: array<callback> = []
+// Lives in the process-wide `EnvioGlobal` record so callbacks registered
+// through a duplicate envio module instance still fire.
+let callbacks =
+  EnvioGlobal.value.rollbackCommitCallbacks->(Utils.magic: array<unknown> => array<callback>)
 
 let register = (callback: callback) => {
   callbacks->Array.push(callback)

package/src/RollbackCommit.res.mjs

@@ -1,8 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 
-let callbacks = [];
+let callbacks = EnvioGlobal.value.rollbackCommitCallbacks;
 
 function register(callback) {
   callbacks.push(callback);
@@ -32,4 +33,4 @@ export {
   register,
   fire,
 }
-/* No side effect */
+/* EnvioGlobal Not a pure module */

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

@@ -195,6 +195,51 @@ 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,
+  ~config: Config.t,
+): Address.t => {
+  switch providedSrcAddress {
+  // Canonicalize to the configured casing; the fallback addresses below already
+  // come from the parsed config and need no normalization. Relaxed (not
+  // Config.normalizeUserAddress) so test placeholders like "0xfoo" are allowed.
+  | Some(addr) => config->Config.normalizeSimulateAddress(addr)
+  | None =>
+    if (
+      HandlerRegister.isWildcard(
+        ~contractName=eventConfig.contractName,
+        ~eventName=eventConfig.name,
+      )
+    ) {
+      dummySrcAddress
+    } else {
+      switch firstContractAddress(~chainConfig, ~contractName=eventConfig.contractName) {
+      | Some(addr) => addr
+      | None => dummySrcAddress
+      }
+    }
+  }
+}
+
 let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Config.chain): array<
   Internal.item,
 > => {
@@ -205,8 +250,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) {
@@ -230,44 +278,41 @@ 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
         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,
+        ~config,
+      )
 
       let rawItem = rawJson->(Utils.magic: JSON.t => {..})
       let blockJson: option<JSON.t> =
         rawItem["block"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
       let transactionJson: option<JSON.t> =
         rawItem["transaction"]->(Utils.magic: 'a => Nullable.t<JSON.t>)->Nullable.toOption
-      let (block, blockNumber, timestamp, blockHash) = switch config.ecosystem.name {
+      let (block, blockNumber) = switch config.ecosystem.name {
       | Fuel =>
         let block = parseFuelSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => fuelSimulateBlock)
-        (block, blockFields.height, blockFields.time, blockFields.id)
+        (block, blockFields.height)
       | Evm =>
         let block = parseEvmSimulateBlock(~defaultBlockNumber=currentBlock.contents, ~blockJson)
         let blockFields = block->(Utils.magic: Internal.eventBlock => evmSimulateBlock)
-        (block, blockFields.number, blockFields.timestamp, blockFields.hash)
+        (block, blockFields.number)
       | Svm => JsError.throwWithMessage("simulate is not supported for SVM ecosystem")
       }
       let transaction = switch config.ecosystem.name {
@@ -279,15 +324,38 @@ 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)
+      }
+
+      // Build a real registration the same way `HandlerRegister.finishRegistration`
+      // does at startup (not a stub), so the address filter and `where`
+      // behave identically to real indexing — the dead-input tracker relies
+      // on `clientAddressFilter` actually gating unrouted items.
+      let onEventRegistration = HandlerRegister.buildOnEventRegistration(
+        ~config,
+        ~chainId,
+        ~eventConfig,
+      )
+
       items
       ->Array.push(
         Internal.Event({
-          eventConfig,
-          timestamp,
+          onEventRegistration,
           chain,
           blockNumber,
-          blockHash,
           logIndex,
+          // Simulate keeps the transaction inline on the payload, so the store
+          // key is unused.
+          transactionIndex: 0,
           payload: (
             {
               contractName: eventConfig.contractName,

package/src/SimulateItems.res.mjs

@@ -1,10 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Config from "./Config.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as SimulateSource from "./sources/SimulateSource.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as HandlerRegister from "./HandlerRegister.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
@@ -135,6 +137,36 @@ 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, config) {
+  if (providedSrcAddress !== undefined) {
+    return Config.normalizeSimulateAddress(config, Primitive_option.valFromOption(providedSrcAddress));
+  }
+  if (HandlerRegister.isWildcard(eventConfig.contractName, eventConfig.name)) {
+    return dummySrcAddress;
+  }
+  let addr = firstContractAddress(chainConfig, eventConfig.contractName);
+  if (addr !== undefined) {
+    return Primitive_option.valFromOption(addr);
+  } else {
+    return dummySrcAddress;
+  }
+}
+
 function parse(simulateItems, config, chainConfig) {
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
@@ -146,7 +178,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) {
@@ -163,32 +196,16 @@ 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;
       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, config);
     let blockJson = rawJson.block;
     let blockJson$1 = (blockJson == null) ? undefined : Primitive_option.some(blockJson);
     let transactionJson = rawJson.transaction;
@@ -200,18 +217,14 @@ function parse(simulateItems, config, chainConfig) {
         let block = parseEvmSimulateBlock(currentBlock.contents, blockJson$1);
         match$3 = [
           block,
-          block.number,
-          block.timestamp,
-          block.hash
+          block.number
         ];
         break;
       case "fuel" :
         let block$1 = parseFuelSimulateBlock(currentBlock.contents, blockJson$1);
         match$3 = [
           block$1,
-          block$1.height,
-          block$1.time,
-          block$1.id
+          block$1.height
         ];
         break;
       case "svm" :
@@ -233,14 +246,21 @@ 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;
+    }
+    let onEventRegistration = HandlerRegister.buildOnEventRegistration(config, chainId, eventConfig, undefined);
     items.push({
       kind: 0,
-      eventConfig: eventConfig,
-      timestamp: match$3[2],
+      onEventRegistration: onEventRegistration,
       chain: chain,
       blockNumber: blockNumber,
-      blockHash: match$3[3],
       logIndex: logIndex,
+      transactionIndex: 0,
       payload: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
@@ -248,8 +268,8 @@ function parse(simulateItems, config, chainConfig) {
         chainId: chainId,
         srcAddress: srcAddress,
         logIndex: logIndex,
-        transaction: transaction,
-        block: match$3[0]
+        transaction: Primitive_option.some(transaction),
+        block: Primitive_option.some(match$3[0])
       }
     });
   });
@@ -317,6 +337,9 @@ export {
   fuelSimulateTransactionSchema,
   parseFuelSimulateTransaction,
   findEventConfig,
+  dummySrcAddress,
+  firstContractAddress,
+  deriveSrcAddress,
   parse,
   patchConfig,
 }