envio 3.5.0-alpha.0 → 3.5.0-alpha.2

package/src/sources/RpcSource.res

@@ -97,7 +97,6 @@ let getErrorMessage = (exn: exn): option<string> =>
   | _ => None
   }
 
-
 // `EvmRpcClient.getNextPage` throws a napi error whose message is a JSON
 // payload describing the retry decision:
 // `{"kind":"Retry","attemptedToBlock":int,"errorMessage":string|null,
@@ -618,6 +617,8 @@ type options = {
   // The chain's registrations, indexed by their sequential `index`.
   onEventRegistrations: array<Internal.evmOnEventRegistration>,
   lowercaseAddresses: bool,
+  // The chain's address index; the client reads it while routing.
+  addressStore: AddressStore.t,
   ws?: string,
   headers?: dict<string>,
 }
@@ -630,6 +631,7 @@ let make = (
     chain,
     onEventRegistrations,
     lowercaseAddresses,
+    addressStore,
     ?ws,
     ?headers,
   }: options,
@@ -647,12 +649,11 @@ let make = (
   let client = Rpc.makeClient(url, ~headers?)
   let rpcClient = EvmRpcClient.make(
     ~url,
-    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(
-      onEventRegistrations,
-    ),
+    ~eventRegistrations=HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations),
     ~checksumAddresses=!lowercaseAddresses,
     ~syncConfig,
     ~headers?,
+    ~addressStore,
   )
 
   // Requests are made from shared, memoized loaders, so they can't be
@@ -799,8 +800,7 @@ let make = (
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
-    ~addressesByContractName,
-    ~contractNameByAddress as _,
+    ~addressSet,
     ~knownHeight,
     ~partitionId,
     ~selection: FetchState.selection,
@@ -833,13 +833,16 @@ let make = (
       )
     }
 
-    let {items, toBlock: queriedToBlock, requestStats} = try await rpcClient.getNextPage({
-      fromBlock,
-      toBlockCeiling: toBlock,
-      partitionId,
-      registrationIndexes: selection.onEventRegistrations->Array.map(reg => reg.index),
-      addressesByContractName,
-    }) catch {
+    let {items, toBlock: queriedToBlock, requestStats} = try await rpcClient.getNextPage(
+      {
+        fromBlock,
+        toBlockCeiling: toBlock,
+        partitionId,
+        registrationIndexes: selection.onEventRegistrations->Array.map(reg => reg.index),
+        clientFilteredContracts: selection.clientFilteredContracts,
+      },
+      addressSet,
+    ) catch {
     | exn =>
       switch exn->parseGetNextPageRetryError {
       | Some((attemptedToBlock, retry, requestStats)) =>
@@ -879,63 +882,64 @@ let make = (
         onEventRegistration.eventConfig->(
           Utils.magic: Internal.eventConfig => Internal.evmEventConfig
         )
+
       (
         async () => {
-                let (block, transaction) = try await Promise.all2((
-                  log->getEventBlockOrThrow(~selectedBlockFields=eventConfig.selectedBlockFields),
-                  log->getEventTransactionOrThrow(
-                    ~selectedTransactionFields=eventConfig.selectedTransactionFields->(
-                      Utils.magic: Utils.Set.t<string> => Utils.Set.t<Internal.evmTransactionField>
-                    ),
-                  ),
-                )) catch {
-                | TransactionDataNotFound({message}) =>
-                  let backoffMillis = switch retry {
-                  | 0 => 100
-                  | _ => 500 * retry
-                  }
-                  throw(
-                    Source.GetItemsError(
-                      FailedGettingItems({
-                        exn: %raw(`null`),
-                        attemptedToBlock: toBlock,
-                        retry: WithBackoff({
-                          message: `${message}. The RPC provider might be load-balanced between nodes that drift independently slightly from the head. Indexing should continue correctly after retrying the query in ${backoffMillis->Int.toString}ms.`,
-                          backoffMillis,
-                        }),
-                      }),
-                    ),
-                  )
-                | exn =>
-                  throw(
-                    Source.GetItemsError(
-                      FailedGettingFieldSelection({
-                        message: "Failed getting selected fields. Please double-check your RPC provider returns correct data.",
-                        exn,
-                        blockNumber: log.blockNumber,
-                        logIndex: log.logIndex,
-                      }),
-                    ),
-                  )
-                }
-
-                Internal.Event({
-                  onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
-                  blockNumber: block->getBlockNumber,
-                  chain,
+          let (block, transaction) = try await Promise.all2((
+            log->getEventBlockOrThrow(~selectedBlockFields=eventConfig.selectedBlockFields),
+            log->getEventTransactionOrThrow(
+              ~selectedTransactionFields=eventConfig.selectedTransactionFields->(
+                Utils.magic: Utils.Set.t<string> => Utils.Set.t<Internal.evmTransactionField>
+              ),
+            ),
+          )) catch {
+          | TransactionDataNotFound({message}) =>
+            let backoffMillis = switch retry {
+            | 0 => 100
+            | _ => 500 * retry
+            }
+            throw(
+              Source.GetItemsError(
+                FailedGettingItems({
+                  exn: %raw(`null`),
+                  attemptedToBlock: toBlock,
+                  retry: WithBackoff({
+                    message: `${message}. The RPC provider might be load-balanced between nodes that drift independently slightly from the head. Indexing should continue correctly after retrying the query in ${backoffMillis->Int.toString}ms.`,
+                    backoffMillis,
+                  }),
+                }),
+              ),
+            )
+          | exn =>
+            throw(
+              Source.GetItemsError(
+                FailedGettingFieldSelection({
+                  message: "Failed getting selected fields. Please double-check your RPC provider returns correct data.",
+                  exn,
+                  blockNumber: log.blockNumber,
                   logIndex: log.logIndex,
-                  transactionIndex: log.transactionIndex,
-                  payload: {
-                    contractName: eventConfig.contractName,
-                    eventName: eventConfig.name,
-                    chainId: chain->ChainMap.Chain.toChainId,
-                    params: decoded,
-                    block,
-                    transaction,
-                    srcAddress: log.address,
-                    logIndex: log.logIndex,
-                  }->Evm.fromPayload,
-                })
+                }),
+              ),
+            )
+          }
+
+          Internal.Event({
+            onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
+            blockNumber: block->getBlockNumber,
+            chain,
+            logIndex: log.logIndex,
+            transactionIndex: log.transactionIndex,
+            payload: {
+              contractName: eventConfig.contractName,
+              eventName: eventConfig.name,
+              chainId: chain->ChainMap.Chain.toChainId,
+              params: decoded,
+              block,
+              transaction,
+              srcAddress: log.address,
+              logIndex: log.logIndex,
+            }->Evm.fromPayload,
+          })
         }
       )()
     })

package/src/sources/RpcSource.res.mjs

@@ -734,7 +734,7 @@ function make(param) {
   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 client = Rpc.makeClient(url, headers);
-  let rpcClient = EvmRpcClient.make(url, !lowercaseAddresses, syncConfig, undefined, headers, HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations));
+  let rpcClient = EvmRpcClient.make(url, !lowercaseAddresses, syncConfig, undefined, headers, HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
   let pendingRequestStats = [];
   let recordRequest = (method, seconds) => {
     pendingRequestStats.push({
@@ -820,7 +820,7 @@ function make(param) {
       Error: new Error()
     };
   }, lowercaseAddresses);
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, partitionId, selection, param$1, retry, param$2) => {
+  let getItemsOrThrow = async (fromBlock, toBlock, addressSet, knownHeight, partitionId, selection, param, retry, param$1) => {
     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);
@@ -841,8 +841,8 @@ function make(param) {
         toBlockCeiling: toBlock$1,
         partitionId: partitionId,
         registrationIndexes: selection.onEventRegistrations.map(reg => reg.index),
-        addressesByContractName: addressesByContractName
-      });
+        clientFilteredContracts: selection.clientFilteredContracts
+      }, addressSet);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       let match$1 = parseGetNextPageRetryError(exn);

package/src/sources/SimulateSource.res

@@ -18,8 +18,7 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
     getItemsOrThrow: (
       ~fromBlock,
       ~toBlock,
-      ~addressesByContractName as _,
-      ~contractNameByAddress,
+      ~addressSet,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection: FetchState.selection,
@@ -28,11 +27,11 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
       ~logger as _,
     ) => {
       // 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.
+      // in the block range, part of the selection, and passing the same address
+      // gates a real source applies natively while routing (the emitter must be
+      // registered for the event's contract at or before the item's block, and
+      // any address-valued param filter must hold). Overlapping queries may
+      // return the same item more than once; the buffer dedups it.
       let toBlockQueried = switch toBlock {
       | Some(toBlock) => toBlock
       | None => reportedHeight
@@ -49,11 +48,27 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
           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 contractName = onEventRegistration.eventConfig.contractName
+          let emitterAllowed =
+            onEventRegistration.isWildcard ||
+              addressSet->AddressSet.has(
+                eventItem.payload->Internal.getPayloadSrcAddress,
+                contractName,
+                blockNumber,
+              )
+          emitterAllowed &&
+          switch onEventRegistration.addressFilterParamGroups {
+          | None
+          | Some([]) => true
+          | Some(groups) =>
+            let params = eventItem.payload->Internal.getPayloadAddressParams
+            groups->Array.some(group =>
+              group->Array.every(name =>
+                addressSet->AddressSet.has(params->Dict.getUnsafe(name), contractName, blockNumber)
+              )
+            )
+          }
         }
       })
 

package/src/sources/SimulateSource.res.mjs

@@ -1,7 +1,6 @@
 // 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 reportedHeight = Primitive_int.max(endBlock, 1);
@@ -22,7 +21,7 @@ function make(items, endBlock, chain) {
       height: reportedHeight,
       requestStats: []
     }),
-    getItemsOrThrow: (fromBlock, toBlock, param, contractNameByAddress, param$1, param$2, selection, param$3, param$4, param$5) => {
+    getItemsOrThrow: (fromBlock, toBlock, addressSet, param, param$1, selection, param$2, param$3, param$4) => {
       let toBlockQueried = toBlock !== undefined ? toBlock : reportedHeight;
       let selectionEventIds = new Set();
       selection.onEventRegistrations.forEach(reg => {
@@ -37,11 +36,20 @@ function make(items, endBlock, chain) {
         if (!selectionEventIds.has(onEventRegistration.eventConfig.id)) {
           return false;
         }
-        if (onEventRegistration.isWildcard) {
+        let contractName = onEventRegistration.eventConfig.contractName;
+        let emitterAllowed = onEventRegistration.isWildcard || addressSet.has(item.payload.srcAddress, contractName, blockNumber);
+        if (!emitterAllowed) {
+          return false;
+        }
+        let groups = onEventRegistration.addressFilterParamGroups;
+        if (groups === undefined) {
+          return true;
+        }
+        if (groups.length === 0) {
           return true;
         }
-        let sa = item.payload.srcAddress;
-        return Stdlib_Option.isSome(contractNameByAddress[sa]);
+        let params = item.payload.params;
+        return groups.some(group => group.every(name => addressSet.has(params[name], contractName, blockNumber)));
       });
       return Promise.resolve({
         knownHeight: reportedHeight,

package/src/sources/Source.res

@@ -73,8 +73,10 @@ type t = {
   getItemsOrThrow: (
     ~fromBlock: int,
     ~toBlock: option<int>,
-    ~addressesByContractName: dict<array<Address.t>>,
-    ~contractNameByAddress: dict<string>,
+    // The partition's slice of the chain's address index. The source hands it
+    // straight to its Rust client, which builds the query's address filter from
+    // it and gates every returned item against the chain-wide store.
+    ~addressSet: AddressSet.t,
     ~knownHeight: int,
     ~partitionId: string,
     ~selection: FetchState.selection,
@@ -82,8 +84,10 @@ type t = {
     // source should ask its backend for, from the query's own estResponseSize.
     // A HyperSync-backed source enforces it server-side, so a wrong estimate
     // truncates the response instead of overshooting the shared buffer. Sources
-    // without an equivalent lever (RPC, Fuel, Simulate) ignore it.
-    ~itemsTarget: int,
+    // without an equivalent lever (RPC, Fuel, Simulate) ignore it. None means no
+    // cap: bounded chunk queries fetch their whole range even if denser than
+    // expected, so client-side-filtered items can't truncate the range short.
+    ~itemsTarget: option<int>,
     ~retry: int,
     ~logger: Pino.t,
   ) => promise<blockRangeFetchResponse>,

package/src/sources/SourceManager.res

@@ -754,7 +754,7 @@ let executeQuery = async (
         "source": source.name,
         "fromBlock": query.fromBlock,
         "toBlock": toBlock,
-        "addresses": query.addressesByContractName->FetchState.addressesByContractNameCount,
+        "addresses": query.addresses->AddressSet.size,
         "retry": retry,
       },
     )
@@ -763,8 +763,7 @@ let executeQuery = async (
       let response = await source.getItemsOrThrow(
         ~fromBlock=query.fromBlock,
         ~toBlock,
-        ~addressesByContractName=query.addressesByContractName,
-        ~contractNameByAddress=query.addressesByContractName->FetchState.deriveContractNameByAddress,
+        ~addressSet=query.addresses,
         ~partitionId=query.partitionId,
         ~knownHeight,
         ~selection=query.selection,

package/src/sources/SourceManager.res.mjs

@@ -3,7 +3,6 @@
 import * as Utils from "../Utils.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as FetchState from "../FetchState.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
@@ -597,11 +596,11 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
       source: source.name,
       fromBlock: query.fromBlock,
       toBlock: toBlock,
-      addresses: FetchState.addressesByContractNameCount(query.addressesByContractName),
+      addresses: query.addresses.size(),
       retry: retry
     });
     try {
-      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, FetchState.deriveContractNameByAddress(query.addressesByContractName), knownHeight, query.partitionId, query.selection, query.itemsTarget, retry, logger$2);
+      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addresses, knownHeight, query.partitionId, query.selection, query.itemsTarget, retry, logger$2);
       recordRequestStats(sourceState, response.requestStats);
       sourceState.lastFailedAt = undefined;
       if (response.knownHeight > sourceState.knownHeight) {

package/src/sources/Svm.res

@@ -100,8 +100,7 @@ let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): S
     getItemsOrThrow: (
       ~fromBlock as _,
       ~toBlock as _,
-      ~addressesByContractName as _,
-      ~contractNameByAddress as _,
+      ~addressSet as _,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,

package/src/sources/Svm.res.mjs

@@ -91,7 +91,7 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
           }]
       };
     },
-    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) => Stdlib_JsError.throwWithMessage("Svm does not support getting items")
+    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) => Stdlib_JsError.throwWithMessage("Svm does not support getting items")
   };
 }
 

package/src/sources/SvmHyperSyncClient.res

@@ -188,9 +188,13 @@ module EventItems = {
     fromSlot: int,
     // Inclusive; None queries to the end of available data.
     toSlot: option<int>,
-    maxNumInstructions: int,
+    // Absent means no server-side cap on the number of instructions returned.
+    maxNumInstructions?: int,
     registrationIndexes: array<int>,
-    addressesByContractName: dict<array<Address.t>>,
+    // Program names to fetch address-free even though their registrations
+    // depend on addresses (client-side filtering). None/empty means every
+    // address-dependent program is filtered server-side.
+    clientFilteredContracts: option<array<string>>,
   }
 
   type log = {
@@ -220,8 +224,10 @@ module EventItems = {
 
   type response = {
     nextSlot: int,
-    // One lean header per slot referenced by `items`; the full blocks live in
-    // the block store returned alongside.
+    // One lean header per returned slot, including slots no item references —
+    // reorg detection and the batch's latest timestamp read them all. The full
+    // blocks live in the block store returned alongside, which keeps only the
+    // slots items reference.
     blocks: array<ResponseTypes.block>,
     items: array<item>,
   }
@@ -239,6 +245,7 @@ type t = {
   // prep.
   getEventItems: (
     ~query: EventItems.query,
+    ~addressSet: AddressSet.t,
   ) => promise<(EventItems.response, TransactionStore.t, BlockStore.t)>,
 }
 
@@ -248,6 +255,7 @@ external classFromConfig: (
   cfg,
   string,
   array<Registration.input>,
+  AddressStore.t,
 ) => t = "fromConfig"
 
 let make = (
@@ -258,6 +266,7 @@ let make = (
   ~retryBaseMs=?,
   ~retryCeilingMs=?,
   ~eventRegistrations=[],
+  ~addressStore,
 ) => {
   let envioVersion = Utils.EnvioPackage.value.version
   Core.getAddon().svmHyperSyncClient->classFromConfig(
@@ -271,5 +280,6 @@ let make = (
     },
     `hyperindex/${envioVersion}`,
     eventRegistrations,
+    addressStore,
   )
 }

package/src/sources/SvmHyperSyncClient.res.mjs

@@ -45,7 +45,7 @@ let ResponseTypes = {};
 
 let EventItems = {};
 
-function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, retryCeilingMs, eventRegistrationsOpt) {
+function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, retryCeilingMs, eventRegistrationsOpt, addressStore) {
   let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let envioVersion = Utils.EnvioPackage.value.version;
   return Core.getAddon().SvmHyperSyncClient.fromConfig({
@@ -55,7 +55,7 @@ function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, retryBaseMs, r
     maxNumRetries: maxNumRetries,
     retryBaseMs: retryBaseMs,
     retryCeilingMs: retryCeilingMs
-  }, `hyperindex/` + envioVersion, eventRegistrations);
+  }, `hyperindex/` + envioVersion, eventRegistrations, addressStore);
 }
 
 export {

package/src/sources/SvmHyperSyncSource.res

@@ -6,6 +6,8 @@ type options = {
   apiToken: option<string>,
   onEventRegistrations: array<Internal.svmOnEventRegistration>,
   clientTimeoutMillis: int,
+  // The chain's address index; the client reads it while routing.
+  addressStore: AddressStore.t,
 }
 
 // Synthesize a stable logIndex for an SVM instruction so the FetchState
@@ -66,7 +68,7 @@ let toSvmInstruction = (
 }
 
 let make = (
-  {chain, endpointUrl, apiToken, onEventRegistrations, clientTimeoutMillis}: options,
+  {chain, endpointUrl, apiToken, onEventRegistrations, clientTimeoutMillis, addressStore}: options,
 ): t => {
   let name = "SvmHyperSync"
 
@@ -80,13 +82,13 @@ let make = (
     ~eventRegistrations=SvmHyperSyncClient.Registration.fromOnEventRegistrations(
       onEventRegistrations,
     ),
+    ~addressStore,
   )
 
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
-    ~addressesByContractName,
-    ~contractNameByAddress as _,
+    ~addressSet,
     ~knownHeight,
     ~partitionId as _,
     ~selection: FetchState.selection,
@@ -100,12 +102,15 @@ let make = (
     let query: SvmHyperSyncClient.EventItems.query = {
       fromSlot: fromBlock,
       toSlot: toBlock,
-      maxNumInstructions: itemsTarget,
+      maxNumInstructions: ?itemsTarget,
       registrationIndexes: selection.onEventRegistrations->Array.map(reg => reg.index),
-      addressesByContractName,
+      clientFilteredContracts: selection.clientFilteredContracts,
     }
 
-    let (resp, transactionStore, blockStore) = try await client.getEventItems(~query) catch {
+    let (resp, transactionStore, blockStore) = try await client.getEventItems(
+      ~query,
+      ~addressSet,
+    ) catch {
     | exn =>
       throw(
         Source.GetItemsError(

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -58,21 +58,22 @@ function toSvmInstruction(item, programName, instructionName) {
 function make(param) {
   let onEventRegistrations = param.onEventRegistrations;
   let chain = param.chain;
-  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations));
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, param$1, selection, itemsTarget, retry, param$2) => {
+  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
+  let getItemsOrThrow = async (fromBlock, toBlock, addressSet, knownHeight, param, selection, itemsTarget, retry, param$1) => {
     let totalTimeRef = Performance.now();
     let pageFetchRef = Performance.now();
     let query_registrationIndexes = selection.onEventRegistrations.map(reg => reg.index);
+    let query_clientFilteredContracts = selection.clientFilteredContracts;
     let query = {
       fromSlot: fromBlock,
       toSlot: toBlock,
       maxNumInstructions: itemsTarget,
       registrationIndexes: query_registrationIndexes,
-      addressesByContractName: addressesByContractName
+      clientFilteredContracts: query_clientFilteredContracts
     };
     let match;
     try {
-      match = await client.getEventItems(query);
+      match = await client.getEventItems(query, addressSet);
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
       throw {