envio 3.3.0-alpha.10 → 3.3.0-alpha.11

package/src/LogSelection.res.mjs

@@ -8,75 +8,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 MissingRequiredTopic0 = /* @__PURE__ */Primitive_exceptions.create("LogSelection.MissingRequiredTopic0");
-
-function makeTopicSelection(topic0, topic1Opt, topic2Opt, topic3Opt) {
-  let topic1 = topic1Opt !== undefined ? topic1Opt : [];
-  let topic2 = topic2Opt !== undefined ? topic2Opt : [];
-  let topic3 = topic3Opt !== undefined ? topic3Opt : [];
-  if (Utils.$$Array.isEmpty(topic0)) {
-    return {
-      TAG: "Error",
-      _0: {
-        RE_EXN_ID: MissingRequiredTopic0
-      }
-    };
-  } else {
-    return {
-      TAG: "Ok",
-      _0: {
-        topic0: topic0,
-        topic1: topic1,
-        topic2: topic2,
-        topic3: topic3
-      }
-    };
-  }
-}
-
-function hasFilters(param) {
-  return Stdlib_Option.isSome([
-    param.topic1,
-    param.topic2,
-    param.topic3
-  ].find(topic => !Utils.$$Array.isEmpty(topic)));
-}
-
-function compressTopicSelections(topicSelections) {
-  let topic0sOfSelectionsWithoutFilters = [];
-  let selectionsWithFilters = [];
-  topicSelections.forEach(selection => {
-    if (hasFilters(selection)) {
-      selectionsWithFilters.push(selection);
-    } else {
-      selection.topic0.forEach(topic0 => {
-        topic0sOfSelectionsWithoutFilters.push(topic0);
-      });
-    }
-  });
-  if (topic0sOfSelectionsWithoutFilters.length === 0) {
-    return selectionsWithFilters;
-  }
-  let selectionWithoutFilters_topic1 = [];
-  let selectionWithoutFilters_topic2 = [];
-  let selectionWithoutFilters_topic3 = [];
-  let selectionWithoutFilters = {
-    topic0: topic0sOfSelectionsWithoutFilters,
-    topic1: selectionWithoutFilters_topic1,
-    topic2: selectionWithoutFilters_topic2,
-    topic3: selectionWithoutFilters_topic3
-  };
-  return [selectionWithoutFilters].concat(selectionsWithFilters);
-}
-
-function make(addresses, topicSelections) {
-  let topicSelections$1 = compressTopicSelections(topicSelections);
-  return {
-    addresses: addresses,
-    topicSelections: topicSelections$1
-  };
-}
-
 function materializeTopicFilter(filter, addresses) {
   if (filter.TAG === "Values") {
     return filter._0;
@@ -299,11 +230,6 @@ function parseWhereOrThrow(where, sighash, params, contractName, chainId, onEven
 }
 
 export {
-  MissingRequiredTopic0,
-  makeTopicSelection,
-  hasFilters,
-  compressTopicSelections,
-  make,
   materializeTopicFilter,
   materializeTopicSelections,
   eventBlockRangeSchema,

package/src/RawEvent.res

@@ -32,8 +32,8 @@ let make = (
   ~blockTimestamp: int,
   ~cleanUpRawEventFieldsInPlace: JSON.t => unit,
 ): Internal.rawEvent => {
-  let {onEventRegistration, chain, blockNumber, logIndex} = eventItem
-  let eventConfig = onEventRegistration.eventConfig
+  let {chain, blockNumber, logIndex} = eventItem
+  let eventConfig = eventItem.onEventRegistration.eventConfig
   let chainId = chain->ChainMap.Chain.toChainId
   let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
   let blockFields =

package/src/SimulateDeadInputTracker.res

@@ -10,7 +10,7 @@ let itemKey = (item: Internal.item): string =>
     `${chain
       ->ChainMap.Chain.toChainId
       ->Int.toString}:${blockNumber->Int.toString}:${logIndex->Int.toString}`
-  | _ => "" // non-event items are never a provided simulate input
+  | Internal.Block(_) => ""
   }
 
 // `index` is the item's position in its chain's `simulate` array, reported back

package/src/SimulateItems.res

@@ -240,9 +240,12 @@ let deriveSrcAddress = (
   }
 }
 
-let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Config.chain): array<
-  Internal.item,
-> => {
+let parse = (
+  ~simulateItems: array<JSON.t>,
+  ~config: Config.t,
+  ~chainConfig: Config.chain,
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+): array<Internal.item> => {
   let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
   let chainId = chainConfig.id
   let startBlock = chainConfig.startBlock
@@ -345,6 +348,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
         ~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(
@@ -382,7 +390,11 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
 
 // Apply simulate source config from processConfig JSON to a Config.t
 // This patches chainMap entries that have simulate items with CustomSources
-let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
+let patchConfig = (
+  ~config: Config.t,
+  ~processConfig: JSON.t,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
+): Config.t => {
   let processChains: option<dict<JSON.t>> =
     (processConfig->(Utils.magic: JSON.t => {..}))["chains"]->Nullable.toOption
   switch processChains {
@@ -395,11 +407,31 @@ let patchConfig = (~config: Config.t, ~processConfig: JSON.t): Config.t => {
         let simulateRaw: option<array<JSON.t>> = raw["simulate"]->Nullable.toOption
         switch simulateRaw {
         | Some(simulateItems) =>
-          let items = parse(~simulateItems, ~config, ~chainConfig)
+          let chainRegistrations = switch registrationsByChainId->Utils.Dict.dangerouslyGetNonOption(
+            chainIdStr,
+          ) {
+          | Some(registrations) => registrations
+          | None =>
+            let registrations: HandlerRegister.chainRegistrations = {
+              onEventRegistrations: [],
+              onBlockRegistrations: [],
+            }
+            registrationsByChainId->Dict.set(chainIdStr, registrations)
+            registrations
+          }
           let startBlock: int = raw["startBlock"]->(Utils.magic: 'a => int)
           let endBlock: int = raw["endBlock"]->(Utils.magic: 'a => int)
+          // Parse with the process's startBlock so items default into the range
+          // the source will be queried over; the source now filters by range.
+          let chainConfig = {...chainConfig, startBlock, endBlock}
+          let items = parse(
+            ~simulateItems,
+            ~config,
+            ~chainConfig,
+            ~onEventRegistrations=chainRegistrations.onEventRegistrations,
+          )
           let source = SimulateSource.make(~items, ~endBlock, ~chain)
-          {...chainConfig, startBlock, endBlock, sourceConfig: Config.CustomSources([source])}
+          {...chainConfig, sourceConfig: Config.CustomSources([source])}
         | None => chainConfig
         }
       | None => chainConfig

package/src/SimulateItems.res.mjs

@@ -167,7 +167,7 @@ function deriveSrcAddress(providedSrcAddress, eventConfig, chainConfig, config)
   }
 }
 
-function parse(simulateItems, config, chainConfig) {
+function parse(simulateItems, config, chainConfig, onEventRegistrations) {
   let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
   let chainId = chainConfig.id;
   let startBlock = chainConfig.startBlock;
@@ -254,9 +254,13 @@ function parse(simulateItems, config, chainConfig) {
       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: onEventRegistration,
+      onEventRegistration: newrecord,
       chain: chain,
       blockNumber: blockNumber,
       logIndex: logIndex,
@@ -276,7 +280,7 @@ function parse(simulateItems, config, chainConfig) {
   return items;
 }
 
-function patchConfig(config, processConfig) {
+function patchConfig(config, processConfig, registrationsByChainId) {
   let processChains = processConfig.chains;
   if (processChains == null) {
     return config;
@@ -291,18 +295,33 @@ function patchConfig(config, processConfig) {
     if (simulateRaw == null) {
       return chainConfig;
     }
-    let items = parse(simulateRaw, config, chainConfig);
+    let registrations = registrationsByChainId[chainIdStr];
+    let chainRegistrations;
+    if (registrations !== undefined) {
+      chainRegistrations = registrations;
+    } else {
+      let registrations_onEventRegistrations = [];
+      let registrations_onBlockRegistrations = [];
+      let registrations$1 = {
+        onEventRegistrations: registrations_onEventRegistrations,
+        onBlockRegistrations: registrations_onBlockRegistrations
+      };
+      registrationsByChainId[chainIdStr] = registrations$1;
+      chainRegistrations = registrations$1;
+    }
     let startBlock = processChainJson.startBlock;
     let endBlock = processChainJson.endBlock;
-    let source = SimulateSource.make(items, endBlock, chain);
     let newrecord = {...chainConfig};
-    newrecord.sourceConfig = {
+    newrecord.endBlock = endBlock;
+    newrecord.startBlock = startBlock;
+    let items = parse(simulateRaw, config, newrecord, chainRegistrations.onEventRegistrations);
+    let source = SimulateSource.make(items, endBlock, chain);
+    let newrecord$1 = {...newrecord};
+    newrecord$1.sourceConfig = {
       TAG: "CustomSources",
       _0: [source]
     };
-    newrecord.endBlock = endBlock;
-    newrecord.startBlock = startBlock;
-    return newrecord;
+    return newrecord$1;
   });
   return {
     name: config.name,

package/src/TestIndexer.res

@@ -863,8 +863,8 @@ let initTestWorker = () => {
     | Some(_) => ()
     }
 
-    let patchConfig = (config: Config.t, _registrations) => {
-      let config = SimulateItems.patchConfig(~config, ~processConfig)
+    let patchConfig = (config: Config.t, registrationsByChainId) => {
+      let config = SimulateItems.patchConfig(~config, ~processConfig, ~registrationsByChainId)
 
       // In auto-exit mode, set batchSize=1 to process one block checkpoint at a time
       if exitAfterFirstEventBlock {

package/src/TestIndexer.res.mjs

@@ -612,8 +612,8 @@ function initTestWorker() {
   } else {
     Logging.setLogLevel("silent");
   }
-  let patchConfig = (config, _registrations) => {
-    let config$1 = SimulateItems.patchConfig(config, processConfig);
+  let patchConfig = (config, registrationsByChainId) => {
+    let config$1 = SimulateItems.patchConfig(config, processConfig, registrationsByChainId);
     if (exitAfterFirstEventBlock) {
       return {
         name: config$1.name,

package/src/TopicFilter.res

@@ -1,27 +1,3 @@
-let toTwosComplement = (num: bigint, ~bytesLen: int) => {
-  let maxValue = 1n->BigInt.shiftLeft(BigInt.fromInt(bytesLen * 8))
-  let mask = maxValue->BigInt.sub(1n)
-  num->BigInt.add(maxValue)->BigInt.bitwiseAnd(mask)
-}
-
-let fromSignedBigInt = val => {
-  let bytesLen = 32
-  let val = val >= 0n ? val : val->toTwosComplement(~bytesLen)
-  val->Viem.bigintToHex(~options={size: bytesLen})
-}
-
 type hex = EvmTypes.Hex.t
-//bytes currently does not work with genType and we also currently generate bytes as a string type
-type bytesHex = string
-let keccak256 = Viem.keccak256
-let bytesToHex = Viem.bytesToHex
-let concat = Viem.concat
-let castToHexUnsafe: 'a => hex = val => val->(Utils.magic: 'a => hex)
-let fromBigInt: bigint => hex = val => val->Viem.bigintToHex(~options={size: 32})
-let fromDynamicString: string => hex = val => val->(Utils.magic: string => hex)->keccak256
-let fromString: string => hex = val => val->Viem.stringToHex(~options={size: 32})
+
 let fromAddress: Address.t => hex = addr => addr->(Utils.magic: Address.t => hex)->Viem.pad
-let fromDynamicBytes: bytesHex => hex = bytes => bytes->(Utils.magic: bytesHex => hex)->keccak256
-let fromBytes: bytesHex => hex = bytes =>
-  bytes->(Utils.magic: bytesHex => Uint8Array.t)->Viem.bytesToHex(~options={size: 32})
-let fromBool: bool => hex = b => b->Viem.boolToHex(~options={size: 32})

package/src/TopicFilter.res.mjs

@@ -1,86 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Viem from "viem";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-
-function toTwosComplement(num, bytesLen) {
-  let maxValue = (1n << BigInt((bytesLen << 3)));
-  let mask = maxValue - 1n;
-  return num + maxValue & mask;
-}
-
-function fromSignedBigInt(val) {
-  let val$1 = val >= 0n ? val : toTwosComplement(val, 32);
-  return Viem.numberToHex(val$1, {
-    size: 32
-  });
-}
-
-function keccak256(prim) {
-  return Viem.keccak256(prim);
-}
-
-function bytesToHex(prim0, prim1) {
-  return Viem.bytesToHex(prim0, prim1 !== undefined ? Primitive_option.valFromOption(prim1) : undefined);
-}
-
-function concat(prim) {
-  return Viem.concat(prim);
-}
-
-function castToHexUnsafe(val) {
-  return val;
-}
-
-function fromBigInt(val) {
-  return Viem.numberToHex(val, {
-    size: 32
-  });
-}
-
-function fromDynamicString(val) {
-  return Viem.keccak256(val);
-}
-
-function fromString(val) {
-  return Viem.stringToHex(val, {
-    size: 32
-  });
-}
 
 function fromAddress(addr) {
   return Viem.pad(addr);
 }
 
-function fromDynamicBytes(bytes) {
-  return Viem.keccak256(bytes);
-}
-
-function fromBytes(bytes) {
-  return Viem.bytesToHex(bytes, {
-    size: 32
-  });
-}
-
-function fromBool(b) {
-  return Viem.boolToHex(b, {
-    size: 32
-  });
-}
-
 export {
-  toTwosComplement,
-  fromSignedBigInt,
-  keccak256,
-  bytesToHex,
-  concat,
-  castToHexUnsafe,
-  fromBigInt,
-  fromDynamicString,
-  fromString,
   fromAddress,
-  fromDynamicBytes,
-  fromBytes,
-  fromBool,
 }
 /* viem Not a pure module */

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/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 */

package/src/sources/EvmRpcClient.res

@@ -10,26 +10,23 @@ type cfg = {
   queryTimeoutMillis: int,
 }
 
-// Decoded `params` keyed by contract name, matching the HyperSync decoder's
-// shape so the caller routes by address then picks its contract's params.
+// Only logs that resolved to a registration cross the boundary, each carrying
+// its registration's chain-scoped index.
 type rpcEventItem = {
   log: Rpc.GetLogs.log,
-  params: Nullable.t<dict<Internal.eventParams>>,
-}
-
-// `addresses` omitted matches any address (a wildcard selection). Each `topics`
-// position is `null` (match any) or a list of accepted topic hashes; the
-// single-match case is a one-element list.
-type logSelectionInput = {
-  addresses?: array<Address.t>,
-  topics: array<Nullable.t<array<string>>>,
+  onEventRegistrationIndex: int,
+  params: Internal.eventParams,
 }
 
 type nextPageParams = {
   fromBlock: int,
   toBlockCeiling: int,
-  logSelections: array<logSelectionInput>,
   partitionId: string,
+  // The partition's registration selection, by chain-scoped index. Log
+  // selections and the routing index are derived on the Rust side from the
+  // registrations passed at construction.
+  registrationIndexes: array<int>,
+  addressesByContractName: dict<array<Address.t>>,
 }
 
 type nextPageResponse = {
@@ -48,7 +45,7 @@ type t = {
 external classNew: (
   Core.evmRpcClientCtor,
   cfg,
-  array<HyperSyncClient.Decoder.eventParamsInput>,
+  array<HyperSyncClient.Registration.input>,
   ~checksumAddresses: bool,
 ) => t = "new"
 
@@ -87,7 +84,7 @@ let make = (
   ~syncConfig: Config.sourceSync,
   ~httpReqTimeoutMillis=?,
   ~headers=?,
-  ~allEventParams=[],
+  ~eventRegistrations=[],
 ) => {
   let client = Core.getAddon().evmRpcClient->classNew(
     {
@@ -101,7 +98,7 @@ let make = (
       backoffMillis: syncConfig.backoffMillis,
       queryTimeoutMillis: syncConfig.queryTimeoutMillis,
     },
-    allEventParams,
+    eventRegistrations,
     ~checksumAddresses,
   )
   {

package/src/sources/EvmRpcClient.res.mjs

@@ -46,8 +46,8 @@ function coerceErrorOrThrow(exn) {
   throw exn;
 }
 
-function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, allEventParamsOpt) {
-  let allEventParams = allEventParamsOpt !== undefined ? allEventParamsOpt : [];
+function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, eventRegistrationsOpt) {
+  let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let client = Core.getAddon().EvmRpcClient.new({
     url: url,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
@@ -58,7 +58,7 @@ function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers,
     intervalCeiling: syncConfig.intervalCeiling,
     backoffMillis: syncConfig.backoffMillis,
     queryTimeoutMillis: syncConfig.queryTimeoutMillis
-  }, allEventParams, checksumAddresses);
+  }, eventRegistrations, checksumAddresses);
   return {
     getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow),
     getNextPage: params => Stdlib_Promise.$$catch(client.getNextPage(params), coerceErrorOrThrow)