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

package/src/sources/HyperSync.res

@@ -1,5 +1,3 @@
-open Belt
-
 module Log = {
   type t = {
     address: Address.t,
@@ -43,7 +41,7 @@ let queryErrorToMsq = (e: queryError): string => {
   switch e {
   | UnexpectedMissingParams({queryName, missingParams}) =>
     `${queryName} query failed due to unexpected missing params on response:
-      ${missingParams->Js.Array2.joinWith(", ")}`
+      ${missingParams->Array.joinUnsafe(", ")}`
   }
 }
 
@@ -85,7 +83,7 @@ module GetLogs = {
         for idx in 0 to fieldNames->Array.length - 1 {
           let fieldName = fieldNames->Array.getUnsafe(idx)
           switch returnedObj
-          ->(Utils.magic: 'a => Js.Dict.t<unknown>)
+          ->(Utils.magic: 'a => dict<unknown>)
           ->Utils.Dict.dangerouslyGetNonOption(fieldName) {
           | Some(_) => ()
           | None => acc->Array.push(prefix ++ "." ++ fieldName)->ignore
@@ -110,12 +108,12 @@ module GetLogs = {
       ~prefix="transaction",
     )
     if missingParams->Array.length > 0 {
-      raise(Error(UnexpectedMissingParams({missingParams: missingParams})))
+      throw(Error(UnexpectedMissingParams({missingParams: missingParams})))
     }
 
     //Topics can be nullable and still need to be filtered
     let logUnsanitized: Log.t = event.log->(Utils.magic: HyperSyncClient.ResponseTypes.log => Log.t)
-    let topics = event.log.topics->Option.getUnsafe->Array.keepMap(Js.Nullable.toOption)
+    let topics = event.log.topics->Option.getUnsafe->Array.filterMap(Nullable.toOption)
     let address = event.log.address->Option.getUnsafe
     let log = {
       ...logUnsanitized,
@@ -149,7 +147,7 @@ module GetLogs = {
     let page: logsQueryPage = {
       items,
       nextBlock,
-      archiveHeight: archiveHeight->Option.getWithDefault(0), //Archive Height is only None if height is 0
+      archiveHeight: archiveHeight->Option.getOr(0), //Archive Height is only None if height is 0
       events: res.data,
       rollbackGuard,
     }
@@ -187,7 +185,7 @@ module GetLogs = {
     let res = await client.getEvents(~query)
     if res.nextBlock <= fromBlock {
       // Might happen when /height response was from another instance of HyperSync
-      raise(Error(WrongInstance))
+      throw(Error(WrongInstance))
     }
 
     res->convertResponse(~nonOptionalBlockFieldNames, ~nonOptionalTransactionFieldNames)
@@ -226,7 +224,7 @@ module BlockData = {
             block.number->Utils.Option.mapNone("block.number"),
             block.timestamp->Utils.Option.mapNone("block.timestamp"),
             block.hash->Utils.Option.mapNone("block.hash"),
-          ]->Array.keepMap(p => p)
+          ]->Array.filterMap(p => p)
 
         Error(
           UnexpectedMissingParams({
@@ -318,7 +316,7 @@ module BlockData = {
           set->Utils.Set.add(blockNumber)->ignore
         }
         if toBlock.contents - fromBlock.contents > 1000 {
-          Js.Exn.raiseError(
+          JsError.throwWithMessage(
             `Invalid block data request. Range of block numbers is too large. Max range is 1000. Requested range: ${fromBlock.contents->Int.toString}-${toBlock.contents->Int.toString}`,
           )
         }
@@ -331,13 +329,13 @@ module BlockData = {
           ~logger,
         )
         let filtered = res->Result.map(datas => {
-          datas->Array.keep(data => set->Utils.Set.delete(data.blockNumber))
+          datas->Array.filter(data => set->Utils.Set.delete(data.blockNumber))
         })
         if set->Utils.Set.size > 0 {
-          Js.Exn.raiseError(
+          JsError.throwWithMessage(
             `Invalid response. Failed to get block data for block numbers: ${set
               ->Utils.Set.toArray
-              ->Js.Array2.joinWith(", ")}`,
+              ->Array.joinUnsafe(", ")}`,
           )
         }
         filtered

package/src/sources/HyperSync.res.mjs

@@ -2,276 +2,270 @@
 
 import * as Time from "../Time.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Logging from "../Logging.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as Prometheus from "../Prometheus.res.mjs";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Belt_Result from "rescript/lib/es6/belt_Result.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
-import * as Caml_exceptions from "rescript/lib/es6/caml_exceptions.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HyperSyncClient from "./HyperSyncClient.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var fieldNames = [
+let fieldNames = [
   "address",
   "data",
   "topics",
   "logIndex"
 ];
 
-var HyperSyncQueryError = /* @__PURE__ */Caml_exceptions.create("HyperSync.HyperSyncQueryError");
+let HyperSyncQueryError = /* @__PURE__ */Primitive_exceptions.create("HyperSync.HyperSyncQueryError");
 
 function queryErrorToMsq(e) {
-  var match = e._0;
-  return match.queryName + " query failed due to unexpected missing params on response:\n      " + match.missingParams.join(", ");
+  let match = e._0;
+  return match.queryName + ` query failed due to unexpected missing params on response:
+      ` + match.missingParams.join(", ");
 }
 
 function mapExn(queryResponse) {
   if (queryResponse.TAG === "Ok") {
     return {
-            TAG: "Ok",
-            _0: queryResponse._0
-          };
+      TAG: "Ok",
+      _0: queryResponse._0
+    };
   } else {
     return {
-            TAG: "Error",
-            _0: {
-              RE_EXN_ID: HyperSyncQueryError,
-              _1: queryResponse._0
-            }
-          };
+      TAG: "Error",
+      _0: {
+        RE_EXN_ID: HyperSyncQueryError,
+        _1: queryResponse._0
+      }
+    };
   }
 }
 
-var $$Error = /* @__PURE__ */Caml_exceptions.create("HyperSync.GetLogs.Error");
+let $$Error = /* @__PURE__ */Primitive_exceptions.create("HyperSync.GetLogs.Error");
 
 function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, fieldSelection) {
   return {
-          fromBlock: fromBlock,
-          toBlock: toBlockInclusive !== undefined ? toBlockInclusive + 1 | 0 : undefined,
-          logs: addressesWithTopics,
-          fieldSelection: fieldSelection
-        };
+    fromBlock: fromBlock,
+    toBlock: toBlockInclusive !== undefined ? toBlockInclusive + 1 | 0 : undefined,
+    logs: addressesWithTopics,
+    fieldSelection: fieldSelection
+  };
 }
 
 async function query(client, fromBlock, toBlock, logSelections, fieldSelection, nonOptionalBlockFieldNames, nonOptionalTransactionFieldNames) {
-  var addressesWithTopics = Belt_Array.flatMap(logSelections, (function (param) {
-          var addresses = param.addresses;
-          return Belt_Array.map(param.topicSelections, (function (param) {
-                        var topics = HyperSyncClient.QueryTypes.makeTopicSelection(param.topic0, param.topic1, param.topic2, param.topic3);
-                        return HyperSyncClient.QueryTypes.makeLogSelection(addresses, topics);
-                      }));
-        }));
-  var query$1 = makeRequestBody(fromBlock, toBlock, addressesWithTopics, fieldSelection);
-  var res = await client.getEvents(query$1);
+  let addressesWithTopics = logSelections.flatMap(param => {
+    let addresses = param.addresses;
+    return param.topicSelections.map(param => {
+      let topics = HyperSyncClient.QueryTypes.makeTopicSelection(param.topic0, param.topic1, param.topic2, param.topic3);
+      return HyperSyncClient.QueryTypes.makeLogSelection(addresses, topics);
+    });
+  });
+  let query$1 = makeRequestBody(fromBlock, toBlock, addressesWithTopics, fieldSelection);
+  let res = await client.getEvents(query$1);
   if (res.nextBlock <= fromBlock) {
     throw {
-          RE_EXN_ID: $$Error,
-          _1: "WrongInstance",
-          Error: new Error()
-        };
+      RE_EXN_ID: $$Error,
+      _1: "WrongInstance",
+      Error: new Error()
+    };
   }
-  var items = Belt_Array.map(res.data, (function (item) {
-          var missingParams = [];
-          var returnedObj = item.log;
-          if (Utils.$$Array.notEmpty(fieldNames)) {
-            if (returnedObj) {
-              for(var idx = 0 ,idx_finish = fieldNames.length; idx < idx_finish; ++idx){
-                var fieldName = fieldNames[idx];
-                var match = returnedObj[fieldName];
-                if (match !== undefined) {
-                  
-                } else {
-                  missingParams.push("log." + fieldName);
-                }
-              }
-            } else {
-              missingParams.push("log");
-            }
+  let items = res.data.map(item => {
+    let missingParams = [];
+    let returnedObj = item.log;
+    if (Utils.$$Array.notEmpty(fieldNames)) {
+      if (returnedObj) {
+        for (let idx = 0, idx_finish = fieldNames.length; idx < idx_finish; ++idx) {
+          let fieldName = fieldNames[idx];
+          let match = returnedObj[fieldName];
+          if (match !== undefined) {
+            
+          } else {
+            missingParams.push("log." + fieldName);
           }
-          var returnedObj$1 = item.block;
-          if (Utils.$$Array.notEmpty(nonOptionalBlockFieldNames)) {
-            if (returnedObj$1) {
-              for(var idx$1 = 0 ,idx_finish$1 = nonOptionalBlockFieldNames.length; idx$1 < idx_finish$1; ++idx$1){
-                var fieldName$1 = nonOptionalBlockFieldNames[idx$1];
-                var match$1 = returnedObj$1[fieldName$1];
-                if (match$1 !== undefined) {
-                  
-                } else {
-                  missingParams.push("block." + fieldName$1);
-                }
-              }
-            } else {
-              missingParams.push("block");
-            }
-          }
-          var returnedObj$2 = item.transaction;
-          if (Utils.$$Array.notEmpty(nonOptionalTransactionFieldNames)) {
-            if (returnedObj$2) {
-              for(var idx$2 = 0 ,idx_finish$2 = nonOptionalTransactionFieldNames.length; idx$2 < idx_finish$2; ++idx$2){
-                var fieldName$2 = nonOptionalTransactionFieldNames[idx$2];
-                var match$2 = returnedObj$2[fieldName$2];
-                if (match$2 !== undefined) {
-                  
-                } else {
-                  missingParams.push("transaction." + fieldName$2);
-                }
-              }
-            } else {
-              missingParams.push("transaction");
-            }
+        }
+      } else {
+        missingParams.push("log");
+      }
+    }
+    let returnedObj$1 = item.block;
+    if (Utils.$$Array.notEmpty(nonOptionalBlockFieldNames)) {
+      if (returnedObj$1) {
+        for (let idx$1 = 0, idx_finish$1 = nonOptionalBlockFieldNames.length; idx$1 < idx_finish$1; ++idx$1) {
+          let fieldName$1 = nonOptionalBlockFieldNames[idx$1];
+          let match$1 = returnedObj$1[fieldName$1];
+          if (match$1 !== undefined) {
+            
+          } else {
+            missingParams.push("block." + fieldName$1);
           }
-          if (missingParams.length !== 0) {
-            throw {
-                  RE_EXN_ID: $$Error,
-                  _1: {
-                    TAG: "UnexpectedMissingParams",
-                    missingParams: missingParams
-                  },
-                  Error: new Error()
-                };
+        }
+      } else {
+        missingParams.push("block");
+      }
+    }
+    let returnedObj$2 = item.transaction;
+    if (Utils.$$Array.notEmpty(nonOptionalTransactionFieldNames)) {
+      if (returnedObj$2) {
+        for (let idx$2 = 0, idx_finish$2 = nonOptionalTransactionFieldNames.length; idx$2 < idx_finish$2; ++idx$2) {
+          let fieldName$2 = nonOptionalTransactionFieldNames[idx$2];
+          let match$2 = returnedObj$2[fieldName$2];
+          if (match$2 !== undefined) {
+            
+          } else {
+            missingParams.push("transaction." + fieldName$2);
           }
-          var logUnsanitized = item.log;
-          var topics = Belt_Array.keepMap(item.log.topics, (function (prim) {
-                  if (prim == null) {
-                    return ;
-                  } else {
-                    return Caml_option.some(prim);
-                  }
-                }));
-          var address = item.log.address;
-          var log_data = logUnsanitized.data;
-          var log_logIndex = logUnsanitized.logIndex;
-          var log = {
-            address: address,
-            data: log_data,
-            topics: topics,
-            logIndex: log_logIndex
-          };
-          return {
-                  log: log,
-                  block: item.block,
-                  transaction: item.transaction
-                };
-        }));
+        }
+      } else {
+        missingParams.push("transaction");
+      }
+    }
+    if (missingParams.length !== 0) {
+      throw {
+        RE_EXN_ID: $$Error,
+        _1: {
+          TAG: "UnexpectedMissingParams",
+          missingParams: missingParams
+        },
+        Error: new Error()
+      };
+    }
+    let logUnsanitized = item.log;
+    let topics = Stdlib_Array.filterMap(item.log.topics, prim => {
+      if (prim == null) {
+        return;
+      } else {
+        return Primitive_option.some(prim);
+      }
+    });
+    let address = item.log.address;
+    let log_data = logUnsanitized.data;
+    let log_logIndex = logUnsanitized.logIndex;
+    let log = {
+      address: address,
+      data: log_data,
+      topics: topics,
+      logIndex: log_logIndex
+    };
+    return {
+      log: log,
+      block: item.block,
+      transaction: item.transaction
+    };
+  });
   return {
-          items: items,
-          nextBlock: res.nextBlock,
-          archiveHeight: Belt_Option.getWithDefault(res.archiveHeight, 0),
-          rollbackGuard: res.rollbackGuard,
-          events: res.data
-        };
+    items: items,
+    nextBlock: res.nextBlock,
+    archiveHeight: Stdlib_Option.getOr(res.archiveHeight, 0),
+    rollbackGuard: res.rollbackGuard,
+    events: res.data
+  };
 }
 
 function makeRequestBody$1(fromBlock, toBlock) {
   return {
-          fromBlock: fromBlock,
-          toBlock: toBlock + 1 | 0,
-          fieldSelection: {
-            block: [
-              "Number",
-              "Hash",
-              "Timestamp"
-            ]
-          },
-          includeAllBlocks: true
-        };
+    fromBlock: fromBlock,
+    toBlock: toBlock + 1 | 0,
+    fieldSelection: {
+      block: [
+        "Number",
+        "Hash",
+        "Timestamp"
+      ]
+    },
+    includeAllBlocks: true
+  };
 }
 
 function convertResponse(res) {
-  return Utils.$$Array.transposeResults(Belt_Array.map(res.data.blocks, (function (block) {
-                    var blockNumber = block.number;
-                    if (blockNumber !== undefined) {
-                      var blockHash = block.hash;
-                      if (blockHash !== undefined) {
-                        var blockTimestamp = block.timestamp;
-                        if (blockTimestamp !== undefined) {
-                          return {
-                                  TAG: "Ok",
-                                  _0: {
-                                    blockHash: blockHash,
-                                    blockNumber: blockNumber,
-                                    blockTimestamp: blockTimestamp
-                                  }
-                                };
-                        }
-                        
-                      }
-                      
-                    }
-                    var missingParams = Belt_Array.keepMap([
-                          Utils.$$Option.mapNone(block.number, "block.number"),
-                          Utils.$$Option.mapNone(block.timestamp, "block.timestamp"),
-                          Utils.$$Option.mapNone(block.hash, "block.hash")
-                        ], (function (p) {
-                            return p;
-                          }));
-                    return {
-                            TAG: "Error",
-                            _0: {
-                              TAG: "UnexpectedMissingParams",
-                              _0: {
-                                queryName: "query block data HyperSync",
-                                missingParams: missingParams
-                              }
-                            }
-                          };
-                  })));
+  return Utils.$$Array.transposeResults(res.data.blocks.map(block => {
+    let blockNumber = block.number;
+    if (blockNumber !== undefined) {
+      let blockHash = block.hash;
+      if (blockHash !== undefined) {
+        let blockTimestamp = block.timestamp;
+        if (blockTimestamp !== undefined) {
+          return {
+            TAG: "Ok",
+            _0: {
+              blockHash: blockHash,
+              blockNumber: blockNumber,
+              blockTimestamp: blockTimestamp
+            }
+          };
+        }
+      }
+    }
+    let missingParams = Stdlib_Array.filterMap([
+      Utils.Option.mapNone(block.number, "block.number"),
+      Utils.Option.mapNone(block.timestamp, "block.timestamp"),
+      Utils.Option.mapNone(block.hash, "block.hash")
+    ], p => p);
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "UnexpectedMissingParams",
+        _0: {
+          queryName: "query block data HyperSync",
+          missingParams: missingParams
+        }
+      }
+    };
+  }));
 }
 
 async function queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger) {
-  var body = makeRequestBody$1(fromBlock, toBlock);
-  var logger$1 = Logging.createChildFrom(logger, {
-        logType: "HyperSync get block hash query",
-        fromBlock: fromBlock,
-        toBlock: toBlock
-      });
+  let body = makeRequestBody$1(fromBlock, toBlock);
+  let logger$1 = Logging.createChildFrom(logger, {
+    logType: "HyperSync get block hash query",
+    fromBlock: fromBlock,
+    toBlock: toBlock
+  });
   Prometheus.SourceRequestCount.increment(sourceName, chainId, "getBlockHashes");
-  var maybeSuccessfulRes;
-  var exit = 0;
-  var res;
+  let maybeSuccessfulRes;
+  let exit = 0;
+  let res;
   try {
     res = await client.get(body);
     exit = 1;
-  }
-  catch (exn){
+  } catch (exn) {
     maybeSuccessfulRes = undefined;
   }
   if (exit === 1) {
     maybeSuccessfulRes = res.nextBlock <= fromBlock ? undefined : res;
   }
   if (maybeSuccessfulRes !== undefined) {
-    var err = convertResponse(maybeSuccessfulRes);
+    let err = convertResponse(maybeSuccessfulRes);
     if (err.TAG !== "Ok") {
       return err;
     }
     if (maybeSuccessfulRes.nextBlock > toBlock) {
       return err;
     }
-    var datas = err._0;
-    var restRes = await queryBlockData(client, maybeSuccessfulRes.nextBlock, toBlock, sourceName, chainId, logger$1);
-    return Belt_Result.map(restRes, (function (rest) {
-                  return Belt_Array.concat(datas, rest);
-                }));
+    let datas = err._0;
+    let restRes = await queryBlockData(client, maybeSuccessfulRes.nextBlock, toBlock, sourceName, chainId, logger$1);
+    return Stdlib_Result.map(restRes, rest => datas.concat(rest));
   }
-  Logging.childInfo(logger$1, "Block #" + String(fromBlock) + " not found in HyperSync. HyperSync has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in " + String(100) + "ms.");
+  Logging.childInfo(logger$1, `Block #` + fromBlock.toString() + ` not found in HyperSync. HyperSync has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ` + (100).toString() + `ms.`);
   await Time.resolvePromiseAfterDelay(100);
   return await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger$1);
 }
 
 async function queryBlockDataMulti(client, blockNumbers, sourceName, chainId, logger) {
-  var firstBlock = Belt_Array.get(blockNumbers, 0);
+  let firstBlock = blockNumbers[0];
   if (firstBlock === undefined) {
     return {
-            TAG: "Ok",
-            _0: []
-          };
+      TAG: "Ok",
+      _0: []
+    };
   }
-  var fromBlock = firstBlock;
-  var toBlock = firstBlock;
-  var set = new Set();
-  for(var idx = 0 ,idx_finish = blockNumbers.length; idx < idx_finish; ++idx){
-    var blockNumber = blockNumbers[idx];
+  let fromBlock = firstBlock;
+  let toBlock = firstBlock;
+  let set = new Set();
+  for (let idx = 0, idx_finish = blockNumbers.length; idx < idx_finish; ++idx) {
+    let blockNumber = blockNumbers[idx];
     if (blockNumber < fromBlock) {
       fromBlock = blockNumber;
     }
@@ -281,41 +275,33 @@ async function queryBlockDataMulti(client, blockNumbers, sourceName, chainId, lo
     set.add(blockNumber);
   }
   if ((toBlock - fromBlock | 0) > 1000) {
-    Js_exn.raiseError("Invalid block data request. Range of block numbers is too large. Max range is 1000. Requested range: " + String(fromBlock) + "-" + String(toBlock));
+    Stdlib_JsError.throwWithMessage(`Invalid block data request. Range of block numbers is too large. Max range is 1000. Requested range: ` + fromBlock.toString() + `-` + toBlock.toString());
   }
-  var res = await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger);
-  var filtered = Belt_Result.map(res, (function (datas) {
-          return Belt_Array.keep(datas, (function (data) {
-                        return set.delete(data.blockNumber);
-                      }));
-        }));
+  let res = await queryBlockData(client, fromBlock, toBlock, sourceName, chainId, logger);
+  let filtered = Stdlib_Result.map(res, datas => datas.filter(data => set.delete(data.blockNumber)));
   if (set.size > 0) {
-    Js_exn.raiseError("Invalid response. Failed to get block data for block numbers: " + Array.from(set).join(", "));
+    Stdlib_JsError.throwWithMessage(`Invalid response. Failed to get block data for block numbers: ` + Array.from(set).join(", "));
   }
   return filtered;
 }
 
 function queryBlockData$1(client, blockNumber, sourceName, chainId, logger) {
-  return queryBlockData(client, blockNumber, blockNumber, sourceName, chainId, logger).then(function (res) {
-              return Belt_Result.map(res, (function (res) {
-                            return Belt_Array.get(res, 0);
-                          }));
-            });
+  return queryBlockData(client, blockNumber, blockNumber, sourceName, chainId, logger).then(res => Stdlib_Result.map(res, res => res[0]));
 }
 
-var Log = {};
+let Log = {};
 
-var GetLogs = {
+let GetLogs = {
   $$Error: $$Error,
   query: query
 };
 
 export {
-  Log ,
-  queryErrorToMsq ,
-  GetLogs ,
+  Log,
+  queryErrorToMsq,
+  GetLogs,
   queryBlockData$1 as queryBlockData,
-  queryBlockDataMulti ,
-  mapExn ,
+  queryBlockDataMulti,
+  mapExn,
 }
 /* Time Not a pure module */

package/src/sources/HyperSyncClient.res

@@ -330,7 +330,6 @@ module ResponseTypes = {
     mixHash?: string,
   }
 
-  @genType
   type accessList = {
     address?: Address.t,
     storageKeys?: array<string>,
@@ -341,7 +340,6 @@ module ResponseTypes = {
     storageKeys: ?s.field("storageKeys", S.option(S.array(S.string))),
   })
 
-  @genType
   type authorizationList = {
     chainId: bigint,
     address: Address.t,
@@ -408,7 +406,7 @@ module ResponseTypes = {
     blockNumber?: int,
     address?: Address.t,
     data?: string,
-    topics?: array<Js.Nullable.t<EvmTypes.Hex.t>>,
+    topics?: array<Nullable.t<EvmTypes.Hex.t>>,
   }
 
   type event = {
@@ -585,10 +583,10 @@ module Decoder = {
   type t = {
     enableChecksummedAddresses: unit => unit,
     disableChecksummedAddresses: unit => unit,
-    decodeLogs: array<log> => promise<array<Js.Nullable.t<decodedEvent>>>,
-    decodeLogsSync: array<log> => array<Js.Nullable.t<decodedEvent>>,
-    decodeEvents: array<ResponseTypes.event> => promise<array<Js.Nullable.t<decodedEvent>>>,
-    decodeEventsSync: array<ResponseTypes.event> => array<Js.Nullable.t<decodedEvent>>,
+    decodeLogs: array<log> => promise<array<Nullable.t<decodedEvent>>>,
+    decodeLogsSync: array<log> => array<Nullable.t<decodedEvent>>,
+    decodeEvents: array<ResponseTypes.event> => promise<array<Nullable.t<decodedEvent>>>,
+    decodeEventsSync: array<ResponseTypes.event> => array<Nullable.t<decodedEvent>>,
   }
 
   @module("@envio-dev/hypersync-client") @scope("Decoder")