envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/sources/HyperSync.res.mjs

@@ -4,15 +4,14 @@ import * as Time from "../Time.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as Prometheus from "../Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 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,15 +61,6 @@ function mapExn(queryResponse) {
 
 let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperSync.GetLogs.Error");
 
-function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, fieldSelection) {
-  return {
-    fromBlock: fromBlock,
-    toBlock: toBlockInclusive !== undefined ? toBlockInclusive + 1 | 0 : undefined,
-    logs: addressesWithTopics,
-    fieldSelection: fieldSelection
-  };
-}
-
 function extractMissingParams(exn) {
   let message = exn.RE_EXN_ID === "JsExn" ? Stdlib_JsExn.message(exn._1) : undefined;
   if (message === undefined) {
@@ -92,18 +82,17 @@ function extractMissingParams(exn) {
   }
 }
 
-async function query(client, fromBlock, toBlock, logSelections, fieldSelection) {
-  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);
-  let res;
+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 {
-    res = await client.getEventItems(query$1);
+    match = await client.getEventItems(query$1);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     reraisIfRateLimited(exn);
@@ -120,6 +109,7 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection)
     }
     throw exn;
   }
+  let res = match[0];
   if (res.nextBlock <= fromBlock) {
     throw {
       RE_EXN_ID: $$Error,
@@ -129,13 +119,22 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection)
   }
   return {
     items: res.items,
+    blocks: res.blocks,
     nextBlock: res.nextBlock,
     archiveHeight: Stdlib_Option.getOr(res.archiveHeight, 0),
-    rollbackGuard: res.rollbackGuard
+    rollbackGuard: res.rollbackGuard,
+    transactionStore: match[1],
+    blockStore: match[2]
   };
 }
 
-function makeRequestBody$1(fromBlock, toBlock) {
+let GetLogs = {
+  $$Error: $$Error,
+  extractMissingParams: extractMissingParams,
+  query: query
+};
+
+function makeRequestBody(fromBlock, toBlock) {
   return {
     fromBlock: fromBlock,
     toBlock: toBlock + 1 | 0,
@@ -187,14 +186,14 @@ function convertResponse(res) {
   }));
 }
 
-async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger) {
-  let body = makeRequestBody$1(fromBlock, toBlock);
+async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger, requestStats) {
+  let body = makeRequestBody(fromBlock, toBlock);
   let logger$1 = Logging.createChildFrom(logger, {
     logType: "HyperSync get block hash query",
     fromBlock: fromBlock,
     toBlock: toBlock
   });
-  Prometheus.SourceRequestCount.increment(sourceName, chainId, "getBlockHashes");
+  let timerRef = Performance.now();
   let maybeSuccessfulRes;
   let exit = 0;
   let res;
@@ -209,6 +208,10 @@ async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, l
   if (exit === 1) {
     maybeSuccessfulRes = res.nextBlock <= fromBlock ? undefined : res;
   }
+  requestStats.push({
+    method: "getBlockHashes",
+    seconds: Performance.secondsSince(timerRef)
+  });
   if (maybeSuccessfulRes !== undefined) {
     let err = convertResponse(maybeSuccessfulRes);
     if (err.TAG !== "Ok") {
@@ -218,56 +221,61 @@ async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, l
       return err;
     }
     let datas = err._0;
-    let restRes = await queryBlockData(client, maybeSuccessfulRes.nextBlock, toBlock, sourceName, chainId, logger$1);
+    let restRes = await queryBlockData(client, maybeSuccessfulRes.nextBlock, toBlock, sourceName, chainId, logger$1, requestStats);
     return Stdlib_Result.map(restRes, rest => datas.concat(rest));
   }
   Logging.childInfo(logger$1, `Block #` + fromBlock.toString() + ` not found in HyperSync. HyperSync has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ` + (100).toString() + `ms.`);
   await Time.resolvePromiseAfterDelay(100);
-  return await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger$1);
+  return await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger$1, requestStats);
 }
 
 async function queryBlockDataMulti(client, blockNumbers, sourceName, chainId, logger) {
+  let requestStats = [];
   let firstBlock = blockNumbers[0];
-  if (firstBlock === undefined) {
-    return {
+  let result;
+  if (firstBlock !== undefined) {
+    let fromBlock = firstBlock;
+    let toBlock = firstBlock;
+    let set = new Set();
+    for (let idx = 0, idx_finish = blockNumbers.length; idx < idx_finish; ++idx) {
+      let blockNumber = blockNumbers[idx];
+      if (blockNumber < fromBlock) {
+        fromBlock = blockNumber;
+      }
+      if (blockNumber > toBlock) {
+        toBlock = blockNumber;
+      }
+      set.add(blockNumber);
+    }
+    if ((toBlock - fromBlock | 0) > 1000) {
+      Stdlib_JsError.throwWithMessage(`Invalid block data request. Range of block numbers is too large. Max range is 1000. Requested range: ` + fromBlock.toString() + `-` + toBlock.toString());
+    }
+    let res = await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger, requestStats);
+    let filtered = Stdlib_Result.map(res, datas => datas.filter(data => set.delete(data.blockNumber)));
+    if (set.size > 0) {
+      Stdlib_JsError.throwWithMessage(`Invalid response. Failed to get block data for block numbers: ` + Array.from(set).join(", "));
+    }
+    result = filtered;
+  } else {
+    result = {
       TAG: "Ok",
       _0: []
     };
   }
-  let fromBlock = firstBlock;
-  let toBlock = firstBlock;
-  let set = new Set();
-  for (let idx = 0, idx_finish = blockNumbers.length; idx < idx_finish; ++idx) {
-    let blockNumber = blockNumbers[idx];
-    if (blockNumber < fromBlock) {
-      fromBlock = blockNumber;
-    }
-    if (blockNumber > toBlock) {
-      toBlock = blockNumber;
-    }
-    set.add(blockNumber);
-  }
-  if ((toBlock - fromBlock | 0) > 1000) {
-    Stdlib_JsError.throwWithMessage(`Invalid block data request. Range of block numbers is too large. Max range is 1000. Requested range: ` + fromBlock.toString() + `-` + toBlock.toString());
-  }
-  let res = await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger);
-  let filtered = Stdlib_Result.map(res, datas => datas.filter(data => set.delete(data.blockNumber)));
-  if (set.size > 0) {
-    Stdlib_JsError.throwWithMessage(`Invalid response. Failed to get block data for block numbers: ` + Array.from(set).join(", "));
-  }
-  return filtered;
+  return [
+    result,
+    requestStats
+  ];
 }
 
 function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
-  return queryBlockData(client, blockNumber, blockNumber, sourceName, chainId, logger).then(res => Stdlib_Result.map(res, res => res[0]));
+  let requestStats = [];
+  return queryBlockData(client, blockNumber, blockNumber, sourceName, chainId, logger, requestStats).then(res => [
+    Stdlib_Result.map(res, res => res[0]),
+    requestStats
+  ]);
 }
 
-let GetLogs = {
-  $$Error: $$Error,
-  extractMissingParams: extractMissingParams,
-  query: query
-};
-
 export {
   queryErrorToMsq,
   GetLogs,

package/src/sources/HyperSync.resi

@@ -1,8 +1,11 @@
 type logsQueryPage = {
   items: array<HyperSyncClient.EventItems.item>,
+  blocks: array<HyperSyncClient.EventItems.blockHeader>,
   nextBlock: int,
   archiveHeight: int,
   rollbackGuard: option<HyperSyncClient.ResponseTypes.rollbackGuard>,
+  transactionStore: TransactionStore.t,
+  blockStore: BlockStore.t,
 }
 
 type missingParams = {
@@ -29,8 +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>
 }
 
@@ -40,7 +44,10 @@ let queryBlockData: (
   ~sourceName: string,
   ~chainId: int,
   ~logger: Pino.t,
-) => promise<queryResponse<option<ReorgDetection.blockDataWithTimestamp>>>
+) => promise<(
+  queryResponse<option<ReorgDetection.blockDataWithTimestamp>>,
+  array<Source.requestStat>,
+)>
 
 let queryBlockDataMulti: (
   ~client: HyperSyncClient.t,
@@ -48,6 +55,9 @@ let queryBlockDataMulti: (
   ~sourceName: string,
   ~chainId: int,
   ~logger: Pino.t,
-) => promise<queryResponse<array<ReorgDetection.blockDataWithTimestamp>>>
+) => promise<(
+  queryResponse<array<ReorgDetection.blockDataWithTimestamp>>,
+  array<Source.requestStat>,
+)>
 
 let mapExn: queryResponse<'a> => result<'a, exn>

package/src/sources/HyperSyncClient.res

@@ -208,90 +208,6 @@ module ResponseTypes = {
     mixHash?: string,
   }
 
-  type accessList = {
-    address?: Address.t,
-    storageKeys?: array<string>,
-  }
-
-  let accessListSchema = S.object(s => {
-    address: ?s.field("address", S.option(Address.schema)),
-    storageKeys: ?s.field("storageKeys", S.option(S.array(S.string))),
-  })
-
-  type authorizationList = {
-    chainId: bigint,
-    address: Address.t,
-    nonce: int,
-    yParity: [#0 | #1],
-    r: string,
-    s: string,
-  }
-
-  let authorizationListSchema = S.object(s => {
-    chainId: s.field("chainId", S.bigint),
-    address: s.field("address", Address.schema),
-    nonce: s.field("nonce", S.int),
-    yParity: s.field("yParity", S.enum([#0, #1])),
-    r: s.field("r", S.string),
-    s: s.field("s", S.string),
-  })
-
-  type transaction = {
-    blockHash?: string,
-    blockNumber?: int,
-    from?: string,
-    gas?: bigint,
-    gasPrice?: bigint,
-    hash?: string,
-    input?: string,
-    nonce?: bigint,
-    to?: string,
-    transactionIndex?: int,
-    value?: bigint,
-    v?: string,
-    r?: string,
-    s?: string,
-    yParity?: string,
-    maxPriorityFeePerGas?: bigint,
-    maxFeePerGas?: bigint,
-    chainId?: int,
-    accessList?: array<accessList>,
-    maxFeePerBlobGas?: bigint,
-    blobVersionedHashes?: array<string>,
-    cumulativeGasUsed?: bigint,
-    effectiveGasPrice?: bigint,
-    gasUsed?: bigint,
-    contractAddress?: string,
-    logsBloom?: string,
-    @as("type") type_?: int,
-    root?: string,
-    status?: int,
-    l1Fee?: bigint,
-    l1GasPrice?: bigint,
-    l1GasUsed?: bigint,
-    l1FeeScalar?: float,
-    gasUsedForL1?: bigint,
-    authorizationList?: array<authorizationList>,
-  }
-
-  type log = {
-    removed?: bool,
-    @as("logIndex") index?: int,
-    transactionIndex?: int,
-    transactionHash?: string,
-    blockHash?: string,
-    blockNumber?: int,
-    address?: Address.t,
-    data?: string,
-    topics?: array<Nullable.t<EvmTypes.Hex.t>>,
-  }
-
-  type event = {
-    transaction?: transaction,
-    block?: block,
-    log: log,
-  }
-
   type rollbackGuard = {
     blockNumber: int,
     timestamp: int,
@@ -303,11 +219,7 @@ module ResponseTypes = {
 
 type query = QueryTypes.query
 
-type queryResponseData = {
-  blocks: array<ResponseTypes.block>,
-  transactions: array<ResponseTypes.transaction>,
-  logs: array<ResponseTypes.log>,
-}
+type queryResponseData = {blocks: array<ResponseTypes.block>}
 
 type queryResponse = {
   archiveHeight: option<int>,
@@ -317,49 +229,121 @@ 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>,
   }
 
-  // Decoded params keyed by contract name. Contracts that emit the same-signature
-  // event share one decode but get their own param names, so the caller picks the
-  // entry for the contract its router resolved the log to.
-  type tWithParams = {
-    decodeLogs: array<ResponseTypes.event> => promise<
-      array<Nullable.t<dict<Internal.eventParams>>>,
-    >,
+  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),
+      }
+    })
   }
-
-  @send
-  external classFromParams: (
-    Core.evmDecoderCtor,
-    array<eventParamsInput>,
-    ~checksumAddresses: bool=?,
-  ) => tWithParams = "fromParams"
-
-  let fromParams = (eventParams, ~checksumAddresses=?) =>
-    Core.getAddon().evmDecoder->classFromParams(eventParams, ~checksumAddresses?)
 }
 
 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,
-    block: ResponseTypes.block,
-    transaction: ResponseTypes.transaction,
-    params: Nullable.t<dict<Internal.eventParams>>,
+    // 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,
+    // 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
+  // fields live raw in the block store and are materialised on demand.
+  type blockHeader = {
+    number: int,
+    timestamp: int,
+    hash: string,
   }
 
   type response = {
     archiveHeight: option<int>,
     nextBlock: int,
+    // One header per block number referenced by `items`.
+    blocks: array<blockHeader>,
     items: array<item>,
     rollbackGuard: option<ResponseTypes.rollbackGuard>,
   }
@@ -367,7 +351,11 @@ module EventItems = {
 
 type t = {
   get: (~query: query) => promise<queryResponse>,
-  getEventItems: (~query: query) => promise<EventItems.response>,
+  // Returns the response plus page stores owning this page's raw transactions
+  // and blocks.
+  getEventItems: (
+    ~query: EventItems.query,
+  ) => promise<(EventItems.response, TransactionStore.t, BlockStore.t)>,
   getHeight: unit => promise<int>,
 }
 
@@ -376,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])
@@ -398,7 +386,7 @@ let make = (
   ~url,
   ~apiToken,
   ~httpReqTimeoutMillis,
-  ~eventParams,
+  ~eventRegistrations,
   ~enableChecksumAddresses=true,
   ~serializationFormat=?,
   ~enableQueryCaching=?,
@@ -424,6 +412,6 @@ let make = (
       logLevel: logLevelToString(logLevel),
     },
     ~userAgent=`hyperindex/${envioVersion}`,
-    ~eventParams,
+    ~eventRegistrations,
   )
 }

package/src/sources/HyperSyncClient.res.mjs

@@ -2,8 +2,6 @@
 
 import * as Core from "../Core.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Address from "../Address.res.mjs";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 let serializationFormatSchema = S$RescriptSchema.$$enum([
@@ -36,40 +34,47 @@ let QueryTypes = {
   makeLogSelection: makeLogSelection
 };
 
-let accessListSchema = S$RescriptSchema.object(s => ({
-  address: s.f("address", S$RescriptSchema.option(Address.schema)),
-  storageKeys: s.f("storageKeys", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string)))
-}));
+let ResponseTypes = {};
 
-let authorizationListSchema = S$RescriptSchema.object(s => ({
-  chainId: s.f("chainId", S$RescriptSchema.bigint),
-  address: s.f("address", Address.schema),
-  nonce: s.f("nonce", S$RescriptSchema.int),
-  yParity: s.f("yParity", S$RescriptSchema.$$enum([
-    0,
-    1
-  ])),
-  r: s.f("r", S$RescriptSchema.string),
-  s: s.f("s", S$RescriptSchema.string)
-}));
-
-let ResponseTypes = {
-  accessListSchema: accessListSchema,
-  authorizationListSchema: authorizationListSchema
-};
+function toTopicFilterInput(filter) {
+  if (filter.TAG === "Values") {
+    return filter._0;
+  }
+}
 
-function fromParams(eventParams, checksumAddresses) {
-  return Core.getAddon().EvmDecoder.fromParams(eventParams, checksumAddresses !== undefined ? Primitive_option.valFromOption(checksumAddresses) : undefined);
+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 Decoder = {
-  fromParams: fromParams
+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([
@@ -94,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;
@@ -110,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,

package/src/sources/HyperSyncHeightStream.res

@@ -35,8 +35,7 @@ let subscribe = (~hyperSyncUrl, ~apiToken, ~chainId, ~onHeight: int => unit): (u
   and scheduleReconnect = () => {
     // Clear any pending stale/reconnect timeout to avoid double reconnect
     timeoutIdRef.contents->clearTimeout
-    let delay =
-      baseDuration * Math.pow(2.0, ~exp=errorCount.contents->Int.toFloat)->Float.toInt
+    let delay = baseDuration * Math.pow(2.0, ~exp=errorCount.contents->Int.toFloat)->Float.toInt
     timeoutIdRef := setTimeout(() => refreshEventSource(), Pervasives.min(delay, 60_000))
   }
   and refreshEventSource = () => {
@@ -102,12 +101,6 @@ let subscribe = (~hyperSyncUrl, ~apiToken, ~chainId, ~onHeight: int => unit): (u
     es->EventSource.addEventListener("height", event => {
       switch event.data->Int.fromString {
       | Some(height) =>
-        // Track the SSE height event
-        Prometheus.SourceRequestCount.increment(
-          ~sourceName="HyperSync",
-          ~chainId,
-          ~method="heightStream",
-        )
         // On a successful height event, update the timeout
         updateTimeoutId()
         // Call the callback with the new height