envio 3.3.0-alpha.9 → 3.3.0

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,

package/src/sources/HyperSyncSource.res

@@ -1,123 +1,5 @@
 open Source
 
-type selectionConfig = {
-  getLogSelectionOrThrow: (
-    ~addressesByContractName: dict<array<Address.t>>,
-  ) => array<LogSelection.t>,
-  fieldSelection: HyperSyncClient.QueryTypes.fieldSelection,
-}
-
-let getSelectionConfig = (selection: FetchState.selection) => {
-  let capitalizedBlockFields = Utils.Set.make()
-  let capitalizedTransactionFields = Utils.Set.make()
-
-  let topicSelectionsByContract = Dict.make()
-  let wildcardTopicSelectionsByContract = Dict.make()
-  let noAddressesTopicSelections = []
-  let contractNames = Utils.Set.make()
-
-  selection.onEventRegistrations
-  ->(Utils.magic: array<Internal.onEventRegistration> => array<Internal.evmOnEventRegistration>)
-  ->Array.forEach(reg => {
-    let eventConfig =
-      reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
-    let contractName = eventConfig.contractName
-    let {selectedBlockFields, selectedTransactionFields} = eventConfig
-    let {dependsOnAddresses, resolvedWhere, isWildcard} = reg
-    selectedBlockFields
-    ->Utils.Set.toArray
-    ->Array.forEach(name =>
-      capitalizedBlockFields
-      ->Utils.Set.add((name :> string)->Utils.String.capitalize)
-      ->ignore
-    )
-    selectedTransactionFields
-    ->Utils.Set.toArray
-    ->Array.forEach(name => {
-      // transactionIndex is read off the log (the store key), so it never needs
-      // to be requested as a transaction column — and requesting it alone would
-      // pull the whole transaction table for nothing.
-      let fieldName = (name :> string)
-      if fieldName != "transactionIndex" {
-        capitalizedTransactionFields->Utils.Set.add(fieldName->Utils.String.capitalize)->ignore
-      }
-    })
-
-    if dependsOnAddresses {
-      let _ = contractNames->Utils.Set.add(contractName)
-
-      (
-        isWildcard ? wildcardTopicSelectionsByContract : topicSelectionsByContract
-      )->Utils.Dict.pushMany(contractName, resolvedWhere.topicSelections)
-    } else {
-      noAddressesTopicSelections
-      ->Array.pushMany(
-        resolvedWhere.topicSelections->LogSelection.materializeTopicSelections(~addresses=[]),
-      )
-      ->ignore
-    }
-  })
-
-  let fieldSelection: HyperSyncClient.QueryTypes.fieldSelection = {
-    log: [Address, Data, LogIndex, Topic0, Topic1, Topic2, Topic3],
-    block: capitalizedBlockFields
-    ->Utils.Set.toArray
-    ->(Utils.magic: array<string> => array<HyperSyncClient.QueryTypes.blockField>),
-    transaction: capitalizedTransactionFields
-    ->Utils.Set.toArray
-    ->(Utils.magic: array<string> => array<HyperSyncClient.QueryTypes.transactionField>),
-  }
-
-  let noAddressesLogSelection = LogSelection.make(
-    ~addresses=[],
-    ~topicSelections=noAddressesTopicSelections,
-  )
-
-  let getLogSelectionOrThrow = (~addressesByContractName): array<LogSelection.t> => {
-    let logSelections = []
-    if noAddressesLogSelection.topicSelections->Utils.Array.isEmpty->not {
-      logSelections->Array.push(noAddressesLogSelection)
-    }
-    contractNames->Utils.Set.forEach(contractName => {
-      switch addressesByContractName->Utils.Dict.dangerouslyGetNonOption(contractName) {
-      | None
-      | Some([]) => ()
-      | Some(addresses) =>
-        switch topicSelectionsByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-        | None => ()
-        | Some(topicSelections) =>
-          logSelections->Array.push(
-            LogSelection.make(
-              ~addresses,
-              ~topicSelections=topicSelections->LogSelection.materializeTopicSelections(~addresses),
-            ),
-          )
-        }
-        // Wildcard events that filter an indexed param by registered addresses:
-        // the addresses fold into the topics, so the query itself stays
-        // address-unbound.
-        switch wildcardTopicSelectionsByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-        | None => ()
-        | Some(topicSelections) =>
-          logSelections->Array.push(
-            LogSelection.make(
-              ~addresses=[],
-              ~topicSelections=topicSelections->LogSelection.materializeTopicSelections(~addresses),
-            ),
-          )
-        }
-      }
-    })
-    logSelections
-  }
-
-  {
-    getLogSelectionOrThrow,
-    fieldSelection,
-  }
-}
-
-let memoGetSelectionConfig = () => Utils.WeakMap.memoize(getSelectionConfig)
 
 // Surfaced by HyperSyncClient.getHeight (Rust) when HyperSync rejects the API
 // token. The corrupted-token test feeds the real server error through this
@@ -127,8 +9,8 @@ let isUnauthorizedError = (message: string) => message->String.includes("401 Una
 type options = {
   chain: ChainMap.Chain.t,
   endpointUrl: string,
-  allEventParams: array<HyperSyncClient.Decoder.eventParamsInput>,
-  eventRouter: EventRouter.t<Internal.evmOnEventRegistration>,
+  // The chain's registrations, indexed by their sequential `index`.
+  onEventRegistrations: array<Internal.evmOnEventRegistration>,
   apiToken: option<string>,
   clientTimeoutMillis: int,
   lowercaseAddresses: bool,
@@ -141,8 +23,7 @@ let make = (
   {
     chain,
     endpointUrl,
-    allEventParams,
-    eventRouter,
+    onEventRegistrations,
     apiToken,
     clientTimeoutMillis,
     lowercaseAddresses,
@@ -153,8 +34,6 @@ let make = (
 ): t => {
   let name = "HyperSync"
 
-  let getSelectionConfig = memoGetSelectionConfig()
-
   let apiToken = switch apiToken {
   | Some(token) => token
   | None =>
@@ -167,7 +46,9 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     ~url=endpointUrl,
     ~apiToken,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
-    ~eventParams=allEventParams,
+    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(
+      onEventRegistrations,
+    ),
     ~enableChecksumAddresses=!lowercaseAddresses,
     ~serializationFormat,
     ~enableQueryCaching,
@@ -180,15 +61,11 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     )
   }
 
-  exception UndefinedValue
-
   let makeEventBatchQueueItem = (
     item: HyperSyncClient.EventItems.item,
-    ~params: Internal.eventParams,
     ~onEventRegistration: Internal.evmOnEventRegistration,
   ): Internal.item => {
     let {transactionIndex, logIndex, srcAddress} = item
-    let chainId = chain->ChainMap.Chain.toChainId
 
     Internal.Event({
       onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
@@ -201,8 +78,8 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       payload: {
         contractName: onEventRegistration.eventConfig.contractName,
         eventName: onEventRegistration.eventConfig.name,
-        chainId,
-        params,
+        chainId: chain->ChainMap.Chain.toChainId,
+        params: item.params,
         srcAddress,
         logIndex,
       }->Evm.fromPayload,
@@ -213,23 +90,16 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     ~fromBlock,
     ~toBlock,
     ~addressesByContractName,
-    ~contractNameByAddress,
+    ~contractNameByAddress as _,
     ~knownHeight,
     ~partitionId as _,
-    ~selection,
+    ~selection: FetchState.selection,
     ~itemsTarget,
     ~retry,
-    ~logger,
+    ~logger as _,
   ) => {
     let totalTimeRef = Performance.now()
 
-    let selectionConfig = selection->getSelectionConfig
-
-    let logSelections = try selectionConfig.getLogSelectionOrThrow(~addressesByContractName) catch {
-    | exn =>
-      exn->ErrorHandling.mkLogAndRaise(~logger, ~msg="Failed getting log selection for the query")
-    }
-
     let startFetchingBatchTimeRef = Performance.now()
 
     //fetch batch
@@ -237,9 +107,9 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       ~client,
       ~fromBlock,
       ~toBlock,
-      ~logSelections,
-      ~fieldSelection=selectionConfig.fieldSelection,
       ~maxNumLogs=itemsTarget,
+      ~registrationIndexes=selection.onEventRegistrations->Array.map(reg => reg.index),
+      ~addressesByContractName,
     ) catch {
     | HyperSync.GetLogs.Error(error) =>
       throw(
@@ -309,63 +179,12 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     })
     let getBlock = blockNumber => blocksByNumber->Utils.Map.unsafeGet(blockNumber)
 
-    let handleDecodeFailure = (
-      ~onEventRegistration: Internal.evmOnEventRegistration,
-      ~logIndex,
-      ~blockNumber,
-      ~chainId,
-      ~exn,
-    ) => {
-      if !onEventRegistration.isWildcard {
-        //Wildcard events can be parsed as undefined if the number of topics
-        //don't match the event with the given topic0
-        //Non wildcard events should be expected to be parsed
-        let msg = `Event ${onEventRegistration.eventConfig.name} was unexpectedly parsed as undefined`
-        let logger = Logging.createChildFrom(
-          ~logger,
-          ~params={
-            "chainId": chainId,
-            "blockNumber": blockNumber,
-            "logIndex": logIndex,
-            "decoder": "hypersync-client",
-          },
-        )
-        exn->ErrorHandling.mkLogAndRaise(~msg, ~logger)
-      }
-    }
-
     pageUnsafe.items->Array.forEach(item => {
-      let chainId = chain->ChainMap.Chain.toChainId
-      let maybeEventConfig =
-        eventRouter->EventRouter.get(
-          ~tag=EventRouter.getEvmEventId(
-            ~sighash=item.topic0->EvmTypes.Hex.toString,
-            ~topicCount=item.topicCount,
-          ),
-          ~contractNameByAddress,
-          ~contractAddress=item.srcAddress,
-        )
-
-      switch maybeEventConfig {
-      | None => () //ignore events that aren't registered
-      | Some(onEventRegistration) =>
-        switch item.params
-        ->Nullable.toOption
-        ->Option.flatMap(Dict.get(_, onEventRegistration.eventConfig.contractName)) {
-        | Some(params) =>
-          parsedQueueItems
-          ->Array.push(makeEventBatchQueueItem(item, ~params, ~onEventRegistration))
-          ->ignore
-        | None =>
-          handleDecodeFailure(
-            ~onEventRegistration,
-            ~logIndex=item.logIndex,
-            ~blockNumber=item.blockNumber,
-            ~chainId,
-            ~exn=UndefinedValue,
-          )
-        }
-      }
+      let onEventRegistration =
+        onEventRegistrations->Array.getUnsafe(item.onEventRegistrationIndex)
+      parsedQueueItems
+      ->Array.push(makeEventBatchQueueItem(item, ~onEventRegistration))
+      ->ignore
     })
 
     let parsingTimeElapsed = parsingTimeRef->Performance.secondsSince