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

package/src/ReorgDetection.res

@@ -1,5 +1,3 @@
-open Belt
-
 type blockDataWithTimestamp = {
   blockHash: string,
   blockNumber: int,
@@ -58,7 +56,7 @@ let make = (
   ~maxReorgDepth,
   ~shouldRollbackOnReorg,
 ) => {
-  let dataByBlockNumber = Js.Dict.empty()
+  let dataByBlockNumber = Dict.make()
 
   chainReorgCheckpoints->Belt.Array.forEach(block => {
     dataByBlockNumber->Utils.Dict.setByInt(
@@ -79,17 +77,17 @@ let make = (
 
 let getDataByBlockNumberCopyInThreshold = ({dataByBlockNumber, maxReorgDepth}: t, ~knownHeight) => {
   // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
+  let ascBlockNumberKeys = dataByBlockNumber->Dict.keysToArray
   let thresholdBlockNumber = knownHeight - maxReorgDepth
 
-  let copy = Js.Dict.empty()
+  let copy = Dict.make()
 
   for idx in 0 to ascBlockNumberKeys->Array.length - 1 {
-    let blockNumberKey = ascBlockNumberKeys->Js.Array2.unsafe_get(idx)
-    let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+    let blockNumberKey = ascBlockNumberKeys->Array.getUnsafe(idx)
+    let scannedBlock = dataByBlockNumber->Dict.getUnsafe(blockNumberKey)
     let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber
     if isInReorgThreshold {
-      copy->Js.Dict.set(blockNumberKey, scannedBlock)
+      copy->Dict.set(blockNumberKey, scannedBlock)
     }
   }
 
@@ -143,14 +141,14 @@ let registerReorgGuard = (
       ReorgDetected(reorgDetected),
     )
   | None => {
-      dataByBlockNumberCopyInThreshold->Js.Dict.set(
+      dataByBlockNumberCopyInThreshold->Dict.set(
         rangeLastBlock.blockNumber->Int.toString,
         rangeLastBlock,
       )
       switch prevRangeLastBlock {
       | None => ()
       | Some(prevRangeLastBlock) =>
-        dataByBlockNumberCopyInThreshold->Js.Dict.set(
+        dataByBlockNumberCopyInThreshold->Dict.set(
           prevRangeLastBlock.blockNumber->Int.toString,
           prevRangeLastBlock,
         )
@@ -176,19 +174,19 @@ let getLatestValidScannedBlock = (
   reorgDetection: t,
   ~blockNumbersAndHashes: array<blockDataWithTimestamp>,
 ) => {
-  let verifiedDataByBlockNumber = Js.Dict.empty()
+  let verifiedDataByBlockNumber = Dict.make()
   for idx in 0 to blockNumbersAndHashes->Array.length - 1 {
     let blockData = blockNumbersAndHashes->Array.getUnsafe(idx)
-    verifiedDataByBlockNumber->Js.Dict.set(blockData.blockNumber->Int.toString, blockData)
+    verifiedDataByBlockNumber->Dict.set(blockData.blockNumber->Int.toString, blockData)
   }
   // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = verifiedDataByBlockNumber->Js.Dict.keys
+  let ascBlockNumberKeys = verifiedDataByBlockNumber->Dict.keysToArray
 
   let getPrevScannedBlockNumber = idx =>
     ascBlockNumberKeys
     ->Belt.Array.get(idx - 1)
     ->Option.map(key => {
-      (verifiedDataByBlockNumber->Js.Dict.unsafeGet(key)).blockNumber
+      (verifiedDataByBlockNumber->Dict.getUnsafe(key)).blockNumber
     })
 
   let rec loop = idx => {
@@ -196,7 +194,7 @@ let getLatestValidScannedBlock = (
     | Some(blockNumberKey) =>
       switch reorgDetection.dataByBlockNumber->Utils.Dict.dangerouslyGetNonOption(blockNumberKey) {
       | Some(scannedBlock)
-        if (verifiedDataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)).blockHash ===
+        if (verifiedDataByBlockNumber->Dict.getUnsafe(blockNumberKey)).blockHash ===
           scannedBlock.blockHash =>
         loop(idx + 1)
       | _ => getPrevScannedBlockNumber(idx)
@@ -216,17 +214,17 @@ let rollbackToValidBlockNumber = (
   ~blockNumber: int,
 ) => {
   // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = dataByBlockNumber->Js.Dict.keys
+  let ascBlockNumberKeys = dataByBlockNumber->Dict.keysToArray
 
-  let newDataByBlockNumber = Js.Dict.empty()
+  let newDataByBlockNumber = Dict.make()
 
   let rec loop = idx => {
     switch ascBlockNumberKeys->Belt.Array.get(idx) {
     | Some(blockNumberKey) => {
-        let scannedBlock = dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+        let scannedBlock = dataByBlockNumber->Dict.getUnsafe(blockNumberKey)
         let shouldKeep = scannedBlock.blockNumber <= blockNumber
         if shouldKeep {
-          newDataByBlockNumber->Js.Dict.set(blockNumberKey, scannedBlock)
+          newDataByBlockNumber->Dict.set(blockNumberKey, scannedBlock)
           loop(idx + 1)
         } else {
           ()
@@ -248,12 +246,12 @@ let getThresholdBlockNumbersBelowBlock = (self: t, ~blockNumber: int, ~knownHeig
   let arr = []
 
   // Js engine automatically orders numeric object keys
-  let ascBlockNumberKeys = self.dataByBlockNumber->Js.Dict.keys
+  let ascBlockNumberKeys = self.dataByBlockNumber->Dict.keysToArray
   let thresholdBlockNumber = knownHeight - self.maxReorgDepth
 
   for idx in 0 to ascBlockNumberKeys->Array.length - 1 {
-    let blockNumberKey = ascBlockNumberKeys->Js.Array2.unsafe_get(idx)
-    let scannedBlock = self.dataByBlockNumber->Js.Dict.unsafeGet(blockNumberKey)
+    let blockNumberKey = ascBlockNumberKeys->Array.getUnsafe(idx)
+    let scannedBlock = self.dataByBlockNumber->Dict.getUnsafe(blockNumberKey)
     let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber
     if isInReorgThreshold && scannedBlock.blockNumber < blockNumber {
       arr->Array.push(scannedBlock.blockNumber)
@@ -264,7 +262,7 @@ let getThresholdBlockNumbersBelowBlock = (self: t, ~blockNumber: int, ~knownHeig
 
 let getHashByBlockNumber = (reorgDetection: t, ~blockNumber) => {
   switch reorgDetection.dataByBlockNumber->Utils.Dict.dangerouslyGetByIntNonOption(blockNumber) {
-  | Some(v) => Js.Null.Value(v.blockHash)
-  | None => Js.Null.Null
+  | Some(v) => Null.Value(v.blockHash)
+  | None => Null.Null
   }
 }

package/src/ReorgDetection.res.mjs

@@ -1,61 +1,60 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function reorgDetectedToLogParams(reorgDetected, shouldRollbackOnReorg) {
-  var scannedBlock = reorgDetected.scannedBlock;
+  let scannedBlock = reorgDetected.scannedBlock;
   return {
-          msg: "Blockchain reorg detected. " + (
-            shouldRollbackOnReorg ? "Initiating indexer rollback" : "NOT initiating indexer rollback due to configuration"
-          ) + ".",
-          blockNumber: scannedBlock.blockNumber,
-          indexedBlockHash: scannedBlock.blockHash,
-          receivedBlockHash: reorgDetected.receivedBlock.blockHash
-        };
+    msg: `Blockchain reorg detected. ` + (
+      shouldRollbackOnReorg ? "Initiating indexer rollback" : "NOT initiating indexer rollback due to configuration"
+    ) + `.`,
+    blockNumber: scannedBlock.blockNumber,
+    indexedBlockHash: scannedBlock.blockHash,
+    receivedBlockHash: reorgDetected.receivedBlock.blockHash
+  };
 }
 
 function make(chainReorgCheckpoints, maxReorgDepth, shouldRollbackOnReorg) {
-  var dataByBlockNumber = {};
-  Belt_Array.forEach(chainReorgCheckpoints, (function (block) {
-          dataByBlockNumber[block.block_number] = {
-            blockHash: block.block_hash,
-            blockNumber: block.block_number
-          };
-        }));
+  let dataByBlockNumber = {};
+  Belt_Array.forEach(chainReorgCheckpoints, block => {
+    dataByBlockNumber[block.block_number] = {
+      blockHash: block.block_hash,
+      blockNumber: block.block_number
+    };
+  });
   return {
-          shouldRollbackOnReorg: shouldRollbackOnReorg,
-          maxReorgDepth: maxReorgDepth,
-          dataByBlockNumber: dataByBlockNumber
-        };
+    shouldRollbackOnReorg: shouldRollbackOnReorg,
+    maxReorgDepth: maxReorgDepth,
+    dataByBlockNumber: dataByBlockNumber
+  };
 }
 
 function getDataByBlockNumberCopyInThreshold(param, knownHeight) {
-  var dataByBlockNumber = param.dataByBlockNumber;
-  var ascBlockNumberKeys = Object.keys(dataByBlockNumber);
-  var thresholdBlockNumber = knownHeight - param.maxReorgDepth | 0;
-  var copy = {};
-  for(var idx = 0 ,idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx){
-    var blockNumberKey = ascBlockNumberKeys[idx];
-    var scannedBlock = dataByBlockNumber[blockNumberKey];
-    var isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
+  let dataByBlockNumber = param.dataByBlockNumber;
+  let ascBlockNumberKeys = Object.keys(dataByBlockNumber);
+  let thresholdBlockNumber = knownHeight - param.maxReorgDepth | 0;
+  let copy = {};
+  for (let idx = 0, idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx) {
+    let blockNumberKey = ascBlockNumberKeys[idx];
+    let scannedBlock = dataByBlockNumber[blockNumberKey];
+    let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
     if (isInReorgThreshold) {
       copy[blockNumberKey] = scannedBlock;
     }
-    
   }
   return copy;
 }
 
 function registerReorgGuard(self, reorgGuard, knownHeight) {
-  var maxReorgDepth = self.maxReorgDepth;
-  var shouldRollbackOnReorg = self.shouldRollbackOnReorg;
-  var dataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshold(self, knownHeight);
-  var prevRangeLastBlock = reorgGuard.prevRangeLastBlock;
-  var rangeLastBlock = reorgGuard.rangeLastBlock;
-  var scannedBlock = dataByBlockNumberCopyInThreshold[String(rangeLastBlock.blockNumber)];
-  var maybeReorgDetected;
-  var exit = 0;
+  let maxReorgDepth = self.maxReorgDepth;
+  let shouldRollbackOnReorg = self.shouldRollbackOnReorg;
+  let dataByBlockNumberCopyInThreshold = getDataByBlockNumberCopyInThreshold(self, knownHeight);
+  let prevRangeLastBlock = reorgGuard.prevRangeLastBlock;
+  let rangeLastBlock = reorgGuard.rangeLastBlock;
+  let scannedBlock = dataByBlockNumberCopyInThreshold[rangeLastBlock.blockNumber.toString()];
+  let maybeReorgDetected;
+  let exit = 0;
   if (scannedBlock !== undefined && scannedBlock.blockHash !== rangeLastBlock.blockHash) {
     maybeReorgDetected = {
       scannedBlock: scannedBlock,
@@ -66,59 +65,55 @@ function registerReorgGuard(self, reorgGuard, knownHeight) {
   }
   if (exit === 1) {
     if (prevRangeLastBlock !== undefined) {
-      var scannedBlock$1 = dataByBlockNumberCopyInThreshold[String(prevRangeLastBlock.blockNumber)];
+      let scannedBlock$1 = dataByBlockNumberCopyInThreshold[prevRangeLastBlock.blockNumber.toString()];
       maybeReorgDetected = scannedBlock$1 !== undefined && scannedBlock$1.blockHash !== prevRangeLastBlock.blockHash ? ({
-            scannedBlock: scannedBlock$1,
-            receivedBlock: prevRangeLastBlock
-          }) : undefined;
+          scannedBlock: scannedBlock$1,
+          receivedBlock: prevRangeLastBlock
+        }) : undefined;
     } else {
       maybeReorgDetected = undefined;
     }
   }
   if (maybeReorgDetected !== undefined) {
     return [
-            shouldRollbackOnReorg ? self : make([], maxReorgDepth, shouldRollbackOnReorg),
-            {
-              TAG: "ReorgDetected",
-              _0: maybeReorgDetected
-            }
-          ];
+      shouldRollbackOnReorg ? self : make([], maxReorgDepth, shouldRollbackOnReorg),
+      {
+        TAG: "ReorgDetected",
+        _0: maybeReorgDetected
+      }
+    ];
   } else {
-    dataByBlockNumberCopyInThreshold[String(rangeLastBlock.blockNumber)] = rangeLastBlock;
+    dataByBlockNumberCopyInThreshold[rangeLastBlock.blockNumber.toString()] = rangeLastBlock;
     if (prevRangeLastBlock !== undefined) {
-      dataByBlockNumberCopyInThreshold[String(prevRangeLastBlock.blockNumber)] = prevRangeLastBlock;
+      dataByBlockNumberCopyInThreshold[prevRangeLastBlock.blockNumber.toString()] = prevRangeLastBlock;
     }
     return [
-            {
-              shouldRollbackOnReorg: shouldRollbackOnReorg,
-              maxReorgDepth: maxReorgDepth,
-              dataByBlockNumber: dataByBlockNumberCopyInThreshold
-            },
-            "NoReorg"
-          ];
+      {
+        shouldRollbackOnReorg: shouldRollbackOnReorg,
+        maxReorgDepth: maxReorgDepth,
+        dataByBlockNumber: dataByBlockNumberCopyInThreshold
+      },
+      "NoReorg"
+    ];
   }
 }
 
 function getLatestValidScannedBlock(reorgDetection, blockNumbersAndHashes) {
-  var verifiedDataByBlockNumber = {};
-  for(var idx = 0 ,idx_finish = blockNumbersAndHashes.length; idx < idx_finish; ++idx){
-    var blockData = blockNumbersAndHashes[idx];
-    verifiedDataByBlockNumber[String(blockData.blockNumber)] = blockData;
+  let verifiedDataByBlockNumber = {};
+  for (let idx = 0, idx_finish = blockNumbersAndHashes.length; idx < idx_finish; ++idx) {
+    let blockData = blockNumbersAndHashes[idx];
+    verifiedDataByBlockNumber[blockData.blockNumber.toString()] = blockData;
   }
-  var ascBlockNumberKeys = Object.keys(verifiedDataByBlockNumber);
-  var getPrevScannedBlockNumber = function (idx) {
-    return Belt_Option.map(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), (function (key) {
-                  return verifiedDataByBlockNumber[key].blockNumber;
-                }));
-  };
-  var _idx = 0;
-  while(true) {
-    var idx$1 = _idx;
-    var blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx$1);
+  let ascBlockNumberKeys = Object.keys(verifiedDataByBlockNumber);
+  let getPrevScannedBlockNumber = idx => Stdlib_Option.map(Belt_Array.get(ascBlockNumberKeys, idx - 1 | 0), key => verifiedDataByBlockNumber[key].blockNumber);
+  let _idx = 0;
+  while (true) {
+    let idx$1 = _idx;
+    let blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx$1);
     if (blockNumberKey === undefined) {
       return getPrevScannedBlockNumber(idx$1);
     }
-    var scannedBlock = reorgDetection.dataByBlockNumber[blockNumberKey];
+    let scannedBlock = reorgDetection.dataByBlockNumber[blockNumberKey];
     if (scannedBlock === undefined) {
       return getPrevScannedBlockNumber(idx$1);
     }
@@ -126,57 +121,56 @@ function getLatestValidScannedBlock(reorgDetection, blockNumbersAndHashes) {
       return getPrevScannedBlockNumber(idx$1);
     }
     _idx = idx$1 + 1 | 0;
-    continue ;
+    continue;
   };
 }
 
 function rollbackToValidBlockNumber(param, blockNumber) {
-  var dataByBlockNumber = param.dataByBlockNumber;
-  var ascBlockNumberKeys = Object.keys(dataByBlockNumber);
-  var newDataByBlockNumber = {};
-  var loop = function (_idx) {
-    while(true) {
-      var idx = _idx;
-      var blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx);
+  let dataByBlockNumber = param.dataByBlockNumber;
+  let ascBlockNumberKeys = Object.keys(dataByBlockNumber);
+  let newDataByBlockNumber = {};
+  let loop = _idx => {
+    while (true) {
+      let idx = _idx;
+      let blockNumberKey = Belt_Array.get(ascBlockNumberKeys, idx);
       if (blockNumberKey === undefined) {
-        return ;
+        return;
       }
-      var scannedBlock = dataByBlockNumber[blockNumberKey];
-      var shouldKeep = scannedBlock.blockNumber <= blockNumber;
+      let scannedBlock = dataByBlockNumber[blockNumberKey];
+      let shouldKeep = scannedBlock.blockNumber <= blockNumber;
       if (!shouldKeep) {
-        return ;
+        return;
       }
       newDataByBlockNumber[blockNumberKey] = scannedBlock;
       _idx = idx + 1 | 0;
-      continue ;
+      continue;
     };
   };
   loop(0);
   return {
-          shouldRollbackOnReorg: param.shouldRollbackOnReorg,
-          maxReorgDepth: param.maxReorgDepth,
-          dataByBlockNumber: newDataByBlockNumber
-        };
+    shouldRollbackOnReorg: param.shouldRollbackOnReorg,
+    maxReorgDepth: param.maxReorgDepth,
+    dataByBlockNumber: newDataByBlockNumber
+  };
 }
 
 function getThresholdBlockNumbersBelowBlock(self, blockNumber, knownHeight) {
-  var arr = [];
-  var ascBlockNumberKeys = Object.keys(self.dataByBlockNumber);
-  var thresholdBlockNumber = knownHeight - self.maxReorgDepth | 0;
-  for(var idx = 0 ,idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx){
-    var blockNumberKey = ascBlockNumberKeys[idx];
-    var scannedBlock = self.dataByBlockNumber[blockNumberKey];
-    var isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
+  let arr = [];
+  let ascBlockNumberKeys = Object.keys(self.dataByBlockNumber);
+  let thresholdBlockNumber = knownHeight - self.maxReorgDepth | 0;
+  for (let idx = 0, idx_finish = ascBlockNumberKeys.length; idx < idx_finish; ++idx) {
+    let blockNumberKey = ascBlockNumberKeys[idx];
+    let scannedBlock = self.dataByBlockNumber[blockNumberKey];
+    let isInReorgThreshold = scannedBlock.blockNumber >= thresholdBlockNumber;
     if (isInReorgThreshold && scannedBlock.blockNumber < blockNumber) {
       arr.push(scannedBlock.blockNumber);
     }
-    
   }
   return arr;
 }
 
 function getHashByBlockNumber(reorgDetection, blockNumber) {
-  var v = reorgDetection.dataByBlockNumber[blockNumber];
+  let v = reorgDetection.dataByBlockNumber[blockNumber];
   if (v !== undefined) {
     return v.blockHash;
   } else {
@@ -185,13 +179,13 @@ function getHashByBlockNumber(reorgDetection, blockNumber) {
 }
 
 export {
-  reorgDetectedToLogParams ,
-  make ,
-  getDataByBlockNumberCopyInThreshold ,
-  registerReorgGuard ,
-  getLatestValidScannedBlock ,
-  rollbackToValidBlockNumber ,
-  getThresholdBlockNumbersBelowBlock ,
-  getHashByBlockNumber ,
+  reorgDetectedToLogParams,
+  make,
+  getDataByBlockNumberCopyInThreshold,
+  registerReorgGuard,
+  getLatestValidScannedBlock,
+  rollbackToValidBlockNumber,
+  getThresholdBlockNumbersBelowBlock,
+  getHashByBlockNumber,
 }
 /* No side effect */

package/src/SafeCheckpointTracking.res

@@ -19,7 +19,7 @@ let make = (
     let checkpointBlockNumbers = Belt.Array.makeUninitializedUnsafe(
       chainReorgCheckpoints->Array.length,
     )
-    chainReorgCheckpoints->Js.Array2.forEachi((checkpoint, idx) => {
+    chainReorgCheckpoints->Array.forEachWithIndex((checkpoint, idx) => {
       checkpointIds->Belt.Array.setUnsafe(idx, checkpoint.checkpointId)
       checkpointBlockNumbers->Belt.Array.setUnsafe(idx, checkpoint.blockNumber)
     })
@@ -84,9 +84,9 @@ let updateOnNewBatch = (
   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
+      mutCheckpointIds->Array.push(checkpointId)->ignore
       mutCheckpointBlockNumbers
-      ->Js.Array2.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->Array.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
       ->ignore
     }
   }
@@ -94,9 +94,9 @@ let updateOnNewBatch = (
   // 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
+      mutCheckpointIds->Array.push(batchCheckpointIds->Belt.Array.getUnsafe(idx))->ignore
       mutCheckpointBlockNumbers
-      ->Js.Array2.push(batchCheckpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->Array.push(batchCheckpointBlockNumbers->Belt.Array.getUnsafe(idx))
       ->ignore
     }
   }
@@ -116,10 +116,10 @@ let rollback = (safeCheckpointTracking: t, ~targetBlockNumber: int) => {
     let blockNumber = safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx)
     if blockNumber <= targetBlockNumber {
       mutCheckpointIds
-      ->Js.Array2.push(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx))
+      ->Array.push(safeCheckpointTracking.checkpointIds->Belt.Array.getUnsafe(idx))
       ->ignore
       mutCheckpointBlockNumbers
-      ->Js.Array2.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
+      ->Array.push(safeCheckpointTracking.checkpointBlockNumbers->Belt.Array.getUnsafe(idx))
       ->ignore
     }
   }

package/src/SafeCheckpointTracking.res.mjs

@@ -3,24 +3,24 @@
 
 function make(maxReorgDepth, shouldRollbackOnReorg, chainReorgCheckpoints) {
   if (!(maxReorgDepth > 0 && shouldRollbackOnReorg)) {
-    return ;
+    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;
-      });
+  let checkpointIds = new Array(chainReorgCheckpoints.length);
+  let checkpointBlockNumbers = new Array(chainReorgCheckpoints.length);
+  chainReorgCheckpoints.forEach((checkpoint, idx) => {
+    checkpointIds[idx] = checkpoint.id;
+    checkpointBlockNumbers[idx] = checkpoint.block_number;
+  });
   return {
-          checkpointIds: checkpointIds,
-          checkpointBlockNumbers: checkpointBlockNumbers,
-          maxReorgDepth: maxReorgDepth
-        };
+    checkpointIds: checkpointIds,
+    checkpointBlockNumbers: checkpointBlockNumbers,
+    maxReorgDepth: maxReorgDepth
+  };
 }
 
 function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
-  var safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
-  var match = safeCheckpointTracking.checkpointIds;
+  let safeBlockNumber = sourceBlockNumber - safeCheckpointTracking.maxReorgDepth | 0;
+  let match = safeCheckpointTracking.checkpointIds;
   if (match.length === 0) {
     return 0n;
   }
@@ -30,16 +30,16 @@ function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
   if (match.length === 1) {
     return match[0];
   }
-  var trackingCheckpointsCount = safeCheckpointTracking.checkpointIds.length;
-  var result;
-  var idx = 1;
-  while(idx < trackingCheckpointsCount && result === undefined) {
+  let trackingCheckpointsCount = safeCheckpointTracking.checkpointIds.length;
+  let result;
+  let 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;
+  let checkpointId = result;
   if (checkpointId !== undefined) {
     return checkpointId;
   } else {
@@ -48,53 +48,50 @@ function getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber) {
 }
 
 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];
+  let safeCheckpointId = getSafeCheckpointId(safeCheckpointTracking, sourceBlockNumber);
+  let mutCheckpointIds = [];
+  let mutCheckpointBlockNumbers = [];
+  for (let idx = 0, idx_finish = safeCheckpointTracking.checkpointIds.length; idx < idx_finish; ++idx) {
+    let 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){
+  for (let 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
-        };
+    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];
+  let mutCheckpointIds = [];
+  let mutCheckpointBlockNumbers = [];
+  for (let idx = 0, idx_finish = safeCheckpointTracking.checkpointIds.length; idx < idx_finish; ++idx) {
+    let 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
-        };
+    checkpointIds: mutCheckpointIds,
+    checkpointBlockNumbers: mutCheckpointBlockNumbers,
+    maxReorgDepth: safeCheckpointTracking.maxReorgDepth
+  };
 }
 
 export {
-  make ,
-  getSafeCheckpointId ,
-  updateOnNewBatch ,
-  rollback ,
+  make,
+  getSafeCheckpointId,
+  updateOnNewBatch,
+  rollback,
 }
 /* No side effect */