envio 3.5.0-alpha.1 → 3.5.0-alpha.3

package/src/sources/AddressStore.res

@@ -0,0 +1,152 @@
+// Binding to the Rust `AddressStore` napi class: the chain-wide index of every
+// address being indexed, config-declared or dynamically registered. It owns
+// registration bookkeeping (conflict detection, `effectiveStartBlock`
+// derivation, reorg rollback) and hands out `AddressSet` snapshots for the
+// fetch state's partitions. One store lives per chain on `ChainState`, shared
+// with that chain's source clients — which read it to drop items whose emitter
+// (or address-valued param) isn't registered at the item's block.
+type t
+
+// A contract the chain has events for. An address registered for anything else
+// gets the `NoEvents` verdict: persisted so a future config that adds events
+// picks it up, but never fetched.
+type contract = {name: string, startBlock: option<int>}
+
+type registration = {
+  address: Address.t,
+  contractName: string,
+  // -1 for a config address (not dynamically registered).
+  registrationBlock: int,
+}
+
+type verdict =
+  | Added({effectiveStartBlock: int})
+  // Contract has no events; tracked and persisted, never fetched.
+  | NoEvents({effectiveStartBlock: int})
+  // Already registered for the same contract.
+  | Duplicate({effectiveStartBlock: int, existingEffectiveStartBlock: int})
+  // Already registered for a different contract.
+  | Conflict({existingContractName: string})
+  // Not a well-formed address for the ecosystem.
+  | Invalid
+
+type rawVerdict = {
+  kind: string,
+  effectiveStartBlock: int,
+  existingContractName: Null.t<string>,
+  existingEffectiveStartBlock: Null.t<int>,
+}
+
+type makeSetOptions = {
+  // Only addresses whose id is at or above this. Ids are handed out in
+  // registration order, so a cursor read before a batch (`nextId`) selects
+  // exactly what that batch added.
+  minId?: int,
+  // Inclusive effectiveStartBlock bounds.
+  fromStartBlock?: int,
+  toStartBlock?: int,
+  offset?: int,
+  limit?: int,
+}
+
+@send
+external newEvm: (Core.addressStoreCtor, bool, array<contract>) => t = "newEvm"
+@send external newSvm: (Core.addressStoreCtor, array<contract>) => t = "newSvm"
+@send external newFuel: (Core.addressStoreCtor, array<contract>) => t = "newFuel"
+
+// The store's ecosystem is fixed here, from the chain's config, and decides how
+// address strings are parsed and rendered back. EVM carries the chain's
+// address-checksumming setting so entries render exactly as the sources do.
+let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool, ~contracts: array<contract>): t => {
+  let ctor = Core.getAddon().addressStore
+  switch ecosystem {
+  | Evm => ctor->newEvm(shouldChecksum, contracts)
+  | Svm => ctor->newSvm(contracts)
+  | Fuel => ctor->newFuel(contracts)
+  }
+}
+
+// The contracts of a chain that have events, with the earliest block any of
+// their events may fire at.
+let contractsOf = (~onEventRegistrations: array<Internal.onEventRegistration>): array<contract> => {
+  let startBlocks = Dict.make()
+  let names = []
+  onEventRegistrations->Array.forEach(reg => {
+    let name = reg.eventConfig.contractName
+    switch startBlocks->Utils.Dict.dangerouslyGetNonOption(name) {
+    | None =>
+      names->Array.push(name)->ignore
+      startBlocks->Dict.set(name, reg.startBlock)
+    | Some(existing) =>
+      startBlocks->Dict.set(
+        name,
+        switch (existing, reg.startBlock) {
+        | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
+        | (Some(_) as s, None) | (None, Some(_) as s) => s
+        | (None, None) => None
+        },
+      )
+    }
+  })
+  names->Array.map(name => {name, startBlock: startBlocks->Dict.getUnsafe(name)})
+}
+
+@send external nextId: t => int = "nextId"
+
+// A set holding nothing — what an address-free (wildcard) partition carries, so
+// every partition is queried through the same handle.
+@send external emptySet: t => AddressSet.t = "emptySet"
+
+// A set over exactly these addresses, in set order. Every set of a chain must
+// come from that chain's one store — ids are store-scoped, so sets from
+// different stores can't be merged.
+@send external makeSetOf: (t, array<Address.t>) => AddressSet.t = "makeSetOf"
+@send external registerBatchRaw: (t, array<registration>) => array<rawVerdict> = "registerBatch"
+@send external makeSetRaw: (t, string, makeSetOptions) => AddressSet.t = "makeSet"
+@send
+external startBlockGroups: (t, string) => array<AddressSet.startBlockGroup> = "startBlockGroups"
+@send external contractCount: (t, string) => int = "contractCount"
+@send external size: t => int = "size"
+
+// The gate routing applies, exposed for the simulate source — it has no real
+// query boundary to gate at.
+@send external has: (t, Address.t, string, int) => bool = "has"
+
+// Drops every address registered after the target block, returning how many
+// were dropped. Ids are tombstoned rather than reused, so sets built before the
+// rollback still point at the right entries.
+@send external rollback: (t, int) => int = "rollback"
+
+@send external getRaw: (t, Address.t) => Null.t<Internal.indexingContract> = "get"
+
+@send external contractAddresses: (t, string) => array<Address.t> = "contractAddresses"
+
+@send external entries: t => array<Internal.indexingContract> = "entries"
+
+let toVerdict = (raw: rawVerdict): verdict =>
+  switch raw.kind {
+  | "added" => Added({effectiveStartBlock: raw.effectiveStartBlock})
+  | "noEvents" => NoEvents({effectiveStartBlock: raw.effectiveStartBlock})
+  | "duplicate" =>
+    Duplicate({
+      effectiveStartBlock: raw.effectiveStartBlock,
+      existingEffectiveStartBlock: raw.existingEffectiveStartBlock->Null.getUnsafe,
+    })
+  | "conflict" => Conflict({existingContractName: raw.existingContractName->Null.getUnsafe})
+  | "invalid" => Invalid
+  | kind => JsError.throwWithMessage(`Unexpected address registration verdict "${kind}"`)
+  }
+
+// Registers a batch, resolving each address against both the store and the
+// batch's own earlier entries — so two contracts claiming one address inside a
+// single batch conflict just as they would across batches. Verdicts come back
+// in the batch's order.
+let registerBatch = (store: t, registrations: array<registration>): array<verdict> =>
+  store->registerBatchRaw(registrations)->Array.map(toVerdict)
+
+let makeSet = (store: t, ~contractName, ~options={}: makeSetOptions) =>
+  store->makeSetRaw(contractName, options)
+
+// The entry an address is registered under, whichever contract holds it —
+// addresses are unique chain-wide. `None` once rolled back.
+let get = (store: t, address) => store->getRaw(address)->Null.toOption

package/src/sources/AddressStore.res.mjs

@@ -0,0 +1,97 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function make(ecosystem, shouldChecksum, contracts) {
+  let ctor = Core.getAddon().AddressStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum, contracts);
+    case "fuel" :
+      return ctor.newFuel(contracts);
+    case "svm" :
+      return ctor.newSvm(contracts);
+  }
+}
+
+function contractsOf(onEventRegistrations) {
+  let startBlocks = {};
+  let names = [];
+  onEventRegistrations.forEach(reg => {
+    let name = reg.eventConfig.contractName;
+    let existing = startBlocks[name];
+    if (existing !== undefined) {
+      let existing$1 = Primitive_option.valFromOption(existing);
+      let match = reg.startBlock;
+      startBlocks[name] = existing$1 !== undefined ? (
+          match !== undefined ? Primitive_int.min(existing$1, match) : existing$1
+        ) : (
+          match !== undefined ? match : undefined
+        );
+      return;
+    }
+    names.push(name);
+    startBlocks[name] = reg.startBlock;
+  });
+  return names.map(name => ({
+    name: name,
+    startBlock: startBlocks[name]
+  }));
+}
+
+function toVerdict(raw) {
+  let kind = raw.kind;
+  switch (kind) {
+    case "added" :
+      return {
+        TAG: "Added",
+        effectiveStartBlock: raw.effectiveStartBlock
+      };
+    case "conflict" :
+      return {
+        TAG: "Conflict",
+        existingContractName: raw.existingContractName
+      };
+    case "duplicate" :
+      return {
+        TAG: "Duplicate",
+        effectiveStartBlock: raw.effectiveStartBlock,
+        existingEffectiveStartBlock: raw.existingEffectiveStartBlock
+      };
+    case "invalid" :
+      return "Invalid";
+    case "noEvents" :
+      return {
+        TAG: "NoEvents",
+        effectiveStartBlock: raw.effectiveStartBlock
+      };
+    default:
+      return Stdlib_JsError.throwWithMessage(`Unexpected address registration verdict "` + kind + `"`);
+  }
+}
+
+function registerBatch(store, registrations) {
+  return store.registerBatch(registrations).map(toVerdict);
+}
+
+function makeSet(store, contractName, optionsOpt) {
+  let options = optionsOpt !== undefined ? optionsOpt : ({});
+  return store.makeSet(contractName, options);
+}
+
+function get(store, address) {
+  return Primitive_option.fromNull(store.get(address));
+}
+
+export {
+  make,
+  contractsOf,
+  toVerdict,
+  registerBatch,
+  makeSet,
+  get,
+}
+/* Core Not a pure module */

package/src/sources/EvmChain.res

@@ -45,6 +45,7 @@ let makeSources = (
   ~hyperSync,
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
+  ~addressStore,
 ) => {
   let sources = switch hyperSync {
   | Some(endpointUrl) => [
@@ -58,6 +59,7 @@ let makeSources = (
         serializationFormat: Env.hypersyncClientSerializationFormat,
         enableQueryCaching: Env.hypersyncClientEnableQueryCaching,
         logLevel: Env.hypersyncLogLevel,
+        addressStore,
       }),
     ]
   | _ => []
@@ -70,6 +72,7 @@ let makeSources = (
       url,
       onEventRegistrations,
       lowercaseAddresses,
+      addressStore,
       ?ws,
       ?headers,
     })

package/src/sources/EvmChain.res.mjs

@@ -19,7 +19,7 @@ function getSyncConfig(param) {
   };
 }
 
-function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses) {
+function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses, addressStore) {
   let sources = hyperSync !== undefined ? [EvmHyperSyncSource.make({
         chain: chain,
         endpointUrl: hyperSync,
@@ -29,7 +29,8 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
         lowercaseAddresses: lowercaseAddresses,
         serializationFormat: Env.hypersyncClientSerializationFormat,
         enableQueryCaching: Env.hypersyncClientEnableQueryCaching,
-        logLevel: Env.hypersyncLogLevel
+        logLevel: Env.hypersyncLogLevel,
+        addressStore: addressStore
       })] : [];
   rpcs.forEach(param => {
     let source = RpcSource.make({
@@ -39,6 +40,7 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
       chain: chain,
       onEventRegistrations: onEventRegistrations,
       lowercaseAddresses: lowercaseAddresses,
+      addressStore: addressStore,
       ws: param.ws,
       headers: param.headers
     });

package/src/sources/EvmHyperSyncSource.res

@@ -16,6 +16,8 @@ type options = {
   serializationFormat: HyperSyncClient.serializationFormat,
   enableQueryCaching: bool,
   logLevel: HyperSyncClient.logLevel,
+  // The chain's address index; the client reads it while routing.
+  addressStore: AddressStore.t,
 }
 
 let make = (
@@ -29,6 +31,7 @@ let make = (
     serializationFormat,
     enableQueryCaching,
     logLevel,
+    addressStore,
   }: options,
 ): t => {
   let name = "HyperSync"
@@ -50,6 +53,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     ~serializationFormat,
     ~enableQueryCaching,
     ~logLevel,
+    ~addressStore,
   ) {
   | client => client
   | exception exn =>
@@ -86,8 +90,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
-    ~addressesByContractName,
-    ~contractNameByAddress as _,
+    ~addressSet,
     ~knownHeight,
     ~partitionId as _,
     ~selection: FetchState.selection,
@@ -106,7 +109,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       ~toBlock,
       ~maxNumLogs=itemsTarget,
       ~registrationIndexes=selection.onEventRegistrations->Array.map(reg => reg.index),
-      ~addressesByContractName,
+      ~addressSet,
       ~clientFilteredContracts=selection.clientFilteredContracts,
     ) catch {
     | HyperSync.GetLogs.Error(error) =>

package/src/sources/EvmHyperSyncSource.res.mjs

@@ -28,7 +28,7 @@ Set the ENVIO_API_TOKEN environment variable in your .env file.
 Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
   let client;
   try {
-    client = HyperSyncClient.make(endpointUrl, apiToken$1, param.clientTimeoutMillis, HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), !param.lowercaseAddresses, param.serializationFormat, param.enableQueryCaching, undefined, undefined, undefined, param.logLevel);
+    client = HyperSyncClient.make(endpointUrl, apiToken$1, param.clientTimeoutMillis, HyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), !param.lowercaseAddresses, param.serializationFormat, param.enableQueryCaching, undefined, undefined, undefined, param.logLevel, param.addressStore);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     client = ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate the hypersync client, please double check your ABI", exn);
@@ -52,12 +52,12 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
       }
     };
   };
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, param$1, selection, itemsTarget, retry, param$2) => {
+  let getItemsOrThrow = async (fromBlock, toBlock, addressSet, knownHeight, param, selection, itemsTarget, retry, param$1) => {
     let totalTimeRef = Performance.now();
     let startFetchingBatchTimeRef = Performance.now();
     let pageUnsafe;
     try {
-      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, itemsTarget, selection.onEventRegistrations.map(reg => reg.index), addressesByContractName, selection.clientFilteredContracts);
+      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, itemsTarget, selection.onEventRegistrations.map(reg => reg.index), addressSet, selection.clientFilteredContracts);
     } catch (raw_error) {
       let error = Primitive_exceptions.internalToException(raw_error);
       if (error.RE_EXN_ID === HyperSync.GetLogs.$$Error) {

package/src/sources/EvmRpcClient.res

@@ -26,7 +26,6 @@ type nextPageParams = {
   // selections and the routing index are derived on the Rust side from the
   // registrations passed at construction.
   registrationIndexes: array<int>,
-  addressesByContractName: dict<array<Address.t>>,
   // Contract names to fetch address-free even though their registrations
   // depend on addresses (client-side filtering). None/empty means
   // every address-dependent contract is filtered server-side.
@@ -42,7 +41,7 @@ type nextPageResponse = {
 // The caller provides a range; Rust decides the actual `toBlock` and returns it.
 type t = {
   getHeight: unit => promise<int>,
-  getNextPage: nextPageParams => promise<nextPageResponse>,
+  getNextPage: (nextPageParams, AddressSet.t) => promise<nextPageResponse>,
 }
 
 @send
@@ -51,6 +50,7 @@ external classNew: (
   cfg,
   array<HyperSyncClient.Registration.input>,
   ~checksumAddresses: bool,
+  ~addressStore: AddressStore.t,
 ) => t = "new"
 
 // Rust encodes JSON-RPC errors as a JSON payload in the napi error's
@@ -89,6 +89,7 @@ let make = (
   ~httpReqTimeoutMillis=?,
   ~headers=?,
   ~eventRegistrations=[],
+  ~addressStore,
 ) => {
   let client = Core.getAddon().evmRpcClient->classNew(
     {
@@ -104,9 +105,11 @@ let make = (
     },
     eventRegistrations,
     ~checksumAddresses,
+    ~addressStore,
   )
   {
     getHeight: () => client.getHeight()->Promise.catch(coerceErrorOrThrow),
-    getNextPage: params => client.getNextPage(params)->Promise.catch(coerceErrorOrThrow),
+    getNextPage: (params, addressSet) =>
+      client.getNextPage(params, addressSet)->Promise.catch(coerceErrorOrThrow),
   }
 }

package/src/sources/EvmRpcClient.res.mjs

@@ -46,7 +46,7 @@ function coerceErrorOrThrow(exn) {
   throw exn;
 }
 
-function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, eventRegistrationsOpt) {
+function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, eventRegistrationsOpt, addressStore) {
   let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let client = Core.getAddon().EvmRpcClient.new({
     url: url,
@@ -58,10 +58,10 @@ function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers,
     intervalCeiling: syncConfig.intervalCeiling,
     backoffMillis: syncConfig.backoffMillis,
     queryTimeoutMillis: syncConfig.queryTimeoutMillis
-  }, eventRegistrations, checksumAddresses);
+  }, eventRegistrations, checksumAddresses, addressStore);
   return {
     getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow),
-    getNextPage: params => Stdlib_Promise.$$catch(client.getNextPage(params), coerceErrorOrThrow)
+    getNextPage: (params, addressSet) => Stdlib_Promise.$$catch(client.getNextPage(params, addressSet), coerceErrorOrThrow)
   };
 }
 

package/src/sources/FuelHyperSync.res

@@ -43,16 +43,17 @@ module GetLogs = {
     ~fromBlock,
     ~toBlock,
     ~registrationIndexes,
-    ~addressesByContractName,
+    ~addressSet,
+    ~clientFilteredContracts,
   ): logsQueryPage => {
     let query: FuelHyperSyncClient.EventItems.query = {
       fromBlock,
       toBlock,
       registrationIndexes,
-      addressesByContractName,
+      clientFilteredContracts,
     }
 
-    let res = switch await client->FuelHyperSyncClient.getEventItems(query) {
+    let res = switch await client->FuelHyperSyncClient.getEventItems(query, addressSet) {
     | res => res
     | exception exn =>
       switch exn->extractMissingParams {

package/src/sources/FuelHyperSync.res.mjs

@@ -29,16 +29,16 @@ function extractMissingParams(exn) {
   }
 }
 
-async function query(client, fromBlock, toBlock, registrationIndexes, addressesByContractName) {
+async function query(client, fromBlock, toBlock, registrationIndexes, addressSet, clientFilteredContracts) {
   let query$1 = {
     fromBlock: fromBlock,
     toBlock: toBlock,
     registrationIndexes: registrationIndexes,
-    addressesByContractName: addressesByContractName
+    clientFilteredContracts: clientFilteredContracts
   };
   let res;
   try {
-    res = await client.getEventItems(query$1);
+    res = await client.getEventItems(query$1, addressSet);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     let missingParams = extractMissingParams(exn);

package/src/sources/FuelHyperSync.resi

@@ -17,6 +17,7 @@ module GetLogs: {
     ~fromBlock: int,
     ~toBlock: option<int>,
     ~registrationIndexes: array<int>,
-    ~addressesByContractName: dict<array<Address.t>>,
+    ~addressSet: AddressSet.t,
+    ~clientFilteredContracts: option<array<string>>,
   ) => promise<logsQueryPage>
 }

package/src/sources/FuelHyperSyncClient.res

@@ -52,15 +52,18 @@ module Registration = {
 }
 
 module EventItems = {
-  // The whole per-query input: block range, the partition's registration
-  // selection (by index), and its current addresses. Receipt selections,
-  // field selection, and routing are derived on the Rust side.
+  // The whole per-query input beside the partition's address set: block range
+  // and the registration selection (by index). Receipt selections, field
+  // selection, and routing are derived on the Rust side.
   type query = {
     fromBlock: int,
     // Inclusive; None queries to the end of available data.
     toBlock: option<int>,
     registrationIndexes: array<int>,
-    addressesByContractName: dict<array<Address.t>>,
+    // Contract names to fetch address-free even though their registrations
+    // depend on addresses (client-side filtering). None/empty means every
+    // address-dependent contract is filtered server-side.
+    clientFilteredContracts: option<array<string>>,
   }
 
   // One routed receipt with its kind-specific columns flattened: LogData
@@ -102,19 +105,22 @@ external classNew: (
   cfg,
   ~userAgent: string,
   array<Registration.input>,
+  AddressStore.t,
 ) => t = "new"
 
-let make = (cfg: cfg, ~eventRegistrations) => {
+let make = (cfg: cfg, ~eventRegistrations, ~addressStore) => {
   let envioVersion = Utils.EnvioPackage.value.version
   Core.getAddon().fuelHyperSyncClient->classNew(
     cfg,
     ~userAgent=`hyperindex/${envioVersion}`,
     eventRegistrations,
+    addressStore,
   )
 }
 
 @send
-external getEventItems: (t, EventItems.query) => promise<EventItems.response> = "getEventItems"
+external getEventItems: (t, EventItems.query, AddressSet.t) => promise<EventItems.response> =
+  "getEventItems"
 
 @send
 external getHeight: t => promise<int> = "getHeight"

package/src/sources/FuelHyperSyncClient.res.mjs

@@ -58,9 +58,9 @@ let Registration = {
 
 let EventItems = {};
 
-function make(cfg, eventRegistrations) {
+function make(cfg, eventRegistrations, addressStore) {
   let envioVersion = Utils.EnvioPackage.value.version;
-  return Core.getAddon().FuelHyperSyncClient.new(cfg, `hyperindex/` + envioVersion, eventRegistrations);
+  return Core.getAddon().FuelHyperSyncClient.new(cfg, `hyperindex/` + envioVersion, eventRegistrations, addressStore);
 }
 
 export {

package/src/sources/FuelHyperSyncSource.res

@@ -8,9 +8,11 @@ type options = {
   apiToken: option<string>,
   // The chain's registrations, indexed by their sequential `index`.
   onEventRegistrations: array<Internal.fuelOnEventRegistration>,
+  // The chain's address index; the client reads it while routing.
+  addressStore: AddressStore.t,
 }
 
-let make = ({chain, endpointUrl, apiToken, onEventRegistrations}: options): t => {
+let make = ({chain, endpointUrl, apiToken, onEventRegistrations, addressStore}: options): t => {
   let name = "HyperFuel"
 
   let apiToken = switch apiToken {
@@ -24,6 +26,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
   let client = switch FuelHyperSyncClient.make(
     {url: endpointUrl, apiToken},
     ~eventRegistrations=FuelHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations),
+    ~addressStore,
   ) {
   | client => client
   | exception exn =>
@@ -33,8 +36,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
-    ~addressesByContractName,
-    ~contractNameByAddress as _,
+    ~addressSet,
     ~knownHeight,
     ~partitionId as _,
     ~selection: FetchState.selection,
@@ -52,7 +54,8 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       ~fromBlock,
       ~toBlock,
       ~registrationIndexes=selection.onEventRegistrations->Array.map(reg => reg.index),
-      ~addressesByContractName,
+      ~addressSet,
+      ~clientFilteredContracts=selection.clientFilteredContracts,
     ) catch {
     | FuelHyperSync.GetLogs.Error(error) =>
       throw(

package/src/sources/FuelHyperSyncSource.res.mjs

@@ -27,17 +27,17 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
     client = FuelHyperSyncClient.make({
       url: param.endpointUrl,
       apiToken: apiToken$1
-    }, FuelHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations));
+    }, FuelHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     client = ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate the HyperFuel client", exn);
   }
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, param, knownHeight, param$1, selection, param$2, retry, logger) => {
+  let getItemsOrThrow = async (fromBlock, toBlock, addressSet, knownHeight, param, selection, param$1, retry, logger) => {
     let totalTimeRef = Performance.now();
     let startFetchingBatchTimeRef = Performance.now();
     let pageUnsafe;
     try {
-      pageUnsafe = await FuelHyperSync.GetLogs.query(client, fromBlock, toBlock, selection.onEventRegistrations.map(reg => reg.index), addressesByContractName);
+      pageUnsafe = await FuelHyperSync.GetLogs.query(client, fromBlock, toBlock, selection.onEventRegistrations.map(reg => reg.index), addressSet, selection.clientFilteredContracts);
     } catch (raw_error) {
       let error = Primitive_exceptions.internalToException(raw_error);
       if (error.RE_EXN_ID === FuelHyperSync.GetLogs.$$Error) {

package/src/sources/HyperSync.res

@@ -16,7 +16,7 @@ let reraisIfRateLimited = exn =>
 
 type logsQueryPage = {
   items: array<HyperSyncClient.EventItems.item>,
-  // Block headers referenced by `items`, deduplicated by block number.
+  // Headers for every returned block, deduplicated by block number.
   blocks: array<HyperSyncClient.EventItems.blockHeader>,
   nextBlock: int,
   archiveHeight: int,
@@ -92,7 +92,7 @@ module GetLogs = {
     ~toBlock,
     ~maxNumLogs,
     ~registrationIndexes,
-    ~addressesByContractName,
+    ~addressSet,
     ~clientFilteredContracts,
   ): logsQueryPage => {
     let query: HyperSyncClient.EventItems.query = {
@@ -100,11 +100,13 @@ module GetLogs = {
       toBlock,
       ?maxNumLogs,
       registrationIndexes,
-      addressesByContractName,
       clientFilteredContracts,
     }
 
-    let (res, transactionStore, blockStore) = switch await client.getEventItems(~query) {
+    let (res, transactionStore, blockStore) = switch await client.getEventItems(
+      ~query,
+      ~addressSet,
+    ) {
     | res => res
     | exception exn =>
       reraisIfRateLimited(exn)

package/src/sources/HyperSync.res.mjs

@@ -82,18 +82,17 @@ function extractMissingParams(exn) {
   }
 }
 
-async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes, addressesByContractName, clientFilteredContracts) {
+async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes, addressSet, clientFilteredContracts) {
   let query$1 = {
     fromBlock: fromBlock,
     toBlock: toBlock,
     maxNumLogs: maxNumLogs,
     registrationIndexes: registrationIndexes,
-    addressesByContractName: addressesByContractName,
     clientFilteredContracts: clientFilteredContracts
   };
   let match;
   try {
-    match = await client.getEventItems(query$1);
+    match = await client.getEventItems(query$1, addressSet);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
     reraisIfRateLimited(exn);