envio 3.1.0-rc.0 → 3.1.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.1.0-rc.0",
+  "version": "3.1.0-rc.1",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -70,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.1.0-rc.0",
-    "envio-linux-x64-musl": "3.1.0-rc.0",
-    "envio-linux-arm64": "3.1.0-rc.0",
-    "envio-darwin-x64": "3.1.0-rc.0",
-    "envio-darwin-arm64": "3.1.0-rc.0"
+    "envio-linux-x64": "3.1.0-rc.1",
+    "envio-linux-x64-musl": "3.1.0-rc.1",
+    "envio-linux-arm64": "3.1.0-rc.1",
+    "envio-darwin-x64": "3.1.0-rc.1",
+    "envio-darwin-arm64": "3.1.0-rc.1"
   }
 }

package/src/ChainFetcher.res

@@ -462,38 +462,23 @@ let getHighestBlockBelowThreshold = (cf: t): int => {
 Finds the last known valid block number below the reorg block
 If not found, returns the highest block below threshold
 */
-let getLastKnownValidBlock = async (
-  chainFetcher: t,
-  ~reorgBlockNumber: int,
-  //Parameter used for dependency injecting in tests
-  ~getBlockHashes=(chainFetcher.sourceManager->SourceManager.getActiveSource).getBlockHashes,
-) => {
-  // Improtant: It's important to not include the reorg detection block number
-  // because there might be different instances of the source
-  // with mismatching hashes between them.
-  // So we MUST always rollback the block number where we detected a reorg.
+let getLastKnownValidBlock = async (chainFetcher: t, ~reorgBlockNumber: int, ~isRealtime: bool) => {
+  // Don't include the reorg block itself — different source instances
+  // may have mismatching hashes at the head, so we always rollback
+  // the block where we detected the reorg.
   let scannedBlockNumbers =
     chainFetcher.reorgDetection->ReorgDetection.getThresholdBlockNumbersBelowBlock(
       ~blockNumber=reorgBlockNumber,
       ~knownHeight=chainFetcher.fetchState.knownHeight,
     )
 
-  let getBlockHashes = blockNumbers => {
-    getBlockHashes(~blockNumbers, ~logger=chainFetcher.logger)->Promise.thenResolve(res =>
-      switch res {
-      | Ok(v) => v
-      | Error(exn) =>
-        exn->ErrorHandling.mkLogAndRaise(
-          ~msg="Failed to fetch blockHashes for given blockNumbers during rollback",
-        )
-      }
-    )
-  }
-
   switch scannedBlockNumbers {
   | [] => chainFetcher->getHighestBlockBelowThreshold
   | _ => {
-      let blockNumbersAndHashes = await getBlockHashes(scannedBlockNumbers)
+      let blockNumbersAndHashes = await chainFetcher.sourceManager->SourceManager.getBlockHashes(
+        ~blockNumbers=scannedBlockNumbers,
+        ~isRealtime,
+      )
 
       switch chainFetcher.reorgDetection->ReorgDetection.getLatestValidScannedBlock(
         ~blockNumbersAndHashes,

package/src/ChainFetcher.res.mjs

@@ -261,20 +261,12 @@ function getHighestBlockBelowThreshold(cf) {
   }
 }
 
-async function getLastKnownValidBlock(chainFetcher, reorgBlockNumber, getBlockHashesOpt) {
-  let getBlockHashes = getBlockHashesOpt !== undefined ? getBlockHashesOpt : SourceManager.getActiveSource(chainFetcher.sourceManager).getBlockHashes;
+async function getLastKnownValidBlock(chainFetcher, reorgBlockNumber, isRealtime) {
   let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(chainFetcher.reorgDetection, reorgBlockNumber, chainFetcher.fetchState.knownHeight);
-  let getBlockHashes$1 = blockNumbers => getBlockHashes(blockNumbers, chainFetcher.logger).then(res => {
-    if (res.TAG === "Ok") {
-      return res._0;
-    } else {
-      return ErrorHandling.mkLogAndRaise(undefined, "Failed to fetch blockHashes for given blockNumbers during rollback", res._0);
-    }
-  });
   if (scannedBlockNumbers.length === 0) {
     return getHighestBlockBelowThreshold(chainFetcher);
   }
-  let blockNumbersAndHashes = await getBlockHashes$1(scannedBlockNumbers);
+  let blockNumbersAndHashes = await SourceManager.getBlockHashes(chainFetcher.sourceManager, scannedBlockNumbers, isRealtime);
   let blockNumber = ReorgDetection.getLatestValidScannedBlock(chainFetcher.reorgDetection, blockNumbersAndHashes);
   if (blockNumber !== undefined) {
     return blockNumber;

package/src/Env.res

@@ -47,13 +47,6 @@ let envioApiToken = envSafe->EnvSafe.get("ENVIO_API_TOKEN", S.option(S.string))
 let hyperSyncClientTimeoutMillis =
   envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S.int, ~fallback=120_000)
 
-/** 
-This is the number of retries that the binary client makes before rejecting the promise with an error 
-Default is 0 so that the indexer can handle retries internally
-*/
-let hyperSyncClientMaxRetries =
-  envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_MAX_RETRIES", S.int, ~fallback=0)
-
 let hypersyncClientSerializationFormat =
   envSafe->EnvSafe.get(
     "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT",

package/src/Env.res.mjs

@@ -53,8 +53,6 @@ let envioApiToken = EnvSafe.get(envSafe, "ENVIO_API_TOKEN", S$RescriptSchema.opt
 
 let hyperSyncClientTimeoutMillis = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S$RescriptSchema.int, undefined, 120000, undefined, undefined);
 
-let hyperSyncClientMaxRetries = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_MAX_RETRIES", S$RescriptSchema.int, undefined, 0, undefined, undefined);
-
 let hypersyncClientSerializationFormat = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT", HyperSyncClient.serializationFormatSchema, undefined, "CapnProto", undefined, undefined);
 
 let hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S$RescriptSchema.bool, undefined, true, undefined, undefined);
@@ -233,7 +231,6 @@ export {
   envioAppUrl,
   envioApiToken,
   hyperSyncClientTimeoutMillis,
-  hyperSyncClientMaxRetries,
   hypersyncClientSerializationFormat,
   hypersyncClientEnableQueryCaching,
   hypersyncLogLevel,

package/src/FetchState.res

@@ -1730,10 +1730,7 @@ let rollback = (fetchState: t, ~targetBlockNumber) => {
   let addressesToRemove = Utils.Set.make()
   let indexingAddresses = Dict.make()
 
-  fetchState.indexingAddresses
-  ->Dict.keysToArray
-  ->Array.forEach(address => {
-    let indexingContract = fetchState.indexingAddresses->Dict.getUnsafe(address)
+  fetchState.indexingAddresses->Utils.Dict.forEachWithKey((indexingContract, address) => {
     if indexingContract.registrationBlock > targetBlockNumber {
       let _ = addressesToRemove->Utils.Set.add(address->Address.unsafeFromString)
     } else {

package/src/FetchState.res.mjs

@@ -1360,8 +1360,7 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
 function rollback(fetchState, targetBlockNumber) {
   let addressesToRemove = new Set();
   let indexingAddresses = {};
-  Object.keys(fetchState.indexingAddresses).forEach(address => {
-    let indexingContract = fetchState.indexingAddresses[address];
+  Utils.Dict.forEachWithKey(fetchState.indexingAddresses, (indexingContract, address) => {
     if (indexingContract.registrationBlock > targetBlockNumber) {
       addressesToRemove.add(address);
     } else {

package/src/GlobalState.res

@@ -1032,6 +1032,7 @@ let injectedTaskReducer = (
           dispatchAction(StartFindingReorgDepth)
           let rollbackTargetBlockNumber = await chainFetcher->getLastKnownValidBlock(
             ~reorgBlockNumber,
+            ~isRealtime=state.chainManager.isRealtime,
           )
 
           chainFetcher.sourceManager->SourceManager.onReorg(
@@ -1215,6 +1216,6 @@ let injectedTaskReducer = (
 let taskReducer = injectedTaskReducer(
   ~waitForNewBlock=SourceManager.waitForNewBlock,
   ~executeQuery=SourceManager.executeQuery,
-  ~getLastKnownValidBlock=(chainFetcher, ~reorgBlockNumber) =>
-    chainFetcher->ChainFetcher.getLastKnownValidBlock(~reorgBlockNumber),
+  ~getLastKnownValidBlock=(chainFetcher, ~reorgBlockNumber, ~isRealtime) =>
+    chainFetcher->ChainFetcher.getLastKnownValidBlock(~reorgBlockNumber, ~isRealtime),
 )

package/src/GlobalState.res.mjs

@@ -1051,7 +1051,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
               let chain = match$1.chain;
               let chainFetcher = ChainMap.get(state.chainManager.chainFetchers, chain);
               dispatchAction("StartFindingReorgDepth");
-              let rollbackTargetBlockNumber = await getLastKnownValidBlock(chainFetcher, match$1.blockNumber);
+              let rollbackTargetBlockNumber = await getLastKnownValidBlock(chainFetcher, match$1.blockNumber, state.chainManager.isRealtime);
               SourceManager.onReorg(chainFetcher.sourceManager, rollbackTargetBlockNumber);
               return dispatchAction({
                 TAG: "FindReorgDepth",
@@ -1218,7 +1218,7 @@ function injectedTaskReducer(waitForNewBlock, executeQuery, getLastKnownValidBlo
   };
 }
 
-let taskReducer = injectedTaskReducer(SourceManager.waitForNewBlock, SourceManager.executeQuery, (chainFetcher, reorgBlockNumber) => ChainFetcher.getLastKnownValidBlock(chainFetcher, reorgBlockNumber, undefined));
+let taskReducer = injectedTaskReducer(SourceManager.waitForNewBlock, SourceManager.executeQuery, ChainFetcher.getLastKnownValidBlock);
 
 export {
   WriteThrottlers,

package/src/InMemoryStore.res

@@ -165,13 +165,37 @@ let writeBatch = async (
     | Some(checkpointId) => checkpointId
     | None => committedCheckpointId
     }
-    persistence.allEntities->Array.forEach(entityConfig => {
-      let table = inMemoryStore->getInMemTable(~entityConfig)
-      let resetTable = keepLatestChanges
-        ? table->InMemoryTable.Entity.resetButKeepLatestChanges
-        : InMemoryTable.Entity.make()
-      inMemoryStore.entities->Dict.set((entityConfig.name :> string), resetTable)
-    })
+    if keepLatestChanges {
+      persistence.allEntities->Array.forEach(entityConfig => {
+        let table = inMemoryStore->getInMemTable(~entityConfig)
+        inMemoryStore.entities->Dict.set(
+          (entityConfig.name :> string),
+          table->InMemoryTable.Entity.resetButKeepLatestChanges,
+        )
+      })
+    } else {
+      // Over the limit: drop everything written in a batch and keep only the
+      // entities loaded from the db, so the next batch can still read them
+      // without hitting the database.
+      let loadedFromDbCount = ref(0.)
+      let resetTables = persistence.allEntities->Array.map(entityConfig => {
+        let resetTable =
+          inMemoryStore
+          ->getInMemTable(~entityConfig)
+          ->InMemoryTable.Entity.resetButKeepLoadedFromDbChanges
+        loadedFromDbCount := loadedFromDbCount.contents +. resetTable.changesCount
+        resetTable
+      })
+      // Even the loaded-from-db entities alone exceed the limit, so there's no
+      // point keeping them around - drop everything.
+      let dropEverything = loadedFromDbCount.contents >= keepLatestChangesLimit
+      persistence.allEntities->Array.forEachWithIndex((entityConfig, idx) => {
+        inMemoryStore.entities->Dict.set(
+          (entityConfig.name :> string),
+          dropEverything ? InMemoryTable.Entity.make() : resetTables->Array.getUnsafe(idx),
+        )
+      })
+    }
   }
 
 let prepareRollbackDiff = async (

package/src/InMemoryStore.res.mjs

@@ -151,10 +151,24 @@ async function writeBatch(inMemoryStore, persistence, batch, config, isInReorgTh
   inMemoryStore.rollback = undefined;
   let checkpointId = Utils.$$Array.last(batch.checkpointIds);
   inMemoryStore.committedCheckpointId = checkpointId !== undefined ? checkpointId : committedCheckpointId;
-  persistence.allEntities.forEach(entityConfig => {
-    let table = getInMemTable(inMemoryStore, entityConfig);
-    let resetTable = keepLatestChanges ? InMemoryTable.Entity.resetButKeepLatestChanges(table) : InMemoryTable.Entity.make();
-    inMemoryStore.entities[entityConfig.name] = resetTable;
+  if (keepLatestChanges) {
+    persistence.allEntities.forEach(entityConfig => {
+      let table = getInMemTable(inMemoryStore, entityConfig);
+      inMemoryStore.entities[entityConfig.name] = InMemoryTable.Entity.resetButKeepLatestChanges(table);
+    });
+    return;
+  }
+  let loadedFromDbCount = {
+    contents: 0
+  };
+  let resetTables = persistence.allEntities.map(entityConfig => {
+    let resetTable = InMemoryTable.Entity.resetButKeepLoadedFromDbChanges(getInMemTable(inMemoryStore, entityConfig));
+    loadedFromDbCount.contents = loadedFromDbCount.contents + resetTable.changesCount;
+    return resetTable;
+  });
+  let dropEverything = loadedFromDbCount.contents >= 50000;
+  persistence.allEntities.forEach((entityConfig, idx) => {
+    inMemoryStore.entities[entityConfig.name] = dropEverything ? InMemoryTable.Entity.make() : resetTables[idx];
   });
 }
 

package/src/InMemoryTable.res

@@ -65,6 +65,25 @@ module Entity = {
     changesCount: self.changesCount,
   }
 
+  // Like resetButKeepLatestChanges, but only keeps entities loaded from the db
+  // (changes carrying loadedFromDbCheckpointId), dropping everything written in
+  // a batch. The kept count is exposed through the table's changesCount.
+  let resetButKeepLoadedFromDbChanges = (self: t): t => {
+    let latestEntityChangeById = Dict.make()
+    let keptCount = ref(0.)
+    self.latestEntityChangeById->Utils.Dict.forEachWithKey((change, key) =>
+      if change->Change.getCheckpointId === Internal.loadedFromDbCheckpointId {
+        latestEntityChangeById->Dict.set(key, change)
+        keptCount := keptCount.contents +. 1.
+      }
+    )
+    {
+      ...make(),
+      latestEntityChangeById,
+      changesCount: keptCount.contents,
+    }
+  }
+
   let updateIndices = (self: t, ~entity: Internal.entity) => {
     let entityId = entity->getEntityIdUnsafe
     //Remove any invalid indices on entity
@@ -83,10 +102,7 @@ module Entity = {
       })
     }
 
-    self.fieldNameIndices
-    ->Dict.keysToArray
-    ->Array.forEach(fieldName => {
-      let indices = self.fieldNameIndices->Dict.getUnsafe(fieldName)
+    self.fieldNameIndices->Utils.Dict.forEachWithKey((indices, fieldName) => {
       // A missing key reads as `undefined`, which matches the `None` arm of
       // `FieldValue.t` (`option<...>`). Mirror `addEmptyIndex` so nullable
       // FK columns that were omitted on the set entity don't crash.

package/src/InMemoryTable.res.mjs

@@ -70,6 +70,34 @@ function resetButKeepLatestChanges(self) {
   };
 }
 
+function resetButKeepLoadedFromDbChanges(self) {
+  let latestEntityChangeById = {};
+  let keptCount = {
+    contents: 0
+  };
+  Utils.Dict.forEachWithKey(self.latestEntityChangeById, (change, key) => {
+    if (change.checkpointId === Internal.loadedFromDbCheckpointId) {
+      latestEntityChangeById[key] = change;
+      keptCount.contents = keptCount.contents + 1;
+      return;
+    }
+  });
+  let init = {
+    latestEntityChangeById: {},
+    changesCount: 0,
+    prevEntityChanges: [],
+    indicesByEntityId: {},
+    fieldNameIndices: {}
+  };
+  return {
+    latestEntityChangeById: latestEntityChangeById,
+    changesCount: keptCount.contents,
+    prevEntityChanges: init.prevEntityChanges,
+    indicesByEntityId: init.indicesByEntityId,
+    fieldNameIndices: init.fieldNameIndices
+  };
+}
+
 function updateIndices(self, entity) {
   let entityId = getEntityIdUnsafe(entity);
   let entityIndices = self.indicesByEntityId[entityId];
@@ -84,8 +112,7 @@ function updateIndices(self, entity) {
       }
     });
   }
-  Object.keys(self.fieldNameIndices).forEach(fieldName => {
-    let indices = self.fieldNameIndices[fieldName];
+  Utils.Dict.forEachWithKey(self.fieldNameIndices, (indices, fieldName) => {
     let fieldValue = entity[fieldName];
     Utils.Dict.forEach(indices, param => {
       let relatedEntityIds = param[1];
@@ -233,6 +260,7 @@ let Entity = {
   makeIndicesSerializedToValue: makeIndicesSerializedToValue,
   make: make,
   resetButKeepLatestChanges: resetButKeepLatestChanges,
+  resetButKeepLoadedFromDbChanges: resetButKeepLoadedFromDbChanges,
   updateIndices: updateIndices,
   deleteEntityFromIndices: deleteEntityFromIndices,
   set: set,

package/src/LogSelection.res

@@ -181,23 +181,21 @@ let parseEventFiltersOrThrow = {
     // parameters of the event — TS type checking doesn't catch this when
     // `where` is a callback.
     let paramsRecordToTopicSelection = (paramsFilter: dict<JSON.t>) => {
-      let filterKeys = paramsFilter->Dict.keysToArray
-      switch filterKeys {
-      | [] => default
-      | _ => {
-          filterKeys->Array.forEach(key => {
-            if params->Array.includes(key)->not {
-              JsError.throwWithMessage(
-                `Invalid where configuration. The event doesn't have an indexed parameter "${key}" and can't use it for filtering`,
-              )
-            }
-          })
-          {
-            Internal.topic0,
-            topic1: topic1(paramsFilter),
-            topic2: topic2(paramsFilter),
-            topic3: topic3(paramsFilter),
+      if paramsFilter->Utils.Dict.isEmpty {
+        default
+      } else {
+        paramsFilter->Utils.Dict.forEachWithKey((_, key) => {
+          if params->Array.includes(key)->not {
+            JsError.throwWithMessage(
+              `Invalid where configuration. The event doesn't have an indexed parameter "${key}" and can't use it for filtering`,
+            )
           }
+        })
+        {
+          Internal.topic0,
+          topic1: topic1(paramsFilter),
+          topic2: topic2(paramsFilter),
+          topic3: topic3(paramsFilter),
         }
       }
     }
@@ -236,9 +234,7 @@ let parseEventFiltersOrThrow = {
         | Object(obj) => {
             // Catch typos (e.g. `parmas:`) and the legacy flat-filter
             // shape (`{from: ...}`) by rejecting any unknown sibling.
-            obj
-            ->Dict.keysToArray
-            ->Array.forEach(key => {
+            obj->Utils.Dict.forEachWithKey((_, key) => {
               if acceptedWhereKeys->Array.includes(key)->not {
                 JsError.throwWithMessage(
                   `Invalid where configuration. Unknown field "${key}". Indexed parameter filters must be nested under \`params\` and block-range filters under \`block\``,

package/src/LogSelection.res.mjs

@@ -145,9 +145,10 @@ function parseEventFiltersOrThrow(eventFilters, sighash, params, contractName, p
     topic3: emptyTopics
   };
   let paramsRecordToTopicSelection = paramsFilter => {
-    let filterKeys = Object.keys(paramsFilter);
-    if (filterKeys.length !== 0) {
-      filterKeys.forEach(key => {
+    if (Utils.Dict.isEmpty(paramsFilter)) {
+      return $$default;
+    } else {
+      Utils.Dict.forEachWithKey(paramsFilter, (param, key) => {
         if (!params.includes(key)) {
           return Stdlib_JsError.throwWithMessage(`Invalid where configuration. The event doesn't have an indexed parameter "` + key + `" and can't use it for filtering`);
         }
@@ -158,8 +159,6 @@ function parseEventFiltersOrThrow(eventFilters, sighash, params, contractName, p
         topic2: topic2(paramsFilter),
         topic3: topic3(paramsFilter)
       };
-    } else {
-      return $$default;
     }
   };
   let acceptedWhereKeys = [
@@ -176,7 +175,7 @@ function parseEventFiltersOrThrow(eventFilters, sighash, params, contractName, p
     if (typeof where !== "object" || where === null || Array.isArray(where)) {
       return Stdlib_JsError.throwWithMessage("Invalid where configuration. Expected an object");
     }
-    Object.keys(where).forEach(key => {
+    Utils.Dict.forEachWithKey(where, (param, key) => {
       if (!acceptedWhereKeys.includes(key)) {
         return Stdlib_JsError.throwWithMessage(`Invalid where configuration. Unknown field "` + key + `". Indexed parameter filters must be nested under \`params\` and block-range filters under \`block\``);
       }

package/src/sources/EnvioApiClient.res

@@ -0,0 +1,15 @@
+// Rest client for envio's own REST endpoints (e.g. the HyperSync/HyperFuel
+// /height poll). Tags requests with the hyperindex User-Agent so they're
+// attributable on the server, mirroring the SSE height stream and the Rust
+// data-query client which already set it.
+let make = (baseUrl: string): Rest.client => {
+  let userAgent = `hyperindex/${Utils.EnvioPackage.value.version}`
+  Rest.client(baseUrl, ~fetcher=(args: Rest.ApiFetcher.args) => {
+    let headers = switch args.headers {
+    | Some(headers) => headers
+    | None => Dict.make()
+    }
+    headers->Dict.set("User-Agent", userAgent->(Utils.magic: string => unknown))
+    Rest.ApiFetcher.default({...args, headers: Some(headers)})
+  })
+}

package/src/sources/EnvioApiClient.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Rest from "../vendored/Rest.res.mjs";
+import * as Utils from "../Utils.res.mjs";
+
+function make(baseUrl) {
+  let userAgent = `hyperindex/` + Utils.EnvioPackage.value.version;
+  return Rest.client(baseUrl, args => {
+    let headers = args.headers;
+    let headers$1 = headers !== undefined ? headers : ({});
+    headers$1["User-Agent"] = userAgent;
+    return Rest.ApiFetcher.$$default({
+      body: args.body,
+      headers: headers$1,
+      method: args.method,
+      path: args.path
+    });
+  });
+}
+
+export {
+  make,
+}
+/* Rest Not a pure module */

package/src/sources/EvmChain.res

@@ -87,7 +87,6 @@ let makeSources = (
         allEventParams,
         eventRouter,
         apiToken: Env.envioApiToken,
-        clientMaxRetries: Env.hyperSyncClientMaxRetries,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses,
         serializationFormat: Env.hypersyncClientSerializationFormat,

package/src/sources/EvmChain.res.mjs

@@ -54,7 +54,6 @@ function makeSources(chain, contracts, hyperSync, rpcs, lowercaseAddresses) {
         allEventParams: allEventParams,
         eventRouter: eventRouter,
         apiToken: Env.envioApiToken,
-        clientMaxRetries: Env.hyperSyncClientMaxRetries,
         clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
         lowercaseAddresses: lowercaseAddresses,
         serializationFormat: Env.hypersyncClientSerializationFormat,

package/src/sources/HyperFuelSource.res

@@ -449,7 +449,7 @@ let make = ({chain, endpointUrl}: options): t => {
   let getBlockHashes = (~blockNumbers as _, ~logger as _) =>
     JsError.throwWithMessage("HyperFuel does not support getting block hashes")
 
-  let jsonApiClient = Rest.client(endpointUrl)
+  let jsonApiClient = EnvioApiClient.make(endpointUrl)
 
   {
     name,

package/src/sources/HyperFuelSource.res.mjs

@@ -11,6 +11,7 @@ import * as Prometheus from "../Prometheus.res.mjs";
 import * as EventRouter from "./EventRouter.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as EnvioApiClient from "./EnvioApiClient.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -387,7 +388,7 @@ function make(param) {
     };
   };
   let getBlockHashes = (param, param$1) => Stdlib_JsError.throwWithMessage("HyperFuel does not support getting block hashes");
-  let jsonApiClient = Rest.client(endpointUrl, undefined);
+  let jsonApiClient = EnvioApiClient.make(endpointUrl);
   return {
     name: name,
     sourceFor: "Sync",

package/src/sources/HyperSync.res

@@ -1,3 +1,19 @@
+let reraisIfRateLimited = exn =>
+  switch exn->JsExn.anyToExnInternal {
+  | JsExn(e) =>
+    switch e->JsExn.message {
+    | Some(msg) if msg->String.startsWith("RATE_LIMITED:") =>
+      let resetMs =
+        msg
+        ->String.slice(~start=13, ~end=msg->String.length)
+        ->Int.fromString
+        ->Option.getOr(1000)
+      throw(Source.RateLimited({resetMs: resetMs}))
+    | _ => ()
+    }
+  | _ => ()
+  }
+
 type logsQueryPage = {
   items: array<HyperSyncClient.EventItems.item>,
   nextBlock: int,
@@ -108,6 +124,7 @@ module GetLogs = {
     let res = switch await client.getEventItems(~query) {
     | res => res
     | exception exn =>
+      reraisIfRateLimited(exn)
       switch extractMissingParams(exn) {
       | Some(missingParams) => throw(Error(UnexpectedMissingParams({missingParams: missingParams})))
       | None => throw(exn)
@@ -193,7 +210,9 @@ module BlockData = {
 
     Prometheus.SourceRequestCount.increment(~sourceName, ~chainId, ~method="getBlockHashes")
     let maybeSuccessfulRes = switch await client.get(~query=body) {
-    | exception _ => None
+    | exception exn =>
+      reraisIfRateLimited(exn)
+      None
     | res if res.nextBlock <= fromBlock => None
     | res => Some(res)
     }

package/src/sources/HyperSync.res.mjs

@@ -2,8 +2,10 @@
 
 import * as Time from "../Time.res.mjs";
 import * as Utils from "../Utils.res.mjs";
+import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
@@ -13,6 +15,26 @@ 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) {
+  let e = Primitive_exceptions.internalToException(exn);
+  if (e.RE_EXN_ID !== "JsExn") {
+    return;
+  }
+  let msg = Stdlib_JsExn.message(e._1);
+  if (msg === undefined) {
+    return;
+  }
+  if (!msg.startsWith("RATE_LIMITED:")) {
+    return;
+  }
+  let resetMs = Stdlib_Option.getOr(Stdlib_Int.fromString(msg.slice(13, msg.length), undefined), 1000);
+  throw {
+    RE_EXN_ID: Source.RateLimited,
+    resetMs: resetMs,
+    Error: new Error()
+  };
+}
+
 let HyperSyncQueryError = /* @__PURE__ */Primitive_exceptions.create("HyperSync.HyperSyncQueryError");
 
 function queryErrorToMsq(e) {
@@ -84,6 +106,7 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection)
     res = await client.getEventItems(query$1);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
+    reraisIfRateLimited(exn);
     let missingParams = extractMissingParams(exn);
     if (missingParams !== undefined) {
       throw {
@@ -178,7 +201,9 @@ async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, l
   try {
     res = await client.get(body);
     exit = 1;
-  } catch (exn) {
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    reraisIfRateLimited(exn);
     maybeSuccessfulRes = undefined;
   }
   if (exit === 1) {

package/src/sources/HyperSyncClient.res

@@ -362,6 +362,7 @@ module EventItems = {
 type t = {
   get: (~query: query) => promise<queryResponse>,
   getEventItems: (~query: query) => promise<EventItems.response>,
+  getHeight: unit => promise<int>,
 }
 
 @send
@@ -387,7 +388,6 @@ let make = (
   ~url,
   ~apiToken,
   ~httpReqTimeoutMillis,
-  ~maxNumRetries,
   ~eventParams,
   ~enableChecksumAddresses=true,
   ~serializationFormat=?,
@@ -404,7 +404,8 @@ let make = (
       enableChecksumAddresses,
       apiToken,
       httpReqTimeoutMillis,
-      maxNumRetries,
+      // Retries are handled internally by the indexer, not the binary client
+      maxNumRetries: 0,
       ?serializationFormat,
       ?enableQueryCaching,
       ?retryBaseMs,