envio 3.3.0-alpha.10 → 3.3.0-alpha.12

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)

package/src/sources/HyperSync.res

@@ -61,23 +61,6 @@ module GetLogs = {
 
   exception Error(error)
 
-  let makeRequestBody = (
-    ~fromBlock,
-    ~toBlockInclusive,
-    ~addressesWithTopics,
-    ~fieldSelection,
-    ~maxNumLogs,
-  ): HyperSyncClient.QueryTypes.query => {
-    fromBlock,
-    toBlockExclusive: ?switch toBlockInclusive {
-    | Some(toBlockInclusive) => Some(toBlockInclusive + 1)
-    | None => None
-    },
-    logs: addressesWithTopics,
-    fieldSelection,
-    maxNumLogs,
-  }
-
   // Rust encodes structured failures as a JSON payload in the napi error's
   // message: `{"kind":"MissingFields","fields":["block.timestamp", ...]}`.
   // JSON.parse + shape check is the recovery protocol — no string-grepping
@@ -107,29 +90,17 @@ module GetLogs = {
     ~client: HyperSyncClient.t,
     ~fromBlock,
     ~toBlock,
-    ~logSelections: array<LogSelection.t>,
-    ~fieldSelection,
     ~maxNumLogs,
+    ~registrationIndexes,
+    ~addressesByContractName,
   ): logsQueryPage => {
-    let addressesWithTopics = logSelections->Array.flatMap(({addresses, topicSelections}) =>
-      topicSelections->Array.map(({topic0, topic1, topic2, topic3}) => {
-        let topics = HyperSyncClient.QueryTypes.makeTopicSelection(
-          ~topic0,
-          ~topic1,
-          ~topic2,
-          ~topic3,
-        )
-        HyperSyncClient.QueryTypes.makeLogSelection(~address=addresses, ~topics)
-      })
-    )
-
-    let query = makeRequestBody(
-      ~fromBlock,
-      ~toBlockInclusive=toBlock,
-      ~addressesWithTopics,
-      ~fieldSelection,
-      ~maxNumLogs,
-    )
+    let query: HyperSyncClient.EventItems.query = {
+      fromBlock,
+      toBlock,
+      maxNumLogs,
+      registrationIndexes,
+      addressesByContractName,
+    }
 
     let (res, transactionStore, blockStore) = switch await client.getEventItems(~query) {
     | res => res

package/src/sources/HyperSync.res.mjs

@@ -12,7 +12,6 @@ import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function reraisIfRateLimited(exn) {
@@ -62,16 +61,6 @@ function mapExn(queryResponse) {
 
 let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperSync.GetLogs.Error");
 
-function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, fieldSelection, maxNumLogs) {
-  return {
-    fromBlock: fromBlock,
-    toBlock: toBlockInclusive !== undefined ? toBlockInclusive + 1 | 0 : undefined,
-    logs: addressesWithTopics,
-    fieldSelection: fieldSelection,
-    maxNumLogs: maxNumLogs
-  };
-}
-
 function extractMissingParams(exn) {
   let message = exn.RE_EXN_ID === "JsExn" ? Stdlib_JsExn.message(exn._1) : undefined;
   if (message === undefined) {
@@ -93,15 +82,14 @@ function extractMissingParams(exn) {
   }
 }
 
-async function query(client, fromBlock, toBlock, logSelections, fieldSelection, maxNumLogs) {
-  let addressesWithTopics = logSelections.flatMap(param => {
-    let addresses = param.addresses;
-    return param.topicSelections.map(param => {
-      let topics = HyperSyncClient.QueryTypes.makeTopicSelection(param.topic0, param.topic1, param.topic2, param.topic3);
-      return HyperSyncClient.QueryTypes.makeLogSelection(addresses, topics);
-    });
-  });
-  let query$1 = makeRequestBody(fromBlock, toBlock, addressesWithTopics, fieldSelection, maxNumLogs);
+async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes, addressesByContractName) {
+  let query$1 = {
+    fromBlock: fromBlock,
+    toBlock: toBlock,
+    maxNumLogs: maxNumLogs,
+    registrationIndexes: registrationIndexes,
+    addressesByContractName: addressesByContractName
+  };
   let match;
   try {
     match = await client.getEventItems(query$1);
@@ -140,7 +128,13 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
   };
 }
 
-function makeRequestBody$1(fromBlock, toBlock) {
+let GetLogs = {
+  $$Error: $$Error,
+  extractMissingParams: extractMissingParams,
+  query: query
+};
+
+function makeRequestBody(fromBlock, toBlock) {
   return {
     fromBlock: fromBlock,
     toBlock: toBlock + 1 | 0,
@@ -193,7 +187,7 @@ function convertResponse(res) {
 }
 
 async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger, requestStats) {
-  let body = makeRequestBody$1(fromBlock, toBlock);
+  let body = makeRequestBody(fromBlock, toBlock);
   let logger$1 = Logging.createChildFrom(logger, {
     logType: "HyperSync get block hash query",
     fromBlock: fromBlock,
@@ -282,12 +276,6 @@ function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
   ]);
 }
 
-let GetLogs = {
-  $$Error: $$Error,
-  extractMissingParams: extractMissingParams,
-  query: query
-};
-
 export {
   queryErrorToMsq,
   GetLogs,

package/src/sources/HyperSync.resi

@@ -32,9 +32,9 @@ module GetLogs: {
     ~client: HyperSyncClient.t,
     ~fromBlock: int,
     ~toBlock: option<int>,
-    ~logSelections: array<LogSelection.t>,
-    ~fieldSelection: HyperSyncClient.QueryTypes.fieldSelection,
     ~maxNumLogs: int,
+    ~registrationIndexes: array<int>,
+    ~addressesByContractName: dict<array<Address.t>>,
   ) => promise<logsQueryPage>
 }
 

package/src/sources/HyperSyncClient.res

@@ -229,29 +229,106 @@ type queryResponse = {
   rollbackGuard: option<ResponseTypes.rollbackGuard>,
 }
 
-module Decoder = {
-  type eventParamsInput = {
+module Registration = {
+  // One topic position of the resolved `where`: static topic values, or
+  // `None` — the "currently registered addresses of this contract" marker,
+  // expanded to padded address topics when Rust builds a query.
+  type topicFilterInput = option<array<string>>
+
+  type topicSelectionInput = {
+    topic0: array<string>,
+    topic1: topicFilterInput,
+    topic2: topicFilterInput,
+    topic3: topicFilterInput,
+  }
+
+  // The full per-(event, chain) registration passed to the Rust clients at
+  // construction: decode metadata, routing identity, and the fetch state
+  // queries are built from.
+  type input = {
+    // Chain-scoped sequential registration index, echoed back on routed items.
+    index: int,
     sighash: string,
     topicCount: int,
     eventName: string,
     contractName: string,
+    isWildcard: bool,
+    dependsOnAddresses: bool,
     params: array<Internal.paramMeta>,
+    topicSelections: array<topicSelectionInput>,
+    // Capitalized field names matching the Rust BlockField/TransactionField
+    // string enums.
+    blockFields: array<string>,
+    transactionFields: array<string>,
+  }
+
+  let toTopicFilterInput = (filter: Internal.topicFilter): topicFilterInput =>
+    switch filter {
+    | Values(values) => Some(values->EvmTypes.Hex.toStrings)
+    | ContractAddresses(_) => None
+    }
+
+  let fromOnEventRegistrations = (
+      onEventRegistrations: array<Internal.evmOnEventRegistration>,
+    ): array<input> => {
+    onEventRegistrations->Array.map(reg => {
+      let event = reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
+      {
+        index: reg.index,
+        sighash: event.sighash,
+        topicCount: event.topicCount,
+        eventName: event.name,
+        contractName: event.contractName,
+        isWildcard: reg.isWildcard,
+        dependsOnAddresses: reg.dependsOnAddresses,
+        params: event.paramsMetadata,
+        topicSelections: reg.resolvedWhere.topicSelections->Array.map((
+          ts
+        ): topicSelectionInput => {
+          topic0: ts.topic0->EvmTypes.Hex.toStrings,
+          topic1: ts.topic1->toTopicFilterInput,
+          topic2: ts.topic2->toTopicFilterInput,
+          topic3: ts.topic3->toTopicFilterInput,
+        }),
+        // Capitalized to match the Rust BlockField/TransactionField string
+        // enums.
+        blockFields: event.selectedBlockFields
+        ->Utils.Set.toArray
+        ->Array.map(name => (name :> string)->Utils.String.capitalize),
+        transactionFields: event.selectedTransactionFields
+        ->Utils.Set.toArray
+        ->Array.map(name => (name :> string)->Utils.String.capitalize),
+      }
+    })
   }
 }
 
 module EventItems = {
+  // The whole per-query input: block range, the partition's registration
+  // selection (by id), and its current addresses. Log selections, field
+  // selection, and the routing index are derived on the Rust side.
+  type query = {
+    fromBlock: int,
+    // Inclusive; None queries to the end of available data.
+    toBlock: option<int>,
+    maxNumLogs: int,
+    registrationIndexes: array<int>,
+    addressesByContractName: dict<array<Address.t>>,
+  }
+
   type item = {
     logIndex: int,
     srcAddress: Address.t,
-    topic0: EvmTypes.Hex.t,
-    topicCount: int,
     // Number of the block this log belongs to; the block itself is resolved from
     // `response.blocks`, deduplicated across items sharing a block.
     blockNumber: int,
     // Key (with the block number) into the transaction store; the transaction
     // is resolved from the store on demand.
     transactionIndex: int,
-    params: Nullable.t<dict<Internal.eventParams>>,
+    // The registration this log routed to, by chain-scoped index. Logs that
+    // route to no registration never cross the boundary.
+    onEventRegistrationIndex: int,
+    params: Internal.eventParams,
   }
 
   // The always-needed block fields, one per block number. The block's remaining
@@ -277,7 +354,7 @@ type t = {
   // Returns the response plus page stores owning this page's raw transactions
   // and blocks.
   getEventItems: (
-    ~query: query,
+    ~query: EventItems.query,
   ) => promise<(EventItems.response, TransactionStore.t, BlockStore.t)>,
   getHeight: unit => promise<int>,
 }
@@ -287,11 +364,11 @@ external classNew: (
   Core.evmHypersyncClientCtor,
   cfg,
   string,
-  array<Decoder.eventParamsInput>,
+  array<Registration.input>,
 ) => t = "new"
 
-let makeWithAgent = (cfg, ~userAgent, ~eventParams) =>
-  Core.getAddon().evmHypersyncClient->classNew(cfg, userAgent, eventParams)
+let makeWithAgent = (cfg, ~userAgent, ~eventRegistrations) =>
+  Core.getAddon().evmHypersyncClient->classNew(cfg, userAgent, eventRegistrations)
 
 type logLevel = [#trace | #debug | #info | #warn | #error]
 let logLevelSchema: S.t<logLevel> = S.enum([#trace, #debug, #info, #warn, #error])
@@ -309,7 +386,7 @@ let make = (
   ~url,
   ~apiToken,
   ~httpReqTimeoutMillis,
-  ~eventParams,
+  ~eventRegistrations,
   ~enableChecksumAddresses=true,
   ~serializationFormat=?,
   ~enableQueryCaching=?,
@@ -335,6 +412,6 @@ let make = (
       logLevel: logLevelToString(logLevel),
     },
     ~userAgent=`hyperindex/${envioVersion}`,
-    ~eventParams,
+    ~eventRegistrations,
   )
 }

package/src/sources/HyperSyncClient.res.mjs

@@ -36,12 +36,45 @@ let QueryTypes = {
 
 let ResponseTypes = {};
 
-let Decoder = {};
+function toTopicFilterInput(filter) {
+  if (filter.TAG === "Values") {
+    return filter._0;
+  }
+}
+
+function fromOnEventRegistrations(onEventRegistrations) {
+  return onEventRegistrations.map(reg => {
+    let event = reg.eventConfig;
+    return {
+      index: reg.index,
+      sighash: event.sighash,
+      topicCount: event.topicCount,
+      eventName: event.name,
+      contractName: event.contractName,
+      isWildcard: reg.isWildcard,
+      dependsOnAddresses: reg.dependsOnAddresses,
+      params: event.paramsMetadata,
+      topicSelections: reg.resolvedWhere.topicSelections.map(ts => ({
+        topic0: ts.topic0,
+        topic1: toTopicFilterInput(ts.topic1),
+        topic2: toTopicFilterInput(ts.topic2),
+        topic3: toTopicFilterInput(ts.topic3)
+      })),
+      blockFields: Array.from(event.selectedBlockFields).map(name => Utils.$$String.capitalize(name)),
+      transactionFields: Array.from(event.selectedTransactionFields).map(name => Utils.$$String.capitalize(name))
+    };
+  });
+}
+
+let Registration = {
+  toTopicFilterInput: toTopicFilterInput,
+  fromOnEventRegistrations: fromOnEventRegistrations
+};
 
 let EventItems = {};
 
-function makeWithAgent(cfg, userAgent, eventParams) {
-  return Core.getAddon().EvmHypersyncClient.new(cfg, userAgent, eventParams);
+function makeWithAgent(cfg, userAgent, eventRegistrations) {
+  return Core.getAddon().EvmHypersyncClient.new(cfg, userAgent, eventRegistrations);
 }
 
 let logLevelSchema = S$RescriptSchema.$$enum([
@@ -66,7 +99,7 @@ function logLevelToString(level) {
   }
 }
 
-function make(url, apiToken, httpReqTimeoutMillis, eventParams, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs, logLevelOpt) {
+function make(url, apiToken, httpReqTimeoutMillis, eventRegistrations, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs, logLevelOpt) {
   let enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
   let logLevel = logLevelOpt !== undefined ? logLevelOpt : "info";
   let envioVersion = Utils.EnvioPackage.value.version;
@@ -82,14 +115,14 @@ function make(url, apiToken, httpReqTimeoutMillis, eventParams, enableChecksumAd
     serializationFormat: serializationFormat,
     enableQueryCaching: enableQueryCaching,
     logLevel: logLevelToString(logLevel)
-  }, `hyperindex/` + envioVersion, eventParams);
+  }, `hyperindex/` + envioVersion, eventRegistrations);
 }
 
 export {
   serializationFormatSchema,
   QueryTypes,
   ResponseTypes,
-  Decoder,
+  Registration,
   EventItems,
   makeWithAgent,
   logLevelSchema,