envio 3.3.0-alpha.9 → 3.3.0-rc.0

package/src/Writing.res.mjs

@@ -2,8 +2,10 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Throttler from "./Throttler.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
+import * as EffectState from "./EffectState.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as InMemoryStore from "./InMemoryStore.res.mjs";
@@ -11,6 +13,7 @@ import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as RollbackCommit from "./RollbackCommit.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as PruneStaleHistory from "./PruneStaleHistory.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function getChangesCount(state) {
@@ -20,7 +23,7 @@ function getChangesCount(state) {
   IndexerState.allEntities(state).forEach(entityConfig => {
     total.contents = total.contents + InMemoryStore.getInMemTable(state, entityConfig).changesCount;
   });
-  Utils.Dict.forEach(IndexerState.effects(state), inMemTable => {
+  EffectState.forEach(IndexerState.effectState(state), inMemTable => {
     total.contents = total.contents + inMemTable.changesCount;
   });
   IndexerState.processedBatches(state).forEach(batch => {
@@ -35,10 +38,12 @@ function waitForCommit(state) {
 
 function snapshotEffects(state, cache) {
   let acc = [];
-  Utils.Dict.forEach(IndexerState.effects(state), inMemTable => {
+  EffectState.forEach(IndexerState.effectState(state), inMemTable => {
     let idsToStore = inMemTable.idsToStore;
     let invalidationsCount = inMemTable.invalidationsCount;
     let dict = inMemTable.dict;
+    let table = inMemTable.table;
+    let scope = inMemTable.scope;
     let effect = inMemTable.effect;
     if (idsToStore.length !== 0) {
       let items = Stdlib_Array.filterMap(idsToStore, id => {
@@ -51,23 +56,27 @@ function snapshotEffects(state, cache) {
         }
       });
       let effectName = effect.name;
-      let c = cache[effectName];
+      let tableName = table.tableName;
+      let c = cache[tableName];
       let effectCacheRecord;
       if (c !== undefined) {
         effectCacheRecord = c;
       } else {
         let c$1 = {
           effectName: effectName,
+          scope: scope,
+          tableName: tableName,
           count: 0
         };
-        cache[effectName] = c$1;
+        cache[tableName] = c$1;
         effectCacheRecord = c$1;
       }
       let shouldInitialize = effectCacheRecord.count === 0;
       effectCacheRecord.count = (effectCacheRecord.count + items.length | 0) - invalidationsCount | 0;
-      Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName);
+      Prometheus.EffectCacheCount.set(effectCacheRecord.count, effectName, Internal.EffectCache.scopeToString(scope));
       acc.push({
-        effect: effect,
+        table: table,
+        itemSchema: effect.storageMeta.itemSchema,
         items: items,
         shouldInitialize: shouldInitialize
       });
@@ -111,11 +120,20 @@ async function runOneWrite(state) {
     }
   });
   let updatedEffectsCache = snapshotEffects(state, cache);
-  await persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, chainMetaData);
+  let writtenEntityNames = new Set();
+  updatedEntities.forEach(param => {
+    writtenEntityNames.add(param.entityConfig.name);
+  });
+  let pruneTargets = PruneStaleHistory.select(state, writtenEntityNames, Stdlib_Option.isSome(rollback));
+  await Promise.all([
+    persistence.storage.writeBatch(batch, rollback, batch.isInReorgThreshold, config, persistence.allEntities, updatedEffectsCache, updatedEntities, chainMetaData),
+    PruneStaleHistory.runConcurrent(state, pruneTargets)
+  ]);
   IndexerState.markCommitted(state, upToCheckpointId);
   if (rollback !== undefined && Utils.$$Array.notEmpty(RollbackCommit.callbacks)) {
-    return await RollbackCommit.fire(rollback.progressBlockNumberByChainId);
+    await RollbackCommit.fire(rollback.progressBlockNumberByChainId);
   }
+  return await PruneStaleHistory.runForced(state, pruneTargets);
 }
 
 function hasPendingWrite(state) {
@@ -164,7 +182,7 @@ function commitBatch(state, batch) {
 function dropCommitted(state, keepLoadedFromDb) {
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
   IndexerState.allEntities(state).forEach(entityConfig => InMemoryTable.Entity.dropCommittedChanges(InMemoryStore.getInMemTable(state, entityConfig), committedCheckpointId, keepLoadedFromDb));
-  Utils.Dict.forEach(IndexerState.effects(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromDb));
+  EffectState.forEach(IndexerState.effectState(state), inMemTable => InMemoryStore.dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromDb));
 }
 
 async function awaitCapacity(state) {

package/src/bindings/NodeJs.res

@@ -173,5 +173,10 @@ module Fs = {
 
     @module("fs") @scope("promises")
     external readdir: Path.t => promise<array<string>> = "readdir"
+
+    type stats
+    @module("fs") @scope("promises")
+    external stat: Path.t => promise<stats> = "stat"
+    @send external statsIsDirectory: stats => bool = "isDirectory"
   }
 }

package/src/bindings/Viem.res

@@ -1,11 +1,6 @@
 type hex = EvmTypes.Hex.t
 @module("viem") external toHex: 'a => hex = "toHex"
-@module("viem") external keccak256: hex => hex = "keccak256"
 @module("viem") external pad: hex => hex = "pad"
 
 type sizeOptions = {size: int}
 @module("viem") external bigintToHex: (bigint, ~options: sizeOptions=?) => hex = "numberToHex"
-@module("viem") external stringToHex: (string, ~options: sizeOptions=?) => hex = "stringToHex"
-@module("viem") external boolToHex: (bool, ~options: sizeOptions=?) => hex = "boolToHex"
-@module("viem") external bytesToHex: (Uint8Array.t, ~options: sizeOptions=?) => hex = "bytesToHex"
-@module("viem") external concat: array<hex> => hex = "concat"

package/src/sources/EventRouter.res

@@ -92,27 +92,6 @@ let get = (router: t<'a>, ~tag, ~contractAddress, ~contractNameByAddress) => {
   }
 }
 
-let getEvmEventId = (~sighash, ~topicCount) => {
-  sighash ++ "_" ++ topicCount->Int.toString
-}
-
-let fromEvmEventModsOrThrow = (events: array<Internal.evmOnEventRegistration>, ~chain): t<
-  Internal.evmOnEventRegistration,
-> => {
-  let router = empty()
-  events->Array.forEach(config => {
-    router->addOrThrow(
-      config.eventConfig.id,
-      config,
-      ~contractName=config.eventConfig.contractName,
-      ~eventName=config.eventConfig.name,
-      ~chain,
-      ~isWildcard=config.isWildcard,
-    )
-  })
-  router
-}
-
 /** Dispatch key for SVM instructions. `None` matches any instruction in the
  program (lowest priority). */
 let getSvmEventId = (~programId: SvmTypes.Pubkey.t, ~discriminator: option<string>) =>

package/src/sources/EventRouter.res.mjs

@@ -97,16 +97,6 @@ function get$1(router, tag, contractAddress, contractNameByAddress) {
   }
 }
 
-function getEvmEventId(sighash, topicCount) {
-  return sighash + "_" + topicCount.toString();
-}
-
-function fromEvmEventModsOrThrow(events, chain) {
-  let router = {};
-  events.forEach(config => addOrThrow$1(router, config.eventConfig.id, config, config.eventConfig.contractName, config.isWildcard, config.eventConfig.name, chain));
-  return router;
-}
-
 function getSvmEventId(programId, discriminator) {
   if (discriminator !== undefined) {
     return programId + "_" + discriminator;
@@ -157,8 +147,6 @@ export {
   empty$1 as empty,
   addOrThrow$1 as addOrThrow,
   get$1 as get,
-  getEvmEventId,
-  fromEvmEventModsOrThrow,
   getSvmEventId,
   fromSvmEventConfigsOrThrow,
 }

package/src/sources/EvmChain.res

@@ -39,25 +39,6 @@ let getSyncConfig = (
   }
 }
 
-let collectEventParams = (onEventRegistrations: array<Internal.evmOnEventRegistration>): array<
-  HyperSyncClient.Decoder.eventParamsInput,
-> => {
-  let result = []
-  onEventRegistrations->Array.forEach(reg => {
-    let event = reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.evmEventConfig)
-    result
-    ->Array.push({
-      HyperSyncClient.Decoder.sighash: event.sighash,
-      topicCount: event.topicCount,
-      eventName: event.name,
-      contractName: event.contractName,
-      params: event.paramsMetadata,
-    })
-    ->ignore
-  })
-  result
-}
-
 let makeSources = (
   ~chain,
   ~onEventRegistrations: array<Internal.evmOnEventRegistration>,
@@ -65,17 +46,12 @@ let makeSources = (
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
 ) => {
-  let eventRouter = onEventRegistrations->EventRouter.fromEvmEventModsOrThrow(~chain)
-
-  let allEventParams = collectEventParams(onEventRegistrations)
-
   let sources = switch hyperSync {
   | Some(endpointUrl) => [
       HyperSyncSource.make({
         chain,
         endpointUrl,
-        allEventParams,
-        eventRouter,
+        onEventRegistrations,
         apiToken: Env.envioApiToken,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses,
@@ -92,8 +68,7 @@ let makeSources = (
       sourceFor,
       syncConfig: getSyncConfig(syncConfig->Option.getOr({})),
       url,
-      eventRouter,
-      allEventParams,
+      onEventRegistrations,
       lowercaseAddresses,
       ?ws,
       ?headers,

package/src/sources/EvmChain.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Env from "../Env.res.mjs";
 import * as RpcSource from "./RpcSource.res.mjs";
-import * as EventRouter from "./EventRouter.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as HyperSyncSource from "./HyperSyncSource.res.mjs";
 
@@ -20,29 +19,11 @@ function getSyncConfig(param) {
   };
 }
 
-function collectEventParams(onEventRegistrations) {
-  let result = [];
-  onEventRegistrations.forEach(reg => {
-    let event = reg.eventConfig;
-    result.push({
-      sighash: event.sighash,
-      topicCount: event.topicCount,
-      eventName: event.name,
-      contractName: event.contractName,
-      params: event.paramsMetadata
-    });
-  });
-  return result;
-}
-
 function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses) {
-  let eventRouter = EventRouter.fromEvmEventModsOrThrow(onEventRegistrations, chain);
-  let allEventParams = collectEventParams(onEventRegistrations);
   let sources = hyperSync !== undefined ? [HyperSyncSource.make({
         chain: chain,
         endpointUrl: hyperSync,
-        allEventParams: allEventParams,
-        eventRouter: eventRouter,
+        onEventRegistrations: onEventRegistrations,
         apiToken: Env.envioApiToken,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses: lowercaseAddresses,
@@ -56,8 +37,7 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
       syncConfig: getSyncConfig(Stdlib_Option.getOr(param.syncConfig, {})),
       url: param.url,
       chain: chain,
-      eventRouter: eventRouter,
-      allEventParams: allEventParams,
+      onEventRegistrations: onEventRegistrations,
       lowercaseAddresses: lowercaseAddresses,
       ws: param.ws,
       headers: param.headers
@@ -69,7 +49,6 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
 
 export {
   getSyncConfig,
-  collectEventParams,
   makeSources,
 }
 /* Env Not a pure module */

package/src/sources/EvmRpcClient.res

@@ -1,32 +1,51 @@
-type cfg = {url: string, httpReqTimeoutMillis?: int, headers?: dict<string>}
-
-// `addresses` omitted matches any address (a wildcard selection). Each `topics`
-// position is `null` (match any) or a list of accepted topic hashes; the
-// single-match case is a one-element list.
-type getLogsParams = {
-  fromBlock: int,
-  toBlock: int,
-  addresses?: array<Address.t>,
-  topics: array<Nullable.t<array<string>>>,
+type cfg = {
+  url: string,
+  httpReqTimeoutMillis?: int,
+  headers?: dict<string>,
+  initialBlockInterval: int,
+  backoffMultiplicative: float,
+  accelerationAdditive: int,
+  intervalCeiling: int,
+  backoffMillis: int,
+  queryTimeoutMillis: int,
 }
 
-// Decoded `params` keyed by contract name, matching the HyperSync decoder's
-// shape so the caller routes by address then picks its contract's params.
+// Only logs that resolved to a registration cross the boundary, each carrying
+// its registration's chain-scoped index.
 type rpcEventItem = {
   log: Rpc.GetLogs.log,
-  params: Nullable.t<dict<Internal.eventParams>>,
+  onEventRegistrationIndex: int,
+  params: Internal.eventParams,
+}
+
+type nextPageParams = {
+  fromBlock: int,
+  toBlockCeiling: int,
+  partitionId: string,
+  // The partition's registration selection, by chain-scoped index. Log
+  // 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>>,
+}
+
+type nextPageResponse = {
+  items: array<rpcEventItem>,
+  toBlock: int,
+  requestStats: array<Source.requestStat>,
 }
 
+// The caller provides a range; Rust decides the actual `toBlock` and returns it.
 type t = {
   getHeight: unit => promise<int>,
-  getLogs: getLogsParams => promise<array<rpcEventItem>>,
+  getNextPage: nextPageParams => promise<nextPageResponse>,
 }
 
 @send
 external classNew: (
   Core.evmRpcClientCtor,
   cfg,
-  array<HyperSyncClient.Decoder.eventParamsInput>,
+  array<HyperSyncClient.Registration.input>,
   ~checksumAddresses: bool,
 ) => t = "new"
 
@@ -59,15 +78,31 @@ let coerceErrorOrThrow = exn =>
   | None => exn->throw
   }
 
-let make = (~url, ~checksumAddresses, ~httpReqTimeoutMillis=?, ~headers=?, ~allEventParams=[]) => {
-  let client =
-    Core.getAddon().evmRpcClient->classNew(
-      {url, ?httpReqTimeoutMillis, ?headers},
-      allEventParams,
-      ~checksumAddresses,
-    )
+let make = (
+  ~url,
+  ~checksumAddresses,
+  ~syncConfig: Config.sourceSync,
+  ~httpReqTimeoutMillis=?,
+  ~headers=?,
+  ~eventRegistrations=[],
+) => {
+  let client = Core.getAddon().evmRpcClient->classNew(
+    {
+      url,
+      ?httpReqTimeoutMillis,
+      ?headers,
+      initialBlockInterval: syncConfig.initialBlockInterval,
+      backoffMultiplicative: syncConfig.backoffMultiplicative,
+      accelerationAdditive: syncConfig.accelerationAdditive,
+      intervalCeiling: syncConfig.intervalCeiling,
+      backoffMillis: syncConfig.backoffMillis,
+      queryTimeoutMillis: syncConfig.queryTimeoutMillis,
+    },
+    eventRegistrations,
+    ~checksumAddresses,
+  )
   {
     getHeight: () => client.getHeight()->Promise.catch(coerceErrorOrThrow),
-    getLogs: params => client.getLogs(params)->Promise.catch(coerceErrorOrThrow),
+    getNextPage: params => client.getNextPage(params)->Promise.catch(coerceErrorOrThrow),
   }
 }

package/src/sources/EvmRpcClient.res.mjs

@@ -46,16 +46,22 @@ function coerceErrorOrThrow(exn) {
   throw exn;
 }
 
-function make(url, checksumAddresses, httpReqTimeoutMillis, headers, allEventParamsOpt) {
-  let allEventParams = allEventParamsOpt !== undefined ? allEventParamsOpt : [];
+function make(url, checksumAddresses, syncConfig, httpReqTimeoutMillis, headers, eventRegistrationsOpt) {
+  let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let client = Core.getAddon().EvmRpcClient.new({
     url: url,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
-    headers: headers
-  }, allEventParams, checksumAddresses);
+    headers: headers,
+    initialBlockInterval: syncConfig.initialBlockInterval,
+    backoffMultiplicative: syncConfig.backoffMultiplicative,
+    accelerationAdditive: syncConfig.accelerationAdditive,
+    intervalCeiling: syncConfig.intervalCeiling,
+    backoffMillis: syncConfig.backoffMillis,
+    queryTimeoutMillis: syncConfig.queryTimeoutMillis
+  }, eventRegistrations, checksumAddresses);
   return {
     getHeight: () => Stdlib_Promise.$$catch(client.getHeight(), coerceErrorOrThrow),
-    getLogs: params => Stdlib_Promise.$$catch(client.getLogs(params), coerceErrorOrThrow)
+    getNextPage: params => Stdlib_Promise.$$catch(client.getNextPage(params), coerceErrorOrThrow)
   };
 }
 

package/src/sources/HyperSync.res

@@ -61,23 +61,6 @@ module GetLogs = {
 
   exception Error(error)
 
-  let makeRequestBody = (
-    ~fromBlock,
-    ~toBlockInclusive,
-    ~addressesWithTopics,
-    ~fieldSelection,
-    ~maxNumLogs,
-  ): HyperSyncClient.QueryTypes.query => {
-    fromBlock,
-    toBlockExclusive: ?switch toBlockInclusive {
-    | Some(toBlockInclusive) => Some(toBlockInclusive + 1)
-    | None => None
-    },
-    logs: addressesWithTopics,
-    fieldSelection,
-    maxNumLogs,
-  }
-
   // Rust encodes structured failures as a JSON payload in the napi error's
   // message: `{"kind":"MissingFields","fields":["block.timestamp", ...]}`.
   // JSON.parse + shape check is the recovery protocol — no string-grepping
@@ -107,29 +90,17 @@ module GetLogs = {
     ~client: HyperSyncClient.t,
     ~fromBlock,
     ~toBlock,
-    ~logSelections: array<LogSelection.t>,
-    ~fieldSelection,
     ~maxNumLogs,
+    ~registrationIndexes,
+    ~addressesByContractName,
   ): logsQueryPage => {
-    let addressesWithTopics = logSelections->Array.flatMap(({addresses, topicSelections}) =>
-      topicSelections->Array.map(({topic0, topic1, topic2, topic3}) => {
-        let topics = HyperSyncClient.QueryTypes.makeTopicSelection(
-          ~topic0,
-          ~topic1,
-          ~topic2,
-          ~topic3,
-        )
-        HyperSyncClient.QueryTypes.makeLogSelection(~address=addresses, ~topics)
-      })
-    )
-
-    let query = makeRequestBody(
-      ~fromBlock,
-      ~toBlockInclusive=toBlock,
-      ~addressesWithTopics,
-      ~fieldSelection,
-      ~maxNumLogs,
-    )
+    let query: HyperSyncClient.EventItems.query = {
+      fromBlock,
+      toBlock,
+      maxNumLogs,
+      registrationIndexes,
+      addressesByContractName,
+    }
 
     let (res, transactionStore, blockStore) = switch await client.getEventItems(~query) {
     | res => res

package/src/sources/HyperSync.res.mjs

@@ -12,7 +12,6 @@ import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function reraisIfRateLimited(exn) {
@@ -62,16 +61,6 @@ function mapExn(queryResponse) {
 
 let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperSync.GetLogs.Error");
 
-function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, fieldSelection, maxNumLogs) {
-  return {
-    fromBlock: fromBlock,
-    toBlock: toBlockInclusive !== undefined ? toBlockInclusive + 1 | 0 : undefined,
-    logs: addressesWithTopics,
-    fieldSelection: fieldSelection,
-    maxNumLogs: maxNumLogs
-  };
-}
-
 function extractMissingParams(exn) {
   let message = exn.RE_EXN_ID === "JsExn" ? Stdlib_JsExn.message(exn._1) : undefined;
   if (message === undefined) {
@@ -93,15 +82,14 @@ function extractMissingParams(exn) {
   }
 }
 
-async function query(client, fromBlock, toBlock, logSelections, fieldSelection, maxNumLogs) {
-  let addressesWithTopics = logSelections.flatMap(param => {
-    let addresses = param.addresses;
-    return param.topicSelections.map(param => {
-      let topics = HyperSyncClient.QueryTypes.makeTopicSelection(param.topic0, param.topic1, param.topic2, param.topic3);
-      return HyperSyncClient.QueryTypes.makeLogSelection(addresses, topics);
-    });
-  });
-  let query$1 = makeRequestBody(fromBlock, toBlock, addressesWithTopics, fieldSelection, maxNumLogs);
+async function query(client, fromBlock, toBlock, maxNumLogs, registrationIndexes, addressesByContractName) {
+  let query$1 = {
+    fromBlock: fromBlock,
+    toBlock: toBlock,
+    maxNumLogs: maxNumLogs,
+    registrationIndexes: registrationIndexes,
+    addressesByContractName: addressesByContractName
+  };
   let match;
   try {
     match = await client.getEventItems(query$1);
@@ -140,7 +128,13 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
   };
 }
 
-function makeRequestBody$1(fromBlock, toBlock) {
+let GetLogs = {
+  $$Error: $$Error,
+  extractMissingParams: extractMissingParams,
+  query: query
+};
+
+function makeRequestBody(fromBlock, toBlock) {
   return {
     fromBlock: fromBlock,
     toBlock: toBlock + 1 | 0,
@@ -193,7 +187,7 @@ function convertResponse(res) {
 }
 
 async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger, requestStats) {
-  let body = makeRequestBody$1(fromBlock, toBlock);
+  let body = makeRequestBody(fromBlock, toBlock);
   let logger$1 = Logging.createChildFrom(logger, {
     logType: "HyperSync get block hash query",
     fromBlock: fromBlock,
@@ -282,12 +276,6 @@ function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
   ]);
 }
 
-let GetLogs = {
-  $$Error: $$Error,
-  extractMissingParams: extractMissingParams,
-  query: query
-};
-
 export {
   queryErrorToMsq,
   GetLogs,

package/src/sources/HyperSync.resi

@@ -32,9 +32,9 @@ module GetLogs: {
     ~client: HyperSyncClient.t,
     ~fromBlock: int,
     ~toBlock: option<int>,
-    ~logSelections: array<LogSelection.t>,
-    ~fieldSelection: HyperSyncClient.QueryTypes.fieldSelection,
     ~maxNumLogs: int,
+    ~registrationIndexes: array<int>,
+    ~addressesByContractName: dict<array<Address.t>>,
   ) => promise<logsQueryPage>
 }