envio 3.0.0-alpha.2 → 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

@@ -249,7 +249,7 @@ let make = (
     ~toBlock,
     ~addressesByContractName,
     ~indexingContracts,
-    ~currentBlockHeight,
+    ~knownHeight,
     ~partitionId as _,
     ~selection,
     ~retry,
@@ -282,7 +282,7 @@ let make = (
         Source.GetItemsError(
           Source.FailedGettingItems({
             exn: %raw(`null`),
-            attemptedToBlock: toBlock->Option.getWithDefault(currentBlockHeight),
+            attemptedToBlock: toBlock->Option.getWithDefault(knownHeight),
             retry: switch error {
             | WrongInstance =>
               let backoffMillis = switch retry {
@@ -308,7 +308,7 @@ let make = (
         Source.GetItemsError(
           Source.FailedGettingItems({
             exn,
-            attemptedToBlock: toBlock->Option.getWithDefault(currentBlockHeight),
+            attemptedToBlock: toBlock->Option.getWithDefault(knownHeight),
             retry: WithBackoff({
               message: `Unexpected issue while fetching events from HyperSync client. Attempt a retry.`,
               backoffMillis: switch retry {
@@ -325,7 +325,7 @@ let make = (
       startFetchingBatchTimeRef->Hrtime.timeSince->Hrtime.toMillis->Hrtime.intFromMillis
 
     //set height and next from block
-    let currentBlockHeight = pageUnsafe.archiveHeight
+    let knownHeight = pageUnsafe.archiveHeight
 
     //The heighest (biggest) blocknumber that was accounted for in
     //Our query. Not necessarily the blocknumber of the last log returned
@@ -537,7 +537,7 @@ let make = (
       parsedQueueItems,
       latestFetchedBlockNumber: rangeLastBlock.blockNumber,
       stats,
-      currentBlockHeight,
+      knownHeight,
       reorgGuard,
       fromBlockQueried: fromBlock,
     }
@@ -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";
 
@@ -179,7 +181,7 @@ function make(param) {
   Belt_Array.forEach(param.contracts, (function (contract) {
           contractNameAbiMapping[contract.name] = contract.abi;
         }));
-  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, currentBlockHeight, param, selection, retry, logger) {
+  var getItemsOrThrow = async function (fromBlock, toBlock, addressesByContractName, indexingContracts, knownHeight, param, selection, retry, logger) {
     var mkLogAndRaise = function (extra, extra$1) {
       return ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
     };
@@ -221,7 +223,7 @@ function make(param) {
               _1: {
                 TAG: "FailedGettingItems",
                 exn: null,
-                attemptedToBlock: Belt_Option.getWithDefault(toBlock, currentBlockHeight),
+                attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
                 retry: tmp
               },
               Error: new Error()
@@ -232,7 +234,7 @@ function make(param) {
             _1: {
               TAG: "FailedGettingItems",
               exn: error,
-              attemptedToBlock: Belt_Option.getWithDefault(toBlock, currentBlockHeight),
+              attemptedToBlock: Belt_Option.getWithDefault(toBlock, knownHeight),
               retry: {
                 TAG: "WithBackoff",
                 message: "Unexpected issue while fetching events from HyperSync client. Attempt a retry.",
@@ -243,7 +245,7 @@ function make(param) {
           };
     }
     var pageFetchTime = Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(startFetchingBatchTimeRef)));
-    var currentBlockHeight$1 = pageUnsafe.archiveHeight;
+    var knownHeight$1 = pageUnsafe.archiveHeight;
     var heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
     var match = pageUnsafe.rollbackGuard;
     var lastBlockQueriedPromise;
@@ -371,7 +373,7 @@ function make(param) {
       "page fetch time (ms)": stats_page$unknownfetch$unknowntime$unknown$lparms$rpar
     };
     return {
-            currentBlockHeight: currentBlockHeight$1,
+            knownHeight: knownHeight$1,
             reorgGuard: reorgGuard,
             parsedQueueItems: parsedQueueItems,
             fromBlockQueried: fromBlock,
@@ -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 */