envio 2.31.0-alpha.0 → 2.31.0-alpha.2

package/src/SafeCheckpointTracking.res

@@ -0,0 +1,132 @@
+// We need this module to effectively track safe checkpoint id
+// this is very cheap to do in memory, while requires a lot of work on a db
+// especially when save_full_history is enabled.
+// The safe checkpoint id can be used to optimize checkpoints traverse logic and
+// make pruning operation super cheap.
+type t = {
+  checkpointIds: array<int>,
+  checkpointBlockNumbers: array<int>,
+  maxReorgDepth: int,
+}
+
+let make = (
+  ~maxReorgDepth,
+  ~shouldRollbackOnReorg,
+  ~chainReorgCheckpoints: array<Internal.reorgCheckpoint>,
+) => {
+  if maxReorgDepth > 0 && shouldRollbackOnReorg {
+    let checkpointIds = Belt.Array.makeUninitializedUnsafe(chainReorgCheckpoints->Array.length)
+    let checkpointBlockNumbers = Belt.Array.makeUninitializedUnsafe(
+      chainReorgCheckpoints->Array.length,
+    )
+    chainReorgCheckpoints->Js.Array2.forEachi((checkpoint, idx) => {
+      checkpointIds->Belt.Array.setUnsafe(idx, checkpoint.checkpointId)
+      checkpointBlockNumbers->Belt.Array.setUnsafe(idx, checkpoint.blockNumber)
+    })
+    Some({
+      checkpointIds,
+      checkpointBlockNumbers,
+      maxReorgDepth,
+    })
+  } else {
+    None
+  }
+}
+
+let getSafeCheckpointId = (safeCheckpointTracking: t, ~sourceBlockNumber: int) => {
+  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth
+
+  if safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(0) > safeBlockNumber {
+    0
+  } else {
+    let trackingCheckpointsCount = safeCheckpointTracking.checkpointBlockNumbers->Array.length
+    switch trackingCheckpointsCount {
+    | 1 => safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(0)
+    | _ => {
+        let result = ref(None)
+        let idx = ref(1)
+
+        while idx.contents < trackingCheckpointsCount && result.contents === None {
+          if (
+            safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx.contents) >
+              safeBlockNumber
+          ) {
+            result :=
+              Some(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx.contents - 1))
+          }
+          idx := idx.contents + 1
+        }
+
+        switch result.contents {
+        | Some(checkpointId) => checkpointId
+        | None =>
+          safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(trackingCheckpointsCount - 1)
+        }
+      }
+    }
+  }
+}
+
+let updateOnNewBatch = (
+  safeCheckpointTracking: t,
+  ~sourceBlockNumber: int,
+  ~chainId: int,
+  ~batchCheckpointIds: array<int>,
+  ~batchCheckpointBlockNumbers: array<int>,
+  ~batchCheckpointChainIds: array<int>,
+) => {
+  let safeCheckpointId = getSafeCheckpointId(safeCheckpointTracking, ~sourceBlockNumber)
+
+  let mutCheckpointIds = []
+  let mutCheckpointBlockNumbers = []
+
+  // Copy + Clean up old checkpoints
+  for idx in 0 to safeCheckpointTracking.checkpointIds->Array.length - 1 {
+    let checkpointId = safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx)
+    if checkpointId >= safeCheckpointId {
+      mutCheckpointIds->Js.Array2.push(checkpointId)->ignore
+      mutCheckpointBlockNumbers
+      ->Js.Array2.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->ignore
+    }
+  }
+
+  // Append new checkpoints
+  for idx in 0 to batchCheckpointIds->Array.length - 1 {
+    if batchCheckpointChainIds->Belt.Array.getUnsafe(idx) === chainId {
+      mutCheckpointIds->Js.Array2.push(batchCheckpointIds->Belt.Array.getUnsafe(idx))->ignore
+      mutCheckpointBlockNumbers
+      ->Js.Array2.push(batchCheckpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->ignore
+    }
+  }
+
+  {
+    checkpointIds: mutCheckpointIds,
+    checkpointBlockNumbers: mutCheckpointBlockNumbers,
+    maxReorgDepth: safeCheckpointTracking.maxReorgDepth,
+  }
+}
+
+let rollback = (safeCheckpointTracking: t, ~targetBlockNumber: int) => {
+  let mutCheckpointIds = []
+  let mutCheckpointBlockNumbers = []
+
+  for idx in 0 to safeCheckpointTracking.checkpointIds->Array.length - 1 {
+    let blockNumber = safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx)
+    if blockNumber <= targetBlockNumber {
+      mutCheckpointIds
+      ->Js.Array2.push(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx))
+      ->ignore
+      mutCheckpointBlockNumbers
+      ->Js.Array2.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->ignore
+    }
+  }
+
+  {
+    checkpointIds: mutCheckpointIds,
+    checkpointBlockNumbers: mutCheckpointBlockNumbers,
+    maxReorgDepth: safeCheckpointTracking.maxReorgDepth,
+  }
+}

package/src/SafeCheckpointTracking.res.js

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+
+function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
+  if (!(maxReorgDepth > 0 && shouldRollbackOnReorg)) {
+    return ;
+  }
+  var checkpointIds = new Array(chainReorgCheckpoints.length);
+  var checkpointBlockNumbers = new Array(chainReorgCheckpoints.length);
+  chainReorgCheckpoints.forEach(function (checkpoint, idx) {
+        checkpointIds[idx] = checkpoint.id;
+        checkpointBlockNumbers[idx] = checkpoint.block_number;
+      });
+  return {
+          checkpointIds: checkpointIds,
+          checkpointBlockNumbers: checkpointBlockNumbers,
+          maxReorgDepth: maxReorgDepth
+        };
+}
+
+function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
+  var safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
+  if (safeCheckpointTracking.checkpointBlockNumbers[0] > safeBlockNumber) {
+    return 0;
+  }
+  var trackingCheckpointsCount = safeCheckpointTracking.checkpointBlockNumbers.length;
+  if (trackingCheckpointsCount === 1) {
+    return safeCheckpointTracking.checkpointIds[0];
+  }
+  var result;
+  var idx = 1;
+  while(idx < trackingCheckpointsCount && result === undefined) {
+    if (safeCheckpointTracking.checkpointBlockNumbers[idx] > safeBlockNumber) {
+      result = safeCheckpointTracking.checkpointIds[idx - 1 | 0];
+    }
+    idx = idx + 1 | 0;
+  };
+  var checkpointId = result;
+  if (checkpointId !== undefined) {
+    return checkpointId;
+  } else {
+    return safeCheckpointTracking.checkpointIds[trackingCheckpointsCount - 1 | 0];
+  }
+}
+
+function updateOnNewBatch(safeCheckpointTracking, sourceBlockNumber, chainId, batchCheckpointIds, batchCheckpointBlockNumbers, batchCheckpointChainIds) {
+  var safeCheckpointId = getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber);
+  var mutCheckpointIds = [];
+  var mutCheckpointBlockNumbers = [];
+  for(var idx = 0 ,idx_finish = safeCheckpointTracking.checkpointIds.length; idx < idx_finish; ++idx){
+    var checkpointId = safeCheckpointTracking.checkpointIds[idx];
+    if (checkpointId >= safeCheckpointId) {
+      mutCheckpointIds.push(checkpointId);
+      mutCheckpointBlockNumbers.push(safeCheckpointTracking.checkpointBlockNumbers[idx]);
+    }
+    
+  }
+  for(var idx$1 = 0 ,idx_finish$1 = batchCheckpointIds.length; idx$1 < idx_finish$1; ++idx$1){
+    if (batchCheckpointChainIds[idx$1] === chainId) {
+      mutCheckpointIds.push(batchCheckpointIds[idx$1]);
+      mutCheckpointBlockNumbers.push(batchCheckpointBlockNumbers[idx$1]);
+    }
+    
+  }
+  return {
+          checkpointIds: mutCheckpointIds,
+          checkpointBlockNumbers: mutCheckpointBlockNumbers,
+          maxReorgDepth: safeCheckpointTracking.maxReorgDepth
+        };
+}
+
+function rollback(safeCheckpointTracking, targetBlockNumber) {
+  var mutCheckpointIds = [];
+  var mutCheckpointBlockNumbers = [];
+  for(var idx = 0 ,idx_finish = safeCheckpointTracking.checkpointIds.length; idx < idx_finish; ++idx){
+    var blockNumber = safeCheckpointTracking.checkpointBlockNumbers[idx];
+    if (blockNumber <= targetBlockNumber) {
+      mutCheckpointIds.push(safeCheckpointTracking.checkpointIds[idx]);
+      mutCheckpointBlockNumbers.push(safeCheckpointTracking.checkpointBlockNumbers[idx]);
+    }
+    
+  }
+  return {
+          checkpointIds: mutCheckpointIds,
+          checkpointBlockNumbers: mutCheckpointBlockNumbers,
+          maxReorgDepth: safeCheckpointTracking.maxReorgDepth
+        };
+}
+
+exports.make = make;
+exports.getSafeCheckpointId = getSafeCheckpointId;
+exports.updateOnNewBatch = updateOnNewBatch;
+exports.rollback = rollback;
+/* No side effect */

package/src/Utils.res

@@ -97,30 +97,66 @@ module Dict = {
   @val
   external mergeInPlace: (dict<'a>, dict<'a>) => dict<'a> = "Object.assign"
 
-  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)))
+  // Use %raw to support for..in which is a ~10% faster than .forEach
+  let mapValues: (dict<'a>, 'a => 'b) => dict<'b> = %raw(`(dict, f) => {
+    var target = {}, i;
+    for (i in dict) {
+      target[i] = f(dict[i]);
     }
-    newDict
-  }
+    return target;
+  }`)
 
-  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)))
+  // Use %raw to support for..in which is a ~10% faster than .forEach
+  let filterMapValues: (dict<'a>, 'a => option<'b>) => dict<'b> = %raw(`(dict, f) => {
+    var target = {}, i, v;
+    for (i in dict) {
+      v = f(dict[i]);
+      if (v !== undefined) {
+        target[i] = v;
+      }
     }
-  }
+    return target;
+  }`)
 
-  let forEachWithKey = (dict, fn) => {
-    let keys = dict->Js.Dict.keys
-    for idx in 0 to keys->Js.Array2.length - 1 {
-      let key = keys->Js.Array2.unsafe_get(idx)
-      fn(key, dict->Js.Dict.unsafeGet(key))
+  // Use %raw to support for..in which is a ~10% faster than .forEach
+  let mapValuesToArray: (dict<'a>, 'a => 'b) => array<'b> = %raw(`(dict, f) => {
+    var target = [], i;
+    for (i in dict) {
+      target.push(f(dict[i]));
     }
-  }
+    return target;
+  }`)
+
+  // Use %raw to support for..in which is a ~10% faster than .forEach
+  let forEach: (dict<'a>, 'a => unit) => unit = %raw(`(dict, f) => {
+    for (var i in dict) {
+      f(dict[i]);
+    }
+  }`)
+
+  // Use %raw to support for..in which is a ~10% faster than .forEach
+  let forEachWithKey: (dict<'a>, ('a, string) => unit) => unit = %raw(`(dict, f) => {
+    for (var i in dict) {
+      f(dict[i], i);
+    }
+  }`)
+
+  // Use %raw to support for..in which is a ~10% faster than Object.keys
+  let size: dict<'a> => int = %raw(`(dict) => {
+    var size = 0, i;
+    for (i in dict) {
+      size++;
+    }
+    return size;
+  }`)
+
+  // Use %raw to support for..in which is a 2x faster than Object.keys
+  let isEmpty: dict<'a> => bool = %raw(`(dict) => {
+    for (var _ in dict) {
+      return false
+    }
+    return true
+  }`)
 
   let deleteInPlace: (dict<'a>, string) => unit = %raw(`(dict, key) => {
       delete dict[key];
@@ -135,8 +171,6 @@ module Dict = {
 
   let shallowCopy: dict<'a> => dict<'a> = %raw(`(dict) => ({...dict})`)
 
-  let size = dict => dict->Js.Dict.keys->Js.Array2.length
-
   @set_index
   external setByInt: (dict<'a>, int, 'a) => unit = ""
 
@@ -155,6 +189,15 @@ module Math = {
     }
 }
 
+// This is a microoptimization to avoid int32 safeguards
+module UnsafeIntOperators = {
+  external \"*": (int, int) => int = "%mulfloat"
+
+  external \"+": (int, int) => int = "%addfloat"
+
+  external \"-": (int, int) => int = "%subfloat"
+}
+
 module Array = {
   @send
   external forEachAsync: (array<'a>, 'a => promise<unit>) => unit = "forEach"

package/src/Utils.res.js

@@ -93,30 +93,59 @@ function pushMany(dict, key, values) {
 
 var merge = ((dictA, dictB) => ({...dictA, ...dictB}));
 
-function map(dict, fn) {
-  var newDict = {};
-  var keys = Object.keys(dict);
-  for(var idx = 0 ,idx_finish = keys.length; idx < idx_finish; ++idx){
-    var key = keys[idx];
-    newDict[key] = fn(dict[key]);
-  }
-  return newDict;
-}
+var mapValues = ((dict, f) => {
+    var target = {}, i;
+    for (i in dict) {
+      target[i] = f(dict[i]);
+    }
+    return target;
+  });
 
-function forEach(dict, fn) {
-  var keys = Object.keys(dict);
-  for(var idx = 0 ,idx_finish = keys.length; idx < idx_finish; ++idx){
-    fn(dict[keys[idx]]);
-  }
-}
+var filterMapValues = ((dict, f) => {
+    var target = {}, i, v;
+    for (i in dict) {
+      v = f(dict[i]);
+      if (v !== undefined) {
+        target[i] = v;
+      }
+    }
+    return target;
+  });
 
-function forEachWithKey(dict, fn) {
-  var keys = Object.keys(dict);
-  for(var idx = 0 ,idx_finish = keys.length; idx < idx_finish; ++idx){
-    var key = keys[idx];
-    fn(key, dict[key]);
-  }
-}
+var mapValuesToArray = ((dict, f) => {
+    var target = [], i;
+    for (i in dict) {
+      target.push(f(dict[i]));
+    }
+    return target;
+  });
+
+var forEach = ((dict, f) => {
+    for (var i in dict) {
+      f(dict[i]);
+    }
+  });
+
+var forEachWithKey = ((dict, f) => {
+    for (var i in dict) {
+      f(dict[i], i);
+    }
+  });
+
+var size = ((dict) => {
+    var size = 0, i;
+    for (i in dict) {
+      size++;
+    }
+    return size;
+  });
+
+var isEmpty = ((dict) => {
+    for (var _ in dict) {
+      return false
+    }
+    return true
+  });
 
 var deleteInPlace = ((dict, key) => {
       delete dict[key];
@@ -126,10 +155,6 @@ var updateImmutable = ((dict, key, value) => ({...dict, [key]: value}));
 
 var shallowCopy = ((dict) => ({...dict}));
 
-function size(dict) {
-  return Object.keys(dict).length;
-}
-
 var incrementByInt = ((dict, key) => {
     dict[key]++
   });
@@ -139,13 +164,16 @@ var Dict = {
   push: push,
   pushMany: pushMany,
   merge: merge,
-  map: map,
+  mapValues: mapValues,
+  filterMapValues: filterMapValues,
+  mapValuesToArray: mapValuesToArray,
   forEach: forEach,
   forEachWithKey: forEachWithKey,
+  size: size,
+  isEmpty: isEmpty,
   deleteInPlace: deleteInPlace,
   updateImmutable: updateImmutable,
   shallowCopy: shallowCopy,
-  size: size,
   incrementByInt: incrementByInt
 };
 
@@ -169,6 +197,8 @@ var $$Math = {
   minOptInt: minOptInt
 };
 
+var UnsafeIntOperators = {};
+
 function mergeSorted(f, xs, ys) {
   if (xs.length === 0) {
     return ys;
@@ -251,7 +281,7 @@ function includes(arr, val) {
                     })));
 }
 
-function isEmpty(arr) {
+function isEmpty$1(arr) {
   return arr.length === 0;
 }
 
@@ -320,7 +350,7 @@ var $$Array$1 = {
   setIndexImmutable: setIndexImmutable,
   transposeResults: transposeResults,
   includes: includes,
-  isEmpty: isEmpty,
+  isEmpty: isEmpty$1,
   notEmpty: notEmpty,
   awaitEach: awaitEach,
   removeAtIndex: removeAtIndex,
@@ -557,6 +587,7 @@ exports.$$Option = $$Option;
 exports.Tuple = Tuple;
 exports.Dict = Dict;
 exports.$$Math = $$Math;
+exports.UnsafeIntOperators = UnsafeIntOperators;
 exports.$$Array = $$Array$1;
 exports.$$String = $$String;
 exports.Result = Result;