envio 3.0.0-alpha.3 → 3.0.0-alpha.4

package/src/sources/HyperSyncHeightStream.res

@@ -1,28 +1,15 @@
 /*
-Pure js implementation of the HyperSync height stream.
+Pure subscription-based 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.
+let subscribe = (~hyperSyncUrl, ~apiToken, ~onHeight: int => unit): (unit => unit) => {
+  let eventsourceRef = ref(None)
+  // Timeout doesn't do anything for initialization
+  let timeoutIdRef = ref(Js.Global.setTimeout(() => (), 0))
 
-  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>>,
-  ) => {
+  // 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 = () => {
     timeoutIdRef.contents->Js.Global.clearTimeout
 
     // Should receive a ping at least every 5s, so 15s is a safe margin
@@ -34,31 +21,15 @@ let make = (~hyperSyncUrl, ~apiToken) => {
         "url": hyperSyncUrl,
         "staleTimeMillis": staleTimeMillis,
       })
-      refreshEventSource(
-        ~eventsourceRef,
-        ~hyperSyncUrl,
-        ~apiToken,
-        ~heightRef,
-        ~errorRef,
-        ~timeoutIdRef,
-      )
+      refreshEventSource()
     }, 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>,
-  ) => {
+  // Instantiate a new EventSource and set it to the shared refs.
+  // Add the necessary event listeners, handle errors
+  // and update the timeout.
+  and refreshEventSource = () => {
     // Close the old EventSource if it exists (on a new connection after timeout)
     switch eventsourceRef.contents {
     | Some(es) => es->EventSource.close
@@ -79,7 +50,7 @@ let make = (~hyperSyncUrl, ~apiToken) => {
     // 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)
+    updateTimeoutId()
 
     es->EventSource.onopen(_ => {
       Logging.trace({"msg": "SSE connection opened for height stream", "url": hyperSyncUrl})
@@ -90,90 +61,37 @@ let make = (~hyperSyncUrl, ~apiToken) => {
         "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
+      // and that the height hasn't updated for 5 seconds
       // 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
+      updateTimeoutId()
     })
 
     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
+        updateTimeoutId()
+        // Call the callback with the new height
+        onHeight(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,
-  }
-}
+  // Start the EventSource connection
+  refreshEventSource()
 
-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 => ()
+  // Return unsubscribe function
+  () => {
+    timeoutIdRef.contents->Js.Global.clearTimeout
+    switch eventsourceRef.contents {
+    | Some(es) => es->EventSource.close
+    | None => ()
+    }
   }
 }

package/src/sources/HyperSyncHeightStream.res.mjs

@@ -1,16 +1,22 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "../Utils.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Js_dict from "rescript/lib/es6/js_dict.js";
 import * as Logging from "../Logging.res.mjs";
 import * as Belt_Int from "rescript/lib/es6/belt_Int.js";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
 import * as Caml_option from "rescript/lib/es6/caml_option.js";
 import * as Eventsource from "eventsource";
 
-function make(hyperSyncUrl, apiToken) {
-  var updateTimeoutId = function (eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef) {
+function subscribe(hyperSyncUrl, apiToken, onHeight) {
+  var eventsourceRef = {
+    contents: undefined
+  };
+  var timeoutIdRef = {
+    contents: setTimeout((function () {
+            
+          }), 0)
+  };
+  var updateTimeoutId = function () {
     clearTimeout(timeoutIdRef.contents);
     var newTimeoutId = setTimeout((function () {
             Logging.trace({
@@ -18,11 +24,11 @@ function make(hyperSyncUrl, apiToken) {
                   url: hyperSyncUrl,
                   staleTimeMillis: 15000
                 });
-            refreshEventSource(eventsourceRef, hyperSyncUrl, apiToken, heightRef, errorRef, timeoutIdRef);
+            refreshEventSource();
           }), 15000);
     timeoutIdRef.contents = newTimeoutId;
   };
-  var refreshEventSource = function (eventsourceRef, hyperSyncUrl, apiToken, heightRef, errorRef, timeoutIdRef) {
+  var refreshEventSource = function () {
     var es = eventsourceRef.contents;
     if (es !== undefined) {
       Caml_option.valFromOption(es).close();
@@ -41,7 +47,7 @@ function make(hyperSyncUrl, apiToken) {
               ])
         });
     eventsourceRef.contents = Caml_option.some(es$1);
-    updateTimeoutId(eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef);
+    updateTimeoutId();
     es$1.onopen = (function () {
         Logging.trace({
               msg: "SSE connection opened for height stream",
@@ -53,75 +59,36 @@ function make(hyperSyncUrl, apiToken) {
               msg: "EventSource error",
               error: error.message
             });
-        errorRef.contents = Belt_Option.getWithDefault(error.message, "Unexpected no error.message");
       });
     es$1.addEventListener("ping", (function (_event) {
-            updateTimeoutId(eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef);
-            errorRef.contents = undefined;
+            updateTimeoutId();
           }));
     es$1.addEventListener("height", (function ($$event) {
             var height = Belt_Int.fromString($$event.data);
             if (height !== undefined) {
-              updateTimeoutId(eventsourceRef, timeoutIdRef, hyperSyncUrl, apiToken, heightRef, errorRef);
-              errorRef.contents = undefined;
-              heightRef.contents = height;
+              updateTimeoutId();
+              return onHeight(height);
             } else {
-              Logging.trace({
-                    msg: "Height was not a number in event.data",
-                    data: $$event.data
-                  });
-              errorRef.contents = "Height was not a number in event.data";
+              return Logging.trace({
+                          msg: "Height was not a number in event.data",
+                          data: $$event.data
+                        });
             }
           }));
   };
-  var heightRef = {
-    contents: 0
-  };
-  var errorRef = {
-    contents: undefined
-  };
-  var eventsourceRef = {
-    contents: undefined
-  };
-  var timeoutIdRef = {
-    contents: setTimeout((function () {
-            
-          }), 0)
-  };
-  refreshEventSource(eventsourceRef, hyperSyncUrl, apiToken, heightRef, errorRef, timeoutIdRef);
-  return {
-          heightRef: heightRef,
-          errorRef: errorRef,
-          timeoutIdRef: timeoutIdRef,
-          eventsourceRef: eventsourceRef
-        };
-}
-
-async function getHeight(t) {
-  while(t.heightRef.contents === 0 && t.errorRef.contents === undefined) {
-    await Utils.delay(200);
+  refreshEventSource();
+  return function () {
+    clearTimeout(timeoutIdRef.contents);
+    var es = eventsourceRef.contents;
+    if (es !== undefined) {
+      Caml_option.valFromOption(es).close();
+      return ;
+    }
+    
   };
-  var error = t.errorRef.contents;
-  if (error !== undefined) {
-    return Js_exn.raiseError(error);
-  } else {
-    return t.heightRef.contents;
-  }
-}
-
-function close(t) {
-  clearTimeout(t.timeoutIdRef.contents);
-  var es = t.eventsourceRef.contents;
-  if (es !== undefined) {
-    Caml_option.valFromOption(es).close();
-    return ;
-  }
-  
 }
 
 export {
-  make ,
-  getHeight ,
-  close ,
+  subscribe ,
 }
 /* Utils Not a pure module */

package/src/sources/HyperSyncSource.res

@@ -551,32 +551,30 @@ let make = (
       ~logger,
     )->Promise.thenResolve(HyperSync.mapExn)
 
-  let malformedTokenMessage = `Your token is malformed. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens.`
+  let jsonApiClient = Rest.client(endpointUrl)
 
-  let heightStream = HyperSyncHeightStream.make(~hyperSyncUrl=endpointUrl, ~apiToken)
+  let malformedTokenMessage = `Your token is malformed. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens.`
 
   {
     name,
     sourceFor: Sync,
     chain,
-    pollingInterval: 32, // purely internal state polling since we now stream the height to the state
+    pollingInterval: 100,
     poweredByHyperSync: true,
     getBlockHashes,
-    getHeightOrThrow: async () => {
-      try await heightStream->HyperSyncHeightStream.getHeight catch {
-      | Js.Exn.Error(exn)
-        if exn
-        ->Js.Exn.message
-        ->Option.getWithDefault("")
-        ->Js.String2.includes(malformedTokenMessage) =>
+    getHeightOrThrow: async () =>
+      switch await HyperSyncJsonApi.heightRoute->Rest.fetch(apiToken, ~client=jsonApiClient) {
+      | Value(height) => height
+      | ErrorMessage(m) if m === malformedTokenMessage =>
         Logging.error(`Your ENVIO_API_TOKEN is malformed. The indexer will not be able to fetch events. Update the token and restart the indexer using 'pnpm envio start'. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens`)
         // Don't want to retry if the token is malformed
         // So just block forever
         let _ = await Promise.make((_, _) => ())
         0
-      | exn => raise(exn)
-      }
-    },
+      | ErrorMessage(m) => Js.Exn.raiseError(m)
+      },
     getItemsOrThrow,
+    createHeightSubscription: (~onHeight) =>
+      HyperSyncHeightStream.subscribe(~hyperSyncUrl=endpointUrl, ~apiToken, ~onHeight),
   }
 }

package/src/sources/HyperSyncSource.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Rest from "../vendored/Rest.res.mjs";
 import * as Viem from "../bindings/Viem.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
@@ -15,6 +16,7 @@ import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
 import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
 import * as Caml_splice_call from "rescript/lib/es6/caml_splice_call.js";
+import * as HyperSyncJsonApi from "./HyperSyncJsonApi.res.mjs";
 import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
 import * as HyperSyncHeightStream from "./HyperSyncHeightStream.res.mjs";
 
@@ -383,34 +385,32 @@ function make(param) {
   var getBlockHashes = function (blockNumbers, logger) {
     return HyperSync.queryBlockDataMulti(endpointUrl, apiToken, blockNumbers, logger).then(HyperSync.mapExn);
   };
-  var heightStream = HyperSyncHeightStream.make(endpointUrl, apiToken);
+  var jsonApiClient = Rest.client(endpointUrl, undefined);
   return {
           name: "HyperSync",
           sourceFor: "Sync",
           chain: chain,
           poweredByHyperSync: true,
-          pollingInterval: 32,
+          pollingInterval: 100,
           getBlockHashes: getBlockHashes,
           getHeightOrThrow: (async function () {
-              try {
-                return await HyperSyncHeightStream.getHeight(heightStream);
-              }
-              catch (raw_exn){
-                var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-                if (exn.RE_EXN_ID === Js_exn.$$Error) {
-                  if (Belt_Option.getWithDefault(exn._1.message, "").includes("Your token is malformed. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens.")) {
-                    Logging.error("Your ENVIO_API_TOKEN is malformed. The indexer will not be able to fetch events. Update the token and restart the indexer using 'pnpm envio start'. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens");
-                    await new Promise((function (param, param$1) {
-                            
-                          }));
-                    return 0;
-                  }
-                  throw exn;
-                }
-                throw exn;
+              var height = await Rest.$$fetch(HyperSyncJsonApi.heightRoute, apiToken, jsonApiClient);
+              if (typeof height === "number") {
+                return height;
+              } else if (height === "Your token is malformed. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens.") {
+                Logging.error("Your ENVIO_API_TOKEN is malformed. The indexer will not be able to fetch events. Update the token and restart the indexer using 'pnpm envio start'. For more info: https://docs.envio.dev/docs/HyperSync/api-tokens");
+                await new Promise((function (param, param$1) {
+                        
+                      }));
+                return 0;
+              } else {
+                return Js_exn.raiseError(height);
               }
             }),
-          getItemsOrThrow: getItemsOrThrow
+          getItemsOrThrow: getItemsOrThrow,
+          createHeightSubscription: (function (onHeight) {
+              return HyperSyncHeightStream.subscribe(endpointUrl, apiToken, onHeight);
+            })
         };
 }
 
@@ -419,4 +419,4 @@ export {
   memoGetSelectionConfig ,
   make ,
 }
-/* Viem Not a pure module */
+/* Rest Not a pure module */

package/src/sources/Rpc.res

@@ -179,3 +179,46 @@ module GetBlockByNumber = {
 module GetBlockHeight = {
   let route = makeRpcRoute("eth_blockNumber", S.tuple(_ => ()), hexIntSchema)
 }
+
+module GetTransactionByHash = {
+  let transactionSchema = S.object((s): Internal.evmTransactionFields => {
+    // We already know the data so ignore the fields
+    // blockHash: ?s.field("blockHash", S.option(S.string)),
+    // blockNumber: ?s.field("blockNumber", S.option(hexIntSchema)),
+    // chainId: ?s.field("chainId", S.option(hexIntSchema)),
+    from: ?s.field("from", S.option(S.string->(Utils.magic: S.t<string> => S.t<Address.t>))),
+    to: ?s.field("to", S.option(S.string->(Utils.magic: S.t<string> => S.t<Address.t>))),
+    gas: ?s.field("gas", S.option(hexBigintSchema)),
+    gasPrice: ?s.field("gasPrice", S.option(hexBigintSchema)),
+    hash: ?s.field("hash", S.option(S.string)),
+    input: ?s.field("input", S.option(S.string)),
+    nonce: ?s.field("nonce", S.option(hexBigintSchema)),
+    transactionIndex: ?s.field("transactionIndex", S.option(hexIntSchema)),
+    value: ?s.field("value", S.option(hexBigintSchema)),
+    type_: ?s.field("type", S.option(hexIntSchema)),
+    // Signature fields - optional for ZKSync EIP-712 compatibility
+    v: ?s.field("v", S.option(S.string)),
+    r: ?s.field("r", S.option(S.string)),
+    s: ?s.field("s", S.option(S.string)),
+    yParity: ?s.field("yParity", S.option(S.string)),
+    // EIP-1559 fields
+    maxPriorityFeePerGas: ?s.field("maxPriorityFeePerGas", S.option(hexBigintSchema)),
+    maxFeePerGas: ?s.field("maxFeePerGas", S.option(hexBigintSchema)),
+    // EIP-4844 blob fields
+    maxFeePerBlobGas: ?s.field("maxFeePerBlobGas", S.option(hexBigintSchema)),
+    blobVersionedHashes: ?s.field("blobVersionedHashes", S.option(S.array(S.string))),
+    // TODO: Fields to add:
+    // pub access_list: Option<Vec<AccessList>>,
+    // pub authorization_list: Option<Vec<Authorization>>,
+    // // OP stack fields
+    // pub deposit_receipt_version: Option<Quantity>,
+    // pub mint: Option<Quantity>,
+    // pub source_hash: Option<Hash>,
+  })
+
+  let route = makeRpcRoute(
+    "eth_getTransactionByHash",
+    S.tuple1(S.string),
+    S.null(transactionSchema),
+  )
+}

package/src/sources/Rpc.res.mjs

@@ -187,6 +187,36 @@ var GetBlockHeight = {
   route: route$2
 };
 
+var transactionSchema = S$RescriptSchema.object(function (s) {
+      return {
+              from: s.f("from", S$RescriptSchema.option(S$RescriptSchema.string)),
+              to: s.f("to", S$RescriptSchema.option(S$RescriptSchema.string)),
+              gas: s.f("gas", S$RescriptSchema.option(hexBigintSchema)),
+              gasPrice: s.f("gasPrice", S$RescriptSchema.option(hexBigintSchema)),
+              hash: s.f("hash", S$RescriptSchema.option(S$RescriptSchema.string)),
+              input: s.f("input", S$RescriptSchema.option(S$RescriptSchema.string)),
+              nonce: s.f("nonce", S$RescriptSchema.option(hexBigintSchema)),
+              transactionIndex: s.f("transactionIndex", S$RescriptSchema.option(hexIntSchema)),
+              value: s.f("value", S$RescriptSchema.option(hexBigintSchema)),
+              v: s.f("v", S$RescriptSchema.option(S$RescriptSchema.string)),
+              r: s.f("r", S$RescriptSchema.option(S$RescriptSchema.string)),
+              s: s.f("s", S$RescriptSchema.option(S$RescriptSchema.string)),
+              yParity: s.f("yParity", S$RescriptSchema.option(S$RescriptSchema.string)),
+              maxPriorityFeePerGas: s.f("maxPriorityFeePerGas", S$RescriptSchema.option(hexBigintSchema)),
+              maxFeePerGas: s.f("maxFeePerGas", S$RescriptSchema.option(hexBigintSchema)),
+              maxFeePerBlobGas: s.f("maxFeePerBlobGas", S$RescriptSchema.option(hexBigintSchema)),
+              blobVersionedHashes: s.f("blobVersionedHashes", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
+              type: s.f("type", S$RescriptSchema.option(hexIntSchema))
+            };
+    });
+
+var route$3 = makeRpcRoute("eth_getTransactionByHash", S$RescriptSchema.tuple1(S$RescriptSchema.string), S$RescriptSchema.$$null(transactionSchema));
+
+var GetTransactionByHash = {
+  transactionSchema: transactionSchema,
+  route: route$3
+};
+
 export {
   makeRpcRoute ,
   makeHexSchema ,
@@ -195,5 +225,6 @@ export {
   GetLogs ,
   GetBlockByNumber ,
   GetBlockHeight ,
+  GetTransactionByHash ,
 }
 /* hexBigintSchema Not a pure module */

package/src/sources/RpcSource.res

@@ -503,10 +503,12 @@ let make = (
 
   let mutSuggestedBlockIntervals = Js.Dict.empty()
 
+  let client = Rest.client(url)
+
   let makeTransactionLoader = () =>
     LazyLoader.make(
       ~loaderFn=transactionHash =>
-        provider->Ethers.JsonRpcProvider.getTransaction(~transactionHash),
+        Rpc.GetTransactionByHash.route->Rest.fetch(transactionHash, ~client),
       ~onError=(am, ~exn) => {
         Logging.error({
           "err": exn->Utils.prettifyExn,
@@ -560,7 +562,12 @@ let make = (
   )
   let getEventTransactionOrThrow = makeThrowingGetEventTransaction(
     ~getTransactionFields=Ethers.JsonRpcProvider.makeGetTransactionFields(
-      ~getTransactionByHash=LazyLoader.get(transactionLoader.contents, _),
+      ~getTransactionByHash=async transactionHash => {
+        switch await transactionLoader.contents->LazyLoader.get(transactionHash) {
+        | Some(tx) => tx
+        | None => Js.Exn.raiseError(`Transaction not found for hash: ${transactionHash}`)
+        }
+      },
       ~lowercaseAddresses,
     ),
   )
@@ -902,8 +909,6 @@ let make = (
     ->Promise.catch(exn => exn->Error->Promise.resolve)
   }
 
-  let client = Rest.client(url)
-
   {
     name,
     sourceFor,

package/src/sources/RpcSource.res.mjs

@@ -518,9 +518,10 @@ function make(param) {
   var provider = Ethers.JsonRpcProvider.make(url, chain);
   var getSelectionConfig = memoGetSelectionConfig(chain);
   var mutSuggestedBlockIntervals = {};
+  var client = Rest.client(url, undefined);
   var makeTransactionLoader = function () {
     return LazyLoader.make((function (transactionHash) {
-                  return provider.getTransaction(transactionHash);
+                  return Rest.$$fetch(Rpc.GetTransactionByHash.route, transactionHash, client);
                 }), (function (am, exn) {
                   Logging.error({
                         err: Utils.prettifyExn(exn),
@@ -559,8 +560,13 @@ function make(param) {
   var getEventBlockOrThrow = makeThrowingGetEventBlock(function (blockNumber) {
         return LazyLoader.get(blockLoader.contents, blockNumber);
       });
-  var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields((function (__x) {
-              return LazyLoader.get(transactionLoader.contents, __x);
+  var getEventTransactionOrThrow = makeThrowingGetEventTransaction(Ethers.JsonRpcProvider.makeGetTransactionFields((async function (transactionHash) {
+              var tx = await LazyLoader.get(transactionLoader.contents, transactionHash);
+              if (tx !== undefined) {
+                return tx;
+              } else {
+                return Js_exn.raiseError("Transaction not found for hash: " + transactionHash);
+              }
             }), lowercaseAddresses));
   var contractNameAbiMapping = {};
   Belt_Array.forEach(param.contracts, (function (contract) {
@@ -819,7 +825,6 @@ function make(param) {
                             });
                 }));
   };
-  var client = Rest.client(url, undefined);
   return {
           name: name,
           sourceFor: param.sourceFor,

package/src/sources/Source.res

@@ -56,4 +56,5 @@ type t = {
     ~retry: int,
     ~logger: Pino.t,
   ) => promise<blockRangeFetchResponse>,
+  createHeightSubscription?: (~onHeight: int => unit) => unit => unit,
 }