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

package/src/sources/RpcSource.res

@@ -97,10 +97,6 @@ let getErrorMessage = (exn: exn): option<string> =>
   | _ => None
   }
 
-type logSelection = {
-  addresses: option<array<Address.t>>,
-  topicQuery: Rpc.GetLogs.topicQuery,
-}
 
 // `EvmRpcClient.getNextPage` throws a napi error whose message is a JSON
 // payload describing the retry decision:
@@ -161,122 +157,6 @@ let parseGetNextPageRetryError = (exn: exn): option<(
   | _ => None
   }
 
-type selectionConfig = {
-  getLogSelectionsOrThrow: (
-    ~addressesByContractName: dict<array<Address.t>>,
-  ) => array<logSelection>,
-}
-
-let getSelectionConfig = (selection: FetchState.selection) => {
-  let evmOnEventRegistrations =
-    selection.onEventRegistrations->(
-      Utils.magic: array<Internal.onEventRegistration> => array<Internal.evmOnEventRegistration>
-    )
-
-  if evmOnEventRegistrations->Utils.Array.isEmpty {
-    throw(
-      Source.GetItemsError(
-        UnsupportedSelection({
-          message: "Invalid events configuration for the partition. Nothing to fetch. Please, report to the Envio team.",
-        }),
-      ),
-    )
-  }
-
-  // eth_getLogs takes one address list and one topic selection per request, so
-  // fan out to one request per selection. Each address-bound event is grouped by
-  // its contract and later scoped to that contract's own addresses — pooling all
-  // contracts' addresses would let one contract's query fetch a sibling's logs,
-  // which route back by address and bypass the sibling's filter (routing never
-  // re-applies it). Pure-wildcard events carry no address constraint, so they're
-  // pooled and resolved once.
-  let noAddressTopicSelections = []
-  let byContract = Dict.make()
-  let wildcardByContract = Dict.make()
-  let contractNames = Utils.Set.make()
-
-  evmOnEventRegistrations->Array.forEach(reg => {
-    let contractName = reg.eventConfig.contractName
-    let {isWildcard, dependsOnAddresses, resolvedWhere} = reg
-    if dependsOnAddresses {
-      contractNames->Utils.Set.add(contractName)->ignore
-      (isWildcard ? wildcardByContract : byContract)->Utils.Dict.pushMany(
-        contractName,
-        resolvedWhere.topicSelections,
-      )
-    } else {
-      noAddressTopicSelections
-      ->Array.pushMany(
-        resolvedWhere.topicSelections->LogSelection.materializeTopicSelections(~addresses=[]),
-      )
-      ->ignore
-    }
-  })
-
-  // `compressTopicSelections` folds the filter-less events into a single topic0
-  // OR-set, keeping the common case at one request.
-  let toLogSelections = (~addresses, topicSelections): array<logSelection> =>
-    topicSelections
-    ->LogSelection.compressTopicSelections
-    ->Array.map(topicSelection => {
-      addresses,
-      topicQuery: topicSelection->Rpc.GetLogs.mapTopicQuery,
-    })
-
-  // Address-independent, so resolve once (the wildcard partition reuses this).
-  let noAddressLogSelections = toLogSelections(~addresses=None, noAddressTopicSelections)
-
-  let getLogSelectionsOrThrow = if contractNames->Utils.Set.size === 0 {
-    (~addressesByContractName as _) => noAddressLogSelections
-  } else {
-    (~addressesByContractName): array<logSelection> => {
-      let logSelections = noAddressLogSelections->Array.copy
-      contractNames->Utils.Set.forEach(contractName => {
-        switch addressesByContractName->Utils.Dict.dangerouslyGetNonOption(contractName) {
-        | None
-        | Some([]) => ()
-        | Some(addresses) =>
-          // Non-wildcard filters, scoped to this contract's addresses.
-          switch byContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-          | Some(topicSelections) =>
-            logSelections
-            ->Array.pushMany(
-              toLogSelections(
-                ~addresses=Some(addresses),
-                topicSelections->LogSelection.materializeTopicSelections(~addresses),
-              ),
-            )
-            ->ignore
-          | None => ()
-          }
-
-          // Wildcard-by-address filters fold the address into the topics,
-          // so they still match any address.
-          switch wildcardByContract->Utils.Dict.dangerouslyGetNonOption(contractName) {
-          | Some(topicSelections) =>
-            logSelections
-            ->Array.pushMany(
-              toLogSelections(
-                ~addresses=None,
-                topicSelections->LogSelection.materializeTopicSelections(~addresses),
-              ),
-            )
-            ->ignore
-          | None => ()
-          }
-        }
-      })
-      logSelections
-    }
-  }
-
-  {
-    getLogSelectionsOrThrow: getLogSelectionsOrThrow,
-  }
-}
-
-let memoGetSelectionConfig = () => Utils.WeakMap.memoize(getSelectionConfig)
-
 // Type-erase a schema for storage in the field registry
 external toFieldSchema: S.t<'a> => S.t<JSON.t> = "%identity"
 
@@ -735,8 +615,8 @@ type options = {
   syncConfig: Config.sourceSync,
   url: string,
   chain: ChainMap.Chain.t,
-  eventRouter: EventRouter.t<Internal.evmOnEventRegistration>,
-  allEventParams: array<HyperSyncClient.Decoder.eventParamsInput>,
+  // The chain's registrations, indexed by their sequential `index`.
+  onEventRegistrations: array<Internal.evmOnEventRegistration>,
   lowercaseAddresses: bool,
   ws?: string,
   headers?: dict<string>,
@@ -748,8 +628,7 @@ let make = (
     syncConfig,
     url,
     chain,
-    eventRouter,
-    allEventParams,
+    onEventRegistrations,
     lowercaseAddresses,
     ?ws,
     ?headers,
@@ -765,12 +644,12 @@ let make = (
   }
   let name = `RPC (${urlHost})`
 
-  let getSelectionConfig = memoGetSelectionConfig()
-
   let client = Rpc.makeClient(url, ~headers?)
   let rpcClient = EvmRpcClient.make(
     ~url,
-    ~allEventParams,
+    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(
+      onEventRegistrations,
+    ),
     ~checksumAddresses=!lowercaseAddresses,
     ~syncConfig,
     ~headers?,
@@ -921,7 +800,7 @@ let make = (
     ~fromBlock,
     ~toBlock,
     ~addressesByContractName,
-    ~contractNameByAddress,
+    ~contractNameByAddress as _,
     ~knownHeight,
     ~partitionId,
     ~selection: FetchState.selection,
@@ -944,26 +823,22 @@ let make = (
           ->Promise.thenResolve(json => Some(parseBlockInfo(json)))
         : Promise.resolve(None)
 
-    let {getLogSelectionsOrThrow} = getSelectionConfig(selection)
-    let logSelections = getLogSelectionsOrThrow(~addressesByContractName)
+    if selection.onEventRegistrations->Utils.Array.isEmpty {
+      throw(
+        Source.GetItemsError(
+          UnsupportedSelection({
+            message: "Invalid events configuration for the partition. Nothing to fetch. Please, report to the Envio team.",
+          }),
+        ),
+      )
+    }
 
     let {items, toBlock: queriedToBlock, requestStats} = try await rpcClient.getNextPage({
       fromBlock,
       toBlockCeiling: toBlock,
-      logSelections: logSelections->Array.map(({
-        addresses,
-        topicQuery,
-      }): EvmRpcClient.logSelectionInput => {
-        ?addresses,
-        topics: topicQuery->Array.map(filter =>
-          switch filter {
-          | Rpc.GetLogs.Null => Nullable.null
-          | Single(topic) => Nullable.make([topic])
-          | Multiple(topics) => Nullable.make(topics)
-          }
-        ),
-      }),
       partitionId,
+      registrationIndexes: selection.onEventRegistrations->Array.map(reg => reg.index),
+      addressesByContractName,
     }) catch {
     | exn =>
       switch exn->parseGetNextPageRetryError {
@@ -997,32 +872,15 @@ let make = (
     ->Promise.thenResolve(parseBlockInfo)
 
     let parsedQueueItems = await items
-    ->Array.filterMap(({log, params: maybeDecodedEvent}: EvmRpcClient.rpcEventItem) => {
-      let topic0 = log.topics[0]->Option.getOr("0x0")
-      let routedAddress = if lowercaseAddresses {
-        log.address->Address.Evm.fromAddressLowercaseOrThrow
-      } else {
-        log.address->Address.Evm.fromAddressOrThrow
-      }
-
-      switch eventRouter->EventRouter.get(
-        ~tag=EventRouter.getEvmEventId(~sighash=topic0, ~topicCount=log.topics->Array.length),
-        ~contractNameByAddress,
-        ~contractAddress=routedAddress,
-      ) {
-      | None => None
-      | Some(onEventRegistration) =>
-        let eventConfig =
-          onEventRegistration.eventConfig->(
-            Utils.magic: Internal.eventConfig => Internal.evmEventConfig
-          )
-        switch maybeDecodedEvent
-        ->Nullable.toOption
-        ->Option.flatMap(Dict.get(_, eventConfig.contractName)) {
-        | Some(decoded) =>
-          Some(
-            (
-              async () => {
+    ->Array.map(({log, onEventRegistrationIndex, params: decoded}: EvmRpcClient.rpcEventItem) => {
+      // `log.address` comes back already normalized to the client's casing.
+      let onEventRegistration = onEventRegistrations->Array.getUnsafe(onEventRegistrationIndex)
+      let eventConfig =
+        onEventRegistration.eventConfig->(
+          Utils.magic: Internal.eventConfig => Internal.evmEventConfig
+        )
+      (
+        async () => {
                 let (block, transaction) = try await Promise.all2((
                   log->getEventBlockOrThrow(~selectedBlockFields=eventConfig.selectedBlockFields),
                   log->getEventTransactionOrThrow(
@@ -1074,16 +932,12 @@ let make = (
                     params: decoded,
                     block,
                     transaction,
-                    srcAddress: routedAddress,
+                    srcAddress: log.address,
                     logIndex: log.logIndex,
                   }->Evm.fromPayload,
                 })
-              }
-            )(),
-          )
-        | None => None
         }
-      }
+      )()
     })
     ->Promise.all
 

package/src/sources/RpcSource.res.mjs

@@ -9,17 +9,16 @@ import * as Address from "../Address.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as Internal from "../Internal.res.mjs";
 import * as LazyLoader from "../LazyLoader.res.mjs";
-import * as EventRouter from "./EventRouter.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as EvmRpcClient from "./EvmRpcClient.res.mjs";
-import * as LogSelection from "../LogSelection.res.mjs";
 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 Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as HyperSyncClient from "./HyperSyncClient.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";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -193,69 +192,6 @@ function parseGetNextPageRetryError(exn) {
   ]);
 }
 
-function getSelectionConfig(selection) {
-  let evmOnEventRegistrations = selection.onEventRegistrations;
-  if (Utils.$$Array.isEmpty(evmOnEventRegistrations)) {
-    throw {
-      RE_EXN_ID: Source.GetItemsError,
-      _1: {
-        TAG: "UnsupportedSelection",
-        message: "Invalid events configuration for the partition. Nothing to fetch. Please, report to the Envio team."
-      },
-      Error: new Error()
-    };
-  }
-  let noAddressTopicSelections = [];
-  let byContract = {};
-  let wildcardByContract = {};
-  let contractNames = new Set();
-  evmOnEventRegistrations.forEach(reg => {
-    let contractName = reg.eventConfig.contractName;
-    let resolvedWhere = reg.resolvedWhere;
-    if (reg.dependsOnAddresses) {
-      contractNames.add(contractName);
-      return Utils.Dict.pushMany(reg.isWildcard ? wildcardByContract : byContract, contractName, resolvedWhere.topicSelections);
-    } else {
-      noAddressTopicSelections.push(...LogSelection.materializeTopicSelections(resolvedWhere.topicSelections, []));
-      return;
-    }
-  });
-  let toLogSelections = (addresses, topicSelections) => LogSelection.compressTopicSelections(topicSelections).map(topicSelection => ({
-    addresses: addresses,
-    topicQuery: Rpc.GetLogs.mapTopicQuery(topicSelection)
-  }));
-  let noAddressLogSelections = toLogSelections(undefined, noAddressTopicSelections);
-  let getLogSelectionsOrThrow = contractNames.size === 0 ? param => noAddressLogSelections : addressesByContractName => {
-      let logSelections = noAddressLogSelections.slice();
-      contractNames.forEach(contractName => {
-        let addresses = addressesByContractName[contractName];
-        if (addresses === undefined) {
-          return;
-        }
-        if (addresses.length === 0) {
-          return;
-        }
-        let topicSelections = byContract[contractName];
-        if (topicSelections !== undefined) {
-          logSelections.push(...toLogSelections(addresses, LogSelection.materializeTopicSelections(topicSelections, addresses)));
-        }
-        let topicSelections$1 = wildcardByContract[contractName];
-        if (topicSelections$1 !== undefined) {
-          logSelections.push(...toLogSelections(undefined, LogSelection.materializeTopicSelections(topicSelections$1, addresses)));
-          return;
-        }
-      });
-      return logSelections;
-    };
-  return {
-    getLogSelectionsOrThrow: getLogSelectionsOrThrow
-  };
-}
-
-function memoGetSelectionConfig() {
-  return Utils.$$WeakMap.memoize(getSelectionConfig);
-}
-
 let lowercaseAddressSchema = S$RescriptSchema.transform(S$RescriptSchema.string, param => ({
   p: str => str.toLowerCase()
 }));
@@ -790,16 +726,15 @@ function makeThrowingGetEventTransaction(getTransactionJson, getReceiptJson, low
 function make(param) {
   let headers = param.headers;
   let lowercaseAddresses = param.lowercaseAddresses;
-  let eventRouter = param.eventRouter;
+  let onEventRegistrations = param.onEventRegistrations;
   let chain = param.chain;
   let url = param.url;
   let syncConfig = param.syncConfig;
   let host = Utils.Url.getHostFromUrl(url);
   let urlHost = host !== undefined ? host : Stdlib_JsError.throwWithMessage(`The RPC url for chain ` + chain.toString() + ` is in incorrect format. The RPC url needs to start with either http:// or https://`);
   let name = `RPC (` + urlHost + `)`;
-  let getSelectionConfig$1 = Utils.$$WeakMap.memoize(getSelectionConfig);
   let client = Rpc.makeClient(url, headers);
-  let rpcClient = EvmRpcClient.make(url, !lowercaseAddresses, syncConfig, undefined, headers, param.allEventParams);
+  let rpcClient = EvmRpcClient.make(url, !lowercaseAddresses, syncConfig, undefined, headers, HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations));
   let pendingRequestStats = [];
   let recordRequest = (method, seconds) => {
     pendingRequestStats.push({
@@ -885,43 +820,41 @@ function make(param) {
       Error: new Error()
     };
   }, lowercaseAddresses);
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, contractNameByAddress, knownHeight, partitionId, selection, param, retry, param$1) => {
+  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, partitionId, selection, param$1, retry, param$2) => {
     let startFetchingBatchTimeRef = Performance.now();
     let toBlock$1 = toBlock !== undefined ? Primitive_int.min(toBlock, knownHeight) : knownHeight;
     let firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(json => parseBlockInfo(json)) : Promise.resolve(undefined);
-    let match = getSelectionConfig$1(selection);
-    let logSelections = match.getLogSelectionsOrThrow(addressesByContractName);
-    let match$1;
+    if (Utils.$$Array.isEmpty(selection.onEventRegistrations)) {
+      throw {
+        RE_EXN_ID: Source.GetItemsError,
+        _1: {
+          TAG: "UnsupportedSelection",
+          message: "Invalid events configuration for the partition. Nothing to fetch. Please, report to the Envio team."
+        },
+        Error: new Error()
+      };
+    }
+    let match;
     try {
-      match$1 = await rpcClient.getNextPage({
+      match = await rpcClient.getNextPage({
         fromBlock: fromBlock,
         toBlockCeiling: toBlock$1,
-        logSelections: logSelections.map(param => ({
-          addresses: param.addresses,
-          topics: param.topicQuery.map(filter => {
-            if (filter === null) {
-              return null;
-            } else if (typeof filter === "string") {
-              return [filter];
-            } else {
-              return filter;
-            }
-          })
-        })),
-        partitionId: partitionId
+        partitionId: partitionId,
+        registrationIndexes: selection.onEventRegistrations.map(reg => reg.index),
+        addressesByContractName: addressesByContractName
       });
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
-      let match$2 = parseGetNextPageRetryError(exn);
-      if (match$2 !== undefined) {
-        match$2[2].forEach(stat => recordRequest(stat.method, stat.seconds));
+      let match$1 = parseGetNextPageRetryError(exn);
+      if (match$1 !== undefined) {
+        match$1[2].forEach(stat => recordRequest(stat.method, stat.seconds));
         throw {
           RE_EXN_ID: Source.GetItemsError,
           _1: {
             TAG: "FailedGettingItems",
             exn: exn,
-            attemptedToBlock: match$2[0],
-            retry: match$2[1]
+            attemptedToBlock: match$1[0],
+            retry: match$1[1]
           },
           Error: new Error()
         };
@@ -941,23 +874,14 @@ function make(param) {
         Error: new Error()
       };
     }
-    let items = match$1.items;
-    match$1.requestStats.forEach(stat => recordRequest(stat.method, stat.seconds));
-    let latestFetchedBlockInfo = await LazyLoader.get(blockLoader.contents, match$1.toBlock).then(parseBlockInfo);
-    let parsedQueueItems = await Promise.all(Stdlib_Array.filterMap(items, param => {
+    let items = match.items;
+    match.requestStats.forEach(stat => recordRequest(stat.method, stat.seconds));
+    let latestFetchedBlockInfo = await LazyLoader.get(blockLoader.contents, match.toBlock).then(parseBlockInfo);
+    let parsedQueueItems = await Promise.all(items.map(param => {
+      let decoded = param.params;
       let log = param.log;
-      let topic0 = Stdlib_Option.getOr(log.topics[0], "0x0");
-      let routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : Address.Evm.fromAddressOrThrow(log.address);
-      let onEventRegistration = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, contractNameByAddress);
-      if (onEventRegistration === undefined) {
-        return;
-      }
+      let onEventRegistration = onEventRegistrations[param.onEventRegistrationIndex];
       let eventConfig = onEventRegistration.eventConfig;
-      let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param.params), __x => __x[eventConfig.contractName]);
-      if (decoded === undefined) {
-        return;
-      }
-      let decoded$1 = Primitive_option.valFromOption(decoded);
       return (async () => {
         let match;
         try {
@@ -1007,9 +931,9 @@ function make(param) {
           payload: {
             contractName: eventConfig.contractName,
             eventName: eventConfig.name,
-            params: decoded$1,
+            params: decoded,
             chainId: chain,
-            srcAddress: routedAddress,
+            srcAddress: log.address,
             logIndex: log.logIndex,
             transaction: Primitive_option.some(match[1]),
             block: Primitive_option.some(block)
@@ -1123,8 +1047,6 @@ export {
   getKnownRawBlockWithBackoff,
   getErrorMessage,
   parseGetNextPageRetryError,
-  getSelectionConfig,
-  memoGetSelectionConfig,
   lowercaseAddressSchema,
   checksumAddressSchema,
   makeBlockFieldRegistry,

package/src/sources/SimulateSource.res

@@ -1,8 +1,5 @@
 let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain.t): Source.t => {
-  // getItemsOrThrow might be called multiple times with different partition ids.
-  // Return all items on the first call and empty on subsequent calls to prevent
-  // duplicate event processing.
-  let delivered = ref(false)
+  let reportedHeight = max(endBlock, 1)
 
   {
     name: "SimulateSource",
@@ -16,38 +13,59 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
     },
     getHeightOrThrow: () => {
       // Report at least height 1 so the engine doesn't treat 0 as "no blocks available"
-      Promise.resolve({Source.height: max(endBlock, 1), requestStats: []})
+      Promise.resolve({Source.height: reportedHeight, requestStats: []})
     },
     getItemsOrThrow: (
-      ~fromBlock as _,
-      ~toBlock as _,
+      ~fromBlock,
+      ~toBlock,
       ~addressesByContractName as _,
-      ~contractNameByAddress as _,
+      ~contractNameByAddress,
       ~knownHeight as _,
       ~partitionId as _,
-      ~selection as _,
+      ~selection: FetchState.selection,
       ~itemsTarget as _,
       ~retry as _,
       ~logger as _,
     ) => {
-      // Return all items on the first call, empty on subsequent.
-      let result = if delivered.contents {
-        []
-      } else {
-        delivered := true
-        items
+      // Mirror a real backend: return only the items this query would match —
+      // in the block range, part of the selection, and (for non-wildcard events)
+      // emitted by an address the partition is querying. Wildcard events are
+      // over-fetched regardless of srcAddress, leaving the client-side address
+      // filter to gate them exactly as it does for a HyperSync response. Overlapping
+      // queries may return the same item more than once; the buffer dedups it.
+      let toBlockQueried = switch toBlock {
+      | Some(toBlock) => toBlock
+      | None => reportedHeight
       }
+      let selectionEventIds = Utils.Set.make()
+      selection.onEventRegistrations->Array.forEach(reg =>
+        selectionEventIds->Utils.Set.add(reg.eventConfig.id)->ignore
+      )
+
+      let parsedQueueItems = items->Array.filter(item => {
+        let eventItem = item->Internal.castUnsafeEventItem
+        let {blockNumber, onEventRegistration} = eventItem
+        if blockNumber < fromBlock || blockNumber > toBlockQueried {
+          false
+        } else if !(selectionEventIds->Utils.Set.has(onEventRegistration.eventConfig.id)) {
+          false
+        } else if onEventRegistration.isWildcard {
+          true
+        } else {
+          let sa = eventItem.payload->Internal.getPayloadSrcAddress->Address.toString
+          contractNameByAddress->Utils.Dict.dangerouslyGetNonOption(sa)->Option.isSome
+        }
+      })
 
-      let reportedHeight = max(endBlock, 1)
       Promise.resolve({
         Source.knownHeight: reportedHeight,
         blockHashes: [],
-        parsedQueueItems: result,
+        parsedQueueItems,
         // Simulate keeps the transaction and block inline on the payload; no store pages.
         transactionStore: None,
         blockStore: None,
-        fromBlockQueried: 0,
-        latestFetchedBlockNumber: reportedHeight,
+        fromBlockQueried: fromBlock,
+        latestFetchedBlockNumber: toBlockQueried,
         latestFetchedBlockTimestamp: 0,
         stats: {
           totalTimeElapsed: 0.,

package/src/sources/SimulateSource.res.mjs

@@ -1,11 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function make(items, endBlock, chain) {
-  let delivered = {
-    contents: false
-  };
+  let reportedHeight = Primitive_int.max(endBlock, 1);
   return {
     name: "SimulateSource",
     sourceFor: "Sync",
@@ -20,20 +19,38 @@ function make(items, endBlock, chain) {
       requestStats: []
     }),
     getHeightOrThrow: () => Promise.resolve({
-      height: Primitive_int.max(endBlock, 1),
+      height: reportedHeight,
       requestStats: []
     }),
-    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) => {
-      let result = delivered.contents ? [] : (delivered.contents = true, items);
-      let reportedHeight = Primitive_int.max(endBlock, 1);
+    getItemsOrThrow: (fromBlock, toBlock, param, contractNameByAddress, param$1, param$2, selection, param$3, param$4, param$5) => {
+      let toBlockQueried = toBlock !== undefined ? toBlock : reportedHeight;
+      let selectionEventIds = new Set();
+      selection.onEventRegistrations.forEach(reg => {
+        selectionEventIds.add(reg.eventConfig.id);
+      });
+      let parsedQueueItems = items.filter(item => {
+        let blockNumber = item.blockNumber;
+        if (blockNumber < fromBlock || blockNumber > toBlockQueried) {
+          return false;
+        }
+        let onEventRegistration = item.onEventRegistration;
+        if (!selectionEventIds.has(onEventRegistration.eventConfig.id)) {
+          return false;
+        }
+        if (onEventRegistration.isWildcard) {
+          return true;
+        }
+        let sa = item.payload.srcAddress;
+        return Stdlib_Option.isSome(contractNameByAddress[sa]);
+      });
       return Promise.resolve({
         knownHeight: reportedHeight,
         blockHashes: [],
-        parsedQueueItems: result,
+        parsedQueueItems: parsedQueueItems,
         transactionStore: undefined,
         blockStore: undefined,
-        fromBlockQueried: 0,
-        latestFetchedBlockNumber: reportedHeight,
+        fromBlockQueried: fromBlock,
+        latestFetchedBlockNumber: toBlockQueried,
         latestFetchedBlockTimestamp: 0,
         stats: {
           "total time elapsed (s)": 0

package/src/sources/SvmHyperSyncSource.res

@@ -285,8 +285,8 @@ let make = (
 ): t => {
   let name = "SvmHyperSync"
 
-  // Definitions drive query/decode building; the registrations drive routing
-  // (they carry `isWildcard` and become each decoded item's `onEventRegistration`).
+  // Definitions drive query/decode building; registrations drive routing and
+  // are attached directly to decoded runtime items.
   let eventConfigs =
     onEventRegistrations->Array.map(reg =>
       reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
@@ -488,6 +488,16 @@ let make = (
 
       switch maybeConfig {
       | None => ()
+      // Exclude instructions from failed transactions. HyperSync has no
+      // server-side predicate to filter instructions by parent-transaction
+      // success (`InstructionSelection` only exposes `is_inner`, and
+      // instruction/transaction selections union at block level rather than
+      // joining), so we filter client-side on the `isCommitted` flag HyperSync
+      // already delivers on every instruction row (a required column, zero extra
+      // bandwidth). When HyperSync adds a server-side `is_committed` predicate the
+      // query can push this down and the client-side check becomes a redundant
+      // safety net.
+      | Some(_) if !instr.isCommitted => ()
       | Some(onEventRegistration) =>
         let eventConfig =
           onEventRegistration.eventConfig->(
@@ -521,7 +531,7 @@ let make = (
         parsedQueueItems
         ->Array.push(
           Internal.Event({
-            onEventRegistration,
+            onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
             chain,
             blockNumber: instr.slot,
             logIndex: synthLogIndex(instr),