envio 2.30.2 → 2.31.0-alpha.1

package/src/Batch.res.js

@@ -1,16 +1,18 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 'use strict';
 
+var Utils = require("./Utils.res.js");
 var ChainMap = require("./ChainMap.res.js");
-var Caml_array = require("rescript/lib/js/caml_array.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var FetchState = require("./FetchState.res.js");
+var ReorgDetection = require("./ReorgDetection.res.js");
 
 function getOrderedNextChain(fetchStates, batchSizePerChain) {
   var earliestChain;
   var earliestChainTimestamp = 0;
   var chainKeys = ChainMap.keys(fetchStates);
-  for(var idx = 0 ,idx_finish = chainKeys.length; idx < idx_finish; ++idx){
-    var chain = Caml_array.get(chainKeys, idx);
+  for(var idx = 0 ,idx_finish = chainKeys.length - 1; idx <= idx_finish; ++idx){
+    var chain = chainKeys[idx];
     var fetchState = ChainMap.get(fetchStates, chain);
     if (FetchState.isActivelyIndexing(fetchState)) {
       var batchSize = batchSizePerChain[chain];
@@ -56,51 +58,307 @@ function hasMultichainReadyItem(fetchStates, multichain) {
   }
 }
 
-function prepareOrderedBatch(batchSizeTarget, fetchStates, mutBatchSizePerChain) {
-  var batchSize = 0;
+function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, fetchStateAfterBatch, batchSize) {
+  if (chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch) {
+    return {
+            batchSize: batchSize,
+            progressBlockNumber: progressBlockNumberAfterBatch,
+            totalEventsProcessed: chainBeforeBatch.totalEventsProcessed + batchSize,
+            fetchState: fetchStateAfterBatch,
+            isProgressAtHeadWhenBatchCreated: progressBlockNumberAfterBatch >= chainBeforeBatch.sourceBlockNumber
+          };
+  }
+  
+}
+
+function getProgressedChainsById(chainsBeforeBatch, batchSizePerChain, progressBlockNumberPerChain) {
+  var progressedChainsById = {};
+  Belt_Array.forEachU(ChainMap.values(chainsBeforeBatch), (function (chainBeforeBatch) {
+          var fetchState = chainBeforeBatch.fetchState;
+          var progressBlockNumber = progressBlockNumberPerChain[String(fetchState.chainId)];
+          var progressBlockNumberAfterBatch = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
+          var batchSize = batchSizePerChain[String(fetchState.chainId)];
+          var progressedChain;
+          if (batchSize !== undefined) {
+            var leftItems = fetchState.buffer.slice(batchSize);
+            progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, FetchState.updateInternal(fetchState, undefined, undefined, undefined, leftItems, undefined), batchSize);
+          } else {
+            progressedChain = getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, chainBeforeBatch.fetchState, 0);
+          }
+          if (progressedChain !== undefined) {
+            progressedChainsById[chainBeforeBatch.fetchState.chainId] = progressedChain;
+            return ;
+          }
+          
+        }));
+  return progressedChainsById;
+}
+
+function addReorgCheckpoints(prevCheckpointId, reorgDetection, fromBlockExclusive, toBlockExclusive, chainId, mutCheckpointIds, mutCheckpointChainIds, mutCheckpointBlockNumbers, mutCheckpointBlockHashes, mutCheckpointEventsProcessed) {
+  if (!(reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber))) {
+    return prevCheckpointId;
+  }
+  var prevCheckpointId$1 = prevCheckpointId;
+  for(var blockNumber = fromBlockExclusive + 1 ,blockNumber_finish = toBlockExclusive - 1; blockNumber <= blockNumber_finish; ++blockNumber){
+    var hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber);
+    if (hash !== null) {
+      var checkpointId = prevCheckpointId$1 + 1;
+      prevCheckpointId$1 = checkpointId;
+      mutCheckpointIds.push(checkpointId);
+      mutCheckpointChainIds.push(chainId);
+      mutCheckpointBlockNumbers.push(blockNumber);
+      mutCheckpointBlockHashes.push(hash);
+      mutCheckpointEventsProcessed.push(0);
+    }
+    
+  }
+  return prevCheckpointId$1;
+}
+
+function prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget) {
+  var totalBatchSize = 0;
   var isFinished = false;
+  var prevCheckpointId = checkpointIdBeforeBatch;
+  var mutBatchSizePerChain = {};
+  var mutProgressBlockNumberPerChain = {};
+  var fetchStates = ChainMap.map(chainsBeforeBatch, (function (chainBeforeBatch) {
+          return chainBeforeBatch.fetchState;
+        }));
   var items = [];
-  while(batchSize < batchSizeTarget && !isFinished) {
+  var checkpointIds = [];
+  var checkpointChainIds = [];
+  var checkpointBlockNumbers = [];
+  var checkpointBlockHashes = [];
+  var checkpointEventsProcessed = [];
+  while(totalBatchSize < batchSizeTarget && !isFinished) {
     var fetchState = getOrderedNextChain(fetchStates, mutBatchSizePerChain);
     if (fetchState !== undefined) {
-      var batchSize$1 = mutBatchSizePerChain[fetchState.chainId];
-      var itemsCountBefore = batchSize$1 !== undefined ? batchSize$1 : 0;
+      var chainBeforeBatch = ChainMap.get(chainsBeforeBatch, ChainMap.Chain.makeUnsafe(fetchState.chainId));
+      var batchSize = mutBatchSizePerChain[fetchState.chainId];
+      var itemsCountBefore = batchSize !== undefined ? batchSize : 0;
+      var progressBlockNumber = mutProgressBlockNumberPerChain[fetchState.chainId];
+      var prevBlockNumber = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
       var newItemsCount = FetchState.getReadyItemsCount(fetchState, 1, itemsCountBefore);
       if (newItemsCount > 0) {
-        for(var idx = itemsCountBefore ,idx_finish = itemsCountBefore + newItemsCount | 0; idx < idx_finish; ++idx){
-          items.push(fetchState.buffer[idx]);
+        var item0 = fetchState.buffer[itemsCountBefore];
+        var blockNumber = item0.blockNumber;
+        var chainId = fetchState.chainId;
+        var reorgDetection = chainBeforeBatch.reorgDetection;
+        var prevCheckpointId$1 = prevCheckpointId;
+        var tmp;
+        if (reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber)) {
+          var prevCheckpointId$2 = prevCheckpointId$1;
+          for(var blockNumber$1 = prevBlockNumber + 1 ,blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1){
+            var hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
+            if (hash !== null) {
+              var checkpointId = prevCheckpointId$2 + 1;
+              prevCheckpointId$2 = checkpointId;
+              checkpointIds.push(checkpointId);
+              checkpointChainIds.push(chainId);
+              checkpointBlockNumbers.push(blockNumber$1);
+              checkpointBlockHashes.push(hash);
+              checkpointEventsProcessed.push(0);
+            }
+            
+          }
+          tmp = prevCheckpointId$2;
+        } else {
+          tmp = prevCheckpointId$1;
         }
-        batchSize = batchSize + newItemsCount | 0;
-        mutBatchSizePerChain[fetchState.chainId] = itemsCountBefore + newItemsCount | 0;
+        prevCheckpointId = tmp;
+        var checkpointId$1 = prevCheckpointId + 1;
+        items.push(item0);
+        for(var idx = 1 ,idx_finish = newItemsCount - 1; idx <= idx_finish; ++idx){
+          items.push(fetchState.buffer[itemsCountBefore + idx]);
+        }
+        checkpointIds.push(checkpointId$1);
+        checkpointChainIds.push(fetchState.chainId);
+        checkpointBlockNumbers.push(blockNumber);
+        checkpointBlockHashes.push(ReorgDetection.getHashByBlockNumber(chainBeforeBatch.reorgDetection, blockNumber));
+        checkpointEventsProcessed.push(newItemsCount);
+        prevCheckpointId = checkpointId$1;
+        totalBatchSize = totalBatchSize + newItemsCount;
+        mutBatchSizePerChain[fetchState.chainId] = itemsCountBefore + newItemsCount;
+        mutProgressBlockNumberPerChain[fetchState.chainId] = blockNumber;
       } else {
+        var blockNumberAfterBatch = FetchState.bufferBlockNumber(fetchState);
+        var chainId$1 = fetchState.chainId;
+        var toBlockExclusive = blockNumberAfterBatch + 1;
+        var reorgDetection$1 = chainBeforeBatch.reorgDetection;
+        var prevCheckpointId$3 = prevCheckpointId;
+        var tmp$1;
+        if (reorgDetection$1.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection$1.dataByBlockNumber)) {
+          var prevCheckpointId$4 = prevCheckpointId$3;
+          for(var blockNumber$2 = prevBlockNumber + 1 ,blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2){
+            var hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
+            if (hash$1 !== null) {
+              var checkpointId$2 = prevCheckpointId$4 + 1;
+              prevCheckpointId$4 = checkpointId$2;
+              checkpointIds.push(checkpointId$2);
+              checkpointChainIds.push(chainId$1);
+              checkpointBlockNumbers.push(blockNumber$2);
+              checkpointBlockHashes.push(hash$1);
+              checkpointEventsProcessed.push(0);
+            }
+            
+          }
+          tmp$1 = prevCheckpointId$4;
+        } else {
+          tmp$1 = prevCheckpointId$3;
+        }
+        prevCheckpointId = tmp$1;
+        mutProgressBlockNumberPerChain[fetchState.chainId] = blockNumberAfterBatch;
         isFinished = true;
       }
     } else {
       isFinished = true;
     }
   };
-  return items;
+  return {
+          totalBatchSize: totalBatchSize,
+          items: items,
+          progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
+          checkpointIds: checkpointIds,
+          checkpointChainIds: checkpointChainIds,
+          checkpointBlockNumbers: checkpointBlockNumbers,
+          checkpointBlockHashes: checkpointBlockHashes,
+          checkpointEventsProcessed: checkpointEventsProcessed
+        };
 }
 
-function prepareUnorderedBatch(batchSizeTarget, fetchStates, mutBatchSizePerChain) {
-  var preparedFetchStates = FetchState.filterAndSortForUnorderedBatch(ChainMap.values(fetchStates), batchSizeTarget);
+function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget) {
+  var preparedFetchStates = FetchState.sortForUnorderedBatch(ChainMap.values(chainsBeforeBatch).map(function (chainBeforeBatch) {
+            return chainBeforeBatch.fetchState;
+          }), batchSizeTarget);
   var chainIdx = 0;
   var preparedNumber = preparedFetchStates.length;
-  var batchSize = 0;
+  var totalBatchSize = 0;
+  var prevCheckpointId = checkpointIdBeforeBatch;
+  var mutBatchSizePerChain = {};
+  var mutProgressBlockNumberPerChain = {};
   var items = [];
-  while(batchSize < batchSizeTarget && chainIdx < preparedNumber) {
+  var checkpointIds = [];
+  var checkpointChainIds = [];
+  var checkpointBlockNumbers = [];
+  var checkpointBlockHashes = [];
+  var checkpointEventsProcessed = [];
+  while(totalBatchSize < batchSizeTarget && chainIdx < preparedNumber) {
     var fetchState = preparedFetchStates[chainIdx];
-    var chainBatchSize = FetchState.getReadyItemsCount(fetchState, batchSizeTarget - batchSize | 0, 0);
+    var chainBatchSize = FetchState.getReadyItemsCount(fetchState, batchSizeTarget - totalBatchSize, 0);
+    var chainBeforeBatch = ChainMap.get(chainsBeforeBatch, ChainMap.Chain.makeUnsafe(fetchState.chainId));
+    var prevBlockNumber = chainBeforeBatch.progressBlockNumber;
     if (chainBatchSize > 0) {
-      for(var idx = 0; idx < chainBatchSize; ++idx){
-        items.push(fetchState.buffer[idx]);
+      for(var idx = 0 ,idx_finish = chainBatchSize - 1; idx <= idx_finish; ++idx){
+        var item = fetchState.buffer[idx];
+        var blockNumber = item.blockNumber;
+        if (blockNumber !== prevBlockNumber) {
+          var chainId = fetchState.chainId;
+          var fromBlockExclusive = prevBlockNumber;
+          var reorgDetection = chainBeforeBatch.reorgDetection;
+          var prevCheckpointId$1 = prevCheckpointId;
+          var tmp;
+          if (reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber)) {
+            var prevCheckpointId$2 = prevCheckpointId$1;
+            for(var blockNumber$1 = fromBlockExclusive + 1 ,blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1){
+              var hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
+              if (hash !== null) {
+                var checkpointId = prevCheckpointId$2 + 1;
+                prevCheckpointId$2 = checkpointId;
+                checkpointIds.push(checkpointId);
+                checkpointChainIds.push(chainId);
+                checkpointBlockNumbers.push(blockNumber$1);
+                checkpointBlockHashes.push(hash);
+                checkpointEventsProcessed.push(0);
+              }
+              
+            }
+            tmp = prevCheckpointId$2;
+          } else {
+            tmp = prevCheckpointId$1;
+          }
+          prevCheckpointId = tmp;
+          var checkpointId$1 = prevCheckpointId + 1;
+          checkpointIds.push(checkpointId$1);
+          checkpointChainIds.push(fetchState.chainId);
+          checkpointBlockNumbers.push(blockNumber);
+          checkpointBlockHashes.push(ReorgDetection.getHashByBlockNumber(chainBeforeBatch.reorgDetection, blockNumber));
+          checkpointEventsProcessed.push(1);
+          prevBlockNumber = blockNumber;
+          prevCheckpointId = checkpointId$1;
+        } else {
+          var lastIndex = checkpointEventsProcessed.length - 1;
+          checkpointEventsProcessed[lastIndex] = checkpointEventsProcessed[lastIndex] + 1;
+        }
+        items.push(item);
       }
-      batchSize = batchSize + chainBatchSize | 0;
+      totalBatchSize = totalBatchSize + chainBatchSize;
       mutBatchSizePerChain[fetchState.chainId] = chainBatchSize;
     }
-    chainIdx = chainIdx + 1 | 0;
+    var progressBlockNumberAfterBatch = FetchState.getUnorderedMultichainProgressBlockNumberAt(fetchState, chainBatchSize);
+    var chainId$1 = fetchState.chainId;
+    var toBlockExclusive = progressBlockNumberAfterBatch + 1;
+    var fromBlockExclusive$1 = prevBlockNumber;
+    var reorgDetection$1 = chainBeforeBatch.reorgDetection;
+    var prevCheckpointId$3 = prevCheckpointId;
+    var tmp$1;
+    if (reorgDetection$1.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection$1.dataByBlockNumber)) {
+      var prevCheckpointId$4 = prevCheckpointId$3;
+      for(var blockNumber$2 = fromBlockExclusive$1 + 1 ,blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2){
+        var hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
+        if (hash$1 !== null) {
+          var checkpointId$2 = prevCheckpointId$4 + 1;
+          prevCheckpointId$4 = checkpointId$2;
+          checkpointIds.push(checkpointId$2);
+          checkpointChainIds.push(chainId$1);
+          checkpointBlockNumbers.push(blockNumber$2);
+          checkpointBlockHashes.push(hash$1);
+          checkpointEventsProcessed.push(0);
+        }
+        
+      }
+      tmp$1 = prevCheckpointId$4;
+    } else {
+      tmp$1 = prevCheckpointId$3;
+    }
+    prevCheckpointId = tmp$1;
+    mutProgressBlockNumberPerChain[fetchState.chainId] = progressBlockNumberAfterBatch;
+    chainIdx = chainIdx + 1;
+  };
+  return {
+          totalBatchSize: totalBatchSize,
+          items: items,
+          progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
+          checkpointIds: checkpointIds,
+          checkpointChainIds: checkpointChainIds,
+          checkpointBlockNumbers: checkpointBlockNumbers,
+          checkpointBlockHashes: checkpointBlockHashes,
+          checkpointEventsProcessed: checkpointEventsProcessed
+        };
+}
+
+function make(checkpointIdBeforeBatch, chainsBeforeBatch, multichain, batchSizeTarget) {
+  var tmp;
+  tmp = multichain === "ordered" ? ChainMap.size(chainsBeforeBatch) === 1 : true;
+  if (tmp) {
+    return prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget);
+  } else {
+    return prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget);
+  }
+}
+
+function findFirstEventBlockNumber(batch, chainId) {
+  var idx = 0;
+  var result;
+  var checkpointsLength = batch.checkpointIds.length;
+  while(idx < checkpointsLength && result === undefined) {
+    var checkpointChainId = batch.checkpointChainIds[idx];
+    if (checkpointChainId === chainId && batch.checkpointEventsProcessed[idx] > 0) {
+      result = batch.checkpointBlockNumbers[idx];
+    } else {
+      idx = idx + 1;
+    }
   };
-  return items;
+  return result;
 }
 
 exports.getOrderedNextChain = getOrderedNextChain;
@@ -108,6 +366,10 @@ exports.immutableEmptyBatchSizePerChain = immutableEmptyBatchSizePerChain;
 exports.hasOrderedReadyItem = hasOrderedReadyItem;
 exports.hasUnorderedReadyItem = hasUnorderedReadyItem;
 exports.hasMultichainReadyItem = hasMultichainReadyItem;
+exports.getProgressedChainsById = getProgressedChainsById;
+exports.addReorgCheckpoints = addReorgCheckpoints;
 exports.prepareOrderedBatch = prepareOrderedBatch;
 exports.prepareUnorderedBatch = prepareUnorderedBatch;
-/* ChainMap Not a pure module */
+exports.make = make;
+exports.findFirstEventBlockNumber = findFirstEventBlockNumber;
+/* Utils Not a pure module */

package/src/EventRegister.res

@@ -1,4 +1,7 @@
-type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
+type registrations = {
+  onBlockByChainId: dict<array<Internal.onBlockConfig>>,
+  mutable hasEvents: bool,
+}
 
 type activeRegistration = {
   ecosystem: InternalConfig.ecosystem,
@@ -40,6 +43,7 @@ let startRegistration = (~ecosystem, ~multichain, ~preloadHandlers) => {
     preloadHandlers,
     registrations: {
       onBlockByChainId: Js.Dict.empty(),
+      hasEvents: false,
     },
     finished: false,
   }
@@ -205,7 +209,8 @@ let setEventOptions = (t: t, ~eventOptions, ~logger=Logging.getLogger()) => {
 }
 
 let setHandler = (t: t, handler, ~eventOptions, ~logger=Logging.getLogger()) => {
-  withRegistration(_ => {
+  withRegistration(registration => {
+    registration.registrations.hasEvents = true
     switch t.handler {
     | None =>
       t.handler =
@@ -225,7 +230,8 @@ let setHandler = (t: t, handler, ~eventOptions, ~logger=Logging.getLogger()) =>
 }
 
 let setContractRegister = (t: t, contractRegister, ~eventOptions, ~logger=Logging.getLogger()) => {
-  withRegistration(_ => {
+  withRegistration(registration => {
+    registration.registrations.hasEvents = true
     switch t.contractRegister {
     | None =>
       t.contractRegister = Some(

package/src/EventRegister.res.js

@@ -34,7 +34,8 @@ function startRegistration(ecosystem, multichain, preloadHandlers) {
     multichain: multichain,
     preloadHandlers: preloadHandlers,
     registrations: {
-      onBlockByChainId: {}
+      onBlockByChainId: {},
+      hasEvents: false
     },
     finished: false
   };
@@ -180,7 +181,8 @@ function setEventOptions(t, eventOptions, loggerOpt) {
 
 function setHandler(t, handler, eventOptions, loggerOpt) {
   var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(function (param) {
+  withRegistration(function (registration) {
+        registration.registrations.hasEvents = true;
         var match = t.handler;
         if (match !== undefined) {
           var eventNamespace_contractName = t.contractName;
@@ -202,7 +204,8 @@ function setHandler(t, handler, eventOptions, loggerOpt) {
 
 function setContractRegister(t, contractRegister, eventOptions, loggerOpt) {
   var logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
-  withRegistration(function (param) {
+  withRegistration(function (registration) {
+        registration.registrations.hasEvents = true;
         var match = t.contractRegister;
         if (match !== undefined) {
           var eventNamespace_contractName = t.contractName;

package/src/EventRegister.resi

@@ -1,4 +1,7 @@
-type registrations = {onBlockByChainId: dict<array<Internal.onBlockConfig>>}
+type registrations = {
+  onBlockByChainId: dict<array<Internal.onBlockConfig>>,
+  mutable hasEvents: bool,
+}
 
 let startRegistration: (
   ~ecosystem: InternalConfig.ecosystem,