envio 3.9.0 → 3.10.0

package/src/sources/HeightStream.res.mjs

@@ -0,0 +1,194 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+function retryDelayFor(count) {
+  if (count <= 0) {
+    return 0;
+  } else {
+    return Utils.expBackoff(250, count - 1 | 0, 60000);
+  }
+}
+
+function truncateDetail(detail) {
+  if (detail.length > 200) {
+    return detail.slice(0, 200) + "...";
+  } else {
+    return detail;
+  }
+}
+
+function subscribe(staleTimeout, onHeight, onStatus, connect) {
+  let closeConnectionRef = {
+    contents: undefined
+  };
+  let failureCount = {
+    contents: 0
+  };
+  let generation = {
+    contents: 0
+  };
+  let timeoutId = {
+    contents: undefined
+  };
+  let unreadableDetail = {
+    contents: undefined
+  };
+  let liveAt = {
+    contents: undefined
+  };
+  let minProvenMillis = staleTimeout / 4 | 0;
+  let closeSafely = close => {
+    try {
+      return close();
+    } catch (exn) {
+      return;
+    }
+  };
+  let closeConnection = () => {
+    let close = closeConnectionRef.contents;
+    if (close !== undefined) {
+      closeSafely(close);
+    }
+    closeConnectionRef.contents = undefined;
+  };
+  let armStaleTimeout = () => {
+    Utils.clearTimeoutRef(timeoutId);
+    timeoutId.contents = Primitive_option.some(setTimeout(() => {
+      timeoutId.contents = undefined;
+      let detail = unreadableDetail.contents;
+      if (detail !== undefined) {
+        return fail("Unreadable", detail);
+      } else {
+        return fail("Stale", undefined);
+      }
+    }, staleTimeout));
+  };
+  let fail = (reason, detail) => {
+    generation.contents = generation.contents + 1 | 0;
+    Utils.clearTimeoutRef(timeoutId);
+    closeConnection();
+    let since = liveAt.contents;
+    let servedMillis = since !== undefined ? Performance.now() - since | 0 : 0;
+    let provenMillis = Primitive_int.max(retryDelayFor(failureCount.contents), minProvenMillis);
+    failureCount.contents = servedMillis >= provenMillis ? 1 : failureCount.contents + 1 | 0;
+    let retryMillis = Utils.jitter(retryDelayFor(failureCount.contents));
+    let reason$1;
+    reason$1 = typeof reason !== "object" && reason === "Closed" && servedMillis >= provenMillis ? "Rotated" : reason;
+    timeoutId.contents = Primitive_option.some(setTimeout(() => {
+      timeoutId.contents = undefined;
+      start();
+    }, retryMillis));
+    onStatus({
+      TAG: "Down",
+      reason: reason$1,
+      detail: Stdlib_Option.map(detail, truncateDetail)
+    });
+  };
+  let start = () => {
+    generation.contents = generation.contents + 1 | 0;
+    unreadableDetail.contents = undefined;
+    liveAt.contents = undefined;
+    let connectionGeneration = generation.contents;
+    armStaleTimeout();
+    let goLive = () => {
+      armStaleTimeout();
+      if (Stdlib_Option.isNone(liveAt.contents)) {
+        liveAt.contents = Performance.now();
+        return onStatus("Live");
+      }
+    };
+    let driver_onConnected = () => {
+      if (generation.contents === connectionGeneration) {
+        return goLive();
+      }
+    };
+    let driver_onKeepAlive = () => {
+      if (generation.contents === connectionGeneration && Stdlib_Option.isNone(unreadableDetail.contents)) {
+        return armStaleTimeout();
+      }
+    };
+    let driver_onHeight = height => {
+      if (generation.contents === connectionGeneration) {
+        unreadableDetail.contents = undefined;
+        goLive();
+        return onHeight(height);
+      }
+    };
+    let driver_onUnreadable = detail => {
+      if (generation.contents === connectionGeneration) {
+        unreadableDetail.contents = detail;
+        return;
+      }
+    };
+    let driver_onFailure = (reason, detail) => {
+      if (generation.contents === connectionGeneration) {
+        return fail(reason, detail);
+      }
+    };
+    let driver = {
+      onConnected: driver_onConnected,
+      onKeepAlive: driver_onKeepAlive,
+      onHeight: driver_onHeight,
+      onUnreadable: driver_onUnreadable,
+      onFailure: driver_onFailure
+    };
+    let connected;
+    try {
+      connected = {
+        TAG: "Ok",
+        _0: connect(driver)
+      };
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      connected = {
+        TAG: "Error",
+        _0: exn
+      };
+    }
+    if (connected.TAG !== "Ok") {
+      if (generation.contents === connectionGeneration) {
+        return fail("ConnectFailed", Utils.exnMessage(connected._0));
+      } else {
+        return;
+      }
+    }
+    let closeCurrentConnection = connected._0;
+    if (generation.contents === connectionGeneration) {
+      closeConnectionRef.contents = closeCurrentConnection;
+      return;
+    } else {
+      return closeSafely(closeCurrentConnection);
+    }
+  };
+  start();
+  return () => {
+    generation.contents = generation.contents + 1 | 0;
+    Utils.clearTimeoutRef(timeoutId);
+    closeConnection();
+  };
+}
+
+let baseRetryMillis = 250;
+
+let maxRetryMillis = 60000;
+
+let provenStaleFraction = 4;
+
+let maxDetailLength = 200;
+
+export {
+  baseRetryMillis,
+  maxRetryMillis,
+  provenStaleFraction,
+  maxDetailLength,
+  retryDelayFor,
+  truncateDetail,
+  subscribe,
+}
+/* Utils Not a pure module */

package/src/sources/HyperSync.res

@@ -1,3 +1,8 @@
+// Short enough that a chain at the head is not held up behind it, long enough
+// that a wait polling through a whole block interval is not thousands of
+// requests.
+let pollingInterval = 400
+
 // A napi error carries nothing but a message, so the native clients signal the
 // recoverable conditions SourceManager knows how to retry as a `PREFIX:<int>`
 // marker. Keep in sync with `request_stats.rs`.

package/src/sources/HyperSync.res.mjs

@@ -159,7 +159,10 @@ let GetLogs = {
   query: query
 };
 
+let pollingInterval = 400;
+
 export {
+  pollingInterval,
   mapNativeFailure,
   mapNativeFailureExn,
   reraiseIfRecoverable,

package/src/sources/HyperSync.resi

@@ -6,6 +6,10 @@ type logsQueryPage = {
   blockStore: BlockStore.t,
 }
 
+// How often a HyperSync source is asked for the height while nothing is pushing
+// one. Every ecosystem's client talks to the same service, so they wait alike.
+let pollingInterval: int
+
 // Map a native client's `PREFIX:<int>` failure marker onto the exception
 // SourceManager retries on (`RateLimited` / `SourceBehindHead`), falling back to
 // the original cause.

package/src/sources/HyperSyncSSE.res

@@ -0,0 +1,49 @@
+// The server pings every 5s, so 15s is a safe margin before treating the
+// connection as dead.
+let staleTimeout = 15_000
+
+let failure = (error: EventSource.errorEvent): (
+  Source.heightSubscriptionDownReason,
+  option<string>,
+) =>
+  switch (error.code, error.message) {
+  | (Some(code), message) => (Http(code), message)
+  | (None, Some(message)) => (TransportError, Some(message))
+  // The stream ended without an HTTP error, which is how a load balancer
+  // rotating connections shows up.
+  | (None, None) => (Closed, None)
+  }
+
+let subscribe = (~hyperSyncUrl, ~apiToken, ~onHeight, ~onStatus) =>
+  HeightStream.subscribe(~staleTimeout, ~onHeight, ~onStatus, ~connect=driver => {
+    let userAgent = `hyperindex/${Utils.EnvioPackage.value.version}`
+    let es = EventSource.create(
+      ~url=`${hyperSyncUrl}/height/sse`,
+      ~options={
+        fetch: (url, ~args) => {
+          let headers =
+            args.headers
+            ->Option.getOr(Dict.make())
+            ->Utils.Dict.merge(
+              Dict.fromArray([("Authorization", `Bearer ${apiToken}`), ("User-Agent", userAgent)]),
+            )
+          EventSource.Fetch.fetch(url, ~args={...args, headers: headers})
+        },
+      },
+    )
+
+    es->EventSource.onopen(_ => driver.onConnected())
+    es->EventSource.onerror(error => {
+      let (reason, detail) = error->failure
+      driver.onFailure(~reason, ~detail?)
+    })
+    es->EventSource.addEventListener("ping", _ => driver.onKeepAlive())
+    es->EventSource.addEventListener("height", event =>
+      switch event.data->Int.fromString {
+      | Some(height) => driver.onHeight(height)
+      | None => driver.onUnreadable(~detail=event.data)
+      }
+    )
+
+    () => es->EventSource.close
+  })

package/src/sources/HyperSyncSSE.res.mjs

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "../Utils.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Eventsource from "eventsource";
+import * as HeightStream from "./HeightStream.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function failure(error) {
+  let match = error.code;
+  let match$1 = error.message;
+  if (match !== undefined) {
+    return [
+      {
+        TAG: "Http",
+        _0: match
+      },
+      match$1
+    ];
+  } else if (match$1 !== undefined) {
+    return [
+      "TransportError",
+      match$1
+    ];
+  } else {
+    return [
+      "Closed",
+      undefined
+    ];
+  }
+}
+
+function subscribe(hyperSyncUrl, apiToken, onHeight, onStatus) {
+  return HeightStream.subscribe(15000, onHeight, onStatus, driver => {
+    let userAgent = `hyperindex/` + Utils.EnvioPackage.value.version;
+    let es = new Eventsource.EventSource(hyperSyncUrl + `/height/sse`, {
+      fetch: (url, args) => {
+        let headers = Utils.Dict.merge(Stdlib_Option.getOr(args.headers, {}), Object.fromEntries([
+          [
+            "Authorization",
+            `Bearer ` + apiToken
+          ],
+          [
+            "User-Agent",
+            userAgent
+          ]
+        ]));
+        let newrecord = {...args};
+        return fetch(url, (newrecord.headers = headers, newrecord));
+      }
+    });
+    es.onopen = () => driver.onConnected();
+    es.onerror = error => {
+      let match = failure(error);
+      driver.onFailure(match[0], match[1]);
+    };
+    es.addEventListener("ping", param => driver.onKeepAlive());
+    es.addEventListener("height", event => {
+      let height = Stdlib_Int.fromString(event.data, undefined);
+      if (height !== undefined) {
+        return driver.onHeight(height);
+      } else {
+        return driver.onUnreadable(event.data);
+      }
+    });
+    return () => {
+      es.close();
+    };
+  });
+}
+
+let staleTimeout = 15000;
+
+export {
+  staleTimeout,
+  failure,
+  subscribe,
+}
+/* Utils Not a pure module */

package/src/sources/RpcSource.res

@@ -1129,7 +1129,7 @@ let make = (
 
   let createHeightSubscription =
     ws->Option.map(wsUrl =>
-      (~onHeight) => RpcWebSocketHeightStream.subscribe(~wsUrl, ~chainId, ~onHeight)
+      (~onHeight, ~onStatus) => EvmRpcWs.subscribe(~wsUrl, ~onHeight, ~onStatus)
     )
 
   {

package/src/sources/RpcSource.res.mjs

@@ -8,6 +8,7 @@ import * as Source from "./Source.res.mjs";
 import * as Address from "../Address.res.mjs";
 import * as ChainId from "../ChainId.res.mjs";
 import * as Logging from "../Logging.res.mjs";
+import * as EvmRpcWs from "./EvmRpcWs.res.mjs";
 import * as Internal from "../Internal.res.mjs";
 import * as BlockStore from "./BlockStore.res.mjs";
 import * as LazyLoader from "../LazyLoader.res.mjs";
@@ -24,7 +25,6 @@ import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 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";
-import * as RpcWebSocketHeightStream from "./RpcWebSocketHeightStream.res.mjs";
 
 let TransactionDataNotFound = /* @__PURE__ */Primitive_exceptions.create("RpcSource.TransactionDataNotFound");
 
@@ -1069,7 +1069,7 @@ function make(param) {
     },
     requestStats: drainRequestStats()
   }));
-  let createHeightSubscription = Stdlib_Option.map(param.ws, wsUrl => (onHeight => RpcWebSocketHeightStream.subscribe(wsUrl, chainId, onHeight)));
+  let createHeightSubscription = Stdlib_Option.map(param.ws, wsUrl => ((onHeight, onStatus) => EvmRpcWs.subscribe(wsUrl, onHeight, onStatus)));
   return {
     name: name,
     sourceFor: param.sourceFor,

package/src/sources/Source.res

@@ -130,6 +130,56 @@ exception GetItemsError(getItemsError)
 
 type sourceFor = Sync | Fallback | Realtime
 
+// Why a height subscription's connection ended. Closed, so a consumer decides
+// what a failure means by matching on it rather than by recognising a string,
+// and so every transport describes an outage in the same words.
+type heightSubscriptionDownReason =
+  // Ended cleanly after serving long enough to have been worth making: a load
+  // balancer moving a connection, and routine.
+  | Rotated
+  // Ended cleanly without having served: a server dropping connections it
+  // ought to be keeping.
+  | Closed
+  // Delivered nothing at all for a whole staleness window.
+  | Stale
+  // Sent frames the transport could not read. Alone among these it never heals
+  // on its own, which is why consumers tell an operator about it.
+  | Unreadable
+  // No connection was established to begin with.
+  | ConnectFailed
+  // The provider refused the subscription.
+  | SubscribeRejected
+  // The socket itself reported an error.
+  | TransportError
+  // Refused with an HTTP status, which is the whole of what an SSE stream is
+  // told about a refusal.
+  | Http(int)
+  // The consumer gave the source up. Not an outage, but the connection is gone
+  // and a count that omitted it would leave the source looking connected.
+  | Unsubscribed
+
+// Bounded, so it is safe as a metric label. Whatever the provider said about
+// one failure belongs in `detail` and in a log line, never here.
+let downReasonLabel = reason =>
+  switch reason {
+  | Rotated => "rotated"
+  | Closed => "closed"
+  | Stale => "stale"
+  | Unreadable => "unreadable"
+  | ConnectFailed => "connect-failed"
+  | SubscribeRejected => "subscribe-rejected"
+  | TransportError => "error"
+  | Http(code) => `http-${code->Int.toString}`
+  | Unsubscribed => "unsubscribed"
+  }
+
+// Connection state of a height subscription, reported by every transport.
+// `Down` repeats on each failed retry while the stream stays broken, and `Live`
+// fires on every (re)connect, so consumers must treat both as idempotent.
+// `detail` is whatever the provider said for this one failure — an error
+// message, or the frame nobody could read.
+type heightSubscriptionStatus = Live | Down({reason: heightSubscriptionDownReason, detail?: string})
+
 type t = {
   name: string,
   sourceFor: sourceFor,
@@ -160,7 +210,10 @@ type t = {
     ~retry: int,
     ~logger: Pino.t,
   ) => promise<blockRangeFetchResponse>,
-  createHeightSubscription?: (~onHeight: int => unit) => unit => unit,
+  createHeightSubscription?: (
+    ~onHeight: int => unit,
+    ~onStatus: heightSubscriptionStatus => unit,
+  ) => unit => unit,
   // Invoked when a reorg or internally inconsistent response means local state
   // may point at an orphaned chain (e.g. the RPC block cache): drop all of it.
   // Deliberately takes no rollback target — the deepest reorged block isn't

package/src/sources/Source.res.mjs

@@ -50,6 +50,30 @@ let RateLimited = /* @__PURE__ */Primitive_exceptions.create("Source.RateLimited
 
 let GetItemsError = /* @__PURE__ */Primitive_exceptions.create("Source.GetItemsError");
 
+function downReasonLabel(reason) {
+  if (typeof reason === "object") {
+    return `http-` + reason._0.toString();
+  }
+  switch (reason) {
+    case "Rotated" :
+      return "rotated";
+    case "Closed" :
+      return "closed";
+    case "Stale" :
+      return "stale";
+    case "Unreadable" :
+      return "unreadable";
+    case "ConnectFailed" :
+      return "connect-failed";
+    case "SubscribeRejected" :
+      return "subscribe-rejected";
+    case "TransportError" :
+      return "error";
+    case "Unsubscribed" :
+      return "unsubscribed";
+  }
+}
+
 export {
   nativeFailurePrefix,
   nativeFailurePayloadSchema,
@@ -58,5 +82,6 @@ export {
   SourceBehindHead,
   RateLimited,
   GetItemsError,
+  downReasonLabel,
 }
 /* nativeFailurePayloadSchema Not a pure module */