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

package/src/sources/RpcWebSocketHeightStream.res

@@ -22,8 +22,8 @@ let subscribeRequestJson =
     "id": int,
     "method": string,
     "params": array<string>,
-  } => Js.Json.t)
-  ->Js.Json.serializeExn
+  } => JSON.t)
+  ->JSON.stringify
 
 let wsMessageSchema = S.union([
   S.object(s => {
@@ -57,12 +57,12 @@ let subscribe = (~wsUrl, ~chainId, ~onHeight: int => unit): (unit => unit) => {
   let wsRef: ref<option<WebSocket.t>> = ref(None)
   let isUnsubscribed = ref(false)
   let errorCount = ref(0)
-  let staleTimeoutId: ref<option<Js.Global.timeoutId>> = ref(None)
+  let staleTimeoutId: ref<option<timeoutId>> = ref(None)
 
   let clearStaleTimeout = () => {
     switch staleTimeoutId.contents {
     | Some(id) =>
-      Js.Global.clearTimeout(id)
+      clearTimeout(id)
       staleTimeoutId := None
     | None => ()
     }
@@ -70,7 +70,7 @@ let subscribe = (~wsUrl, ~chainId, ~onHeight: int => unit): (unit => unit) => {
 
   let resetStaleTimeout = () => {
     clearStaleTimeout()
-    staleTimeoutId := Some(Js.Global.setTimeout(() => {
+    staleTimeoutId := Some(setTimeout(() => {
           // Connection went stale - close to trigger reconnect
           switch wsRef.contents {
           | Some(ws) => ws->WebSocket.close
@@ -82,9 +82,8 @@ let subscribe = (~wsUrl, ~chainId, ~onHeight: int => unit): (unit => unit) => {
   let rec scheduleReconnect = () => {
     if !isUnsubscribed.contents && errorCount.contents < retryCount {
       let duration =
-        baseDuration *
-        Js.Math.pow_float(~base=2.0, ~exp=errorCount.contents->Belt.Int.toFloat)->Belt.Float.toInt
-      let _ = Js.Global.setTimeout(() => {
+        baseDuration * Math.pow(2.0, ~exp=errorCount.contents->Belt.Int.toFloat)->Belt.Float.toInt
+      let _ = setTimeout(() => {
         if !isUnsubscribed.contents {
           startConnection()
         }
@@ -105,7 +104,7 @@ let subscribe = (~wsUrl, ~chainId, ~onHeight: int => unit): (unit => unit) => {
 
       ws->WebSocket.onmessage(event => {
         try {
-          switch event.data->Js.Json.parseExn->S.parseOrThrow(wsMessageSchema) {
+          switch event.data->JSON.parseOrThrow->S.parseOrThrow(wsMessageSchema) {
           | NewHead(blockNumber) =>
             errorCount := 0
             resetStaleTimeout()
@@ -132,7 +131,7 @@ let subscribe = (~wsUrl, ~chainId, ~onHeight: int => unit): (unit => unit) => {
             "chainId": chainId,
             "data": event.data,
           })
-        | Js.Exn.Error(_) as e =>
+        | JsExn(_) as e =>
           Logging.warn({
             "msg": "WebSocket height stream failed to parse message",
             "chainId": chainId,
@@ -146,7 +145,7 @@ let subscribe = (~wsUrl, ~chainId, ~onHeight: int => unit): (unit => unit) => {
             "err": e->Utils.prettifyExn,
             "data": event.data,
           })
-          raise(e)
+          throw(e)
         }
       })
 

package/src/sources/RpcWebSocketHeightStream.res.mjs

@@ -2,195 +2,181 @@
 
 import * as Rpc from "./Rpc.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
-import * as Js_json from "rescript/lib/es6/js_json.js";
 import * as Logging from "../Logging.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
+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 Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var subscribeRequestJson = Js_json.serializeExn({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "eth_subscribe",
-      params: ["newHeads"]
-    });
+let subscribeRequestJson = JSON.stringify({
+  jsonrpc: "2.0",
+  id: 1,
+  method: "eth_subscribe",
+  params: ["newHeads"]
+});
 
-var wsMessageSchema = S$RescriptSchema.union([
-      S$RescriptSchema.object(function (s) {
-            s.f("method", S$RescriptSchema.literal("eth_subscription"));
-            return {
-                    TAG: "NewHead",
-                    _0: s.f("params", S$RescriptSchema.object(function (s) {
-                              return s.f("result", S$RescriptSchema.object(function (s) {
-                                              return s.f("number", Rpc.hexIntSchema);
-                                            }));
-                            }))
-                  };
-          }),
-      S$RescriptSchema.object(function (s) {
-            return {
-                    TAG: "SubscriptionConfirmed",
-                    _0: s.f("result", S$RescriptSchema.string)
-                  };
-          }),
-      S$RescriptSchema.object(function (s) {
-            s.f("error", S$RescriptSchema.unknown);
-            return "ErrorResponse";
-          })
-    ]);
+let wsMessageSchema = S$RescriptSchema.union([
+  S$RescriptSchema.object(s => {
+    s.f("method", S$RescriptSchema.literal("eth_subscription"));
+    return {
+      TAG: "NewHead",
+      _0: s.f("params", S$RescriptSchema.object(s => s.f("result", S$RescriptSchema.object(s => s.f("number", Rpc.hexIntSchema)))))
+    };
+  }),
+  S$RescriptSchema.object(s => ({
+    TAG: "SubscriptionConfirmed",
+    _0: s.f("result", S$RescriptSchema.string)
+  })),
+  S$RescriptSchema.object(s => {
+    s.f("error", S$RescriptSchema.unknown);
+    return "ErrorResponse";
+  })
+]);
 
 function subscribe(wsUrl, chainId, onHeight) {
-  var wsRef = {
+  let wsRef = {
     contents: undefined
   };
-  var isUnsubscribed = {
+  let isUnsubscribed = {
     contents: false
   };
-  var errorCount = {
+  let errorCount = {
     contents: 0
   };
-  var staleTimeoutId = {
+  let staleTimeoutId = {
     contents: undefined
   };
-  var clearStaleTimeout = function () {
-    var id = staleTimeoutId.contents;
+  let clearStaleTimeout = () => {
+    let id = staleTimeoutId.contents;
     if (id !== undefined) {
-      clearTimeout(Caml_option.valFromOption(id));
+      clearTimeout(Primitive_option.valFromOption(id));
       staleTimeoutId.contents = undefined;
-      return ;
+      return;
     }
-    
   };
-  var resetStaleTimeout = function () {
+  let resetStaleTimeout = () => {
     clearStaleTimeout();
-    staleTimeoutId.contents = Caml_option.some(setTimeout((function () {
-                var ws = wsRef.contents;
-                if (ws !== undefined) {
-                  Caml_option.valFromOption(ws).close();
-                  return ;
-                }
-                
-              }), 60000));
+    staleTimeoutId.contents = Primitive_option.some(setTimeout(() => {
+      let ws = wsRef.contents;
+      if (ws !== undefined) {
+        Primitive_option.valFromOption(ws).close();
+        return;
+      }
+    }, 60000));
   };
-  var scheduleReconnect = function () {
+  let scheduleReconnect = () => {
     if (!(!isUnsubscribed.contents && errorCount.contents < 9)) {
-      return ;
+      return;
     }
-    var duration = Math.imul(125, Math.pow(2.0, errorCount.contents) | 0);
-    setTimeout((function () {
-            if (!isUnsubscribed.contents) {
-              return startConnection();
-            }
-            
-          }), duration);
+    let duration = 125 * (Math.pow(2.0, errorCount.contents) | 0) | 0;
+    setTimeout(() => {
+      if (!isUnsubscribed.contents) {
+        return startConnection();
+      }
+    }, duration);
   };
-  var startConnection = function () {
+  let startConnection = () => {
     if (isUnsubscribed.contents || errorCount.contents >= 9) {
-      return ;
+      return;
     }
-    var ws = new WebSocket(wsUrl);
-    wsRef.contents = Caml_option.some(ws);
-    ws.onopen = (function () {
-        ws.send(subscribeRequestJson);
-        resetStaleTimeout();
-      });
-    ws.onmessage = (function ($$event) {
-        try {
-          var blockNumber = S$RescriptSchema.parseOrThrow(JSON.parse($$event.data), wsMessageSchema);
-          if (typeof blockNumber !== "object") {
-            if (errorCount.contents < 9) {
-              errorCount.contents = errorCount.contents + 1 | 0;
-            }
-            var ws = wsRef.contents;
-            if (ws !== undefined) {
-              Caml_option.valFromOption(ws).close();
-              return ;
-            } else {
-              return ;
-            }
+    let ws = new WebSocket(wsUrl);
+    wsRef.contents = Primitive_option.some(ws);
+    ws.onopen = () => {
+      ws.send(subscribeRequestJson);
+      resetStaleTimeout();
+    };
+    ws.onmessage = event => {
+      try {
+        let blockNumber = S$RescriptSchema.parseOrThrow(JSON.parse(event.data), wsMessageSchema);
+        if (typeof blockNumber !== "object") {
+          if (errorCount.contents < 9) {
+            errorCount.contents = errorCount.contents + 1 | 0;
           }
-          if (blockNumber.TAG !== "NewHead") {
-            return resetStaleTimeout();
+          let ws = wsRef.contents;
+          if (ws !== undefined) {
+            Primitive_option.valFromOption(ws).close();
+            return;
+          } else {
+            return;
           }
-          errorCount.contents = 0;
-          resetStaleTimeout();
-          Prometheus.SourceRequestCount.increment("WebSocket", chainId, "eth_subscribe");
-          return onHeight(blockNumber._0);
         }
-        catch (raw_e){
-          var e = Caml_js_exceptions.internalToOCamlException(raw_e);
-          if (e.RE_EXN_ID === S$RescriptSchema.Raised) {
-            return Logging.warn({
-                        msg: "WebSocket height stream received unrecognized message",
-                        chainId: chainId,
-                        data: $$event.data
-                      });
-          }
-          if (e.RE_EXN_ID === Js_exn.$$Error) {
-            return Logging.warn({
-                        msg: "WebSocket height stream failed to parse message",
-                        chainId: chainId,
-                        err: Utils.prettifyExn(e),
-                        data: $$event.data
-                      });
-          }
-          Logging.error({
-                msg: "Unexpected error in WebSocket height stream message handler",
-                chainId: chainId,
-                err: Utils.prettifyExn(e),
-                data: $$event.data
-              });
-          throw e;
+        if (blockNumber.TAG !== "NewHead") {
+          return resetStaleTimeout();
         }
-      });
-    ws.onerror = (function (_error) {
-        if (errorCount.contents < 9) {
-          errorCount.contents = errorCount.contents + 1 | 0;
-        }
-        var ws = wsRef.contents;
-        if (ws === undefined) {
-          return ;
+        errorCount.contents = 0;
+        resetStaleTimeout();
+        Prometheus.SourceRequestCount.increment("WebSocket", chainId, "eth_subscribe");
+        return onHeight(blockNumber._0);
+      } catch (raw_e) {
+        let e = Primitive_exceptions.internalToException(raw_e);
+        if (e.RE_EXN_ID === S$RescriptSchema.Raised) {
+          return Logging.warn({
+            msg: "WebSocket height stream received unrecognized message",
+            chainId: chainId,
+            data: event.data
+          });
         }
-        var ws$1 = Caml_option.valFromOption(ws);
-        if (ws$1.readyState === 1) {
-          ws$1.close();
-          return ;
+        if (e.RE_EXN_ID === "JsExn") {
+          return Logging.warn({
+            msg: "WebSocket height stream failed to parse message",
+            chainId: chainId,
+            err: Utils.prettifyExn(e),
+            data: event.data
+          });
         }
-        
-      });
-    ws.onclose = (function () {
-        wsRef.contents = undefined;
-        clearStaleTimeout();
-        scheduleReconnect();
-      });
+        Logging.error({
+          msg: "Unexpected error in WebSocket height stream message handler",
+          chainId: chainId,
+          err: Utils.prettifyExn(e),
+          data: event.data
+        });
+        throw e;
+      }
+    };
+    ws.onerror = _error => {
+      if (errorCount.contents < 9) {
+        errorCount.contents = errorCount.contents + 1 | 0;
+      }
+      let ws = wsRef.contents;
+      if (ws === undefined) {
+        return;
+      }
+      let ws$1 = Primitive_option.valFromOption(ws);
+      if (ws$1.readyState === 1) {
+        ws$1.close();
+        return;
+      }
+    };
+    ws.onclose = () => {
+      wsRef.contents = undefined;
+      clearStaleTimeout();
+      scheduleReconnect();
+    };
   };
   startConnection();
-  return function () {
+  return () => {
     isUnsubscribed.contents = true;
     clearStaleTimeout();
-    var ws = wsRef.contents;
+    let ws = wsRef.contents;
     if (ws !== undefined) {
-      Caml_option.valFromOption(ws).close();
-      return ;
+      Primitive_option.valFromOption(ws).close();
+      return;
     }
-    
   };
 }
 
-var retryCount = 9;
+let retryCount = 9;
 
-var baseDuration = 125;
+let baseDuration = 125;
 
-var staleTimeMillis = 60000;
+let staleTimeMillis = 60000;
 
 export {
-  retryCount ,
-  baseDuration ,
-  staleTimeMillis ,
-  subscribeRequestJson ,
-  wsMessageSchema ,
-  subscribe ,
+  retryCount,
+  baseDuration,
+  staleTimeMillis,
+  subscribeRequestJson,
+  wsMessageSchema,
+  subscribe,
 }
 /* subscribeRequestJson Not a pure module */

package/src/sources/SimulateSource.res

@@ -21,7 +21,7 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
       ~fromBlock as _,
       ~toBlock as _,
       ~addressesByContractName as _,
-      ~indexingContracts as _,
+      ~indexingAddresses as _,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,

package/src/sources/SimulateSource.res.mjs

@@ -1,50 +1,47 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 
 function make(items, endBlock, chain) {
-  var delivered = {
+  let delivered = {
     contents: false
   };
   return {
-          name: "SimulateSource",
-          sourceFor: "Sync",
-          chain: chain,
-          poweredByHyperSync: false,
-          pollingInterval: 0,
-          getBlockHashes: (function (param, param$1) {
-              return Promise.resolve({
-                          TAG: "Ok",
-                          _0: []
-                        });
-            }),
-          getHeightOrThrow: (function () {
-              return Promise.resolve(endBlock > 1 ? endBlock : 1);
-            }),
-          getItemsOrThrow: (function (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) {
-              var result = delivered.contents ? [] : (delivered.contents = true, items);
-              var reportedHeight = endBlock > 1 ? endBlock : 1;
-              return Promise.resolve({
-                          knownHeight: reportedHeight,
-                          reorgGuard: {
-                            rangeLastBlock: {
-                              blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-                              blockNumber: reportedHeight
-                            },
-                            prevRangeLastBlock: undefined
-                          },
-                          parsedQueueItems: result,
-                          fromBlockQueried: 0,
-                          latestFetchedBlockNumber: reportedHeight,
-                          latestFetchedBlockTimestamp: 0,
-                          stats: {
-                            "total time elapsed (s)": 0
-                          }
-                        });
-            })
-        };
+    name: "SimulateSource",
+    sourceFor: "Sync",
+    chain: chain,
+    poweredByHyperSync: false,
+    pollingInterval: 0,
+    getBlockHashes: (param, param$1) => Promise.resolve({
+      TAG: "Ok",
+      _0: []
+    }),
+    getHeightOrThrow: () => Promise.resolve(Primitive_int.max(endBlock, 1)),
+    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) => {
+      let result = delivered.contents ? [] : (delivered.contents = true, items);
+      let reportedHeight = Primitive_int.max(endBlock, 1);
+      return Promise.resolve({
+        knownHeight: reportedHeight,
+        reorgGuard: {
+          rangeLastBlock: {
+            blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+            blockNumber: reportedHeight
+          },
+          prevRangeLastBlock: undefined
+        },
+        parsedQueueItems: result,
+        fromBlockQueried: 0,
+        latestFetchedBlockNumber: reportedHeight,
+        latestFetchedBlockTimestamp: 0,
+        stats: {
+          "total time elapsed (s)": 0
+        }
+      });
+    }
+  };
 }
 
 export {
-  make ,
+  make,
 }
 /* No side effect */

package/src/sources/Source.res

@@ -50,7 +50,7 @@ type t = {
     ~fromBlock: int,
     ~toBlock: option<int>,
     ~addressesByContractName: dict<array<Address.t>>,
-    ~indexingContracts: dict<Internal.indexingContract>,
+    ~indexingAddresses: dict<FetchState.indexingAddress>,
     ~knownHeight: int,
     ~partitionId: string,
     ~selection: FetchState.selection,

package/src/sources/Source.res.mjs

@@ -1,10 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var GetItemsError = /* @__PURE__ */Caml_exceptions.create("Source.GetItemsError");
+let GetItemsError = /* @__PURE__ */Primitive_exceptions.create("Source.GetItemsError");
 
 export {
-  GetItemsError ,
+  GetItemsError,
 }
 /* No side effect */