envio 3.10.0 → 3.11.0

package/src/sources/StartBlockResolver.res

@@ -0,0 +1,173 @@
+// Resolves a chain's `start_block: latest` to a concrete block number, once,
+// right before the indexer's first-ever persisted state is written (see
+// `Persistence.init`). Never runs on a normal resume (crash recovery, a plain
+// restarted process): `envio_chains.start_block` is written once and read
+// back verbatim from then on, so a resolved "latest" naturally stays fixed
+// across downtime instead of jumping to a new head - any gap gets backfilled
+// rather than skipped. The CLI's `-r` (`--restart`) flag is the exception: it
+// forces `reset=true` in `Persistence.init`, which wipes the DB and runs this
+// again, the same as any other fresh deploy.
+
+// Sources built only to read the chain's height. No registrations exist yet at
+// this point in startup - handler files load after persistence initializes -
+// and none are needed to ask a backend how far it has got. These are not the
+// sources the chain goes on to index with; those are built later, once
+// registrations exist.
+let makeProbeSources = (chainConfig: Config.chain, ~lowercaseAddresses): array<Source.t> => {
+  let addressStore = AddressStore.make(
+    ~ecosystem=chainConfig.ecosystem,
+    ~shouldChecksum=!lowercaseAddresses,
+    ~contracts=[],
+  )
+  ChainSources.make(~chainConfig, ~onEventRegistrations=[], ~addressStore, ~lowercaseAddresses)
+}
+
+// How long to keep asking a chain that won't answer.
+type retry =
+  // The indexer. A chain it can't reach is the operator's to fix, and the
+  // process staying up is what gives them the chance to - the same thing it
+  // does for a chain that goes unreachable while it runs.
+  | UntilItAnswers
+  // `envio local db-migrate up/setup`. A one-shot command has nobody waiting to
+  // watch it recover, so every source gets one attempt and then it reports what
+  // each of them said.
+  | Once
+
+// Sources that can serve historical sync, primaries first - the same ordering a
+// backfill would use. A realtime-only source is left out: it isn't what this
+// chain reads its history from.
+let candidateSources = (sources: array<Source.t>) => {
+  let hasRealtime = sources->Array.some(source => source.sourceFor === Realtime)
+  let roleOf = (source: Source.t) =>
+    SourceManager.getSourceRole(~sourceFor=source.sourceFor, ~isRealtime=false, ~hasRealtime)
+  sources
+  ->Array.filter(source => roleOf(source)->Option.isSome)
+  ->Array.toSorted((a, b) =>
+    switch (roleOf(a), roleOf(b)) {
+    | (Some(Primary), Some(Secondary)) => Ordering.less
+    | (Some(Secondary), Some(Primary)) => Ordering.greater
+    | _ => Ordering.equal
+    }
+  )
+}
+
+// One attempt per source. Trying the next source is not a retry - it's the
+// failover the config asked for - but no source is asked twice.
+let readHeadOnceOrThrow = async (chainConfig: Config.chain, ~sources): int => {
+  let candidates = candidateSources(sources)
+  if candidates->Utils.Array.isEmpty {
+    // The condition `SourceManager.make` rejects on the retrying path. Sharing
+    // its wording keeps one misconfiguration from having two explanations - and
+    // "no source answered" would be untrue here, since none was asked.
+    JsError.throwWithMessage("Invalid configuration, no data-source for historical sync provided")
+  }
+  let failures = []
+  let head = ref(None)
+  for i in 0 to candidates->Array.length - 1 {
+    if head.contents->Option.isNone {
+      let source = candidates->Array.getUnsafe(i)
+      switch await source.getHeightOrThrow() {
+      | {height} => head := Some(height)
+      | exception exn =>
+        failures
+        ->Array.push(`${source.name}: ${exn->Utils.exnMessage->Option.getOr("unknown error")}`)
+        ->ignore
+      }
+    }
+  }
+  switch head.contents {
+  | Some(head) => head
+  | None =>
+    JsError.throwWithMessage(
+      `Chain ${chainConfig.id->ChainId.toString}: couldn't resolve the "latest" start block - no source answered a height request.${failures
+        ->Array.map(failure => `\n  ${failure}`)
+        ->Array.join("")}`,
+    )
+  }
+}
+
+// Waiting for a height above 0 is the same question as "what is the head", and
+// it comes with the runtime's own answer to a source that won't say: retry with
+// backoff, a bound on how long any one request is waited for, and failover to
+// `for: fallback` sources once the primary has been quiet for a stall window.
+//
+// It never gives up, which is what makes it safe to use here. A deadline would
+// need a race, and the losing side of that race is a registered waiter and a
+// live poll loop that nothing can reach to stop.
+let resolveHeadOrThrow = async (
+  chainConfig: Config.chain,
+  ~lowercaseAddresses,
+  ~retry,
+  ~getHeightRetryInterval=?,
+  ~newBlockStallTimeout=?,
+): int => {
+  let sources = chainConfig->makeProbeSources(~lowercaseAddresses)
+  switch retry {
+  | Once => await chainConfig->readHeadOnceOrThrow(~sources)
+  | UntilItAnswers =>
+    let sourceManager = SourceManager.make(
+      ~sources,
+      ~isRealtime=false,
+      ~getHeightRetryInterval?,
+      ~newBlockStallTimeout?,
+    )
+    await sourceManager->SourceManager.waitForNewBlock(
+      ~knownHeight=0,
+      ~isRealtime=false,
+      ~reducedPolling=false,
+    )
+  }
+}
+
+// Sequential rather than `Promise.all`: a chain that fails validation must not
+// leave sibling chains' height polling running behind the rejection.
+let resolveAllOrThrow = async (
+  chainConfigs: array<Config.chain>,
+  ~lowercaseAddresses,
+  ~retry=UntilItAnswers,
+  ~getHeightRetryInterval=?,
+  ~newBlockStallTimeout=?,
+): array<Config.chain> => {
+  let resolved = []
+  for i in 0 to chainConfigs->Array.length - 1 {
+    let chainConfig = chainConfigs->Array.getUnsafe(i)
+    let chainConfig = switch chainConfig.startBlock {
+    | Config.Block(_) => chainConfig
+    | Config.Latest =>
+      let head = await chainConfig->resolveHeadOrThrow(
+        ~lowercaseAddresses,
+        ~retry,
+        ~getHeightRetryInterval?,
+        ~newBlockStallTimeout?,
+      )
+      let chainId = chainConfig.id->ChainId.toString
+      switch chainConfig.endBlock {
+      | Some(endBlock) if head > endBlock =>
+        JsError.throwWithMessage(
+          `Chain ${chainId}: the "latest" start block resolved to ${head->Int.toString}, which is past the configured end_block (${endBlock->Int.toString}). There is nothing to index - remove end_block, raise it above the chain's current head, or pin start_block to a fixed value instead of "latest".`,
+        )
+      | _ => ()
+      }
+      // Checked here, before anything is persisted: the same guard in
+      // `ChainState.makeInternal` would only fire after the resolved head is
+      // written to envio_chains, and then again on every resume.
+      chainConfig.contracts->Array.forEach(contract =>
+        switch contract.startBlock {
+        | Some(contractStartBlock) if contractStartBlock < head =>
+          JsError.throwWithMessage(
+            `Chain ${chainId}: contract "${contract.name}" has start_block ${contractStartBlock->Int.toString}, but the chain's "latest" start block resolved to ${head->Int.toString}. A contract can't start before its chain does - remove the contract's start_block, or pin the chain's start_block to a fixed value instead of "latest".`,
+          )
+        | _ => ()
+        }
+      )
+      Logging.info({
+        "msg": `Resolved the "latest" start block for chain ${chainId} to block ${head->Int.toString}.`,
+        "chainId": chainConfig.id,
+        "startBlock": head,
+      })
+      {...chainConfig, startBlock: Config.Block(head)}
+    }
+    resolved->Array.push(chainConfig)->ignore
+  }
+  resolved
+}

package/src/sources/StartBlockResolver.res.mjs

@@ -0,0 +1,134 @@
+// 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 AddressStore from "./AddressStore.res.mjs";
+import * as ChainSources from "./ChainSources.res.mjs";
+import * as SourceManager from "./SourceManager.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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function makeProbeSources(chainConfig, lowercaseAddresses) {
+  let addressStore = AddressStore.make(chainConfig.ecosystem, !lowercaseAddresses, []);
+  return ChainSources.make(chainConfig, [], addressStore, lowercaseAddresses);
+}
+
+function candidateSources(sources) {
+  let hasRealtime = sources.some(source => source.sourceFor === "Realtime");
+  let roleOf = source => SourceManager.getSourceRole(source.sourceFor, false, hasRealtime);
+  return sources.filter(source => Stdlib_Option.isSome(roleOf(source))).toSorted((a, b) => {
+    let match = roleOf(a);
+    let match$1 = roleOf(b);
+    if (match !== undefined) {
+      if (match === "Primary") {
+        if (match$1 !== undefined) {
+          if (match$1 === "Primary") {
+            return 0;
+          } else {
+            return -1;
+          }
+        } else {
+          return 0;
+        }
+      } else if (match$1 !== undefined) {
+        if (match$1 === "Primary") {
+          return 1;
+        } else {
+          return 0;
+        }
+      } else {
+        return 0;
+      }
+    } else {
+      return 0;
+    }
+  });
+}
+
+async function readHeadOnceOrThrow(chainConfig, sources) {
+  let candidates = candidateSources(sources);
+  if (Utils.$$Array.isEmpty(candidates)) {
+    Stdlib_JsError.throwWithMessage("Invalid configuration, no data-source for historical sync provided");
+  }
+  let failures = [];
+  let head;
+  for (let i = 0, i_finish = candidates.length; i < i_finish; ++i) {
+    if (Stdlib_Option.isNone(head)) {
+      let source = candidates[i];
+      let exit = 0;
+      let val;
+      try {
+        val = await source.getHeightOrThrow();
+        exit = 1;
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        failures.push(source.name + `: ` + Stdlib_Option.getOr(Utils.exnMessage(exn), "unknown error"));
+      }
+      if (exit === 1) {
+        head = val.height;
+      }
+    }
+  }
+  let head$1 = head;
+  if (head$1 !== undefined) {
+    return head$1;
+  } else {
+    return Stdlib_JsError.throwWithMessage(`Chain ` + ChainId.toString(chainConfig.id) + `: couldn't resolve the "latest" start block - no source answered a height request.` + failures.map(failure => `\n  ` + failure).join(""));
+  }
+}
+
+async function resolveHeadOrThrow(chainConfig, lowercaseAddresses, retry, getHeightRetryInterval, newBlockStallTimeout) {
+  let sources = makeProbeSources(chainConfig, lowercaseAddresses);
+  if (retry !== "UntilItAnswers") {
+    return await readHeadOnceOrThrow(chainConfig, sources);
+  }
+  let sourceManager = SourceManager.make(sources, false, newBlockStallTimeout, undefined, undefined, undefined, undefined, getHeightRetryInterval);
+  return await SourceManager.waitForNewBlock(sourceManager, 0, false, false);
+}
+
+async function resolveAllOrThrow(chainConfigs, lowercaseAddresses, retryOpt, getHeightRetryInterval, newBlockStallTimeout) {
+  let retry = retryOpt !== undefined ? retryOpt : "UntilItAnswers";
+  let resolved = [];
+  for (let i = 0, i_finish = chainConfigs.length; i < i_finish; ++i) {
+    let chainConfig = chainConfigs[i];
+    let match = chainConfig.startBlock;
+    let chainConfig$1;
+    if (match === "latest") {
+      let head = await resolveHeadOrThrow(chainConfig, lowercaseAddresses, retry, getHeightRetryInterval, newBlockStallTimeout);
+      let chainId = ChainId.toString(chainConfig.id);
+      let endBlock = chainConfig.endBlock;
+      if (endBlock !== undefined && head > endBlock) {
+        Stdlib_JsError.throwWithMessage(`Chain ` + chainId + `: the "latest" start block resolved to ` + head.toString() + `, which is past the configured end_block (` + endBlock.toString() + `). There is nothing to index - remove end_block, raise it above the chain's current head, or pin start_block to a fixed value instead of "latest".`);
+      }
+      chainConfig.contracts.forEach(contract => {
+        let contractStartBlock = contract.startBlock;
+        if (contractStartBlock !== undefined && contractStartBlock < head) {
+          return Stdlib_JsError.throwWithMessage(`Chain ` + chainId + `: contract "` + contract.name + `" has start_block ` + contractStartBlock.toString() + `, but the chain's "latest" start block resolved to ` + head.toString() + `. A contract can't start before its chain does - remove the contract's start_block, or pin the chain's start_block to a fixed value instead of "latest".`);
+        }
+      });
+      Logging.info({
+        msg: `Resolved the "latest" start block for chain ` + chainId + ` to block ` + head.toString() + `.`,
+        chainId: chainConfig.id,
+        startBlock: head
+      });
+      let newrecord = {...chainConfig};
+      newrecord.startBlock = head;
+      chainConfig$1 = newrecord;
+    } else {
+      chainConfig$1 = chainConfig;
+    }
+    resolved.push(chainConfig$1);
+  }
+  return resolved;
+}
+
+export {
+  makeProbeSources,
+  candidateSources,
+  readHeadOnceOrThrow,
+  resolveHeadOrThrow,
+  resolveAllOrThrow,
+}
+/* Utils Not a pure module */

package/src/sources/Svm.res

@@ -80,54 +80,3 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   },
   toRawEvent: _ => JsError.throwWithMessage("Raw events are not supported for SVM"),
 }
-
-module GetFinalizedSlot = {
-  let route = Rpc.makeRpcRoute(
-    "getSlot",
-    S.tuple(s => {
-      s.tag(0, {"commitment": "finalized"})
-      ()
-    }),
-    S.int,
-  )
-}
-
-let makeRPCSource = (~chainId, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): Source.t => {
-  let client = Rest.client(rpc)
-
-  let urlHost = switch Utils.Url.getHostFromUrl(rpc) {
-  | None =>
-    JsError.throwWithMessage(
-      `The RPC url for chain ${chainId->ChainId.toString} is in incorrect format. The RPC url needs to start with either http:// or https://`,
-    )
-  | Some(host) => host
-  }
-  let name = `RPC (${urlHost})`
-
-  {
-    name,
-    sourceFor,
-    chainId,
-    poweredByHyperSync: false,
-    pollingInterval: 10_000,
-    getBlockHashes: (~blockNumbers as _, ~logger as _) =>
-      JsError.throwWithMessage("Svm does not support getting block hashes"),
-    getHeightOrThrow: async () => {
-      let timerRef = Performance.now()
-      let height = await GetFinalizedSlot.route->Rest.fetch((), ~client)
-      let seconds = timerRef->Performance.secondsSince
-      {Source.height, requestStats: [{Source.method: "getSlot", seconds}]}
-    },
-    getItemsOrThrow: (
-      ~fromBlock as _,
-      ~toBlock as _,
-      ~addressSet as _,
-      ~knownHeight as _,
-      ~partitionId as _,
-      ~selection as _,
-      ~itemsTarget as _,
-      ~retry as _,
-      ~logger as _,
-    ) => JsError.throwWithMessage("Svm does not support getting items"),
-  }
-}

package/src/sources/Svm.res.mjs

@@ -1,13 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Rpc from "./Rpc.res.mjs";
-import * as Rest from "../vendored/Rest.res.mjs";
-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 BlockStore from "./BlockStore.res.mjs";
-import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -79,45 +74,6 @@ function make(logger) {
   };
 }
 
-let route = Rpc.makeRpcRoute("getSlot", S$RescriptSchema.tuple(s => {
-  s.tag(0, {
-    commitment: "finalized"
-  });
-}), S$RescriptSchema.int);
-
-let GetFinalizedSlot = {
-  route: route
-};
-
-function makeRPCSource(chainId, rpc, sourceForOpt) {
-  let sourceFor = sourceForOpt !== undefined ? sourceForOpt : "Sync";
-  let client = Rest.client(rpc, undefined);
-  let host = Utils.Url.getHostFromUrl(rpc);
-  let urlHost = host !== undefined ? host : Stdlib_JsError.throwWithMessage(`The RPC url for chain ` + ChainId.toString(chainId) + ` is in incorrect format. The RPC url needs to start with either http:// or https://`);
-  let name = `RPC (` + urlHost + `)`;
-  return {
-    name: name,
-    sourceFor: sourceFor,
-    chainId: chainId,
-    poweredByHyperSync: false,
-    pollingInterval: 10000,
-    getBlockHashes: (param, param$1) => Stdlib_JsError.throwWithMessage("Svm does not support getting block hashes"),
-    getHeightOrThrow: async () => {
-      let timerRef = Performance.now();
-      let height = await Rest.fetch(route, undefined, client);
-      let seconds = Performance.secondsSince(timerRef);
-      return {
-        height: height,
-        requestStats: [{
-            method: "getSlot",
-            seconds: seconds
-          }]
-      };
-    },
-    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) => Stdlib_JsError.throwWithMessage("Svm does not support getting items")
-  };
-}
-
 let transactionFields = Internal.allSvmTransactionFields;
 
 export {
@@ -127,7 +83,5 @@ export {
   eventBlockFieldMask,
   attachAccountActivities,
   make,
-  GetFinalizedSlot,
-  makeRPCSource,
 }
 /* eventTransactionFieldMask Not a pure module */

package/src/sources/SvmHyperSyncSource.res

@@ -10,13 +10,17 @@ type options = {
   addressStore: AddressStore.t,
 }
 
-let namedAccounts = (~idlNames: array<string>, ~accountArguments: array<string>): dict<
-  Envio.svmInstructionAccount,
-> => {
+let namedAccounts = (
+  ~slots: array<Internal.svmAccountSlot>,
+  ~accountArguments: array<string>,
+  ~programId: string,
+): dict<Envio.svmInstructionAccount> => {
   let out = Dict.make()
-  idlNames->Array.forEachWithIndex((name, i) =>
-    switch accountArguments->Array.get(i) {
-    | Some(address) =>
+  slots->Array.forEachWithIndex((slot, i) =>
+    switch (slot, accountArguments->Array.get(i)) {
+    | (Unnamed, _) | (_, None) => ()
+    | (Optional(_), Some(address)) if address === programId => ()
+    | (Required(name), Some(address)) | (Optional(name), Some(address)) =>
       out->Dict.set(
         name,
         {
@@ -25,7 +29,6 @@ let namedAccounts = (~idlNames: array<string>, ~accountArguments: array<string>)
           instructionAccountIndex: i,
         },
       )
-    | None => ()
     }
   )
   out
@@ -94,7 +97,11 @@ let toSvmInstruction = (
   if hasSelection("accounts") {
     out->setField(
       "accounts",
-      namedAccounts(~idlNames=eventConfig.accounts, ~accountArguments=item.accounts),
+      namedAccounts(
+        ~slots=eventConfig.accounts,
+        ~accountArguments=item.accounts,
+        ~programId=item.programId,
+      ),
     )
   }
   if hasSelection("accountArguments") {
@@ -123,12 +130,14 @@ let make = (
 ): t => {
   let name = "SvmHyperSync"
 
+  let apiToken = apiToken->HyperSync.requireApiToken
+
   // The whole per-(instruction, chain) registration set crosses the boundary
   // once at construction; the client derives instruction selections, field
   // selections, Borsh decoders, and the routing index from it.
   let client = SvmHyperSyncClient.make(
     ~url=endpointUrl,
-    ~apiToken?,
+    ~apiToken,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
     ~programs=SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations),
     ~addressStore,
@@ -257,5 +266,7 @@ let make = (
       {height, requestStats: [{method: "getHeight", seconds}]}
     },
     getItemsOrThrow,
+    createHeightSubscription: (~onHeight, ~onStatus) =>
+      HyperSyncSSE.subscribe(~hyperSyncUrl=endpointUrl, ~apiToken, ~onHeight, ~onStatus),
   }
 }

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -4,23 +4,42 @@ import * as Source from "./Source.res.mjs";
 import * as HyperSync from "./HyperSync.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
+import * as HyperSyncSSE from "./HyperSyncSSE.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as SvmHyperSyncClient from "./SvmHyperSyncClient.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function namedAccounts(idlNames, accountArguments) {
+function namedAccounts(slots, accountArguments, programId) {
   let out = {};
-  idlNames.forEach((name, i) => {
-    let address = accountArguments[i];
-    if (address !== undefined) {
-      out[name] = {
-        address: address,
-        accountName: name,
-        instructionAccountIndex: i
-      };
+  slots.forEach((slot, i) => {
+    let match = accountArguments[i];
+    let name;
+    let address;
+    if (typeof slot !== "object") {
       return;
     }
+    if (slot.TAG === "Required") {
+      if (match === undefined) {
+        return;
+      }
+      name = slot._0;
+      address = match;
+    } else {
+      if (match === undefined) {
+        return;
+      }
+      if (match === programId) {
+        return;
+      }
+      name = slot._0;
+      address = match;
+    }
+    out[name] = {
+      address: address,
+      accountName: name,
+      instructionAccountIndex: i
+    };
   });
   return out;
 }
@@ -70,7 +89,7 @@ function toSvmInstruction(item, programName, instructionName, eventConfig, field
     setField(out, "args", args);
   }
   if (fieldSelection.instructionFields.has("accounts")) {
-    setField(out, "accounts", namedAccounts(eventConfig.accounts, item.accounts));
+    setField(out, "accounts", namedAccounts(eventConfig.accounts, item.accounts, item.programId));
   }
   if (fieldSelection.instructionFields.has("accountArguments")) {
     setField(out, "accountArguments", item.accounts);
@@ -83,8 +102,10 @@ function toSvmInstruction(item, programName, instructionName, eventConfig, field
 
 function make(param) {
   let onEventRegistrations = param.onEventRegistrations;
+  let endpointUrl = param.endpointUrl;
   let chainId = param.chainId;
-  let client = SvmHyperSyncClient.make(param.endpointUrl, param.apiToken, param.clientTimeoutMillis, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
+  let apiToken = HyperSync.requireApiToken(param.apiToken);
+  let client = SvmHyperSyncClient.make(endpointUrl, apiToken, param.clientTimeoutMillis, undefined, undefined, SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations), param.addressStore);
   let getItemsOrThrow = async (fromBlock, toBlock, addressSet, knownHeight, param, selection, itemsTarget, retry, param$1) => {
     let totalTimeRef = Performance.now();
     let pageFetchRef = Performance.now();
@@ -178,7 +199,8 @@ function make(param) {
           }]
       };
     },
-    getItemsOrThrow: getItemsOrThrow
+    getItemsOrThrow: getItemsOrThrow,
+    createHeightSubscription: (onHeight, onStatus) => HyperSyncSSE.subscribe(endpointUrl, apiToken, onHeight, onStatus)
   };
 }