envio 2.28.0-rc.0 → 2.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.28.0-rc.0",
+  "version": "v2.28.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,13 +25,13 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.28.0-rc.0",
-    "envio-linux-arm64": "v2.28.0-rc.0",
-    "envio-darwin-x64": "v2.28.0-rc.0",
-    "envio-darwin-arm64": "v2.28.0-rc.0"
+    "envio-linux-x64": "v2.28.0",
+    "envio-linux-arm64": "v2.28.0",
+    "envio-darwin-x64": "v2.28.0",
+    "envio-darwin-arm64": "v2.28.0"
   },
   "dependencies": {
-    "@envio-dev/hypersync-client": "0.6.5",
+    "@envio-dev/hypersync-client": "0.6.6",
     "rescript": "11.1.3",
     "rescript-schema": "9.3.0",
     "viem": "2.21.0",

package/src/InternalConfig.res

@@ -18,3 +18,13 @@ type chain = {
   contracts: array<contract>,
   sources: array<Source.t>,
 }
+
+type sourceSync = {
+  initialBlockInterval: int,
+  backoffMultiplicative: float,
+  accelerationAdditive: int,
+  intervalCeiling: int,
+  backoffMillis: int,
+  queryTimeoutMillis: int,
+  fallbackStallTimeout: int,
+}

package/src/sources/EventRouter.res

@@ -0,0 +1,113 @@
+open Belt
+
+exception EventDuplicate
+exception WildcardCollision
+
+module Group = {
+  type t<'a> = {
+    mutable wildcard: option<'a>,
+    byContractName: dict<'a>,
+  }
+
+  let empty = () => {
+    wildcard: None,
+    byContractName: Js.Dict.empty(),
+  }
+
+  let addOrThrow = (group: t<'a>, event, ~contractName, ~isWildcard) => {
+    let {byContractName, wildcard} = group
+    switch byContractName->Utils.Dict.dangerouslyGetNonOption(contractName) {
+    | Some(_) => raise(EventDuplicate)
+    | None =>
+      if isWildcard && wildcard->Option.isSome {
+        raise(WildcardCollision)
+      } else {
+        if isWildcard {
+          group.wildcard = Some(event)
+        }
+        byContractName->Js.Dict.set(contractName, event)
+      }
+    }
+  }
+
+  let get = (
+    group: t<'a>,
+    ~contractAddress,
+    ~blockNumber,
+    ~indexingContracts: dict<FetchState.indexingContract>,
+  ) =>
+    switch group {
+    | {wildcard, byContractName} =>
+      switch indexingContracts->Utils.Dict.dangerouslyGetNonOption(
+        contractAddress->Address.toString,
+      ) {
+      | Some(indexingContract) =>
+        if indexingContract.startBlock <= blockNumber {
+          byContractName->Utils.Dict.dangerouslyGetNonOption(indexingContract.contractName)
+        } else {
+          None
+        }
+      | None => wildcard
+      }
+    }
+}
+
+type t<'a> = dict<Group.t<'a>>
+
+let empty = () => Js.Dict.empty()
+
+let addOrThrow = (
+  router: t<'a>,
+  eventId,
+  event,
+  ~contractName,
+  ~isWildcard,
+  ~eventName,
+  ~chain,
+) => {
+  let group = switch router->Utils.Dict.dangerouslyGetNonOption(eventId) {
+  | None =>
+    let group = Group.empty()
+    router->Js.Dict.set(eventId, group)
+    group
+  | Some(group) => group
+  }
+  try group->Group.addOrThrow(event, ~contractName, ~isWildcard) catch {
+  | EventDuplicate =>
+    Js.Exn.raiseError(
+      `Duplicate event detected: ${eventName} for contract ${contractName} on chain ${chain->ChainMap.Chain.toString}`,
+    )
+  | WildcardCollision =>
+    Js.Exn.raiseError(
+      `Another event is already registered with the same signature that would interfer with wildcard filtering: ${eventName} for contract ${contractName} on chain ${chain->ChainMap.Chain.toString}`,
+    )
+  }
+}
+
+let get = (router: t<'a>, ~tag, ~contractAddress, ~blockNumber, ~indexingContracts) => {
+  switch router->Utils.Dict.dangerouslyGetNonOption(tag) {
+  | None => None
+  | Some(group) => group->Group.get(~contractAddress, ~blockNumber, ~indexingContracts)
+  }
+}
+
+let getEvmEventId = (~sighash, ~topicCount) => {
+  sighash ++ "_" ++ topicCount->Belt.Int.toString
+}
+
+let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain): t<
+  Internal.evmEventConfig,
+> => {
+  let router = empty()
+  events->Belt.Array.forEach(config => {
+    router->addOrThrow(
+      config.id,
+      config,
+      ~contractName=config.contractName,
+      ~eventName=config.name,
+      ~chain,
+      ~isWildcard=config.isWildcard,
+    )
+  })
+  router
+}

package/src/sources/EventRouter.res.js

@@ -0,0 +1,125 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var ChainMap = require("../ChainMap.res.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
+var Caml_exceptions = require("rescript/lib/js/caml_exceptions.js");
+var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
+
+var EventDuplicate = /* @__PURE__ */Caml_exceptions.create("EventRouter.EventDuplicate");
+
+var WildcardCollision = /* @__PURE__ */Caml_exceptions.create("EventRouter.WildcardCollision");
+
+function empty() {
+  return {
+          wildcard: undefined,
+          byContractName: {}
+        };
+}
+
+function addOrThrow(group, $$event, contractName, isWildcard) {
+  var wildcard = group.wildcard;
+  var byContractName = group.byContractName;
+  var match = byContractName[contractName];
+  if (match !== undefined) {
+    throw {
+          RE_EXN_ID: EventDuplicate,
+          Error: new Error()
+        };
+  }
+  if (isWildcard && Belt_Option.isSome(wildcard)) {
+    throw {
+          RE_EXN_ID: WildcardCollision,
+          Error: new Error()
+        };
+  }
+  if (isWildcard) {
+    group.wildcard = Caml_option.some($$event);
+  }
+  byContractName[contractName] = $$event;
+}
+
+function get(group, contractAddress, blockNumber, indexingContracts) {
+  var wildcard = group.wildcard;
+  var indexingContract = indexingContracts[contractAddress];
+  if (indexingContract !== undefined) {
+    if (indexingContract.startBlock <= blockNumber) {
+      return group.byContractName[indexingContract.contractName];
+    } else {
+      return ;
+    }
+  } else {
+    return wildcard;
+  }
+}
+
+var Group = {
+  empty: empty,
+  addOrThrow: addOrThrow,
+  get: get
+};
+
+function empty$1() {
+  return {};
+}
+
+function addOrThrow$1(router, eventId, $$event, contractName, isWildcard, eventName, chain) {
+  var group = router[eventId];
+  var group$1;
+  if (group !== undefined) {
+    group$1 = group;
+  } else {
+    var group$2 = {
+      wildcard: undefined,
+      byContractName: {}
+    };
+    router[eventId] = group$2;
+    group$1 = group$2;
+  }
+  try {
+    return addOrThrow(group$1, $$event, contractName, isWildcard);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === EventDuplicate) {
+      return Js_exn.raiseError("Duplicate event detected: " + eventName + " for contract " + contractName + " on chain " + ChainMap.Chain.toString(chain));
+    }
+    if (exn.RE_EXN_ID === WildcardCollision) {
+      return Js_exn.raiseError("Another event is already registered with the same signature that would interfer with wildcard filtering: " + eventName + " for contract " + contractName + " on chain " + ChainMap.Chain.toString(chain));
+    }
+    throw exn;
+  }
+}
+
+function get$1(router, tag, contractAddress, blockNumber, indexingContracts) {
+  var group = router[tag];
+  if (group !== undefined) {
+    return get(group, contractAddress, blockNumber, indexingContracts);
+  }
+  
+}
+
+function getEvmEventId(sighash, topicCount) {
+  return sighash + "_" + String(topicCount);
+}
+
+function fromEvmEventModsOrThrow(events, chain) {
+  var router = {};
+  Belt_Array.forEach(events, (function (config) {
+          addOrThrow$1(router, config.id, config, config.contractName, config.isWildcard, config.name, chain);
+        }));
+  return router;
+}
+
+exports.EventDuplicate = EventDuplicate;
+exports.WildcardCollision = WildcardCollision;
+exports.Group = Group;
+exports.empty = empty$1;
+exports.addOrThrow = addOrThrow$1;
+exports.get = get$1;
+exports.getEvmEventId = getEvmEventId;
+exports.fromEvmEventModsOrThrow = fromEvmEventModsOrThrow;
+/* ChainMap Not a pure module */

package/src/sources/HyperSync.res

@@ -76,15 +76,23 @@ module GetLogs = {
     fieldSelection,
   }
 
+  @inline
   let addMissingParams = (acc, fieldNames, returnedObj, ~prefix) => {
-    fieldNames->Array.forEach(fieldName => {
-      switch returnedObj
-      ->(Utils.magic: 'a => Js.Dict.t<unknown>)
-      ->Utils.Dict.dangerouslyGetNonOption(fieldName) {
-      | Some(_) => ()
-      | None => acc->Array.push(prefix ++ "." ++ fieldName)->ignore
+    if fieldNames->Utils.Array.notEmpty {
+      if !(returnedObj->Obj.magic) {
+        acc->Array.push(prefix)->ignore
+      } else {
+        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.Dict.dangerouslyGetNonOption(fieldName) {
+          | Some(_) => ()
+          | None => acc->Array.push(prefix ++ "." ++ fieldName)->ignore
+          }
+        }
       }
-    })
+    }
   }
 
   //Note this function can throw an error

package/src/sources/HyperSync.res.js

@@ -57,18 +57,6 @@ function makeRequestBody(fromBlock, toBlockInclusive, addressesWithTopics, field
         };
 }
 
-function addMissingParams(acc, fieldNames, returnedObj, prefix) {
-  Belt_Array.forEach(fieldNames, (function (fieldName) {
-          var match = returnedObj[fieldName];
-          if (match !== undefined) {
-            return ;
-          } else {
-            acc.push(prefix + "." + fieldName);
-            return ;
-          }
-        }));
-}
-
 async function query(client, fromBlock, toBlock, logSelections, fieldSelection, nonOptionalBlockFieldNames, nonOptionalTransactionFieldNames) {
   var addressesWithTopics = Belt_Array.flatMap(logSelections, (function (param) {
           var addresses = param.addresses;
@@ -88,9 +76,54 @@ async function query(client, fromBlock, toBlock, logSelections, fieldSelection,
   }
   var items = Belt_Array.map(res.data, (function (item) {
           var missingParams = [];
-          addMissingParams(missingParams, fieldNames, item.log, "log");
-          addMissingParams(missingParams, nonOptionalBlockFieldNames, item.block, "block");
-          addMissingParams(missingParams, nonOptionalTransactionFieldNames, item.transaction, "transaction");
+          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");
+            }
+          }
+          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");
+            }
+          }
           if (missingParams.length !== 0) {
             throw {
                   RE_EXN_ID: $$Error,

package/src/sources/HyperSyncClient.res

@@ -447,10 +447,9 @@ type t = {
   streamEvents: (~query: query, ~config: streamConfig) => promise<eventStream>,
 }
 
-@module("@envio-dev/hypersync-client") @scope("HypersyncClient") external new: cfg => t = "new"
-
+@module("@envio-dev/hypersync-client") @scope("HypersyncClient") external make: cfg => t = "new"
 let make = (~url, ~apiToken, ~httpReqTimeoutMillis, ~maxNumRetries) =>
-  new({
+  make({
     url,
     enableChecksumAddresses: true,
     bearerToken: apiToken,
@@ -503,4 +502,6 @@ module Decoder = {
 
   @module("@envio-dev/hypersync-client") @scope("Decoder")
   external fromSignatures: array<string> => t = "fromSignatures"
+  // Keep the @envio-dev/hypersync-client import inside of the package
+  let fromSignatures = fromSignatures
 }

package/src/sources/HyperSyncClient.res.js

@@ -88,8 +88,13 @@ function toUnderlying(_d) {
   };
 }
 
+function fromSignatures(prim) {
+  return HypersyncClient.Decoder.fromSignatures(prim);
+}
+
 var Decoder = {
-  toUnderlying: toUnderlying
+  toUnderlying: toUnderlying,
+  fromSignatures: fromSignatures
 };
 
 exports.QueryTypes = QueryTypes;