envio 3.0.0-alpha.1 → 3.0.0-alpha.2

package/src/Env.res.mjs

@@ -0,0 +1,273 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as EnvSafe from "rescript-envsafe/src/EnvSafe.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Postgres from "./bindings/Postgres.res.mjs";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+import 'dotenv/config'
+;
+
+var envSafe = EnvSafe.make(undefined);
+
+function getLogLevelConfig(name, $$default) {
+  return EnvSafe.get(envSafe, name, S$RescriptSchema.$$enum([
+                  "trace",
+                  "debug",
+                  "info",
+                  "warn",
+                  "error",
+                  "fatal",
+                  "udebug",
+                  "uinfo",
+                  "uwarn",
+                  "uerror"
+                ]), undefined, $$default, undefined, undefined);
+}
+
+var updateSyncTimeOnRestart = EnvSafe.get(envSafe, "UPDATE_SYNC_TIME_ON_RESTART", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var batchSize = EnvSafe.get(envSafe, "MAX_BATCH_SIZE", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var targetBufferSize = EnvSafe.get(envSafe, "ENVIO_INDEXING_MAX_BUFFER_SIZE", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var maxAddrInPartition = EnvSafe.get(envSafe, "MAX_PARTITION_SIZE", S$RescriptSchema.$$int, undefined, 5000, undefined, undefined);
+
+var maxPartitionConcurrency = EnvSafe.get(envSafe, "ENVIO_MAX_PARTITION_CONCURRENCY", S$RescriptSchema.$$int, undefined, 10, undefined, undefined);
+
+var indexingBlockLag = EnvSafe.get(envSafe, "ENVIO_INDEXING_BLOCK_LAG", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var serverPort = EnvSafe.get(envSafe, "ENVIO_INDEXER_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, EnvSafe.get(envSafe, "METRICS_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, 9898, undefined, undefined), undefined, undefined);
+
+var tuiOffEnvVar = EnvSafe.get(envSafe, "TUI_OFF", S$RescriptSchema.bool, undefined, false, undefined, undefined);
+
+var logFilePath = EnvSafe.get(envSafe, "LOG_FILE", S$RescriptSchema.string, undefined, "logs/envio.log", undefined, undefined);
+
+var userLogLevel = getLogLevelConfig("LOG_LEVEL", "info");
+
+var defaultFileLogLevel = getLogLevelConfig("FILE_LOG_LEVEL", "trace");
+
+var prodEnvioAppUrl = "https://envio.dev";
+
+var envioAppUrl = EnvSafe.get(envSafe, "ENVIO_APP", S$RescriptSchema.string, undefined, prodEnvioAppUrl, undefined, undefined);
+
+var envioApiToken = EnvSafe.get(envSafe, "ENVIO_API_TOKEN", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var hyperSyncClientTimeoutMillis = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S$RescriptSchema.$$int, undefined, 120000, undefined, undefined);
+
+var hyperSyncClientMaxRetries = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_MAX_RETRIES", S$RescriptSchema.$$int, undefined, 0, undefined, undefined);
+
+var hypersyncClientSerializationFormat = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT", HyperSyncClient.serializationFormatSchema, undefined, "CapnProto", undefined, undefined);
+
+var hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var schema = S$RescriptSchema.$$enum([
+      true,
+      false,
+      "json-file",
+      "prometheus"
+    ]);
+
+var $$default = false;
+
+function shouldSaveJsonFile(self) {
+  if (typeof self !== "boolean") {
+    if (self === "json-file") {
+      return true;
+    } else {
+      return false;
+    }
+  } else if (self) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function shouldSavePrometheus(param) {
+  return true;
+}
+
+function shouldSaveData(self) {
+  return true;
+}
+
+var SaveDataStrategy = {
+  schema: schema,
+  $$default: $$default,
+  shouldSaveJsonFile: shouldSaveJsonFile,
+  shouldSavePrometheus: shouldSavePrometheus,
+  shouldSaveData: shouldSaveData
+};
+
+var saveDataStrategy = EnvSafe.get(envSafe, "ENVIO_SAVE_BENCHMARK_DATA", schema, undefined, Caml_option.some($$default), undefined, undefined);
+
+var shouldSaveData$1 = shouldSaveData(saveDataStrategy);
+
+var shouldSaveStdDev = shouldSaveJsonFile(saveDataStrategy);
+
+var Benchmark = {
+  SaveDataStrategy: SaveDataStrategy,
+  saveDataStrategy: saveDataStrategy,
+  shouldSaveData: shouldSaveData$1,
+  shouldSaveStdDev: shouldSaveStdDev
+};
+
+var logStrategy = EnvSafe.get(envSafe, "LOG_STRATEGY", S$RescriptSchema.$$enum([
+          "ecs-file",
+          "ecs-console",
+          "ecs-console-multistream",
+          "file-only",
+          "console-raw",
+          "console-pretty",
+          "both-prettyconsole"
+        ]), undefined, "console-pretty", undefined, undefined);
+
+Logging.setLogger(Logging.makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel));
+
+var host = EnvSafe.get(envSafe, "ENVIO_PG_HOST", S$RescriptSchema.string, undefined, undefined, "localhost", undefined);
+
+var port = EnvSafe.get(envSafe, "ENVIO_PG_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, undefined, 5433, undefined);
+
+var user = EnvSafe.get(envSafe, "ENVIO_PG_USER", S$RescriptSchema.string, undefined, undefined, "postgres", undefined);
+
+var password = EnvSafe.get(envSafe, "ENVIO_PG_PASSWORD", S$RescriptSchema.string, undefined, EnvSafe.get(envSafe, "ENVIO_POSTGRES_PASSWORD", S$RescriptSchema.string, undefined, "testing", undefined, undefined), undefined, undefined);
+
+var database = EnvSafe.get(envSafe, "ENVIO_PG_DATABASE", S$RescriptSchema.string, undefined, undefined, "envio-dev", undefined);
+
+var publicSchema = EnvSafe.get(envSafe, "ENVIO_PG_PUBLIC_SCHEMA", S$RescriptSchema.string, undefined, "public", undefined, undefined);
+
+var ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Postgres.sslOptionsSchema, undefined, undefined, false, undefined);
+
+var Db = {
+  host: host,
+  port: port,
+  user: user,
+  password: password,
+  database: database,
+  publicSchema: publicSchema,
+  ssl: ssl
+};
+
+var host$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_HOST", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var database$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_DATABASE", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var username = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_USERNAME", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+
+var password$1 = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_PASSWORD", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+
+var ClickHouseSink = {
+  host: host$1,
+  database: database$1,
+  username: username,
+  password: password$1
+};
+
+var enabled = EnvSafe.get(envSafe, "ENVIO_HASURA", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var s = EnvSafe.get(envSafe, "ENVIO_HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var responseLimit = s !== undefined ? s : EnvSafe.get(envSafe, "HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var graphqlEndpoint = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ENDPOINT", S$RescriptSchema.string, undefined, undefined, "http://localhost:8080/v1/metadata", undefined);
+
+var url = graphqlEndpoint.slice(0, -"/v1/metadata".length | 0);
+
+var role = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ROLE", S$RescriptSchema.string, undefined, undefined, "admin", undefined);
+
+var secret = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ADMIN_SECRET", S$RescriptSchema.string, undefined, undefined, "testing", undefined);
+
+var aggregateEntities = EnvSafe.get(envSafe, "ENVIO_HASURA_PUBLIC_AGGREGATE", S$RescriptSchema.union([
+          S$RescriptSchema.array(S$RescriptSchema.string),
+          S$RescriptSchema.transform(S$RescriptSchema.string, (function (s) {
+                  return {
+                          p: (function (string) {
+                              var entities = string.split("&");
+                              var len = entities.length;
+                              if (len !== 1 && len !== 0) {
+                                return entities;
+                              } else {
+                                return s.fail("Provide an array of entities in the JSON format.", undefined);
+                              }
+                            })
+                        };
+                }))
+        ]), undefined, [], undefined, undefined);
+
+var Hasura = {
+  enabled: enabled,
+  responseLimit: responseLimit,
+  graphqlEndpoint: graphqlEndpoint,
+  url: url,
+  role: role,
+  secret: secret,
+  aggregateEntities: aggregateEntities
+};
+
+var initialBlockInterval = EnvSafe.get(envSafe, "ENVIO_RPC_INITIAL_BLOCK_INTERVAL", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var backoffMultiplicative = EnvSafe.get(envSafe, "ENVIO_RPC_BACKOFF_MULTIPLICATIVE", S$RescriptSchema.option(S$RescriptSchema.$$float), undefined, undefined, undefined, undefined);
+
+var accelerationAdditive = EnvSafe.get(envSafe, "ENVIO_RPC_ACCELERATION_ADDITIVE", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var intervalCeiling = EnvSafe.get(envSafe, "ENVIO_RPC_INTERVAL_CEILING", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var SyncConfig = {
+  initialBlockInterval: initialBlockInterval,
+  backoffMultiplicative: backoffMultiplicative,
+  accelerationAdditive: accelerationAdditive,
+  intervalCeiling: intervalCeiling
+};
+
+var Configurable = {
+  SyncConfig: SyncConfig
+};
+
+var chainMetadataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_CHAIN_METADATA_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 500, undefined);
+
+var pruneStaleDataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_PRUNE_STALE_DATA_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 30000, undefined);
+
+var liveMetricsBenchmarkIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_LIVE_METRICS_BENCHMARK_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 1000, undefined);
+
+var jsonFileBenchmarkIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_JSON_FILE_BENCHMARK_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 500, undefined);
+
+var ThrottleWrites = {
+  chainMetadataIntervalMillis: chainMetadataIntervalMillis,
+  pruneStaleDataIntervalMillis: pruneStaleDataIntervalMillis,
+  liveMetricsBenchmarkIntervalMillis: liveMetricsBenchmarkIntervalMillis,
+  jsonFileBenchmarkIntervalMillis: jsonFileBenchmarkIntervalMillis
+};
+
+EnvSafe.close(envSafe);
+
+export {
+  updateSyncTimeOnRestart ,
+  batchSize ,
+  targetBufferSize ,
+  maxAddrInPartition ,
+  maxPartitionConcurrency ,
+  indexingBlockLag ,
+  serverPort ,
+  tuiOffEnvVar ,
+  logFilePath ,
+  userLogLevel ,
+  defaultFileLogLevel ,
+  prodEnvioAppUrl ,
+  envioAppUrl ,
+  envioApiToken ,
+  hyperSyncClientTimeoutMillis ,
+  hyperSyncClientMaxRetries ,
+  hypersyncClientSerializationFormat ,
+  hypersyncClientEnableQueryCaching ,
+  Benchmark ,
+  logStrategy ,
+  Db ,
+  ClickHouseSink ,
+  Hasura ,
+  Configurable ,
+  ThrottleWrites ,
+}
+/*  Not a pure module */

package/src/EventRegister.res

@@ -4,9 +4,8 @@ type registrations = {
 }
 
 type activeRegistration = {
-  platform: Platform.t,
+  ecosystem: Ecosystem.t,
   multichain: Config.multichain,
-  preloadHandlers: bool,
   registrations: registrations,
   mutable finished: bool,
 }
@@ -36,11 +35,10 @@ let withRegistration = (fn: activeRegistration => unit) => {
   }
 }
 
-let startRegistration = (~platform, ~multichain, ~preloadHandlers) => {
+let startRegistration = (~ecosystem, ~multichain) => {
   let r = {
-    platform,
+    ecosystem,
     multichain,
-    preloadHandlers,
     registrations: {
       onBlockByChainId: Js.Dict.empty(),
       hasEvents: false,
@@ -92,16 +90,7 @@ let onBlock = (rawOptions: unknown, handler: Internal.onBlockArgs => promise<uni
     | Unordered => ()
     | Ordered =>
       Js.Exn.raiseError(
-        "Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature or enable unordered multichain mode with `unordered_multichain_mode: true` in your config.",
-      )
-    }
-    // So we encourage users to upgrade to preload optimization
-    // otherwise block handlers will be extremely slow
-    switch registration.preloadHandlers {
-    | true => ()
-    | false =>
-      Js.Exn.raiseError(
-        "Block Handlers require the Preload Optimization feature. Enable it by setting the `preload_handlers` option to `true` in your config.",
+        "Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.",
       )
     }
 

package/src/EventRegister.res.mjs

@@ -27,11 +27,10 @@ function withRegistration(fn) {
   }
 }
 
-function startRegistration(platform, multichain, preloadHandlers) {
+function startRegistration(ecosystem, multichain) {
   var r = {
-    platform: platform,
+    ecosystem: ecosystem,
     multichain: multichain,
-    preloadHandlers: preloadHandlers,
     registrations: {
       onBlockByChainId: {},
       hasEvents: false
@@ -81,12 +80,7 @@ function onBlock(rawOptions, handler) {
   withRegistration(function (registration) {
         var match = registration.multichain;
         if (match === "ordered") {
-          Js_exn.raiseError("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature or enable unordered multichain mode with `unordered_multichain_mode: true` in your config.");
-        }
-        if (registration.preloadHandlers) {
-          
-        } else {
-          Js_exn.raiseError("Block Handlers require the Preload Optimization feature. Enable it by setting the `preload_handlers` option to `true` in your config.");
+          Js_exn.raiseError("Block Handlers are not supported for ordered multichain mode. Please reach out to the Envio team if you need this feature. Or enable unordered multichain mode by removing `multichain: ordered` from the config.yaml file.");
         }
         var options = S$RescriptSchema.parseOrThrow(rawOptions, onBlockOptionsSchema);
         var chainId = options.chain;

package/src/EventRegister.resi

@@ -3,11 +3,7 @@ type registrations = {
   mutable hasEvents: bool,
 }
 
-let startRegistration: (
-  ~platform: Platform.t,
-  ~multichain: Config.multichain,
-  ~preloadHandlers: bool,
-) => unit
+let startRegistration: (~ecosystem: Ecosystem.t, ~multichain: Config.multichain) => unit
 let isPendingRegistration: unit => bool
 let finishRegistration: unit => registrations
 
@@ -15,9 +11,7 @@ type t
 let make: (~contractName: string, ~eventName: string) => t
 let setHandler: (
   t,
-  Internal.genericHandler<
-    Internal.genericHandlerArgs<'event, Internal.handlerContext, 'loaderReturn>,
-  >,
+  Internal.genericHandler<Internal.genericHandlerArgs<'event, Internal.handlerContext>>,
   ~eventOptions: option<Internal.eventOptions<'eventFilters>>,
   ~logger: Pino.t=?,
 ) => unit

package/src/Internal.gen.ts

@@ -26,11 +26,7 @@ export type genericContractRegisterArgs<event,context> = { readonly event: event
 
 export type genericContractRegister<args> = $$genericContractRegister<args>;
 
-export type genericHandlerArgs<event,context,loaderReturn> = {
-  readonly event: event; 
-  readonly context: context; 
-  readonly loaderReturn: loaderReturn
-};
+export type genericHandlerArgs<event,context> = { readonly event: event; readonly context: context };
 
 export type genericHandler<args> = (_1:args) => Promise<void>;
 
@@ -46,17 +42,10 @@ export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly loader: loader; 
   readonly handler: handler; 
   readonly wildcard?: boolean; 
-  readonly eventFilters?: eventFilters; 
-  /** @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration. */
-  readonly preRegisterDynamicContracts?: boolean
+  readonly eventFilters?: eventFilters
 };
 
-export type eventOptions<eventFilters> = {
-  readonly wildcard?: boolean; 
-  readonly eventFilters?: eventFilters; 
-  /** @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration. */
-  readonly preRegisterDynamicContracts?: boolean
-};
+export type eventOptions<eventFilters> = { readonly wildcard?: boolean; readonly eventFilters?: eventFilters };
 
 export type fuelSupplyParams = { readonly subId: string; readonly amount: bigint };
 

package/src/Internal.res

@@ -37,10 +37,9 @@ type contractRegisterArgs = genericContractRegisterArgs<event, contractRegisterC
 type contractRegister = genericContractRegister<contractRegisterArgs>
 
 @genType
-type genericHandlerArgs<'event, 'context, 'loaderReturn> = {
+type genericHandlerArgs<'event, 'context> = {
   event: 'event,
   context: 'context,
-  loaderReturn: 'loaderReturn,
 }
 @genType
 type genericHandler<'args> = 'args => promise<unit>
@@ -81,10 +80,6 @@ type genericHandlerWithLoader<'loader, 'handler, 'eventFilters> = {
   handler: 'handler,
   wildcard?: bool,
   eventFilters?: 'eventFilters,
-  /**
-   @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration.
-   */
-  preRegisterDynamicContracts?: bool,
 }
 
 // This is private so it's not manually constructed internally
@@ -170,7 +165,7 @@ type eventItem = private {
   event: event,
 }
 
-// Opaque type to support both EVM and Fuel platforms
+// Opaque type to support both EVM and other ecosystems
 type blockEvent
 
 type onBlockArgs = {
@@ -225,10 +220,6 @@ external setItemDcs: (item, dcs) => unit = "dcs"
 type eventOptions<'eventFilters> = {
   wildcard?: bool,
   eventFilters?: 'eventFilters,
-  /**
-    @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration.
-  */
-  preRegisterDynamicContracts?: bool,
 }
 
 @genType

package/src/bindings/EventSource.res

@@ -0,0 +1,13 @@
+type t
+
+type options = {headers?: Js.Dict.t<string>}
+
+@module("eventsource") @new
+external create: (~url: string, ~options: options=?) => t = "EventSource"
+
+@set external onopen: (t, unit => unit) => unit = "onopen"
+@set external onerror: (t, Js.Exn.t => unit) => unit = "onerror"
+
+type event = {data: string}
+@send external addEventListener: (t, string, event => unit) => unit = "addEventListener"
+@send external close: t => unit = "close"

package/src/bindings/EventSource.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/sources/HyperSyncHeightStream.res

@@ -0,0 +1,179 @@
+/*
+Pure js implementation of the HyperSync height stream.
+*/
+
+type t = {
+  heightRef: ref<int>,
+  errorRef: ref<option<string>>,
+  timeoutIdRef: ref<Js.Global.timeoutId>,
+  eventsourceRef: ref<option<EventSource.t>>,
+}
+
+let make = (~hyperSyncUrl, ~apiToken) => {
+  /**
+  On every successful ping or height event, clear the timeout and set a new one.
+
+  if the timeout lapses, close and reconnect the EventSource.
+  */
+  let rec updateTimeoutId = (
+    ~eventsourceRef: ref<option<EventSource.t>>,
+    ~timeoutIdRef: ref<Js.Global.timeoutId>,
+    ~hyperSyncUrl,
+    ~apiToken,
+    ~heightRef: ref<int>,
+    ~errorRef: ref<option<string>>,
+  ) => {
+    timeoutIdRef.contents->Js.Global.clearTimeout
+
+    // Should receive a ping at least every 5s, so 15s is a safe margin
+    // for staleness to restart the EventSource connection
+    let staleTimeMillis = 15_000
+    let newTimeoutId = Js.Global.setTimeout(() => {
+      Logging.trace({
+        "msg": "Timeout fired for height stream",
+        "url": hyperSyncUrl,
+        "staleTimeMillis": staleTimeMillis,
+      })
+      refreshEventSource(
+        ~eventsourceRef,
+        ~hyperSyncUrl,
+        ~apiToken,
+        ~heightRef,
+        ~errorRef,
+        ~timeoutIdRef,
+      )
+    }, staleTimeMillis)
+
+    timeoutIdRef := newTimeoutId
+  }
+  and /**
+    Instantiate a new EventSource and set it to the shared refs.
+    Add the necessary event listeners, handle errors
+    and update the timeout.
+    */
+  refreshEventSource = (
+    ~eventsourceRef: ref<option<EventSource.t>>,
+    ~hyperSyncUrl,
+    ~apiToken,
+    ~heightRef: ref<int>,
+    ~errorRef: ref<option<string>>,
+    ~timeoutIdRef: ref<Js.Global.timeoutId>,
+  ) => {
+    // Close the old EventSource if it exists (on a new connection after timeout)
+    switch eventsourceRef.contents {
+    | Some(es) => es->EventSource.close
+    | None => ()
+    }
+
+    let userAgent = `hyperindex/${Utils.EnvioPackage.value.version}`
+    let es = EventSource.create(
+      ~url=`${hyperSyncUrl}/height/sse`,
+      ~options={
+        headers: Js.Dict.fromArray([
+          ("Authorization", `Bearer ${apiToken}`),
+          ("User-Agent", userAgent),
+        ]),
+      },
+    )
+
+    // Set the new EventSource to the shared ref
+    eventsourceRef := Some(es)
+    // Update the timeout in case connection goes stale
+    updateTimeoutId(~eventsourceRef, ~timeoutIdRef, ~hyperSyncUrl, ~apiToken, ~heightRef, ~errorRef)
+
+    es->EventSource.onopen(_ => {
+      Logging.trace({"msg": "SSE connection opened for height stream", "url": hyperSyncUrl})
+    })
+
+    es->EventSource.onerror(error => {
+      Logging.trace({
+        "msg": "EventSource error",
+        "error": error->Js.Exn.message,
+      })
+      // On errors, set the error ref
+      // so that getHeight can raise an error
+      errorRef :=
+        Some(error->Js.Exn.message->Belt.Option.getWithDefault("Unexpected no error.message"))
+    })
+
+    es->EventSource.addEventListener("ping", _event => {
+      // ping lets us know from the server that the connection is still alive
+      // and that the height hasn't updated for 5seconds
+      // update the timeout on each successful ping received
+      updateTimeoutId(
+        ~eventsourceRef,
+        ~timeoutIdRef,
+        ~hyperSyncUrl,
+        ~apiToken,
+        ~heightRef,
+        ~errorRef,
+      )
+      // reset the error ref, since we had a successful ping
+      errorRef := None
+    })
+
+    es->EventSource.addEventListener("height", event => {
+      switch event.data->Belt.Int.fromString {
+      | Some(height) =>
+        // On a successful height event, update the timeout
+        // and reset the error ref
+        updateTimeoutId(
+          ~eventsourceRef,
+          ~timeoutIdRef,
+          ~hyperSyncUrl,
+          ~apiToken,
+          ~heightRef,
+          ~errorRef,
+        )
+        errorRef := None
+        // Set the actual height ref
+        heightRef := height
+      | None =>
+        Logging.trace({"msg": "Height was not a number in event.data", "data": event.data})
+        errorRef := Some("Height was not a number in event.data")
+      }
+    })
+  }
+
+  // Refs used between the functions
+
+  let heightRef = ref(0)
+  let errorRef = ref(None)
+  let eventsourceRef = ref(None)
+  // Timeout doesn't do anything for initalization
+  let timeoutIdRef = ref(Js.Global.setTimeout(() => (), 0))
+  refreshEventSource(
+    ~eventsourceRef,
+    ~hyperSyncUrl,
+    ~apiToken,
+    ~heightRef,
+    ~errorRef,
+    ~timeoutIdRef,
+  )
+
+  {
+    heightRef,
+    errorRef,
+    timeoutIdRef,
+    eventsourceRef,
+  }
+}
+
+let getHeight = async (t: t) => {
+  while t.heightRef.contents == 0 && t.errorRef.contents == None {
+    // Poll internally until height is over 0
+    await Utils.delay(200)
+  }
+  switch t.errorRef.contents {
+  | None => t.heightRef.contents
+  | Some(error) => Js.Exn.raiseError(error)
+  }
+}
+
+let close = t => {
+  t.timeoutIdRef.contents->Js.Global.clearTimeout
+  switch t.eventsourceRef.contents {
+  | Some(es) => es->EventSource.close
+  | None => ()
+  }
+}