envio 3.3.0-alpha.8 → 3.3.0-rc.0

package/src/UserContext.res

@@ -28,10 +28,23 @@ Utils.Object.defineProperty(
   },
 )
 %%raw(`
-var EffectContext = function(params, defaultShouldCache, callEffect) {
+// Top-level so the getter is created once, not per context. \`this\` is the
+// EffectContext instance; only cross-chain contexts install it.
+function throwCrossChainChainAccess() {
+  throw new Error('context.chain is not available on the cross-chain effect "' + this._effectName + '". Set \`crossChain: false\` in its options to scope the effect to a single chain, then read context.chain.id.');
+}
+var crossChainChainDescriptor = { get: throwCrossChainChainAccess, enumerable: true };
+var EffectContext = function(params, chainId, effectName, defaultShouldCache, callEffect) {
   paramsByThis.set(this, params);
   this.effect = callEffect;
   this.cache = defaultShouldCache;
+  if (chainId === undefined) {
+    // Cross-chain: reading context.chain throws, via the shared getter.
+    Object.defineProperty(this, "_effectName", { value: effectName });
+    Object.defineProperty(this, "chain", crossChainChainDescriptor);
+  } else {
+    this.chain = { id: chainId };
+  }
 };
 EffectContext.prototype = effectContextPrototype;
 `)
@@ -39,35 +52,61 @@ EffectContext.prototype = effectContextPrototype;
 @new
 external makeEffectContext: (
   contextParams,
+  ~chainId: option<int>,
+  ~effectName: string,
   ~defaultShouldCache: bool,
   ~callEffect: (Internal.effect, Internal.effectInput) => promise<Internal.effectOutput>,
 ) => Internal.effectContext = "EffectContext"
 
 let initEffect = (params: contextParams) => {
-  let rec callEffect = (effect: Internal.effect, input: Internal.effectInput) => {
-    let effectContext = makeEffectContext(
-      params,
-      ~defaultShouldCache=effect.defaultShouldCache,
-      ~callEffect,
-    )
-    let effectArgs: Internal.effectArgs = {
-      input,
-      context: effectContext,
-      cacheKey: input->S.reverseConvertOrThrow(effect.input)->Utils.Hash.makeOrThrow,
-      checkpointId: params.checkpointId,
+  let handlerChainId = params.item->Internal.getItemChainId
+  // A chain-scoped effect always resolves against the chain of the handler that
+  // triggered the call, even several effects deep, so the chain id is captured
+  // once from the item and reused for the whole nested-call tree.
+  let rec makeCaller = (~caller: option<Internal.effect>) => {
+    (effect: Internal.effect, input: Internal.effectInput) => {
+      let scope = effect.crossChain ? Internal.CrossChain : Internal.Chain(handlerChainId)
+
+      switch caller {
+      | Some(callerEffect) if callerEffect.crossChain && !effect.crossChain =>
+        // A cross-chain effect isn't tied to a single chain, so it has no chain
+        // to resolve a chain-scoped child against. Reject before any cache work.
+        JsError.throwWithMessage(
+          `The cross-chain effect "${callerEffect.name}" cannot call the chain-scoped effect "${effect.name}", because a cross-chain effect isn't tied to a single chain. Make "${effect.name}" cross-chain (\`crossChain: true\`), or make "${callerEffect.name}" chain-scoped (\`crossChain: false\`).`,
+        )
+      | _ => ()
+      }
+
+      let effectContext = makeEffectContext(
+        params,
+        ~chainId=switch scope {
+        | Internal.Chain(chainId) => Some(chainId)
+        | Internal.CrossChain => None
+        },
+        ~effectName=effect.name,
+        ~defaultShouldCache=effect.defaultShouldCache,
+        ~callEffect=makeCaller(~caller=Some(effect)),
+      )
+      let effectArgs: Internal.effectArgs = {
+        input,
+        context: effectContext,
+        cacheKey: input->S.reverseConvertOrThrow(effect.input)->Utils.Hash.makeOrThrow,
+        checkpointId: params.checkpointId,
+      }
+      LoadLayer.loadEffect(
+        ~loadManager=params.loadManager,
+        ~persistence=params.persistence,
+        ~effect,
+        ~effectArgs,
+        ~scope,
+        ~indexerState=params.indexerState,
+        ~shouldGroup=params.isPreload,
+        ~item=params.item,
+        ~ecosystem=params.config.ecosystem,
+      )
     }
-    LoadLayer.loadEffect(
-      ~loadManager=params.loadManager,
-      ~persistence=params.persistence,
-      ~effect,
-      ~effectArgs,
-      ~indexerState=params.indexerState,
-      ~shouldGroup=params.isPreload,
-      ~item=params.item,
-      ~ecosystem=params.config.ecosystem,
-    )
   }
-  callEffect
+  makeCaller(~caller=None)
 }
 
 type entityContextParams = {

package/src/UserContext.res.mjs

@@ -25,17 +25,37 @@ Object.defineProperty(effectContextPrototype, "log", {
   }
 });
 
-var EffectContext = function(params, defaultShouldCache, callEffect) {
+// Top-level so the getter is created once, not per context. \`this\` is the
+// EffectContext instance; only cross-chain contexts install it.
+function throwCrossChainChainAccess() {
+  throw new Error('context.chain is not available on the cross-chain effect "' + this._effectName + '". Set \`crossChain: false\` in its options to scope the effect to a single chain, then read context.chain.id.');
+}
+var crossChainChainDescriptor = { get: throwCrossChainChainAccess, enumerable: true };
+var EffectContext = function(params, chainId, effectName, defaultShouldCache, callEffect) {
   paramsByThis.set(this, params);
   this.effect = callEffect;
   this.cache = defaultShouldCache;
+  if (chainId === undefined) {
+    // Cross-chain: reading context.chain throws, via the shared getter.
+    Object.defineProperty(this, "_effectName", { value: effectName });
+    Object.defineProperty(this, "chain", crossChainChainDescriptor);
+  } else {
+    this.chain = { id: chainId };
+  }
 };
 EffectContext.prototype = effectContextPrototype;
 ;
 
 function initEffect(params) {
-  let callEffect = (effect, input) => {
-    let effectContext = new EffectContext(params, effect.defaultShouldCache, callEffect);
+  let handlerChainId = Internal.getItemChainId(params.item);
+  let makeCaller = caller => ((effect, input) => {
+    let scope = effect.crossChain ? "crossChain" : handlerChainId;
+    if (caller !== undefined && caller.crossChain && !effect.crossChain) {
+      Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
+    }
+    let tmp;
+    tmp = scope === "crossChain" ? undefined : scope;
+    let effectContext = new EffectContext(params, tmp, effect.name, effect.defaultShouldCache, makeCaller(effect));
     let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
     let effectArgs_checkpointId = params.checkpointId;
     let effectArgs = {
@@ -44,9 +64,9 @@ function initEffect(params) {
       cacheKey: effectArgs_cacheKey,
       checkpointId: effectArgs_checkpointId
     };
-    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
-  };
-  return callEffect;
+    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
+  });
+  return makeCaller(undefined);
 }
 
 function getWhereHandler(params, filter) {

package/src/Writing.res

@@ -16,8 +16,8 @@ let getChangesCount = (state: IndexerState.t) => {
     total := total.contents +. (state->InMemoryStore.getInMemTable(~entityConfig)).changesCount
   })
   state
-  ->IndexerState.effects
-  ->Utils.Dict.forEach(inMemTable => {
+  ->IndexerState.effectState
+  ->EffectState.forEach(inMemTable => {
     total := total.contents +. inMemTable.changesCount
   })
   state
@@ -38,9 +38,9 @@ let waitForCommit = (state: IndexerState.t): promise<unit> =>
 let snapshotEffects = (state: IndexerState.t, ~cache): array<Persistence.updatedEffectCache> => {
   let acc = []
   state
-  ->IndexerState.effects
-  ->Utils.Dict.forEach(inMemTable => {
-    let {idsToStore, dict, effect, invalidationsCount} = inMemTable
+  ->IndexerState.effectState
+  ->EffectState.forEach(inMemTable => {
+    let {idsToStore, dict, effect, invalidationsCount, scope, table} = inMemTable
     switch idsToStore {
     | [] => ()
     | ids =>
@@ -51,17 +51,33 @@ let snapshotEffects = (state: IndexerState.t, ~cache): array<Persistence.updated
         }
       )
       let effectName = effect.name
-      let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(effectName) {
+      let tableName = table.tableName
+      let effectCacheRecord = switch cache->Utils.Dict.dangerouslyGetNonOption(tableName) {
       | Some(c) => c
       | None =>
-        let c: Persistence.effectCacheRecord = {effectName, count: 0}
-        cache->Dict.set(effectName, c)
+        let c: Persistence.effectCacheRecord = {effectName, scope, tableName, count: 0}
+        cache->Dict.set(tableName, c)
         c
       }
       let shouldInitialize = effectCacheRecord.count === 0
       effectCacheRecord.count = effectCacheRecord.count + items->Array.length - invalidationsCount
-      Prometheus.EffectCacheCount.set(~count=effectCacheRecord.count, ~effectName)
-      acc->Array.push(({effect, items, shouldInitialize}: Persistence.updatedEffectCache))->ignore
+      Prometheus.EffectCacheCount.set(
+        ~count=effectCacheRecord.count,
+        ~effectName,
+        ~scope=scope->Internal.EffectCache.scopeToString,
+      )
+      acc
+      ->Array.push(
+        (
+          {
+            table,
+            itemSchema: effect.storageMeta.itemSchema,
+            items,
+            shouldInitialize,
+          }: Persistence.updatedEffectCache
+        ),
+      )
+      ->ignore
     }
     inMemTable.idsToStore = []
     inMemTable.invalidationsCount = 0
@@ -113,17 +129,36 @@ let runOneWrite = async (state: IndexerState.t) => {
     })
     let updatedEffectsCache = snapshotEffects(state, ~cache)
 
-    await persistence.storage.writeBatch(
-      ~batch,
-      ~rollback,
-      ~isInReorgThreshold=batch.isInReorgThreshold,
-      ~config,
-      ~allEntities=persistence.allEntities,
-      ~updatedEntities,
-      ~updatedEffectsCache,
-      ~chainMetaData,
+    let writtenEntityNames = Utils.Set.make()
+    updatedEntities->Array.forEach(({entityConfig}) =>
+      writtenEntityNames->Utils.Set.add(entityConfig.name)->ignore
+    )
+    let pruneTargets = PruneStaleHistory.select(
+      state,
+      ~writtenEntityNames,
+      ~isRollback=rollback->Option.isSome,
     )
 
+    // The prune runs concurrently with the batch write, but only for entities
+    // absent from it, so they never touch the same history table. Both must be
+    // awaited before the next write starts, otherwise a still-running prune
+    // could overlap the next batch's history writes and lose an anchor (which
+    // breaks a later rollback). Rollback writes touch every history table, so
+    // they get no concurrent prune at all.
+    let _ = await Promise.all2((
+      persistence.storage.writeBatch(
+        ~batch,
+        ~rollback,
+        ~isInReorgThreshold=batch.isInReorgThreshold,
+        ~config,
+        ~allEntities=persistence.allEntities,
+        ~updatedEntities,
+        ~updatedEffectsCache,
+        ~chainMetaData,
+      ),
+      PruneStaleHistory.runConcurrent(state, ~targets=pruneTargets),
+    ))
+
     state->IndexerState.markCommitted(~upToCheckpointId)
 
     switch rollback {
@@ -131,6 +166,10 @@ let runOneWrite = async (state: IndexerState.t) => {
       await RollbackCommit.fire(~progressBlockNumberByChainId)
     | _ => ()
     }
+
+    // Entities starved of the concurrent prune (eg written in every batch) are
+    // pruned here with no other pg writer running.
+    await PruneStaleHistory.runForced(state, ~targets=pruneTargets)
   }
 }
 
@@ -192,8 +231,8 @@ let dropCommitted = (state: IndexerState.t, ~keepLoadedFromDb) => {
     ->InMemoryTable.Entity.dropCommittedChanges(~committedCheckpointId, ~keepLoadedFromDb)
   )
   state
-  ->IndexerState.effects
-  ->Utils.Dict.forEach(inMemTable =>
+  ->IndexerState.effectState
+  ->EffectState.forEach(inMemTable =>
     inMemTable->InMemoryStore.dropCommittedEffects(~committedCheckpointId, ~keepLoadedFromDb)
   )
 }

package/src/Writing.res.mjs

@@ -2,8 +2,10 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as EffectState from "./EffectState.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
@@ -11,6 +13,7 @@ import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as RollbackCommit from "./RollbackCommit.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as PruneStaleHistory from "./PruneStaleHistory.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function getChangesCount(state) {
@@ -20,7 +23,7 @@ function getChangesCount(state) {
   IndexerState.allEntities(state).forEach(entityConfig => {
     total.contents = total.contents + InMemoryStore.getInMemTable(state, entityConfig).changesCount;
   });
-  Utils.Dict.forEach(IndexerState.effects(state), inMemTable => {
+  EffectState.forEach(IndexerState.effectState(state), inMemTable => {
     total.contents = total.contents + inMemTable.changesCount;
   });
   IndexerState.processedBatches(state).forEach(batch => {
@@ -35,10 +38,12 @@ function waitForCommit(state) {
 
 function snapshotEffects(state, cache) {
   let acc = [];
-  Utils.Dict.forEach(IndexerState.effects(state), inMemTable => {
+  EffectState.forEach(IndexerState.effectState(state), inMemTable => {
     let idsToStore = inMemTable.idsToStore;
     let invalidationsCount = inMemTable.invalidationsCount;
     let dict = inMemTable.dict;
+    let table = inMemTable.table;
+    let scope = inMemTable.scope;
     let effect = inMemTable.effect;
     if (idsToStore.length !== 0) {
       let items = Stdlib_Array.filterMap(idsToStore, id => {
@@ -51,23 +56,27 @@ function snapshotEffects(state, cache) {
         }
       });
       let effectName = effect.name;
-      let c = cache[effectName];
+      let tableName = table.tableName;
+      let c = cache[tableName];
       let effectCacheRecord;
       if (c !== undefined) {
         effectCacheRecord = c;
       } else {
         let c$1 = {
           effectName: effectName,
+          scope: scope,
+          tableName: tableName,
           count: 0
         };
-        cache[effectName] = c$1;
+        cache[tableName] = c$1;
         effectCacheRecord = c$1;
       }
       let shouldInitialize = effectCacheRecord.count === 0;
       effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0;
-      Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName);
+      Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName, Internal.EffectCache.scopeToString(scope));
       acc.push({
-        effect: effect,
+        table: table,
+        itemSchema: effect.storageMeta.itemSchema,
         items: items,
         shouldInitialize: shouldInitialize
       });
@@ -111,11 +120,20 @@ async function runOneWrite(state) {
     }
   });
   let updatedEffectsCache = snapshotEffects(state, cache);
-  await persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, chainMetaData);
+  let writtenEntityNames = new Set();
+  updatedEntities.forEach(param => {
+    writtenEntityNames.add(param.entityConfig.name);
+  });
+  let pruneTargets = PruneStaleHistory.select(state, writtenEntityNames, Stdlib_Option.isSome(rollback));
+  await Promise.all([
+    persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, chainMetaData),
+    PruneStaleHistory.runConcurrent(state, pruneTargets)
+  ]);
   IndexerState.markCommitted(state, upToCheckpointId);
   if (rollback !== undefined && Utils.$$Array.notEmpty(RollbackCommit.callbacks)) {
-    return await RollbackCommit.fire(rollback.progressBlockNumberByChainId);
+    await RollbackCommit.fire(rollback.progressBlockNumberByChainId);
   }
+  return await PruneStaleHistory.runForced(state, pruneTargets);
 }
 
 function hasPendingWrite(state) {
@@ -164,7 +182,7 @@ function commitBatch(state, batch) {
 function dropCommitted(state, keepLoadedFromDb) {
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
   IndexerState.allEntities(state).forEach(entityConfig => InMemoryTable.Entity.dropCommittedChanges(InMemoryStore.getInMemTable(state, entityConfig), committedCheckpointId, keepLoadedFromDb));
-  Utils.Dict.forEach(IndexerState.effects(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromDb));
+  EffectState.forEach(IndexerState.effectState(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromDb));
 }
 
 async function awaitCapacity(state) {

package/src/bindings/NodeJs.res

@@ -173,5 +173,10 @@ module Fs = {
 
     @module("fs") @scope("promises")
     external readdir: Path.t => promise<array<string>> = "readdir"
+
+    type stats
+    @module("fs") @scope("promises")
+    external stat: Path.t => promise<stats> = "stat"
+    @send external statsIsDirectory: stats => bool = "isDirectory"
   }
 }

package/src/bindings/Viem.res

@@ -1,11 +1,6 @@
 type hex = EvmTypes.Hex.t
 @module("viem") external toHex: 'a => hex = "toHex"
-@module("viem") external keccak256: hex => hex = "keccak256"
 @module("viem") external pad: hex => hex = "pad"
 
 type sizeOptions = {size: int}
 @module("viem") external bigintToHex: (bigint, ~options: sizeOptions=?) => hex = "numberToHex"
-@module("viem") external stringToHex: (string, ~options: sizeOptions=?) => hex = "stringToHex"
-@module("viem") external boolToHex: (bool, ~options: sizeOptions=?) => hex = "boolToHex"
-@module("viem") external bytesToHex: (Uint8Array.t, ~options: sizeOptions=?) => hex = "bytesToHex"
-@module("viem") external concat: array<hex> => hex = "concat"

package/src/sources/EventRouter.res

@@ -92,27 +92,6 @@ let get = (router: t<'a>, ~tag, ~contractAddress, ~contractNameByAddress) => {
   }
 }
 
-let getEvmEventId = (~sighash, ~topicCount) => {
-  sighash ++ "_" ++ topicCount->Int.toString
-}
-
-let fromEvmEventModsOrThrow = (events: array<Internal.evmOnEventRegistration>, ~chain): t<
-  Internal.evmOnEventRegistration,
-> => {
-  let router = empty()
-  events->Array.forEach(config => {
-    router->addOrThrow(
-      config.eventConfig.id,
-      config,
-      ~contractName=config.eventConfig.contractName,
-      ~eventName=config.eventConfig.name,
-      ~chain,
-      ~isWildcard=config.isWildcard,
-    )
-  })
-  router
-}
-
 /** Dispatch key for SVM instructions. `None` matches any instruction in the
  program (lowest priority). */
 let getSvmEventId = (~programId: SvmTypes.Pubkey.t, ~discriminator: option<string>) =>

package/src/sources/EventRouter.res.mjs

@@ -97,16 +97,6 @@ function get$1(router, tag, contractAddress, contractNameByAddress) {
   }
 }
 
-function getEvmEventId(sighash, topicCount) {
-  return sighash + "_" + topicCount.toString();
-}
-
-function fromEvmEventModsOrThrow(events, chain) {
-  let router = {};
-  events.forEach(config => addOrThrow$1(router, config.eventConfig.id, config, config.eventConfig.contractName, config.isWildcard, config.eventConfig.name, chain));
-  return router;
-}
-
 function getSvmEventId(programId, discriminator) {
   if (discriminator !== undefined) {
     return programId + "_" + discriminator;
@@ -157,8 +147,6 @@ export {
   empty$1 as empty,
   addOrThrow$1 as addOrThrow,
   get$1 as get,
-  getEvmEventId,
-  fromEvmEventModsOrThrow,
   getSvmEventId,
   fromSvmEventConfigsOrThrow,
 }

package/src/sources/Evm.res

@@ -90,8 +90,11 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // range chunk is validated by `eventBlockRangeSchema` in
   // `LogSelection.res` which rejects `_lte`/`_every` (use `onBlock` for
   // stride- and endBlock-based block handlers).
+  // `S.strict` on the inner object rejects unknown `block` fields (e.g. a
+  // `numbre` typo or `block: {timestamp: ...}`) instead of silently
+  // ignoring them.
   onEventBlockFilterSchema: S.object(s =>
-    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))))
+    s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))->S.strict))
   ),
   logger,
   // The payload carries `transaction` by batch prep (HyperSync) or inline

package/src/sources/Evm.res.mjs

@@ -58,7 +58,7 @@ function make(logger) {
     cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
-    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
+    onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown)))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {

package/src/sources/EvmChain.res

@@ -39,25 +39,6 @@ let getSyncConfig = (
   }
 }
 
-let collectEventParams = (onEventRegistrations: array<Internal.evmOnEventRegistration>): array<
-  HyperSyncClient.Decoder.eventParamsInput,
-> => {
-  let result = []
-  onEventRegistrations->Array.forEach(reg => {
-    let event = reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
-    result
-    ->Array.push({
-      HyperSyncClient.Decoder.sighash: event.sighash,
-      topicCount: event.topicCount,
-      eventName: event.name,
-      contractName: event.contractName,
-      params: event.paramsMetadata,
-    })
-    ->ignore
-  })
-  result
-}
-
 let makeSources = (
   ~chain,
   ~onEventRegistrations: array<Internal.evmOnEventRegistration>,
@@ -65,17 +46,12 @@ let makeSources = (
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
 ) => {
-  let eventRouter = onEventRegistrations->EventRouter.fromEvmEventModsOrThrow(~chain)
-
-  let allEventParams = collectEventParams(onEventRegistrations)
-
   let sources = switch hyperSync {
   | Some(endpointUrl) => [
       HyperSyncSource.make({
         chain,
         endpointUrl,
-        allEventParams,
-        eventRouter,
+        onEventRegistrations,
         apiToken: Env.envioApiToken,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses,
@@ -92,8 +68,7 @@ let makeSources = (
       sourceFor,
       syncConfig: getSyncConfig(syncConfig->Option.getOr({})),
       url,
-      eventRouter,
-      allEventParams,
+      onEventRegistrations,
       lowercaseAddresses,
       ?ws,
       ?headers,

package/src/sources/EvmChain.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Env from "../Env.res.mjs";
 import * as RpcSource from "./RpcSource.res.mjs";
-import * as EventRouter from "./EventRouter.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as HyperSyncSource from "./HyperSyncSource.res.mjs";
 
@@ -20,29 +19,11 @@ function getSyncConfig(param) {
   };
 }
 
-function collectEventParams(onEventRegistrations) {
-  let result = [];
-  onEventRegistrations.forEach(reg => {
-    let event = reg.eventConfig;
-    result.push({
-      sighash: event.sighash,
-      topicCount: event.topicCount,
-      eventName: event.name,
-      contractName: event.contractName,
-      params: event.paramsMetadata
-    });
-  });
-  return result;
-}
-
 function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses) {
-  let eventRouter = EventRouter.fromEvmEventModsOrThrow(onEventRegistrations, chain);
-  let allEventParams = collectEventParams(onEventRegistrations);
   let sources = hyperSync !== undefined ? [HyperSyncSource.make({
         chain: chain,
         endpointUrl: hyperSync,
-        allEventParams: allEventParams,
-        eventRouter: eventRouter,
+        onEventRegistrations: onEventRegistrations,
         apiToken: Env.envioApiToken,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses: lowercaseAddresses,
@@ -56,8 +37,7 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
       syncConfig: getSyncConfig(Stdlib_Option.getOr(param.syncConfig, {})),
       url: param.url,
       chain: chain,
-      eventRouter: eventRouter,
-      allEventParams: allEventParams,
+      onEventRegistrations: onEventRegistrations,
       lowercaseAddresses: lowercaseAddresses,
       ws: param.ws,
       headers: param.headers
@@ -69,7 +49,6 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
 
 export {
   getSyncConfig,
-  collectEventParams,
   makeSources,
 }
 /* Env Not a pure module */