envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/sources/HyperSyncClient.res.mjs

@@ -2,110 +2,105 @@
 
 import * as Utils from "../Utils.res.mjs";
 import * as Address from "../Address.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as HypersyncClient from "@envio-dev/hypersync-client";
 
-var serializationFormatSchema = S$RescriptSchema.$$enum([
-      "Json",
-      "CapnProto"
-    ]);
+let serializationFormatSchema = S$RescriptSchema.$$enum([
+  "Json",
+  "CapnProto"
+]);
 
 function makeTopicSelection(topic0Opt, topic1Opt, topic2Opt, topic3Opt) {
-  var topic0 = topic0Opt !== undefined ? topic0Opt : [];
-  var topic1 = topic1Opt !== undefined ? topic1Opt : [];
-  var topic2 = topic2Opt !== undefined ? topic2Opt : [];
-  var topic3 = topic3Opt !== undefined ? topic3Opt : [];
+  let topic0 = topic0Opt !== undefined ? topic0Opt : [];
+  let topic1 = topic1Opt !== undefined ? topic1Opt : [];
+  let topic2 = topic2Opt !== undefined ? topic2Opt : [];
+  let topic3 = topic3Opt !== undefined ? topic3Opt : [];
   return [
-          topic0,
-          topic1,
-          topic2,
-          topic3
-        ];
+    topic0,
+    topic1,
+    topic2,
+    topic3
+  ];
 }
 
 function makeLogSelection(address, topics) {
   return {
-          address: address,
-          topics: topics
-        };
+    address: address,
+    topics: topics
+  };
 }
 
-var QueryTypes = {
+let QueryTypes = {
   makeTopicSelection: makeTopicSelection,
   makeLogSelection: makeLogSelection
 };
 
-var accessListSchema = S$RescriptSchema.object(function (s) {
-      return {
-              address: s.f("address", S$RescriptSchema.option(Address.schema)),
-              storageKeys: s.f("storageKeys", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string)))
-            };
-    });
+let accessListSchema = S$RescriptSchema.object(s => ({
+  address: s.f("address", S$RescriptSchema.option(Address.schema)),
+  storageKeys: s.f("storageKeys", S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string)))
+}));
 
-var authorizationListSchema = S$RescriptSchema.object(function (s) {
-      return {
-              chainId: s.f("chainId", S$RescriptSchema.bigint),
-              address: s.f("address", Address.schema),
-              nonce: s.f("nonce", S$RescriptSchema.$$int),
-              yParity: s.f("yParity", S$RescriptSchema.$$enum([
-                        0,
-                        1
-                      ])),
-              r: s.f("r", S$RescriptSchema.string),
-              s: s.f("s", S$RescriptSchema.string)
-            };
-    });
+let authorizationListSchema = S$RescriptSchema.object(s => ({
+  chainId: s.f("chainId", S$RescriptSchema.bigint),
+  address: s.f("address", Address.schema),
+  nonce: s.f("nonce", S$RescriptSchema.int),
+  yParity: s.f("yParity", S$RescriptSchema.$$enum([
+    0,
+    1
+  ])),
+  r: s.f("r", S$RescriptSchema.string),
+  s: s.f("s", S$RescriptSchema.string)
+}));
 
-var ResponseTypes = {
+let ResponseTypes = {
   accessListSchema: accessListSchema,
   authorizationListSchema: authorizationListSchema
 };
 
-var HeightStream = {};
+let HeightStream = {};
 
 function make(url, apiToken, httpReqTimeoutMillis, maxNumRetries, enableChecksumAddressesOpt, serializationFormat, enableQueryCaching, retryBaseMs, retryBackoffMs, retryCeilingMs) {
-  var enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
-  var envioVersion = Utils.EnvioPackage.value.version;
+  let enableChecksumAddresses = enableChecksumAddressesOpt !== undefined ? enableChecksumAddressesOpt : true;
+  let envioVersion = Utils.EnvioPackage.value.version;
   return HypersyncClient.HypersyncClient.newWithAgent({
-              url: url,
-              apiToken: apiToken,
-              httpReqTimeoutMillis: httpReqTimeoutMillis,
-              maxNumRetries: maxNumRetries,
-              retryBackoffMs: retryBackoffMs,
-              retryBaseMs: retryBaseMs,
-              retryCeilingMs: retryCeilingMs,
-              enableChecksumAddresses: enableChecksumAddresses,
-              serializationFormat: serializationFormat,
-              enableQueryCaching: enableQueryCaching
-            }, "hyperindex/" + envioVersion);
+    url: url,
+    apiToken: apiToken,
+    httpReqTimeoutMillis: httpReqTimeoutMillis,
+    maxNumRetries: maxNumRetries,
+    retryBackoffMs: retryBackoffMs,
+    retryBaseMs: retryBaseMs,
+    retryCeilingMs: retryCeilingMs,
+    enableChecksumAddresses: enableChecksumAddresses,
+    serializationFormat: serializationFormat,
+    enableQueryCaching: enableQueryCaching
+  }, `hyperindex/` + envioVersion);
 }
 
-var logLevelSchema = S$RescriptSchema.$$enum([
-      "trace",
-      "debug",
-      "info",
-      "warn",
-      "error"
-    ]);
+let logLevelSchema = S$RescriptSchema.$$enum([
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error"
+]);
 
 function toUnderlying(_d) {
-  while(true) {
-    var d = _d;
+  while (true) {
+    let d = _d;
     if (Array.isArray(d)) {
       return Belt_Array.map(d, toUnderlying);
     }
     switch (typeof d) {
       case "boolean" :
-          return d;
+        return d;
       case "string" :
-          return d;
+        return d;
       case "bigint" :
-          return d;
+        return d;
       case "object" :
-          _d = d.val;
-          continue ;
-      
+        _d = d.val;
+        continue;
     }
   };
 }
@@ -114,18 +109,18 @@ function fromSignatures(prim) {
   return HypersyncClient.Decoder.fromSignatures(prim);
 }
 
-var Decoder = {
+let Decoder = {
   toUnderlying: toUnderlying,
   fromSignatures: fromSignatures
 };
 
 export {
-  serializationFormatSchema ,
-  QueryTypes ,
-  ResponseTypes ,
-  HeightStream ,
-  make ,
-  logLevelSchema ,
-  Decoder ,
+  serializationFormatSchema,
+  QueryTypes,
+  ResponseTypes,
+  HeightStream,
+  make,
+  logLevelSchema,
+  Decoder,
 }
 /* serializationFormatSchema Not a pure module */

package/src/sources/HyperSyncHeightStream.res

@@ -7,17 +7,17 @@ let subscribe = (~hyperSyncUrl, ~apiToken, ~chainId, ~onHeight: int => unit): (u
   let errorCount = ref(0)
   let baseDuration = 50
   // Timeout doesn't do anything for initialization
-  let timeoutIdRef = ref(Js.Global.setTimeout(() => (), 0))
+  let timeoutIdRef = ref(setTimeout(() => (), 0))
 
   // 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
+    timeoutIdRef.contents->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(() => {
+    let newTimeoutId = setTimeout(() => {
       Logging.trace({
         "msg": "Timeout fired for height stream",
         "chainId": chainId,
@@ -34,11 +34,10 @@ let subscribe = (~hyperSyncUrl, ~apiToken, ~chainId, ~onHeight: int => unit): (u
   // and update the timeout.
   and scheduleReconnect = () => {
     // Clear any pending stale/reconnect timeout to avoid double reconnect
-    timeoutIdRef.contents->Js.Global.clearTimeout
+    timeoutIdRef.contents->clearTimeout
     let delay =
-      baseDuration *
-      Js.Math.pow_float(~base=2.0, ~exp=errorCount.contents->Belt.Int.toFloat)->Belt.Float.toInt
-    timeoutIdRef := Js.Global.setTimeout(() => refreshEventSource(), Pervasives.min(delay, 60_000))
+      baseDuration * Math.pow(2.0, ~exp=errorCount.contents->Belt.Int.toFloat)->Belt.Float.toInt
+    timeoutIdRef := setTimeout(() => refreshEventSource(), Pervasives.min(delay, 60_000))
   }
   and refreshEventSource = () => {
     // Close the old EventSource if it exists (on a new connection after timeout)
@@ -56,7 +55,7 @@ let subscribe = (~hyperSyncUrl, ~apiToken, ~chainId, ~onHeight: int => unit): (u
             url,
             ~args={
               ...args,
-              headers: Js.Dict.fromArray([
+              headers: Dict.fromArray([
                 ("Authorization", `Bearer ${apiToken}`),
                 ("User-Agent", userAgent),
               ]),
@@ -128,7 +127,7 @@ let subscribe = (~hyperSyncUrl, ~apiToken, ~chainId, ~onHeight: int => unit): (u
 
   // Return unsubscribe function
   () => {
-    timeoutIdRef.contents->Js.Global.clearTimeout
+    timeoutIdRef.contents->clearTimeout
     switch eventsourceRef.contents {
     | Some(es) => es->EventSource.close
     | None => ()

package/src/sources/HyperSyncHeightStream.res.mjs

@@ -1,120 +1,112 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "../Utils.res.mjs";
-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 Caml_obj from "rescript/lib/es6/caml_obj.js";
+import * as Belt_Int from "@rescript/runtime/lib/es6/Belt_Int.js";
 import * as Prometheus from "../Prometheus.res.mjs";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
 import * as Eventsource from "eventsource";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
 function subscribe(hyperSyncUrl, apiToken, chainId, onHeight) {
-  var eventsourceRef = {
+  let eventsourceRef = {
     contents: undefined
   };
-  var errorCount = {
+  let errorCount = {
     contents: 0
   };
-  var timeoutIdRef = {
-    contents: setTimeout((function () {
-            
-          }), 0)
+  let timeoutIdRef = {
+    contents: setTimeout(() => {}, 0)
   };
-  var updateTimeoutId = function () {
+  let updateTimeoutId = () => {
     clearTimeout(timeoutIdRef.contents);
-    var newTimeoutId = setTimeout((function () {
-            Logging.trace({
-                  msg: "Timeout fired for height stream",
-                  chainId: chainId,
-                  url: hyperSyncUrl,
-                  staleTimeMillis: 15000
-                });
-            refreshEventSource();
-          }), 15000);
+    let newTimeoutId = setTimeout(() => {
+      Logging.trace({
+        msg: "Timeout fired for height stream",
+        chainId: chainId,
+        url: hyperSyncUrl,
+        staleTimeMillis: 15000
+      });
+      refreshEventSource();
+    }, 15000);
     timeoutIdRef.contents = newTimeoutId;
   };
-  var scheduleReconnect = function () {
+  let scheduleReconnect = () => {
     clearTimeout(timeoutIdRef.contents);
-    var delay = Math.imul(50, Math.pow(2.0, errorCount.contents) | 0);
-    timeoutIdRef.contents = setTimeout((function () {
-            refreshEventSource();
-          }), delay < 60000 ? delay : 60000);
+    let delay = 50 * (Math.pow(2.0, errorCount.contents) | 0) | 0;
+    timeoutIdRef.contents = setTimeout(() => refreshEventSource(), Primitive_int.min(delay, 60000));
   };
-  var refreshEventSource = function () {
-    var es = eventsourceRef.contents;
+  let refreshEventSource = () => {
+    let es = eventsourceRef.contents;
     if (es !== undefined) {
-      Caml_option.valFromOption(es).close();
+      Primitive_option.valFromOption(es).close();
     }
-    var userAgent = "hyperindex/" + Utils.EnvioPackage.value.version;
-    var es$1 = new Eventsource.EventSource(hyperSyncUrl + "/height/sse", {
-          fetch: (function (url, args) {
-              var newrecord = Caml_obj.obj_dup(args);
-              return fetch(url, (newrecord.headers = Js_dict.fromArray([
-                                [
-                                  "Authorization",
-                                  "Bearer " + apiToken
-                                ],
-                                [
-                                  "User-Agent",
-                                  userAgent
-                                ]
-                              ]), newrecord));
-            })
-        });
-    eventsourceRef.contents = Caml_option.some(es$1);
+    let userAgent = `hyperindex/` + Utils.EnvioPackage.value.version;
+    let es$1 = new Eventsource.EventSource(hyperSyncUrl + `/height/sse`, {
+      fetch: (url, args) => {
+        let newrecord = {...args};
+        return fetch(url, (newrecord.headers = Object.fromEntries([
+          [
+            "Authorization",
+            `Bearer ` + apiToken
+          ],
+          [
+            "User-Agent",
+            userAgent
+          ]
+        ]), newrecord));
+      }
+    });
+    eventsourceRef.contents = Primitive_option.some(es$1);
     updateTimeoutId();
-    es$1.onopen = (function () {
-        errorCount.contents = 0;
-        Logging.trace({
-              msg: "SSE connection opened for height stream",
-              chainId: chainId,
-              url: hyperSyncUrl
-            });
+    es$1.onopen = () => {
+      errorCount.contents = 0;
+      Logging.trace({
+        msg: "SSE connection opened for height stream",
+        chainId: chainId,
+        url: hyperSyncUrl
       });
-    es$1.onerror = (function (error) {
-        errorCount.contents = errorCount.contents + 1 | 0;
-        Logging.trace({
-              msg: "EventSource error on height stream, reconnecting",
-              chainId: chainId,
-              url: hyperSyncUrl,
-              status: error.status,
-              error: error.message,
-              errorCount: errorCount.contents
-            });
-        scheduleReconnect();
+    };
+    es$1.onerror = error => {
+      errorCount.contents = errorCount.contents + 1 | 0;
+      Logging.trace({
+        msg: "EventSource error on height stream, reconnecting",
+        chainId: chainId,
+        url: hyperSyncUrl,
+        status: error.status,
+        error: error.message,
+        errorCount: errorCount.contents
       });
-    es$1.addEventListener("ping", (function (_event) {
-            updateTimeoutId();
-          }));
-    es$1.addEventListener("height", (function ($$event) {
-            var height = Belt_Int.fromString($$event.data);
-            if (height !== undefined) {
-              Prometheus.SourceRequestCount.increment("HyperSync", chainId, "heightStream");
-              updateTimeoutId();
-              return onHeight(height);
-            } else {
-              return Logging.trace({
-                          msg: "Height was not a number in event.data",
-                          chainId: chainId,
-                          data: $$event.data
-                        });
-            }
-          }));
+      scheduleReconnect();
+    };
+    es$1.addEventListener("ping", _event => updateTimeoutId());
+    es$1.addEventListener("height", event => {
+      let height = Belt_Int.fromString(event.data);
+      if (height !== undefined) {
+        Prometheus.SourceRequestCount.increment("HyperSync", chainId, "heightStream");
+        updateTimeoutId();
+        return onHeight(height);
+      } else {
+        return Logging.trace({
+          msg: "Height was not a number in event.data",
+          chainId: chainId,
+          data: event.data
+        });
+      }
+    });
   };
   refreshEventSource();
-  return function () {
+  return () => {
     clearTimeout(timeoutIdRef.contents);
-    var es = eventsourceRef.contents;
+    let es = eventsourceRef.contents;
     if (es !== undefined) {
-      Caml_option.valFromOption(es).close();
-      return ;
+      Primitive_option.valFromOption(es).close();
+      return;
     }
-    
   };
 }
 
 export {
-  subscribe ,
+  subscribe,
 }
 /* Utils Not a pure module */

package/src/sources/HyperSyncJsonApi.res

@@ -231,15 +231,15 @@ module ResponseTypes = {
     stateRoot: ?s.field("state_root", S.option(S.string)),
     receiptsRoot: ?s.field("receipts_root", S.option(S.string)),
     miner: ?s.field("miner", S.option(S.string)),
-    difficulty: ?s.field("difficulty", S.option(S.null(BigInt.schema))),
-    totalDifficulty: ?s.field("total_difficulty", S.option(S.null(BigInt.schema))),
+    difficulty: ?s.field("difficulty", S.option(S.null(Utils.BigInt.schema))),
+    totalDifficulty: ?s.field("total_difficulty", S.option(S.null(Utils.BigInt.schema))),
     extraData: ?s.field("extra_data", S.option(S.string)),
-    size: ?s.field("size", S.option(BigInt.schema)),
-    gasLimit: ?s.field("gas_limit", S.option(BigInt.schema)),
-    gasUsed: ?s.field("gas_used", S.option(BigInt.schema)),
-    timestamp: ?s.field("timestamp", S.option(BigInt.schema)),
+    size: ?s.field("size", S.option(Utils.BigInt.schema)),
+    gasLimit: ?s.field("gas_limit", S.option(Utils.BigInt.schema)),
+    gasUsed: ?s.field("gas_used", S.option(Utils.BigInt.schema)),
+    timestamp: ?s.field("timestamp", S.option(Utils.BigInt.schema)),
     uncles: ?s.field("unclus", S.option(S.null(S.string))),
-    baseFeePerGas: ?s.field("base_fee_per_gas", S.option(S.null(BigInt.schema))),
+    baseFeePerGas: ?s.field("base_fee_per_gas", S.option(S.null(Utils.BigInt.schema))),
   })
 
   type transactionData = {
@@ -275,23 +275,26 @@ module ResponseTypes = {
     blockHash: ?s.field("block_hash", S.option(S.string)),
     blockNumber: ?s.field("block_number", S.option(S.int)),
     from: ?s.field("from", S.option(S.null(S.string))),
-    gas: ?s.field("gas", S.option(BigInt.schema)),
-    gasPrice: ?s.field("gas_price", S.option(S.null(BigInt.schema))),
+    gas: ?s.field("gas", S.option(Utils.BigInt.schema)),
+    gasPrice: ?s.field("gas_price", S.option(S.null(Utils.BigInt.schema))),
     hash: ?s.field("hash", S.option(S.string)),
     input: ?s.field("input", S.option(S.string)),
     nonce: ?s.field("nonce", S.option(S.int)),
     to: ?s.field("to", S.option(S.null(S.string))),
     transactionIndex: ?s.field("transaction_index", S.option(S.int)),
-    value: ?s.field("value", S.option(BigInt.schema)),
+    value: ?s.field("value", S.option(Utils.BigInt.schema)),
     v: ?s.field("v", S.option(S.null(S.string))),
     r: ?s.field("r", S.option(S.null(S.string))),
     s: ?s.field("s", S.option(S.null(S.string))),
-    maxPriorityFeePerGas: ?s.field("max_priority_fee_per_gas", S.option(S.null(BigInt.schema))),
-    maxFeePerGas: ?s.field("max_fee_per_gas", S.option(S.null(BigInt.schema))),
+    maxPriorityFeePerGas: ?s.field(
+      "max_priority_fee_per_gas",
+      S.option(S.null(Utils.BigInt.schema)),
+    ),
+    maxFeePerGas: ?s.field("max_fee_per_gas", S.option(S.null(Utils.BigInt.schema))),
     chainId: ?s.field("chain_id", S.option(S.null(S.int))),
-    cumulativeGasUsed: ?s.field("cumulative_gas_used", S.option(BigInt.schema)),
-    effectiveGasPrice: ?s.field("effective_gas_price", S.option(BigInt.schema)),
-    gasUsed: ?s.field("gas_used", S.option(BigInt.schema)),
+    cumulativeGasUsed: ?s.field("cumulative_gas_used", S.option(Utils.BigInt.schema)),
+    effectiveGasPrice: ?s.field("effective_gas_price", S.option(Utils.BigInt.schema)),
+    gasUsed: ?s.field("gas_used", S.option(Utils.BigInt.schema)),
     contractAddress: ?s.field("contract_address", S.option(S.null(S.string))),
     logsBoom: ?s.field("logs_bloom", S.option(S.string)),
     type_: ?s.field("type", S.option(S.null(S.int))),