envio 3.15.0 → 3.16.0-subgraph

package/src/sources/CallSource.res

@@ -0,0 +1,274 @@
+// Subgraph mode only. A subgraph's call handlers run on calls, which a log
+// source never sees, so each source of a chain is wrapped: it fetches the logs
+// of a query as before, and the calls of the same block range from a trace
+// backend (`subgraph/calls-source.ts`). A call comes back as the event item it
+// travels as for the rest of envio — partitioning, ordering, the register
+// pass and rollback never tell it from a log.
+
+type callRegistration = {
+  index: int,
+  contractName: string,
+  eventName: string,
+  selector: Nullable.t<string>,
+  rank: int,
+  isWildcard: bool,
+  startBlock: Nullable.t<int>,
+}
+
+type request = {
+  chainId: ChainId.t,
+  fromBlock: int,
+  toBlock: int,
+  registrations: array<callRegistration>,
+  addresses: dict<array<string>>,
+  rpcUrls: array<string>,
+}
+
+type callItem = {
+  registrationIndex: int,
+  blockNumber: int,
+  transactionIndex: int,
+  traceAddress: array<int>,
+  payload: Internal.eventPayload,
+}
+
+type response = {
+  items: array<callItem>,
+  latestFetchedBlockNumber: int,
+  blocks: array<BlockStore.inputBlock>,
+  knownHeight: Nullable.t<int>,
+}
+
+type installed = {
+  fetchCalls: request => promise<response>,
+  rpcUrls: array<string>,
+}
+
+let installed: ref<option<installed>> = ref(None)
+
+let install = (~fetchCalls, ~rpcUrls) => {
+  installed := Some({fetchCalls, rpcUrls})
+}
+
+// The block range one call query covers when the partition's own is open-ended.
+let openEndedSpan = 1_000_000
+
+let callRankOf = (registration: Internal.onEventRegistration) =>
+  Internal.callRankOfEventName(registration.eventConfig.name)
+
+// `__envio_call_<8 hex digits>_<function>`
+let selectorOf = (registration: Internal.onEventRegistration) =>
+  switch registration->callRankOf {
+  | Some(1) =>
+    Nullable.Value(
+      "0x" ++ registration.eventConfig.name->String.slice(~start=13, ~end=21)->String.toLowerCase,
+    )
+  | _ => Nullable.null
+  }
+
+let wrap = (
+  source: Source.t,
+  ~addressStore: AddressStore.t,
+  ~ecosystem: Ecosystem.name,
+  installed: installed,
+): Source.t => {
+  ...source,
+  getItemsOrThrow: async (
+    ~fromBlock,
+    ~toBlock,
+    ~addressSet,
+    ~reorgableFrom,
+    ~knownHeight,
+    ~partitionId,
+    ~selection: FetchState.selection,
+    ~itemsTarget,
+    ~retry,
+    ~logger,
+  ) => {
+    let callRegistrations =
+      selection.onEventRegistrations->Array.filter(registration =>
+        registration->callRankOf->Option.isSome
+      )
+    if callRegistrations->Utils.Array.isEmpty {
+      await source.getItemsOrThrow(
+        ~fromBlock,
+        ~toBlock,
+        ~addressSet,
+        ~reorgableFrom,
+        ~knownHeight,
+        ~partitionId,
+        ~selection,
+        ~itemsTarget,
+        ~retry,
+        ~logger,
+      )
+    } else {
+      let logRegistrations =
+        selection.onEventRegistrations->Array.filter(registration =>
+          registration->callRankOf->Option.isNone
+        )
+      let logs = if (
+        logRegistrations->Utils.Array.isEmpty && selection.onBlockRegistrations->Utils.Array.isEmpty
+      ) {
+        None
+      } else {
+        Some(
+          await source.getItemsOrThrow(
+            ~fromBlock,
+            ~toBlock,
+            ~addressSet,
+            ~reorgableFrom,
+            ~knownHeight,
+            ~partitionId,
+            ~selection={...selection, onEventRegistrations: logRegistrations},
+            ~itemsTarget,
+            ~retry,
+            ~logger,
+          ),
+        )
+      }
+
+      // Calls are asked for only as far as the logs were: a source may stop a
+      // page short, and the two have to agree on where the answer ends.
+      let rangeEnd = switch (logs, toBlock) {
+      | (Some(logs), _) => logs.latestFetchedBlockNumber
+      | (None, Some(toBlock)) => toBlock
+      | (None, None) => Math.Int.min(knownHeight, fromBlock + openEndedSpan)
+      }
+
+      let clientFiltered = contractName =>
+        switch selection.clientFilteredContracts {
+        | Some(contractNames) => contractNames->Array.includes(contractName)
+        | None => false
+        }
+      let addresses = Dict.make()
+      callRegistrations->Array.forEach(registration => {
+        let contractName = registration.eventConfig.contractName
+        if !registration.isWildcard && addresses->Dict.get(contractName)->Option.isNone {
+          addresses->Dict.set(
+            contractName,
+            clientFiltered(contractName)
+              ? addressStore->AddressStore.contractAddresses(contractName, ~shouldChecksum=false)
+              : addressSet->AddressSet.addressesOf(contractName),
+          )
+        }
+      })
+
+      let startedAt = Performance.now()
+      let response = try await installed.fetchCalls({
+        chainId: source.chainId,
+        fromBlock,
+        toBlock: rangeEnd,
+        registrations: callRegistrations->Array.map(registration => {
+          index: registration.index,
+          contractName: registration.eventConfig.contractName,
+          eventName: registration.eventConfig.name,
+          selector: registration->selectorOf,
+          rank: registration->callRankOf->Option.getOr(1),
+          isWildcard: registration.isWildcard,
+          startBlock: registration.startBlock->Nullable.fromOption,
+        }),
+        addresses: addresses->(Utils.magic: dict<array<Address.t>> => dict<array<string>>),
+        rpcUrls: installed.rpcUrls,
+      }) catch {
+      | exn =>
+        throw(
+          Source.GetItemsError(
+            Source.FailedGettingItems({
+              exn,
+              attemptedToBlock: rangeEnd,
+              retry: WithBackoff({
+                message: `Failed reading the calls of blocks ${fromBlock->Int.toString} to ${rangeEnd->Int.toString}. Attempt a retry.`,
+                backoffMillis: switch retry {
+                | 0 => 500
+                | _ => 1000 * retry
+                },
+              }),
+              requestStats: [],
+            }),
+          ),
+        )
+      }
+      let callSeconds = startedAt->Performance.secondsSince
+
+      let registrationByIndex = Dict.make()
+      callRegistrations->Array.forEach(registration =>
+        registrationByIndex->Dict.set(registration.index->Int.toString, registration)
+      )
+      let latest = response.latestFetchedBlockNumber
+      let callItems = response.items->Array.filterMap(callItem => {
+        let registration =
+          registrationByIndex->Dict.getUnsafe(callItem.registrationIndex->Int.toString)
+        let contractName = registration.eventConfig.contractName
+        // The partition's own slice of the contract's addresses, as a log's
+        // router applies it; a client-filtered contract answers to the store.
+        let ownsCall =
+          registration.isWildcard || {
+            let address = callItem.payload->Internal.getPayloadSrcAddress
+            if clientFiltered(contractName) {
+              addressStore->AddressStore.isIndexedAt(address, contractName, callItem.blockNumber)
+            } else {
+              addressSet->AddressSet.containsAt(address, contractName, callItem.blockNumber)
+            }
+          }
+        if callItem.blockNumber <= latest && ownsCall {
+          let item = Internal.Event({
+            onEventRegistration: registration,
+            chainId: source.chainId,
+            blockNumber: callItem.blockNumber,
+            logIndex: 0,
+            orderPath: callItem.traceAddress,
+            transactionIndex: callItem.transactionIndex,
+            payload: callItem.payload,
+          })
+          item->Internal.markItemCall(~rank=registration->callRankOf->Option.getOr(1))
+          Some(item)
+        } else {
+          None
+        }
+      })
+
+      let callBlocks = BlockStore.fromJs(response.blocks, ~ecosystem)
+      let callRequestStat = {Source.method: "getCalls", seconds: callSeconds}
+      switch logs {
+      | Some(logs) =>
+        logs.blockStore->BlockStore.appendPage(callBlocks)
+        {
+          ...logs,
+          parsedQueueItems: Array.concat(
+            logs.parsedQueueItems->Array.filter(item =>
+              item->Internal.getItemBlockNumber <= latest
+            ),
+            callItems,
+          ),
+          latestFetchedBlockNumber: Math.Int.min(logs.latestFetchedBlockNumber, latest),
+          requestStats: Array.concat(logs.requestStats, [callRequestStat]),
+        }
+      | None => {
+          Source.knownHeight: response.knownHeight->Nullable.getOr(knownHeight),
+          parsedQueueItems: callItems,
+          transactionStore: None,
+          blockStore: callBlocks,
+          latestFetchedBlockNumber: latest,
+          stats: {totalTimeElapsed: callSeconds},
+          requestStats: [callRequestStat],
+        }
+      }
+    }
+  },
+}
+
+// Wraps every source of a chain when its registrations hold a call trigger
+// and the subgraph runtime has installed the backend that reads them.
+let wrapSources = (
+  sources: array<Source.t>,
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+  ~addressStore,
+  ~ecosystem,
+) =>
+  switch installed.contents {
+  | Some(installed)
+    if onEventRegistrations->Array.some(registration => registration->callRankOf->Option.isSome) =>
+    sources->Array.map(source => source->wrap(~addressStore, ~ecosystem, installed))
+  | _ => sources
+  }

package/src/sources/CallSource.res.mjs

@@ -0,0 +1,196 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as Source from "./Source.res.mjs";
+import * as Internal from "../Internal.res.mjs";
+import * as BlockStore from "./BlockStore.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let installed = {
+  contents: undefined
+};
+
+function install(fetchCalls, rpcUrls) {
+  installed.contents = {
+    fetchCalls: fetchCalls,
+    rpcUrls: rpcUrls
+  };
+}
+
+function callRankOf(registration) {
+  return Internal.callRankOfEventName(registration.eventConfig.name);
+}
+
+function selectorOf(registration) {
+  let match = Internal.callRankOfEventName(registration.eventConfig.name);
+  if (match === 1) {
+    return "0x" + registration.eventConfig.name.slice(13, 21).toLowerCase();
+  } else {
+    return null;
+  }
+}
+
+function wrap(source, addressStore, ecosystem, installed) {
+  let newrecord = {...source};
+  newrecord.getItemsOrThrow = async (fromBlock, toBlock, addressSet, reorgableFrom, knownHeight, partitionId, selection, itemsTarget, retry, logger) => {
+    let callRegistrations = selection.onEventRegistrations.filter(registration => Stdlib_Option.isSome(Internal.callRankOfEventName(registration.eventConfig.name)));
+    if (Utils.$$Array.isEmpty(callRegistrations)) {
+      return await source.getItemsOrThrow(fromBlock, toBlock, addressSet, reorgableFrom, knownHeight, partitionId, selection, itemsTarget, retry, logger);
+    }
+    let logRegistrations = selection.onEventRegistrations.filter(registration => Stdlib_Option.isNone(Internal.callRankOfEventName(registration.eventConfig.name)));
+    let logs;
+    if (Utils.$$Array.isEmpty(logRegistrations) && Utils.$$Array.isEmpty(selection.onBlockRegistrations)) {
+      logs = undefined;
+    } else {
+      let newrecord = {...selection};
+      logs = await source.getItemsOrThrow(fromBlock, toBlock, addressSet, reorgableFrom, knownHeight, partitionId, (newrecord.onEventRegistrations = logRegistrations, newrecord), itemsTarget, retry, logger);
+    }
+    let rangeEnd = logs !== undefined ? logs.latestFetchedBlockNumber : (
+        toBlock !== undefined ? toBlock : Math.min(knownHeight, fromBlock + 1000000 | 0)
+      );
+    let clientFiltered = contractName => {
+      let contractNames = selection.clientFilteredContracts;
+      if (contractNames !== undefined) {
+        return contractNames.includes(contractName);
+      } else {
+        return false;
+      }
+    };
+    let addresses = {};
+    callRegistrations.forEach(registration => {
+      let contractName = registration.eventConfig.contractName;
+      if (!registration.isWildcard && Stdlib_Option.isNone(addresses[contractName])) {
+        addresses[contractName] = clientFiltered(contractName) ? addressStore.contractAddresses(contractName, false) : addressSet.addressesOf(contractName);
+        return;
+      }
+    });
+    let startedAt = Performance.now();
+    let response;
+    try {
+      response = await installed.fetchCalls({
+        chainId: source.chainId,
+        fromBlock: fromBlock,
+        toBlock: rangeEnd,
+        registrations: callRegistrations.map(registration => ({
+          index: registration.index,
+          contractName: registration.eventConfig.contractName,
+          eventName: registration.eventConfig.name,
+          selector: selectorOf(registration),
+          rank: Stdlib_Option.getOr(Internal.callRankOfEventName(registration.eventConfig.name), 1),
+          isWildcard: registration.isWildcard,
+          startBlock: Stdlib_Nullable.fromOption(registration.startBlock)
+        })),
+        addresses: addresses,
+        rpcUrls: installed.rpcUrls
+      });
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      throw {
+        RE_EXN_ID: Source.GetItemsError,
+        _1: {
+          TAG: "FailedGettingItems",
+          exn: exn,
+          attemptedToBlock: rangeEnd,
+          retry: {
+            TAG: "WithBackoff",
+            message: `Failed reading the calls of blocks ` + fromBlock.toString() + ` to ` + rangeEnd.toString() + `. Attempt a retry.`,
+            backoffMillis: retry !== 0 ? 1000 * retry | 0 : 500
+          },
+          requestStats: []
+        },
+        Error: new Error()
+      };
+    }
+    let callSeconds = Performance.secondsSince(startedAt);
+    let registrationByIndex = {};
+    callRegistrations.forEach(registration => {
+      registrationByIndex[registration.index.toString()] = registration;
+    });
+    let latest = response.latestFetchedBlockNumber;
+    let callItems = Stdlib_Array.filterMap(response.items, callItem => {
+      let registration = registrationByIndex[callItem.registrationIndex.toString()];
+      let contractName = registration.eventConfig.contractName;
+      let ownsCall = true;
+      if (!registration.isWildcard) {
+        let address = callItem.payload.srcAddress;
+        ownsCall = clientFiltered(contractName) ? addressStore.isIndexedAt(address, contractName, callItem.blockNumber) : addressSet.containsAt(address, contractName, callItem.blockNumber);
+      }
+      if (!(callItem.blockNumber <= latest && ownsCall)) {
+        return;
+      }
+      let item_1 = source.chainId;
+      let item_2 = callItem.blockNumber;
+      let item_4 = callItem.traceAddress;
+      let item_5 = callItem.transactionIndex;
+      let item_6 = callItem.payload;
+      let item = {
+        kind: 0,
+        onEventRegistration: registration,
+        chainId: item_1,
+        blockNumber: item_2,
+        logIndex: 0,
+        orderPath: item_4,
+        transactionIndex: item_5,
+        payload: item_6
+      };
+      Internal.markItemCall(item, Stdlib_Option.getOr(Internal.callRankOfEventName(registration.eventConfig.name), 1));
+      return item;
+    });
+    let callBlocks = BlockStore.fromJs(response.blocks, ecosystem);
+    let callRequestStat = {
+      method: "getCalls",
+      seconds: callSeconds
+    };
+    if (logs !== undefined) {
+      logs.blockStore.appendPage(callBlocks);
+      return {
+        knownHeight: logs.knownHeight,
+        parsedQueueItems: logs.parsedQueueItems.filter(item => item.blockNumber <= latest).concat(callItems),
+        transactionStore: logs.transactionStore,
+        blockStore: logs.blockStore,
+        latestFetchedBlockNumber: Math.min(logs.latestFetchedBlockNumber, latest),
+        stats: logs.stats,
+        requestStats: logs.requestStats.concat([callRequestStat])
+      };
+    } else {
+      return {
+        knownHeight: Stdlib_Nullable.getOr(response.knownHeight, knownHeight),
+        parsedQueueItems: callItems,
+        transactionStore: undefined,
+        blockStore: callBlocks,
+        latestFetchedBlockNumber: latest,
+        stats: {
+          "total time elapsed (s)": callSeconds
+        },
+        requestStats: [callRequestStat]
+      };
+    }
+  };
+  return newrecord;
+}
+
+function wrapSources(sources, onEventRegistrations, addressStore, ecosystem) {
+  let installed$1 = installed.contents;
+  if (installed$1 !== undefined && onEventRegistrations.some(registration => Stdlib_Option.isSome(Internal.callRankOfEventName(registration.eventConfig.name)))) {
+    return sources.map(source => wrap(source, addressStore, ecosystem, installed$1));
+  } else {
+    return sources;
+  }
+}
+
+let openEndedSpan = 1000000;
+
+export {
+  installed,
+  install,
+  openEndedSpan,
+  callRankOf,
+  selectorOf,
+  wrap,
+  wrapSources,
+}
+/* Utils Not a pure module */

package/src/sources/ChainSources.res

@@ -10,6 +10,7 @@ let make = (
   ~blockStore: BlockStore.t,
   ~transactionStore: TransactionStore.t,
   ~logger: Logger.t,
+  ~maxAddressesPerRequest: int,
 ): array<Source.t> => {
   let chainId = chainConfig.id
   switch chainConfig.sourceConfig {
@@ -39,6 +40,7 @@ let make = (
       ~blockStore,
       ~transactionStore,
       ~logger,
+      ~maxAddressesPerRequest,
     )
   | Config.FuelSourceConfig({hypersync}) => [
       FuelHyperSyncSource.make({

package/src/sources/ChainSources.res.mjs

@@ -7,7 +7,7 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as SvmHyperSyncSource from "./SvmHyperSyncSource.res.mjs";
 import * as FuelHyperSyncSource from "./FuelHyperSyncSource.res.mjs";
 
-function make(chainConfig, onEventRegistrations, onBlockRegistrationsOpt, addressStore, lowercaseAddresses, blockStore, transactionStore, logger) {
+function make(chainConfig, onEventRegistrations, onBlockRegistrationsOpt, addressStore, lowercaseAddresses, blockStore, transactionStore, logger, maxAddressesPerRequest) {
   let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   let chainId = chainConfig.id;
   let sources = chainConfig.sourceConfig;
@@ -25,7 +25,7 @@ function make(chainConfig, onEventRegistrations, onBlockRegistrationsOpt, addres
           headers: headers
         };
       });
-      return EvmChain.makeSources(chainId, onEventRegistrations, onBlockRegistrations, sources.hypersync, evmRpcs, lowercaseAddresses, addressStore, blockStore, transactionStore, logger);
+      return EvmChain.makeSources(chainId, onEventRegistrations, onBlockRegistrations, sources.hypersync, evmRpcs, lowercaseAddresses, addressStore, blockStore, transactionStore, logger, maxAddressesPerRequest);
     case "FuelSourceConfig" :
       return [FuelHyperSyncSource.make({
           chainId: chainId,

package/src/sources/EvmChain.res

@@ -50,6 +50,7 @@ let makeSources = (
   ~blockStore,
   ~transactionStore,
   ~logger,
+  ~maxAddressesPerRequest,
 ) => {
   let sources = switch hyperSync {
   | Some(endpointUrl) => [
@@ -84,9 +85,17 @@ let makeSources = (
       transactionStore,
       ?ws,
       ?headers,
+      maxAddressesPerRequest,
+      logger,
     })
     let _ = sources->Array.push(source)
   })
 
-  sources
+  sources->CallSource.wrapSources(
+    ~onEventRegistrations=onEventRegistrations->(
+      Utils.magic: array<Internal.evmOnEventRegistration> => array<Internal.onEventRegistration>
+    ),
+    ~addressStore,
+    ~ecosystem=Evm,
+  )
 }

package/src/sources/EvmChain.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Env from "../Env.res.mjs";
 import * as RpcSource from "./RpcSource.res.mjs";
+import * as CallSource from "./CallSource.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as EvmHyperSyncSource from "./EvmHyperSyncSource.res.mjs";
 
@@ -19,7 +20,7 @@ function getSyncConfig(param) {
   };
 }
 
-function makeSources(chainId, onEventRegistrations, onBlockRegistrations, hyperSync, rpcs, lowercaseAddresses, addressStore, blockStore, transactionStore, logger) {
+function makeSources(chainId, onEventRegistrations, onBlockRegistrations, hyperSync, rpcs, lowercaseAddresses, addressStore, blockStore, transactionStore, logger, maxAddressesPerRequest) {
   let sources = hyperSync !== undefined ? [EvmHyperSyncSource.make({
         chainId: chainId,
         endpointUrl: hyperSync,
@@ -47,11 +48,13 @@ function makeSources(chainId, onEventRegistrations, onBlockRegistrations, hyperS
       blockStore: blockStore,
       transactionStore: transactionStore,
       ws: param.ws,
-      headers: param.headers
+      headers: param.headers,
+      maxAddressesPerRequest: maxAddressesPerRequest,
+      logger: logger
     });
     sources.push(source);
   });
-  return sources;
+  return CallSource.wrapSources(sources, onEventRegistrations, addressStore, "evm");
 }
 
 export {

package/src/sources/EvmHyperSyncSource.res

@@ -202,7 +202,7 @@ let make = (
       {height, requestStats: [{method: "getHeight", seconds}]}
     },
     getItemsOrThrow,
-    createHeightSubscription: (~onHeight, ~onStatus) =>
-      HyperSyncSSE.subscribe(~hyperSyncUrl=endpointUrl, ~apiToken, ~onHeight, ~onStatus),
+    createHeightSubscription: (~clock, ~onHeight, ~onStatus) =>
+      HyperSyncSSE.subscribe(~clock, ~hyperSyncUrl=endpointUrl, ~apiToken, ~onHeight, ~onStatus),
   }
 }

package/src/sources/EvmHyperSyncSource.res.mjs

@@ -149,7 +149,7 @@ function make(param) {
       };
     },
     getItemsOrThrow: getItemsOrThrow,
-    createHeightSubscription: (onHeight, onStatus) => HyperSyncSSE.subscribe(endpointUrl, apiToken, onHeight, onStatus)
+    createHeightSubscription: (clock, onHeight, onStatus) => HyperSyncSSE.subscribe(clock, endpointUrl, apiToken, onHeight, onStatus)
   };
 }
 

package/src/sources/EvmRpcClient.res

@@ -8,6 +8,7 @@ type cfg = {
   intervalCeiling: int,
   backoffMillis: int,
   queryTimeoutMillis: int,
+  maxAddressesPerRequest: int,
 }
 
 type nextPageParams = {
@@ -18,10 +19,12 @@ type nextPageParams = {
   onBlockRegistrationIndexes: array<int>,
   clientFilteredContracts: option<array<string>>,
   retry: int,
-  // Blocks at or above this one can still be reorged, so a blocks-only page
-  // reaching them is read for the hashes of its boundary blocks even with no
-  // handler block in range. None when the range is final.
+  // Blocks at or above this one can still be reorged, so each of them in the
+  // page has its header read and its logs checked against it, even a
+  // blocks-only page with no handler block in range. None when the range is
+  // final.
   reorgableFrom?: int,
+  knownHeight: int,
 }
 
 // Rust reports what to do about a page it could not read rather than throwing
@@ -77,6 +80,8 @@ external classNew: (
   array<BlockItem.registrationInput>,
   ~checksumAddresses: bool,
   ~addressStore: AddressStore.t,
+  Logger.native,
+  array<string>,
 ) => t = "new"
 
 let make = (
@@ -88,6 +93,8 @@ let make = (
   ~eventRegistrations=[],
   ~onBlockRegistrations=[],
   ~addressStore,
+  ~maxAddressesPerRequest,
+  ~logger: Logger.t,
 ) =>
   Core.getAddon().evmRpcClient->classNew(
     {
@@ -100,9 +107,12 @@ let make = (
       intervalCeiling: syncConfig.intervalCeiling,
       backoffMillis: syncConfig.backoffMillis,
       queryTimeoutMillis: syncConfig.queryTimeoutMillis,
+      maxAddressesPerRequest,
     },
     eventRegistrations,
     onBlockRegistrations->BlockItem.toRegistrationInputs,
     ~checksumAddresses,
     ~addressStore,
+    logger.output.native,
+    logger.boundFieldsJson,
   )

package/src/sources/EvmRpcClient.res.mjs

@@ -3,7 +3,7 @@
 import * as Core from "../Core.res.mjs";
 import * as BlockItem from "./BlockItem.res.mjs";
 
-function make(url, checksumAddresses, syncConfig, maxConcurrentRequests, headers, eventRegistrationsOpt, onBlockRegistrationsOpt, addressStore) {
+function make(url, checksumAddresses, syncConfig, maxConcurrentRequests, headers, eventRegistrationsOpt, onBlockRegistrationsOpt, addressStore, maxAddressesPerRequest, logger) {
   let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
   let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   return Core.getAddon().EvmRpcClient.new({
@@ -15,8 +15,9 @@ function make(url, checksumAddresses, syncConfig, maxConcurrentRequests, headers
     accelerationAdditive: syncConfig.accelerationAdditive,
     intervalCeiling: syncConfig.intervalCeiling,
     backoffMillis: syncConfig.backoffMillis,
-    queryTimeoutMillis: syncConfig.queryTimeoutMillis
-  }, eventRegistrations, BlockItem.toRegistrationInputs(onBlockRegistrations), checksumAddresses, addressStore);
+    queryTimeoutMillis: syncConfig.queryTimeoutMillis,
+    maxAddressesPerRequest: maxAddressesPerRequest
+  }, eventRegistrations, BlockItem.toRegistrationInputs(onBlockRegistrations), checksumAddresses, addressStore, logger.output.native, logger.boundFieldsJson);
 }
 
 export {

package/src/sources/EvmRpcWs.res

@@ -81,8 +81,8 @@ let wsMessageSchema = S.union([
   }),
 ])
 
-let subscribe = (~wsUrl, ~onHeight, ~onStatus) =>
-  HeightStream.subscribe(~staleTimeout, ~onHeight, ~onStatus, ~connect=driver => {
+let subscribe = (~clock, ~wsUrl, ~onHeight, ~onStatus) =>
+  HeightStream.subscribe(~clock, ~staleTimeout, ~onHeight, ~onStatus, ~connect=driver => {
     let ws = WebSocket.create(wsUrl)
     let subscribed = ref(false)
 
@@ -103,7 +103,8 @@ let subscribe = (~wsUrl, ~onHeight, ~onStatus) =>
         | Some(Response({id: Some(id), isError: false})) if id === subscribeRequestIdText =>
           subscribed := true
           driver.onConnected()
-        | Some(Response({id, isError: true})) if id->refusesSubscribe(~subscribed=subscribed.contents) =>
+        | Some(Response({id, isError: true}))
+          if id->refusesSubscribe(~subscribed=subscribed.contents) =>
           driver.onFailure(~reason=SubscribeRejected, ~detail=text)
         // A provider talking about something other than the subscription this
         // socket asked for — a rate limit, a request nobody here made. Read