envio 2.11.7 → 2.11.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.11.7",
+  "version": "v2.11.9",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "repository": {
@@ -23,10 +23,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.11.7",
-    "envio-linux-arm64": "v2.11.7",
-    "envio-darwin-x64": "v2.11.7",
-    "envio-darwin-arm64": "v2.11.7"
+    "envio-linux-x64": "v2.11.9",
+    "envio-linux-arm64": "v2.11.9",
+    "envio-darwin-x64": "v2.11.9",
+    "envio-darwin-arm64": "v2.11.9"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.3",

package/src/ReorgDetection.res

@@ -11,6 +11,11 @@ type blockData = {
   blockTimestamp: int,
 }
 
+type reorgGuard = {
+  lastBlockScannedData: blockData,
+  firstBlockParentNumberAndHash: option<blockNumberAndHash>,
+}
+
 module LastBlockScannedHashes: {
   type t
   /**Instantiat t with existing data*/
@@ -69,7 +74,7 @@ module LastBlockScannedHashes: {
 
   let getAllBlockNumbers: t => Belt.Array.t<int>
 
-  let hasReorgOccurred: (t, ~firstBlockParentNumberAndHash: option<blockNumberAndHash>) => bool
+  let hasReorgOccurred: (t, ~reorgGuard: reorgGuard) => bool
 
   /**
   Return a BlockNumbersAndHashes.t rolled back to where blockData is less
@@ -402,31 +407,34 @@ module LastBlockScannedHashes: {
   /**
   Checks whether reorg has occured by comparing the parent hash with the last saved block hash.
   */
-  let rec hasReorgOccurredInternal = (
-    lastBlockScannedDataList,
-    ~firstBlockParentNumberAndHash: option<blockNumberAndHash>,
-  ) => {
-    switch (firstBlockParentNumberAndHash, lastBlockScannedDataList) {
-    | (Some({blockHash: parentHash, blockNumber: parentBlockNumber}), list{head, ...tail}) =>
-      if parentBlockNumber == head.blockNumber {
-        parentHash != head.blockHash
-      } else {
-        //if block numbers do not match, this is a dynamic contract case and should recurse
-        //through the list to look for a matching block or nothing to validate
-        tail->hasReorgOccurredInternal(~firstBlockParentNumberAndHash)
-      }
-    | _ => //If parentHash is None, either it's the genesis block (no reorg)
+  let rec hasReorgOccurredInternal = (lastBlockScannedDataList, ~reorgGuard: reorgGuard) => {
+    switch lastBlockScannedDataList {
+    | list{head, ...tail} =>
+      switch reorgGuard {
+      | {lastBlockScannedData} if lastBlockScannedData.blockNumber == head.blockNumber =>
+        lastBlockScannedData.blockHash != head.blockHash
+      //If parentHash is None, either it's the genesis block (no reorg)
       //Or its already confirmed so no Reorg
-      //If recentLastBlockData is None, we have not yet saved blockData to compare against
-      false
+      | {firstBlockParentNumberAndHash: None} => false
+      | {
+          firstBlockParentNumberAndHash: Some({
+            blockHash: parentHash,
+            blockNumber: parentBlockNumber,
+          }),
+        } =>
+        if parentBlockNumber == head.blockNumber {
+          parentHash != head.blockHash
+        } else {
+          //if block numbers do not match, this is a dynamic contract case and should recurse
+          //through the list to look for a matching block or nothing to validate
+          tail->hasReorgOccurredInternal(~reorgGuard)
+        }
+      }
+    //If recentLastBlockData is None, we have not yet saved blockData to compare against
+    | _ => false
     }
   }
 
-  let hasReorgOccurred = (
-    lastBlockScannedHashes: t,
-    ~firstBlockParentNumberAndHash: option<blockNumberAndHash>,
-  ) =>
-    lastBlockScannedHashes.lastBlockScannedDataList->hasReorgOccurredInternal(
-      ~firstBlockParentNumberAndHash,
-    )
+  let hasReorgOccurred = (lastBlockScannedHashes: t, ~reorgGuard: reorgGuard) =>
+    lastBlockScannedHashes.lastBlockScannedDataList->hasReorgOccurredInternal(~reorgGuard)
 }

package/src/Utils.res

@@ -52,11 +52,35 @@ module Dict = {
 
   let merge: (dict<'a>, dict<'a>) => dict<'a> = %raw(`(dictA, dictB) => ({...dictA, ...dictB})`)
 
+  let map = (dict, fn) => {
+    let newDict = Js.Dict.empty()
+    let keys = dict->Js.Dict.keys
+    for idx in 0 to keys->Js.Array2.length - 1 {
+      let key = keys->Js.Array2.unsafe_get(idx)
+      newDict->Js.Dict.set(key, fn(dict->Js.Dict.unsafeGet(key)))
+    }
+    newDict
+  }
+
+  let forEach = (dict, fn) => {
+    let keys = dict->Js.Dict.keys
+    for idx in 0 to keys->Js.Array2.length - 1 {
+      fn(dict->Js.Dict.unsafeGet(keys->Js.Array2.unsafe_get(idx)))
+    }
+  }
+
+  let deleteInPlace: (dict<'a>, string) => unit = %raw(`(dict, key) => {
+      delete dict[key];
+    }
+  `)
+
   let updateImmutable: (
     dict<'a>,
     string,
     'a,
   ) => dict<'a> = %raw(`(dict, key, value) => ({...dict, [key]: value})`)
+
+  let shallowCopy: dict<'a> => dict<'a> = %raw(`(dict) => ({...dict})`)
 }
 
 module Math = {
@@ -156,12 +180,12 @@ Helper to check if a value exists in an array
   Index > array length or < 0 results in a copy of the array
   */
   let removeAtIndex = (array, index) => {
-    if index < 0 || index >= array->Array.length {
+    if index < 0 {
       array->Array.copy
     } else {
-      let head = array->Js.Array2.slice(~start=0, ~end_=index)
-      let tail = array->Belt.Array.sliceToEnd(index + 1)
-      Belt.Array.concat(head, tail)
+      array
+      ->Js.Array2.slice(~start=0, ~end_=index)
+      ->Js.Array2.concat(array->Js.Array2.sliceFrom(index + 1))
     }
   }
 
@@ -205,6 +229,9 @@ Helper to check if a value exists in an array
     })
     interleaved
   }
+
+  @send
+  external flatten: (array<array<'a>>, @as(1) _) => array<'a> = "flat"
 }
 
 module String = {
@@ -214,6 +241,16 @@ module String = {
   }
 }
 
+module Result = {
+  let forEach = (result, fn) => {
+    switch result {
+    | Ok(v) => fn(v)
+    | Error(_) => ()
+    }
+    result
+  }
+}
+
 /**
 Useful when an unsafe unwrap is needed on Result type
 and Error holds an exn. This is better than Result.getExn