envio 3.10.0-subgraph → 3.11.0

package/src/UserContext.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
@@ -13,70 +12,8 @@ import * as InMemoryStore from "./InMemoryStore.res.mjs";
 import * as InMemoryTable from "./InMemoryTable.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
-
-let Suspend = /* @__PURE__ */Primitive_exceptions.create("UserContext.Suspend");
-
-function isSuspend(exn) {
-  return exn.RE_EXN_ID === Suspend;
-}
-
-function makeSyncState() {
-  return {
-    status: "Active",
-    pending: undefined,
-    memo: undefined
-  };
-}
-
-function getPending(sync) {
-  let pending = sync.pending;
-  if (pending !== undefined) {
-    return pending;
-  }
-  let pending$1 = [];
-  sync.pending = pending$1;
-  return pending$1;
-}
-
-function getMemo(sync) {
-  let memo = sync.memo;
-  if (memo !== undefined) {
-    return memo;
-  }
-  let memo$1 = {};
-  sync.memo = memo$1;
-  return memo$1;
-}
-
-function checkStatusOrThrow(params, access) {
-  let exn = params.sync.status;
-  if (typeof exn !== "object") {
-    if (exn === "Active") {
-      return;
-    } else {
-      return ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access ` + access + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
-    }
-  }
-  throw exn._0;
-}
-
-function scheduleAndSuspend(params, promise) {
-  getPending(params.sync).push(promise);
-  params.sync.status = {
-    TAG: "Aborted",
-    _0: {
-      RE_EXN_ID: Suspend
-    }
-  };
-  throw {
-    RE_EXN_ID: Suspend,
-    Error: new Error()
-  };
-}
 
 let paramsByThis = new WeakMap();
 
@@ -110,69 +47,28 @@ var EffectContext = function(params, chainId, effectName, defaultShouldCache, ca
 EffectContext.prototype = effectContextPrototype;
 ;
 
-function prepareEffectCall(params, effect, input, caller) {
-  let isCrossChain = effect => Stdlib_Option.getOr(effect.crossChain, params.config.defaultCrossChain);
-  let scope = isCrossChain(effect) ? "crossChain" : Internal.getItemChainId(params.item);
-  if (caller !== undefined && isCrossChain(caller) && !isCrossChain(effect)) {
-    Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
-  }
-  let tmp;
-  tmp = scope === "crossChain" ? undefined : Primitive_option.some(scope);
-  let effectContext = new EffectContext(params, tmp, effect.name, effect.defaultShouldCache, (nested, nestedInput) => callEffectAsync(params, nested, nestedInput, effect));
-  let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
-  let effectArgs_checkpointId = params.checkpointId;
-  let effectArgs = {
-    input: input,
-    context: effectContext,
-    cacheKey: effectArgs_cacheKey,
-    checkpointId: effectArgs_checkpointId
-  };
-  return [
-    scope,
-    effectArgs
-  ];
-}
-
-function callEffectAsync(params, effect, input, caller) {
-  let match = prepareEffectCall(params, effect, input, caller);
-  return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, match[1], match[0], params.indexerState, params.isPreload, params.item, params.config.ecosystem);
-}
-
 function initEffect(params) {
-  return (effect, input) => {
-    checkStatusOrThrow(params, "context.effect");
-    return callEffectAsync(params, effect, input, undefined);
-  };
-}
-
-function effectMemoKey(effect, scope, cacheKey) {
-  if (scope === "crossChain") {
-    return effect.name + `.` + cacheKey;
-  } else {
-    return effect.name + `.` + ChainId.toString(scope) + `.` + cacheKey;
-  }
-}
-
-function initEffectSync(params) {
-  return (effect, input) => {
-    checkStatusOrThrow(params, "context.effectSync");
-    let match = prepareEffectCall(params, effect, input, undefined);
-    let effectArgs = match[1];
-    let scope = match[0];
-    let memo = getMemo(params.sync);
-    let memoKey = effectMemoKey(effect, scope, effectArgs.cacheKey);
-    let output = memo[memoKey];
-    if (output !== undefined) {
-      return Primitive_option.valFromOption(output);
-    }
-    let inMemTable = InMemoryStore.getEffectInMemTable(params.indexerState, effect, scope);
-    if (!InMemoryStore.hasEffectOutput(inMemTable, effectArgs.cacheKey)) {
-      return scheduleAndSuspend(params, LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem));
+  let handlerChainId = Internal.getItemChainId(params.item);
+  let isCrossChain = effect => Stdlib_Option.getOr(effect.crossChain, params.config.defaultCrossChain);
+  let makeCaller = caller => ((effect, input) => {
+    let scope = isCrossChain(effect) ? "crossChain" : handlerChainId;
+    if (caller !== undefined && isCrossChain(caller) && !isCrossChain(effect)) {
+      Stdlib_JsError.throwWithMessage(`The cross-chain effect "` + caller.name + `" cannot call the chain-scoped effect "` + effect.name + `", because a cross-chain effect isn't tied to a single chain. Make "` + effect.name + `" cross-chain (\`crossChain: true\`), or make "` + caller.name + `" chain-scoped (\`crossChain: false\`).`);
     }
-    let output$1 = InMemoryStore.getEffectOutputUnsafe(inMemTable, effectArgs.cacheKey);
-    memo[memoKey] = output$1;
-    return output$1;
-  };
+    let tmp;
+    tmp = scope === "crossChain" ? undefined : Primitive_option.some(scope);
+    let effectContext = new EffectContext(params, tmp, effect.name, effect.defaultShouldCache, makeCaller(effect));
+    let effectArgs_cacheKey = Utils.Hash.makeOrThrow(S$RescriptSchema.reverseConvertOrThrow(input, effect.input));
+    let effectArgs_checkpointId = params.checkpointId;
+    let effectArgs = {
+      input: input,
+      context: effectContext,
+      cacheKey: effectArgs_cacheKey,
+      checkpointId: effectArgs_checkpointId
+    };
+    return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
+  });
+  return makeCaller(undefined);
 }
 
 function entityScope(params) {
@@ -201,83 +97,24 @@ function throwClickHouseReadOnly(entityConfig, op) {
   return Stdlib_JsError.throwWithMessage(`context.` + entityConfig.name + `.` + op + `() is unavailable: ClickHouse storage is currently write-only. Follow Envio releases to be notified when ClickHouse supports both reads and writes from handlers.`);
 }
 
-function getSyncHandler(params, entityId) {
-  let inMemTable = InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params));
-  if (entityId in inMemTable.latestEntityChangeById) {
-    return InMemoryTable.Entity.getUnsafe(inMemTable)(entityId);
-  } else {
-    return scheduleAndSuspend(params, LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId));
-  }
-}
-
-function getWhereSyncHandler(params, filter) {
-  let entityConfig = params.entityConfig;
-  let inMemTable = InMemoryStore.getInMemTable(params.indexerState, entityConfig, entityScope(params));
-  let hasIndex = InMemoryTable.Entity.hasIndex(inMemTable);
-  let getOnIndex = InMemoryTable.Entity.getUnsafeOnIndex(inMemTable);
-  let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
-  let missing = [];
-  let entities = [];
-  filters.forEach(filter => {
-    let filterKey = EntityFilter.toString(filter);
-    if (hasIndex(filterKey)) {
-      entities.push(...getOnIndex(filterKey));
-    } else {
-      missing.push(LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter));
-    }
-  });
-  if (Utils.$$Array.notEmpty(missing)) {
-    let pending = getPending(params.sync);
-    missing.forEach(promise => {
-      pending.push(promise);
-    });
-    params.sync.status = {
-      TAG: "Aborted",
-      _0: {
-        RE_EXN_ID: Suspend
-      }
-    };
-    throw {
-      RE_EXN_ID: Suspend,
-      Error: new Error()
-    };
-  }
-  return entities;
-}
-
-function getInBlockSyncHandler(params, entityId) {
-  let inMemTable = InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params));
-  let change = inMemTable.latestEntityChangeById[entityId];
-  if (change !== undefined && change.checkpointId === params.checkpointId) {
-    return InMemoryTable.Entity.mapChangeToEntity(change);
-  }
-}
-
 let entityTraps_get = (params, prop) => {
-  checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.` + prop);
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => {
-      checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.set`);
-      InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
-        type: "SET",
-        entityId: entity.id,
-        entity: entity,
-        checkpointId: params.checkpointId
-      });
-    };
+  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+      type: "SET",
+      entityId: entity.id,
+      entity: entity,
+      checkpointId: params.checkpointId
+    });
   switch (prop) {
     case "deleteUnsafe" :
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => {
-          checkStatusOrThrow(params, `context.` + params.entityConfig.name + `.deleteUnsafe`);
-          InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
-            type: "DELETE",
-            entityId: entityId,
-            checkpointId: params.checkpointId
-          });
-        };
+        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+          type: "DELETE",
+          entityId: entityId,
+          checkpointId: params.checkpointId
+        });
       }
     case "get" :
       if (isClickHouseOnly) {
@@ -285,8 +122,6 @@ let entityTraps_get = (params, prop) => {
       } else {
         return entityId => LoadLayer.loadById(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, entityId);
       }
-    case "getInBlockSync" :
-      return entityId => getInBlockSyncHandler(params, entityId);
     case "getOrCreate" :
       if (isClickHouseOnly) {
         return _entity => throwClickHouseReadOnly(params.entityConfig, "getOrCreate");
@@ -312,16 +147,12 @@ let entityTraps_get = (params, prop) => {
           }
         });
       }
-    case "getSync" :
-      return entityId => getSyncHandler(params, entityId);
     case "getWhere" :
       if (isClickHouseOnly) {
         return _filter => throwClickHouseReadOnly(params.entityConfig, "getWhere");
       } else {
         return filter => getWhereHandler(params, filter);
       }
-    case "getWhereSync" :
-      return filter => getWhereSyncHandler(params, filter);
     case "set" :
       return set;
     default:
@@ -333,63 +164,16 @@ let entityTraps = {
   get: entityTraps_get
 };
 
-async function runSyncRound(params, fn, round) {
-  if (round > 10000) {
-    Stdlib_JsError.throwWithMessage(`The handler suspended on a synchronous read too many times: gave up after ` + (10000).toString() + ` rounds. This usually means the code isn't deterministic across reruns.`);
-  }
-  params.sync.status = "Active";
-  params.sync.pending = undefined;
-  let suspended;
-  try {
-    fn();
-    suspended = false;
-  } catch (raw_exn) {
-    let exn = Primitive_exceptions.internalToException(raw_exn);
-    if (exn.RE_EXN_ID === Suspend) {
-      suspended = true;
-    } else {
-      let pending = params.sync.pending;
-      if (pending !== undefined) {
-        params.sync.pending = undefined;
-        pending.forEach(promise => {
-          Utils.$$Promise.silentCatch(promise);
-        });
-      }
-      throw exn;
-    }
-  }
-  let pending$1 = params.sync.pending;
-  if (pending$1 === undefined) {
-    return;
-  }
-  params.sync.pending = undefined;
-  if (suspended) {
-    let errors = [];
-    await Promise.all(pending$1.map(promise => Stdlib_Promise.$$catch(promise, exn => {
-      errors.push(exn);
-      return Promise.resolve();
-    })));
-    let exn$1 = errors[0];
-    if (exn$1 !== undefined) {
-      throw exn$1;
-    }
-    return await runSyncRound(params, fn, round + 1 | 0);
-  }
-  pending$1.forEach(promise => {
-    Utils.$$Promise.silentCatch(promise);
-  });
-}
-
 let handlerTraps_get = (params, prop) => {
-  checkStatusOrThrow(params, `context.` + prop);
+  if (params.isResolved) {
+    ErrorHandling.mkLogAndRaise(Ecosystem.getItemLogger(params.item, params.config.ecosystem), undefined, new Error(`Impossible to access context.` + prop + ` after the handler is resolved. Make sure you didn't miss an await in the handler.`));
+  }
   switch (prop) {
     case "chain" :
       let chainId = Internal.getItemChainId(params.item);
       return params.chains[chainId];
     case "effect" :
       return initEffect(params);
-    case "effectSync" :
-      return initEffectSync(params);
     case "isPreload" :
       return params.isPreload;
     case "log" :
@@ -398,8 +182,6 @@ let handlerTraps_get = (params, prop) => {
       } else {
         return Ecosystem.getItemUserLogger(params.item, params.config.ecosystem);
       }
-    case "runSync" :
-      return fn => runSyncRound(params, fn, 1);
     default:
       let entityConfig = params.config.userEntitiesByName[prop];
       if (entityConfig !== undefined) {
@@ -412,7 +194,7 @@ let handlerTraps_get = (params, prop) => {
           isPreload: params.isPreload,
           chains: params.chains,
           config: params.config,
-          sync: params.sync,
+          isResolved: params.isResolved,
           entityConfig: entityConfig
         }, entityTraps);
       } else {
@@ -429,34 +211,16 @@ function getHandlerContext(params) {
   return new Proxy(params, handlerTraps);
 }
 
-let maxSyncRounds = 10000;
-
 export {
-  Suspend,
-  isSuspend,
-  makeSyncState,
-  getPending,
-  getMemo,
-  checkStatusOrThrow,
-  scheduleAndSuspend,
   paramsByThis,
   effectContextPrototype,
-  prepareEffectCall,
-  callEffectAsync,
   initEffect,
-  effectMemoKey,
-  initEffectSync,
   entityScope,
   getWhereHandler,
   noopSet,
   noopDeleteUnsafe,
   throwClickHouseReadOnly,
-  getSyncHandler,
-  getWhereSyncHandler,
-  getInBlockSyncHandler,
   entityTraps,
-  maxSyncRounds,
-  runSyncRound,
   handlerTraps,
   getHandlerContext,
 }

package/src/db/InternalTable.res

@@ -272,7 +272,7 @@ module Chains = {
     {
       id: chainConfig.id,
       ecosystem: (chainConfig.ecosystem: Ecosystem.name :> string),
-      startBlock: chainConfig.startBlock,
+      startBlock: chainConfig->Config.startBlockOrThrow,
       endBlock: chainConfig.endBlock->Null.fromOption,
       maxReorgDepth: chainConfig.maxReorgDepth,
       blockHeight: 0,

package/src/db/InternalTable.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Table from "./Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
+import * as Config from "../Config.res.mjs";
 import * as Address from "../Address.res.mjs";
 import * as ChainId from "../ChainId.res.mjs";
 import * as Postgres from "../bindings/Postgres.res.mjs";
@@ -181,7 +182,7 @@ function initialFromConfig(chainConfig) {
   return {
     id: chainConfig.id,
     ecosystem: chainConfig.ecosystem,
-    start_block: chainConfig.startBlock,
+    start_block: Config.startBlockOrThrow(chainConfig),
     end_block: Stdlib_Null.fromOption(chainConfig.endBlock),
     max_reorg_depth: chainConfig.maxReorgDepth,
     source_block: 0,

package/src/sources/ChainSources.res

@@ -0,0 +1,72 @@
+// Sits below `ChainState`/`Persistence` in the module graph so that
+// `StartBlockResolver` (called from `Persistence.init`) can build a chain's
+// sources without a dependency cycle.
+let make = (
+  ~chainConfig: Config.chain,
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+  ~addressStore: AddressStore.t,
+  ~lowercaseAddresses: bool,
+): array<Source.t> => {
+  let chainId = chainConfig.id
+  switch chainConfig.sourceConfig {
+  | Config.EvmSourceConfig({hypersync, rpcs}) =>
+    let evmRpcs: array<EvmChain.rpc> = rpcs->Array.map((rpc): EvmChain.rpc => {
+      let syncConfig = rpc.syncConfig
+      let ws = rpc.ws
+      let headers = rpc.headers
+      {
+        url: rpc.url,
+        sourceFor: rpc.sourceFor,
+        ?syncConfig,
+        ?ws,
+        ?headers,
+      }
+    })
+    EvmChain.makeSources(
+      ~chainId,
+      ~onEventRegistrations=onEventRegistrations->(
+        Utils.magic: array<Internal.onEventRegistration> => array<Internal.evmOnEventRegistration>
+      ),
+      ~hyperSync=hypersync,
+      ~rpcs=evmRpcs,
+      ~lowercaseAddresses,
+      ~addressStore,
+    )
+  | Config.FuelSourceConfig({hypersync}) => [
+      FuelHyperSyncSource.make({
+        chainId,
+        endpointUrl: hypersync,
+        apiToken: Env.envioApiToken,
+        onEventRegistrations,
+        addressStore,
+      }),
+    ]
+  | Config.SvmSourceConfig({hypersync}) => [
+      SvmHyperSyncSource.make({
+        chainId,
+        endpointUrl: hypersync,
+        apiToken: Env.envioApiToken,
+        onEventRegistrations: onEventRegistrations->(
+          Utils.magic: array<Internal.onEventRegistration> => array<
+            Internal.svmOnEventRegistration,
+          >
+        ),
+        clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
+        addressStore,
+      }),
+    ]
+  | Config.SimulateSourceConfig({items, endBlock, ?transactionStore, ?blockStore}) => [
+      SimulateSource.make(
+        ~items,
+        ~endBlock,
+        ~chainId,
+        ~addressStore,
+        ~ecosystem=chainConfig.ecosystem,
+        ~transactionStore,
+        ~blockStore,
+      ),
+    ]
+  // For tests: use ready-to-use sources directly
+  | Config.CustomSources(sources) => sources
+  }
+}

package/src/sources/ChainSources.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "../Env.res.mjs";
+import * as EvmChain from "./EvmChain.res.mjs";
+import * as SimulateSource from "./SimulateSource.res.mjs";
+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, addressStore, lowercaseAddresses) {
+  let chainId = chainConfig.id;
+  let sources = chainConfig.sourceConfig;
+  switch (sources.TAG) {
+    case "EvmSourceConfig" :
+      let evmRpcs = sources.rpcs.map(rpc => {
+        let syncConfig = rpc.syncConfig;
+        let ws = rpc.ws;
+        let headers = rpc.headers;
+        return {
+          url: rpc.url,
+          sourceFor: rpc.sourceFor,
+          syncConfig: syncConfig,
+          ws: ws,
+          headers: headers
+        };
+      });
+      return EvmChain.makeSources(chainId, onEventRegistrations, sources.hypersync, evmRpcs, lowercaseAddresses, addressStore);
+    case "FuelSourceConfig" :
+      return [FuelHyperSyncSource.make({
+          chainId: chainId,
+          endpointUrl: sources.hypersync,
+          apiToken: Env.envioApiToken,
+          onEventRegistrations: onEventRegistrations,
+          addressStore: addressStore
+        })];
+    case "SvmSourceConfig" :
+      return [SvmHyperSyncSource.make({
+          chainId: chainId,
+          endpointUrl: sources.hypersync,
+          apiToken: Env.envioApiToken,
+          onEventRegistrations: onEventRegistrations,
+          clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
+          addressStore: addressStore
+        })];
+    case "SimulateSourceConfig" :
+      return [SimulateSource.make(sources.items, sources.endBlock, chainId, addressStore, chainConfig.ecosystem, Primitive_option.some(sources.transactionStore), Primitive_option.some(sources.blockStore))];
+    case "CustomSources" :
+      return sources._0;
+  }
+}
+
+export {
+  make,
+}
+/* Env Not a pure module */

package/src/sources/EvmHyperSyncSource.res

@@ -1,11 +1,5 @@
 open Source
 
-// Surfaced by the HyperSync client (Rust) when HyperSync rejects the API
-// token. The corrupted-token test feeds the real server error (from the query
-// endpoint; the edge no longer 401s malformed tokens on /height) through this
-// check so it can't silently drift away from what getHeightOrThrow guards on.
-let isUnauthorizedError = (message: string) => message->String.includes("401 Unauthorized")
-
 type options = {
   chainId: ChainId.t,
   endpointUrl: string,
@@ -37,13 +31,11 @@ let make = (
 ): t => {
   let name = "HyperSync"
 
-  let apiToken = switch apiToken {
-  | Some(token) => token
-  | None =>
-    JsError.throwWithMessage(`An Envio API token is required for using HyperSync as a data-source.
-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`)
-  }
+  // Per source, so one rejected token is reported once rather than on every
+  // height retry for the life of the process.
+  let unauthorizedWarned = ref(false)
+
+  let apiToken = apiToken->HyperSync.requireApiToken
 
   let client = switch HyperSyncClient.make(
     ~url=endpointUrl,
@@ -213,15 +205,11 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       let height = try {
         await client.getHeight()
       } catch {
-      | JsExn(e) =>
-        switch e->JsExn.message {
-        | Some(message) if message->isUnauthorizedError =>
-          Logging.error(`Your ENVIO_API_TOKEN was rejected by HyperSync (401 Unauthorized). The indexer will not be able to fetch events. Update the token and try again using 'envio start' or 'envio dev'. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens`)
-          // Retrying an unauthorized request can never succeed, so block forever
-          let _ = await Promise.make((_, _) => ())
-          0
-        | _ => throw(JsExn(e))
-        }
+      | exn =>
+        exn->HyperSync.rethrowLoggingUnauthorized(
+          ~warned=unauthorizedWarned,
+          ~product="HyperSync",
+        )
       }
       let seconds = timerRef->Performance.secondsSince
       {height, requestStats: [{method: "getHeight", seconds}]}