envio 3.3.1 → 3.4.0

package/src/IndexerState.res.mjs

@@ -44,7 +44,7 @@ function get(self, entityName) {
   }
 }
 
-function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError) {
+function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSizeOpt, committedCheckpointIdOpt, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, onError, onExit) {
   let targetBufferSize = targetBufferSizeOpt !== undefined ? targetBufferSizeOpt : CrossChainState.calculateTargetBufferSize();
   let committedCheckpointId = committedCheckpointIdOpt !== undefined ? committedCheckpointIdOpt : Internal.initialCheckpointId;
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
@@ -81,6 +81,7 @@ function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime
     keepProcessAlive: isDevelopmentMode || shouldUseTui,
     exitAfterFirstEventBlock: exitAfterFirstEventBlock,
     onError: onError,
+    onExit: onExit,
     isStopped: false,
     epoch: 0,
     simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
@@ -96,7 +97,7 @@ function make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime
   };
 }
 
-function makeFromDbState(config, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, targetBufferSizeOpt, onError) {
+function makeFromDbState(config, persistence, initialState, registrationsByChainId, isDevelopmentModeOpt, shouldUseTuiOpt, exitAfterFirstEventBlockOpt, reducedPollingInterval, targetBufferSizeOpt, onError, onExit) {
   let isDevelopmentMode = isDevelopmentModeOpt !== undefined ? isDevelopmentModeOpt : false;
   let shouldUseTui = shouldUseTuiOpt !== undefined ? shouldUseTuiOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
@@ -118,7 +119,7 @@ function makeFromDbState(config, persistence, initialState, registrationsByChain
     let chainConfig = ChainMap.get(config.chainMap, chain);
     chainStates[resumedChainState.id] = ChainState.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrationsByChainId, reducedPollingInterval);
   });
-  let state = make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError);
+  let state = make$1(config, persistence, chainStates, isInReorgThreshold, isRealtime, targetBufferSize, initialState.checkpointId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, onError, onExit);
   Utils.Dict.forEach(initialState.cache, param => {
     let count = param.count;
     EffectState.setUnregisteredCacheCount(state.effectState, param.effectName, param.scope, count);
@@ -319,6 +320,10 @@ function exitAfterFirstEventBlock(state) {
   return state.exitAfterFirstEventBlock;
 }
 
+function onExit(state) {
+  return state.onExit;
+}
+
 function isStopped(state) {
   return state.isStopped;
 }
@@ -718,6 +723,7 @@ export {
   loadManager,
   keepProcessAlive,
   exitAfterFirstEventBlock,
+  onExit,
   isStopped,
   epoch,
   lastPrunedAtMillis,

package/src/IndexerState.resi

@@ -30,6 +30,7 @@ let make: (
   ~shouldUseTui: bool=?,
   ~exitAfterFirstEventBlock: bool=?,
   ~onError: ErrorHandling.t => unit,
+  ~onExit: unit => unit=?,
 ) => t
 
 let makeFromDbState: (
@@ -43,6 +44,7 @@ let makeFromDbState: (
   ~reducedPollingInterval: int=?,
   ~targetBufferSize: int=?,
   ~onError: ErrorHandling.t => unit,
+  ~onExit: unit => unit=?,
 ) => t
 
 let unexpectedErrorMsg: string
@@ -96,6 +98,7 @@ let indexerStartTime: t => Date.t
 let loadManager: t => LoadManager.t
 let keepProcessAlive: t => bool
 let exitAfterFirstEventBlock: t => bool
+let onExit: t => option<unit => unit>
 let isStopped: t => bool
 let epoch: t => int
 let lastPrunedAtMillis: t => dict<float>

package/src/Internal.res

@@ -179,7 +179,7 @@ type svmBlockField =
 let allSvmBlockFields: array<svmBlockField> = [Height, ParentSlot, ParentHash]
 let svmBlockFieldSchema = S.enum(allSvmBlockFields)
 
-// Static sets of nullable field names — used by RpcSource and HyperSyncSource to wrap schemas with S.nullable
+// Static sets of field names whose source schemas must be wrapped with S.nullable.
 let evmNullableBlockFields = Utils.Set.fromArray(
   (
     [
@@ -720,11 +720,20 @@ let fuelTransferParamsSchema = S.schema(s => {
 
 type entity = private {id: string}
 
+// Raw ClickHouse expressions/field names from the entity's
+// @storage(clickhouse: {...}) directive, applied to the history table DDL.
+type clickhouseTableOptions = {
+  partitionBy?: string,
+  orderBy?: array<string>,
+  ttl?: string,
+}
+
 // Per-entity storage resolved at parse time against the global storage
 // config. Downstream PG/CH consumers just check the matching boolean.
 type entityStorage = {
   postgres: bool,
   clickhouse: bool,
+  clickhouseOptions?: clickhouseTableOptions,
 }
 
 type genericEntityConfig<'entity> = {

package/src/Main.res.mjs

@@ -247,7 +247,7 @@ function getGlobalIndexer() {
   let onEventFn = (identityConfig, handler) => {
     HandlerRegister.throwIfFinishedRegistration("onEvent");
     let match = parseIdentityConfig(identityConfig);
-    HandlerRegister.setHandler(match[0], match[1], handler, match[2], undefined);
+    HandlerRegister.setHandler(match[0], match[1], handler, match[2]);
   };
   let parseSvmIdentityConfig = identityConfig => {
     let match;
@@ -279,12 +279,12 @@ function getGlobalIndexer() {
     HandlerRegister.setHandler(match[0], match[1], args => handler({
       instruction: args.event,
       context: args.context
-    }), match[2], undefined);
+    }), match[2]);
   };
   let contractRegisterFn = (identityConfig, handler) => {
     HandlerRegister.throwIfFinishedRegistration("contractRegister");
     let match = parseIdentityConfig(identityConfig);
-    HandlerRegister.setContractRegister(match[0], match[1], handler, match[2], undefined);
+    HandlerRegister.setContractRegister(match[0], match[1], handler, match[2]);
   };
   let onRollbackCommitFn = callback => {
     HandlerRegister.throwIfFinishedRegistration("~internalAndWillBeRemovedSoon_onRollbackCommit");
@@ -524,7 +524,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
       };
     }, persistence$1, isDevelopmentMode);
   }
-  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
+  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrationsByChainId, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError, undefined);
   if (shouldUseTui) {
     Tui.start(() => state);
   }

package/src/PgStorage.res

@@ -1,5 +1,3 @@
-let getCacheRowCountFnName = "get_cache_row_count"
-
 let makeClient = () => {
   Postgres.makeSql(
     ~config={
@@ -267,18 +265,7 @@ GRANT ALL ON SCHEMA "${pgSchema}" TO public;`,
   | None => ()
   }
 
-  [
-    query.contents,
-    `CREATE OR REPLACE FUNCTION ${getCacheRowCountFnName}(table_name text) 
-RETURNS integer AS $$
-DECLARE
-  result integer;
-BEGIN
-  EXECUTE format('SELECT COUNT(*) FROM "${pgSchema}".%I', table_name) INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;`,
-  ]
+  [query.contents]
 }
 
 let makeLoadQuery = (~pgSchema, ~tableName, ~condition) => {
@@ -661,16 +648,19 @@ type schemaCacheTableInfo = {
   count: int,
 }
 
+type cacheRowCount = {
+  @as("count")
+  count: int,
+}
+
 // Matches both the cross-chain (`envio_effect_<name>`) and chain-scoped
 // (`envio_<chainId>_effect_<name>`) cache-table formats. Kept in sync with
 // Internal.EffectCache.
-let makeSchemaCacheTableInfoQuery = (~pgSchema) => {
+let makeEffectCacheTableNamesQuery = (~pgSchema) => {
   // The column guard requires the effect-cache shape (exactly an `id` + `output`
   // pair) so a user entity table that happens to match the name pattern is never
   // mistaken for an effect cache.
-  `SELECT
-    t.table_name,
-    ${getCacheRowCountFnName}(t.table_name) as count
+  `SELECT t.table_name
    FROM information_schema.tables t
    WHERE t.table_schema = '${pgSchema}'
    AND t.table_name ~ '^envio_([0-9]+_)?effect_.+'
@@ -681,6 +671,15 @@ let makeSchemaCacheTableInfoQuery = (~pgSchema) => {
    ) = ARRAY['id', 'output'];`
 }
 
+let makeCacheRowCountQuery = (~pgSchema, ~tableName) => {
+  // The table name comes from information_schema, so anything cache-shaped that
+  // was created out-of-band in the schema reaches here. Splice both identifiers
+  // as quoted identifiers, doubling embedded quotes, so a crafted name can't
+  // break out into raw SQL.
+  let quoteIdent = ident => `"${ident->String.replaceAll("\"", "\"\"")}"`
+  `SELECT COUNT(*)::int AS count FROM ${quoteIdent(pgSchema)}.${quoteIdent(tableName)};`
+}
+
 type psqlExecState =
   Unknown | Pending(promise<result<string, string>>) | Resolved(result<string, string>)
 
@@ -850,9 +849,24 @@ let rec writeBatch = async (
     let specificError = ref(None)
 
     let rawEvents = if config.enableRawEvents {
+      // A single on-chain log fans out to one item per matching registration;
+      // `raw_events` records the log itself, so dedupe by its coordinate
+      // (chain, block, logIndex) to keep one row per log.
+      let seenLogCoordinates = Utils.Set.make()
       let rows = batch.items->Array.filterMap(item =>
         switch item {
-        | Internal.Event(_) => Some(config.ecosystem.toRawEvent(item->Internal.castUnsafeEventItem))
+        | Internal.Event(_) =>
+          let coordinate = `${item
+            ->Internal.getItemChainId
+            ->Int.toString}-${item
+            ->Internal.getItemBlockNumber
+            ->Int.toString}-${item->Internal.getItemLogIndex->Int.toString}`
+          if seenLogCoordinates->Utils.Set.has(coordinate) {
+            None
+          } else {
+            seenLogCoordinates->Utils.Set.add(coordinate)->ignore
+            Some(config.ecosystem.toRawEvent(item->Internal.castUnsafeEventItem))
+          }
         | Internal.Block(_) => None
         }
       )
@@ -1301,6 +1315,23 @@ let make = (
     result
   }
 
+  // Each indexer counts the effect-cache tables in its own schema. The counts
+  // are computed here per table rather than through a shared SQL helper so
+  // indexers isolated by schema in one database never touch each other's state.
+  let queryCacheTableInfo = async (): array<schemaCacheTableInfo> => {
+    let tableNames: array<schemaTableName> = await sql->Postgres.unsafe(
+      makeEffectCacheTableNamesQuery(~pgSchema),
+    )
+    await tableNames
+    ->Array.map(async ({tableName}) => {
+      let rows: array<cacheRowCount> = await sql->Postgres.unsafe(
+        makeCacheRowCountQuery(~pgSchema, ~tableName),
+      )
+      ({tableName, count: (rows->Array.getUnsafe(0)).count}: schemaCacheTableInfo)
+    })
+    ->Promise.all
+  }
+
   let restoreEffectCache = async (~withUpload) => {
     if withUpload {
       // Try to restore cache tables from the .envio/cache TSV files
@@ -1340,9 +1371,7 @@ let make = (
       }
     }
 
-    let cacheTableInfo: array<schemaCacheTableInfo> = await sql->Postgres.unsafe(
-      makeSchemaCacheTableInfoQuery(~pgSchema),
-    )
+    let cacheTableInfo = await queryCacheTableInfo()
 
     if withUpload && cacheTableInfo->Utils.Array.notEmpty {
       // Integration with other tools like Hasura
@@ -1551,10 +1580,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
 
   let dumpEffectCache = async () => {
     try {
-      let cacheTableInfo: array<schemaCacheTableInfo> =
-        (await sql->Postgres.unsafe(makeSchemaCacheTableInfoQuery(~pgSchema)))->Array.filter(i =>
-          i.count > 0
-        )
+      let cacheTableInfo = (await queryCacheTableInfo())->Array.filter(i => i.count > 0)
 
       if cacheTableInfo->Utils.Array.notEmpty {
         // Create .envio/cache directory if it doesn't exist

package/src/PgStorage.res.mjs

@@ -27,8 +27,6 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-let getCacheRowCountFnName = "get_cache_row_count";
-
 function makeClient() {
   return Postgres({
     host: Env.Db.host,
@@ -222,18 +220,7 @@ GRANT ALL ON SCHEMA "` + pgSchema + `" TO public;`)
   if (initialChainsValuesQuery !== undefined) {
     query.contents = query.contents + "\n" + initialChainsValuesQuery;
   }
-  return [
-    query.contents,
-    `CREATE OR REPLACE FUNCTION ` + getCacheRowCountFnName + `(table_name text) 
-RETURNS integer AS $$
-DECLARE
-  result integer;
-BEGIN
-  EXECUTE format('SELECT COUNT(*) FROM "` + pgSchema + `".%I', table_name) INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;`
-  ];
+  return [query.contents];
 }
 
 function makeLoadQuery(pgSchema, tableName, condition) {
@@ -492,10 +479,8 @@ function makeSchemaTableNamesQuery(pgSchema) {
   return `SELECT table_name FROM information_schema.tables WHERE table_schema = '` + pgSchema + `';`;
 }
 
-function makeSchemaCacheTableInfoQuery(pgSchema) {
-  return `SELECT
-    t.table_name,
-    ` + getCacheRowCountFnName + `(t.table_name) as count
+function makeEffectCacheTableNamesQuery(pgSchema) {
+  return `SELECT t.table_name
    FROM information_schema.tables t
    WHERE t.table_schema = '` + pgSchema + `'
    AND t.table_name ~ '^envio_([0-9]+_)?effect_.+'
@@ -506,6 +491,11 @@ function makeSchemaCacheTableInfoQuery(pgSchema) {
    ) = ARRAY['id', 'output'];`;
 }
 
+function makeCacheRowCountQuery(pgSchema, tableName) {
+  let quoteIdent = ident => `"` + ident.replaceAll("\"", "\"\"") + `"`;
+  return `SELECT COUNT(*)::int AS count FROM ` + quoteIdent(pgSchema) + `.` + quoteIdent(tableName) + `;`;
+}
+
 let psqlExecState = {
   contents: "Unknown"
 };
@@ -617,8 +607,16 @@ async function writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, co
     };
     let rawEvents;
     if (config.enableRawEvents) {
+      let seenLogCoordinates = new Set();
       let rows = Stdlib_Array.filterMap(batch.items, item => {
-        if (item.kind === 0) {
+        if (item.kind !== 0) {
+          return;
+        }
+        let coordinate = Internal.getItemChainId(item).toString() + `-` + item.blockNumber.toString() + `-` + item.logIndex.toString();
+        if (seenLogCoordinates.has(coordinate)) {
+          return;
+        } else {
+          seenLogCoordinates.add(coordinate);
           return config.ecosystem.toRawEvent(item);
         }
       });
@@ -889,6 +887,17 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
     }));
     return result;
   };
+  let queryCacheTableInfo = async () => {
+    let tableNames = await sql.unsafe(makeEffectCacheTableNamesQuery(pgSchema));
+    return await Promise.all(tableNames.map(async param => {
+      let tableName = param.table_name;
+      let rows = await sql.unsafe(makeCacheRowCountQuery(pgSchema, tableName));
+      return {
+        table_name: tableName,
+        count: rows[0].count
+      };
+    }));
+  };
   let restoreEffectCache = async withUpload => {
     if (withUpload) {
       let entries = await scanCacheDir();
@@ -920,7 +929,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         Logging.info("No cache found to upload.");
       }
     }
-    let cacheTableInfo = await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema));
+    let cacheTableInfo = await queryCacheTableInfo();
     if (withUpload && Utils.$$Array.notEmpty(cacheTableInfo) && onNewTables !== undefined) {
       await onNewTables(cacheTableInfo.map(info => info.table_name));
     }
@@ -1041,7 +1050,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
   };
   let dumpEffectCache = async () => {
     try {
-      let cacheTableInfo = (await sql.unsafe(makeSchemaCacheTableInfoQuery(pgSchema))).filter(i => i.count > 0);
+      let cacheTableInfo = (await queryCacheTableInfo()).filter(i => i.count > 0);
       if (!Utils.$$Array.notEmpty(cacheTableInfo)) {
         return;
       }
@@ -1250,7 +1259,6 @@ function makePersistenceFromConfig(config, storageOpt) {
 let maxItemsPerQuery = 500;
 
 export {
-  getCacheRowCountFnName,
   makeClient,
   makeCreateIndexQuery,
   directionToSql,
@@ -1279,7 +1287,8 @@ export {
   setQueryCache,
   setOrThrow,
   makeSchemaTableNamesQuery,
-  makeSchemaCacheTableInfoQuery,
+  makeEffectCacheTableNamesQuery,
+  makeCacheRowCountQuery,
   getConnectedPsqlExec,
   deleteByIdsOrThrow,
   makeInsertDeleteUpdatesQuery,

package/src/SimulateItems.res

@@ -339,46 +339,67 @@ let parse = (
       | 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,
-      )
-      // Append into the registration array that the chain state will own and
-      // put that same registration object directly on the simulated item.
-      let onEventRegistrationIndex = onEventRegistrations->Array.length
-      let onEventRegistration = {...onEventRegistration, index: onEventRegistrationIndex}
-      onEventRegistrations->Array.push(onEventRegistration)->ignore
-
-      items
-      ->Array.push(
-        Internal.Event({
-          onEventRegistration,
-          chain,
-          blockNumber,
-          logIndex,
-          // Simulate keeps the transaction inline on the payload, so the store
-          // key is unused.
-          transactionIndex: 0,
-          payload: (
-            {
-              contractName: eventConfig.contractName,
-              eventName: eventConfig.name,
-              params,
-              chainId,
-              srcAddress,
-              logIndex,
-              transaction,
-              block,
-            }: Evm.payload
-          )->Evm.fromPayload,
-        }),
-      )
-      ->ignore
+      // Fan the simulated event out to every registration that would actually
+      // run here the way real routing does (one item per registration).
+      // Registrations are built the same way `HandlerRegister.finishRegistration`
+      // does at startup (not stubs), so the address filter and `where` behave
+      // identically to real indexing — the dead-input tracker relies on
+      // `clientAddressFilter` actually gating unrouted items. Drop registrations
+      // whose `where` excludes this chain (they wouldn't be fetched live), and
+      // ignore the bare handler-less fallback so a missing handler surfaces below
+      // instead of silently running nothing.
+      let liveRegistrations =
+        HandlerRegister.getSimulateOnEventRegistrations(
+          ~config,
+          ~chainId,
+          ~eventConfig,
+        )->Array.filter(reg =>
+          (reg.handler->Option.isSome || reg.contractRegister->Option.isSome) &&
+            !HandlerRegister.isDroppedByWhere(~config, reg)
+        )
+      if liveRegistrations->Utils.Array.isEmpty {
+        JsError.throwWithMessage(
+          `simulate: no handler runs for event "${eventName}" on contract "${contractName}"${switch config.chainMap
+            ->ChainMap.values
+            ->Array.length {
+            | 1 => ""
+            | _ => ` on chain ${chainId->Int.toString}`
+            }}. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`,
+        )
+      }
+      liveRegistrations->Array.forEach(reg => {
+        // Append into the registration array that the chain state will own and
+        // put that same registration object directly on the simulated item.
+        let onEventRegistrationIndex = onEventRegistrations->Array.length
+        let onEventRegistration = {...reg, index: onEventRegistrationIndex}
+        onEventRegistrations->Array.push(onEventRegistration)->ignore
+
+        items
+        ->Array.push(
+          Internal.Event({
+            onEventRegistration,
+            chain,
+            blockNumber,
+            logIndex,
+            // Simulate keeps the transaction inline on the payload, so the store
+            // key is unused.
+            transactionIndex: 0,
+            payload: (
+              {
+                contractName: eventConfig.contractName,
+                eventName: eventConfig.name,
+                params,
+                chainId,
+                srcAddress,
+                logIndex,
+                transaction,
+                block,
+              }: Evm.payload
+            )->Evm.fromPayload,
+          }),
+        )
+        ->ignore
+      })
 
     | _ =>
       JsError.throwWithMessage(`simulate: Invalid item. Each item must have "contract" and "event" fields.`)

package/src/SimulateItems.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Address from "./Address.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
@@ -232,6 +233,7 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
         break;
     }
     let blockNumber = match$3[1];
+    let block$2 = match$3[0];
     let match$4 = config.ecosystem.name;
     let transaction;
     switch (match$4) {
@@ -253,29 +255,43 @@ function parse(simulateItems, config, chainConfig, onEventRegistrations) {
     } else {
       seenCoordinates[coordinate] = itemIndex;
     }
-    let onEventRegistration = HandlerRegister.buildOnEventRegistration(config, chainId, eventConfig, undefined);
-    let onEventRegistrationIndex = onEventRegistrations.length;
-    let newrecord = {...onEventRegistration};
-    newrecord.index = onEventRegistrationIndex;
-    onEventRegistrations.push(newrecord);
-    items.push({
-      kind: 0,
-      onEventRegistration: newrecord,
-      chain: chain,
-      blockNumber: blockNumber,
-      logIndex: logIndex,
-      transactionIndex: 0,
-      payload: {
-        contractName: eventConfig.contractName,
-        eventName: eventConfig.name,
-        params: params,
-        chainId: chainId,
-        srcAddress: srcAddress,
-        logIndex: logIndex,
-        transaction: Primitive_option.some(transaction),
-        block: Primitive_option.some(match$3[0])
+    let liveRegistrations = HandlerRegister.getSimulateOnEventRegistrations(config, chainId, eventConfig).filter(reg => {
+      if (Stdlib_Option.isSome(reg.handler) || Stdlib_Option.isSome(reg.contractRegister)) {
+        return !HandlerRegister.isDroppedByWhere(config, reg);
+      } else {
+        return false;
       }
     });
+    if (Utils.$$Array.isEmpty(liveRegistrations)) {
+      let match$5 = ChainMap.values(config.chainMap).length;
+      Stdlib_JsError.throwWithMessage(`simulate: no handler runs for event "` + match$1 + `" on contract "` + match + `"` + (
+        match$5 !== 1 ? ` on chain ` + chainId.toString() : ""
+      ) + `. Register a handler with indexer.onEvent (and check any \`where\` filter isn't excluding this chain) before simulating it.`);
+    }
+    liveRegistrations.forEach(reg => {
+      let onEventRegistrationIndex = onEventRegistrations.length;
+      let newrecord = {...reg};
+      newrecord.index = onEventRegistrationIndex;
+      onEventRegistrations.push(newrecord);
+      items.push({
+        kind: 0,
+        onEventRegistration: newrecord,
+        chain: chain,
+        blockNumber: blockNumber,
+        logIndex: logIndex,
+        transactionIndex: 0,
+        payload: {
+          contractName: eventConfig.contractName,
+          eventName: eventConfig.name,
+          params: params,
+          chainId: chainId,
+          srcAddress: srcAddress,
+          logIndex: logIndex,
+          transaction: Primitive_option.some(transaction),
+          block: Primitive_option.some(block$2)
+        }
+      });
+    });
   });
   return items;
 }