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

package/src/ChainManager.res.mjs

@@ -3,10 +3,8 @@
 import * as Env from "./Env.res.mjs";
 import * as Batch from "./Batch.res.mjs";
 import * as Utils from "./Utils.res.mjs";
-import * as $$BigInt from "./bindings/BigInt.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as ChainFetcher from "./ChainFetcher.res.mjs";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
@@ -25,65 +23,63 @@ function calculateTargetBufferSize(activeChainsCount) {
   }
   switch (activeChainsCount) {
     case 1 :
-        return 60000;
+      return 60000;
     case 2 :
-        return 30000;
+      return 30000;
     case 3 :
-        return 20000;
+      return 20000;
     case 4 :
-        return 15000;
+      return 15000;
     case 5 :
-        return 10000;
+      return 10000;
     default:
       return 5000;
   }
 }
 
-async function makeFromDbState(initialState, config, registrations) {
-  var isInReorgThreshold = initialState.cleanRun ? false : Belt_Array.some(initialState.chains, (function (chain) {
-            return isProgressInReorgThreshold(chain.progressBlockNumber, chain.sourceBlockNumber, chain.maxReorgDepth);
-          }));
-  var targetBufferSize = calculateTargetBufferSize(initialState.chains.length);
+function makeFromDbState(initialState, config, registrations) {
+  let isInReorgThreshold = initialState.cleanRun ? false : initialState.chains.some(chain => isProgressInReorgThreshold(chain.progressBlockNumber, chain.sourceBlockNumber, chain.maxReorgDepth));
+  let targetBufferSize = calculateTargetBufferSize(initialState.chains.length);
   Prometheus.ProcessingMaxBatchSize.set(config.batchSize);
   Prometheus.IndexingTargetBufferSize.set(targetBufferSize);
   Prometheus.ReorgThreshold.set(isInReorgThreshold);
-  Utils.Dict.forEach(initialState.cache, (function (param) {
-          var count = param.count;
-          Prometheus.EffectCacheCount.set(count, param.effectName);
-        }));
-  var chainFetchersArr = await Promise.all(Belt_Array.map(initialState.chains, (async function (resumedChainState) {
-              var chain = Config.getChain(config, resumedChainState.id);
-              var chainConfig = ChainMap.get(config.chainMap, chain);
-              return [
-                      chain,
-                      await ChainFetcher.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, config, registrations, targetBufferSize)
-                    ];
-            })));
-  var chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr);
-  var allChainsReady = {
+  Utils.Dict.forEach(initialState.cache, param => {
+    let count = param.count;
+    Prometheus.EffectCacheCount.set(count, param.effectName);
+  });
+  let chainFetchersArr = initialState.chains.map(resumedChainState => {
+    let chain = Config.getChain(config, resumedChainState.id);
+    let chainConfig = ChainMap.get(config.chainMap, chain);
+    return [
+      chain,
+      ChainFetcher.makeFromDbState(chainConfig, resumedChainState, initialState.reorgCheckpoints, isInReorgThreshold, config, registrations, targetBufferSize)
+    ];
+  });
+  let chainFetchers = ChainMap.fromArrayUnsafe(chainFetchersArr);
+  let allChainsReady = {
     contents: chainFetchersArr.length !== 0
   };
-  Belt_Array.forEach(chainFetchersArr, (function (param) {
-          var cf = param[1];
-          var chain = param[0];
-          Prometheus.ProgressBlockNumber.set(cf.committedProgressBlockNumber, chain);
-          Prometheus.ProgressReady.init(chain);
-          if (ChainFetcher.isReady(cf)) {
-            return Prometheus.ProgressReady.set(chain);
-          } else {
-            allChainsReady.contents = false;
-            return ;
-          }
-        }));
+  chainFetchersArr.forEach(param => {
+    let cf = param[1];
+    let chain = param[0];
+    Prometheus.ProgressBlockNumber.set(cf.committedProgressBlockNumber, chain);
+    Prometheus.ProgressReady.init(chain);
+    if (ChainFetcher.isReady(cf)) {
+      return Prometheus.ProgressReady.set(chain);
+    } else {
+      allChainsReady.contents = false;
+      return;
+    }
+  });
   if (allChainsReady.contents) {
     Prometheus.ProgressReady.setAllReady();
   }
   return {
-          committedCheckpointId: initialState.checkpointId,
-          chainFetchers: chainFetchers,
-          multichain: config.multichain,
-          isInReorgThreshold: isInReorgThreshold
-        };
+    committedCheckpointId: initialState.checkpointId,
+    chainFetchers: chainFetchers,
+    multichain: config.multichain,
+    isInReorgThreshold: isInReorgThreshold
+  };
 }
 
 function getChainFetcher(chainManager, chain) {
@@ -92,36 +88,32 @@ function getChainFetcher(chainManager, chain) {
 
 function setChainFetcher(chainManager, chainFetcher) {
   return {
-          committedCheckpointId: chainManager.committedCheckpointId,
-          chainFetchers: ChainMap.set(chainManager.chainFetchers, ChainMap.Chain.makeUnsafe(chainFetcher.chainConfig.id), chainFetcher),
-          multichain: chainManager.multichain,
-          isInReorgThreshold: chainManager.isInReorgThreshold
-        };
+    committedCheckpointId: chainManager.committedCheckpointId,
+    chainFetchers: ChainMap.set(chainManager.chainFetchers, ChainMap.Chain.makeUnsafe(chainFetcher.chainConfig.id), chainFetcher),
+    multichain: chainManager.multichain,
+    isInReorgThreshold: chainManager.isInReorgThreshold
+  };
 }
 
 function nextItemIsNone(chainManager) {
-  return !Batch.hasMultichainReadyItem(ChainMap.map(chainManager.chainFetchers, (function (cf) {
-                    return cf.fetchState;
-                  })), chainManager.multichain);
+  return !Batch.hasMultichainReadyItem(ChainMap.map(chainManager.chainFetchers, cf => cf.fetchState), chainManager.multichain);
 }
 
 function createBatch(chainManager, batchSizeTarget, isRollback) {
-  return Batch.make($$BigInt.add(chainManager.committedCheckpointId, isRollback ? 1n : 0n), ChainMap.map(chainManager.chainFetchers, (function (cf) {
-                    return {
-                            fetchState: cf.fetchState,
-                            reorgDetection: cf.reorgDetection,
-                            progressBlockNumber: cf.committedProgressBlockNumber,
-                            sourceBlockNumber: cf.fetchState.knownHeight,
-                            totalEventsProcessed: cf.numEventsProcessed,
-                            chainConfig: cf.chainConfig
-                          };
-                  })), chainManager.multichain, batchSizeTarget);
+  return Batch.make(chainManager.committedCheckpointId + (
+    isRollback ? 1n : 0n
+  ), ChainMap.map(chainManager.chainFetchers, cf => ({
+    fetchState: cf.fetchState,
+    reorgDetection: cf.reorgDetection,
+    progressBlockNumber: cf.committedProgressBlockNumber,
+    sourceBlockNumber: cf.fetchState.knownHeight,
+    totalEventsProcessed: cf.numEventsProcessed,
+    chainConfig: cf.chainConfig
+  })), chainManager.multichain, batchSizeTarget);
 }
 
 function isProgressAtHead(chainManager) {
-  return ChainMap.values(chainManager.chainFetchers).every(function (cf) {
-              return cf.isProgressAtHead;
-            });
+  return ChainMap.values(chainManager.chainFetchers).every(cf => cf.isProgressAtHead);
 }
 
 function isActivelyIndexing(chainManager) {
@@ -129,38 +121,35 @@ function isActivelyIndexing(chainManager) {
 }
 
 function getSafeCheckpointId(chainManager) {
-  var chainFetchers = ChainMap.values(chainManager.chainFetchers);
-  var result;
-  for(var idx = 0 ,idx_finish = chainFetchers.length; idx < idx_finish; ++idx){
-    var chainFetcher = chainFetchers[idx];
-    var safeCheckpointTracking = chainFetcher.safeCheckpointTracking;
+  let chainFetchers = ChainMap.values(chainManager.chainFetchers);
+  let result;
+  for (let idx = 0, idx_finish = chainFetchers.length; idx < idx_finish; ++idx) {
+    let chainFetcher = chainFetchers[idx];
+    let safeCheckpointTracking = chainFetcher.safeCheckpointTracking;
     if (safeCheckpointTracking !== undefined) {
-      var safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, chainFetcher.fetchState.knownHeight);
-      var current = result;
+      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, chainFetcher.fetchState.knownHeight);
+      let current = result;
       if (!(current !== undefined && safeCheckpointId >= current)) {
         result = safeCheckpointId;
       }
-      
     }
-    
   }
-  var id = result;
+  let id = result;
   if (id !== undefined && id > 0n) {
     return id;
   }
-  
 }
 
 export {
-  isProgressInReorgThreshold ,
-  calculateTargetBufferSize ,
-  makeFromDbState ,
-  getChainFetcher ,
-  setChainFetcher ,
-  nextItemIsNone ,
-  createBatch ,
-  isProgressAtHead ,
-  isActivelyIndexing ,
-  getSafeCheckpointId ,
+  isProgressInReorgThreshold,
+  calculateTargetBufferSize,
+  makeFromDbState,
+  getChainFetcher,
+  setChainFetcher,
+  nextItemIsNone,
+  createBatch,
+  isProgressAtHead,
+  isActivelyIndexing,
+  getSafeCheckpointId,
 }
 /* Env Not a pure module */

package/src/ChainMap.res

@@ -1,5 +1,3 @@
-open Belt
-
 module Chain = {
   type t = int
 
@@ -10,33 +8,33 @@ module Chain = {
   let makeUnsafe = (~chainId) => chainId
 }
 
-module ChainIdCmp = Belt.Id.MakeComparableU({
+module ChainIdCmp = Belt.Id.MakeComparable({
   type t = Chain.t
-  let cmp = (a, b) => Pervasives.compare(a->Chain.toChainId, b->Chain.toChainId)
+  let cmp = (a, b) => Int.compare(a->Chain.toChainId, b->Chain.toChainId)->Int.fromFloat
 })
 
 type t<'a> = Belt.Map.t<ChainIdCmp.t, 'a, ChainIdCmp.identity>
 
 let fromArrayUnsafe: array<(Chain.t, 'a)> => t<'a> = arr => {
-  arr->Map.fromArray(~id=module(ChainIdCmp))
+  arr->Belt.Map.fromArray(~id=module(ChainIdCmp))
 }
 
 let get: (t<'a>, Chain.t) => 'a = (self, chain) =>
-  switch Map.get(self, chain) {
+  switch Belt.Map.get(self, chain) {
   | Some(v) => v
   | None =>
     // Should be unreachable, since we validate on Chain.t creation
     // Still throw just in case something went wrong
-    Js.Exn.raiseError("No chain with id " ++ chain->Chain.toString ++ " found in chain map")
+    JsError.throwWithMessage("No chain with id " ++ chain->Chain.toString ++ " found in chain map")
   }
 
-let set: (t<'a>, Chain.t, 'a) => t<'a> = (map, chain, v) => Map.set(map, chain, v)
-let values: t<'a> => array<'a> = map => Map.valuesToArray(map)
-let keys: t<'a> => array<Chain.t> = map => Map.keysToArray(map)
-let entries: t<'a> => array<(Chain.t, 'a)> = map => Map.toArray(map)
-let has: (t<'a>, Chain.t) => bool = (map, chain) => Map.has(map, chain)
-let map: (t<'a>, 'a => 'b) => t<'b> = (map, fn) => Map.map(map, fn)
-let mapWithKey: (t<'a>, (Chain.t, 'a) => 'b) => t<'b> = (map, fn) => Map.mapWithKey(map, fn)
-let size: t<'a> => int = map => Map.size(map)
+let set: (t<'a>, Chain.t, 'a) => t<'a> = (map, chain, v) => Belt.Map.set(map, chain, v)
+let values: t<'a> => array<'a> = map => Belt.Map.valuesToArray(map)
+let keys: t<'a> => array<Chain.t> = map => Belt.Map.keysToArray(map)
+let entries: t<'a> => array<(Chain.t, 'a)> = map => Belt.Map.toArray(map)
+let has: (t<'a>, Chain.t) => bool = (map, chain) => Belt.Map.has(map, chain)
+let map: (t<'a>, 'a => 'b) => t<'b> = (map, fn) => Belt.Map.map(map, fn)
+let mapWithKey: (t<'a>, (Chain.t, 'a) => 'b) => t<'b> = (map, fn) => Belt.Map.mapWithKey(map, fn)
+let size: t<'a> => int = map => Belt.Map.size(map)
 let update: (t<'a>, Chain.t, 'a => 'a) => t<'a> = (map, chain, updateFn) =>
-  Map.update(map, chain, opt => opt->Option.map(updateFn))
+  Belt.Map.update(map, chain, opt => opt->Option.map(updateFn))

package/src/ChainMap.res.mjs

@@ -1,78 +1,78 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Caml from "rescript/lib/es6/caml.js";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
-import * as Belt_Id from "rescript/lib/es6/belt_Id.js";
-import * as Belt_Map from "rescript/lib/es6/belt_Map.js";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Belt_Id from "@rescript/runtime/lib/es6/Belt_Id.js";
+import * as Belt_Map from "@rescript/runtime/lib/es6/Belt_Map.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
 function toString(chainId) {
-  return String(chainId);
+  return chainId.toString();
 }
 
 function makeUnsafe(chainId) {
   return chainId;
 }
 
-var Chain = {
+let Chain = {
   toString: toString,
   makeUnsafe: makeUnsafe
 };
 
-var cmp = Caml.int_compare;
+function cmp(a, b) {
+  return Primitive_int.compare(a, b) | 0;
+}
 
-var ChainIdCmp = Belt_Id.MakeComparableU({
-      cmp: cmp
-    });
+let ChainIdCmp = Belt_Id.MakeComparable({
+  cmp: cmp
+});
 
 function fromArrayUnsafe(arr) {
   return Belt_Map.fromArray(arr, ChainIdCmp);
 }
 
 function get(self, chain) {
-  var v = Belt_Map.get(self, chain);
+  let v = Belt_Map.get(self, chain);
   if (v !== undefined) {
-    return Caml_option.valFromOption(v);
+    return Primitive_option.valFromOption(v);
   } else {
-    return Js_exn.raiseError("No chain with id " + String(chain) + " found in chain map");
+    return Stdlib_JsError.throwWithMessage("No chain with id " + chain.toString() + " found in chain map");
   }
 }
 
-var set = Belt_Map.set;
+let set = Belt_Map.set;
 
-var values = Belt_Map.valuesToArray;
+let values = Belt_Map.valuesToArray;
 
-var keys = Belt_Map.keysToArray;
+let keys = Belt_Map.keysToArray;
 
-var entries = Belt_Map.toArray;
+let entries = Belt_Map.toArray;
 
-var has = Belt_Map.has;
+let has = Belt_Map.has;
 
-var map = Belt_Map.map;
+let map = Belt_Map.map;
 
-var mapWithKey = Belt_Map.mapWithKey;
+let mapWithKey = Belt_Map.mapWithKey;
 
-var size = Belt_Map.size;
+let size = Belt_Map.size;
 
 function update(map, chain, updateFn) {
-  return Belt_Map.update(map, chain, (function (opt) {
-                return Belt_Option.map(opt, updateFn);
-              }));
+  return Belt_Map.update(map, chain, opt => Stdlib_Option.map(opt, updateFn));
 }
 
 export {
-  Chain ,
-  fromArrayUnsafe ,
-  get ,
-  set ,
-  values ,
-  keys ,
-  entries ,
-  has ,
-  map ,
-  mapWithKey ,
-  size ,
-  update ,
+  Chain,
+  fromArrayUnsafe,
+  get,
+  set,
+  values,
+  keys,
+  entries,
+  has,
+  map,
+  mapWithKey,
+  size,
+  update,
 }
 /* ChainIdCmp Not a pure module */