envio 2.27.1 → 2.27.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "v2.27.1",
+  "version": "v2.27.3",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
   "main": "./index.js",
@@ -25,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.27.1",
-    "envio-linux-arm64": "v2.27.1",
-    "envio-darwin-x64": "v2.27.1",
-    "envio-darwin-arm64": "v2.27.1"
+    "envio-linux-x64": "v2.27.3",
+    "envio-linux-arm64": "v2.27.3",
+    "envio-darwin-x64": "v2.27.3",
+    "envio-darwin-arm64": "v2.27.3"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.5",

package/src/FetchState.res

@@ -68,8 +68,8 @@ type t = {
   // Fields computed by updateInternal
   latestFullyFetchedBlock: blockNumberAndTimestamp,
   // How much blocks behind the head we should query
-  // Added for the purpose of avoiding reorg handling
-  blockLag: option<int>,
+  // Needed to query before entering reorg threshold
+  blockLag: int,
   //Items ordered from latest to earliest
   queue: array<Internal.eventItem>,
 }
@@ -229,6 +229,7 @@ let updateInternal = (
   ~dcsToStore=fetchState.dcsToStore,
   ~currentBlockHeight=?,
   ~queue=fetchState.queue,
+  ~blockLag=fetchState.blockLag,
 ): t => {
   let firstPartition = partitions->Js.Array2.unsafe_get(0)
   let latestFullyFetchedBlock = ref(firstPartition.latestFetchedBlock)
@@ -257,12 +258,12 @@ let updateInternal = (
     }
   }
 
-  let queueSize = queue->Array.length
+  let bufferSize = queue->Array.length
   Prometheus.IndexingPartitions.set(
     ~partitionsCount=partitions->Array.length,
     ~chainId=fetchState.chainId,
   )
-  Prometheus.IndexingBufferSize.set(~bufferSize=queueSize, ~chainId=fetchState.chainId)
+  Prometheus.IndexingBufferSize.set(~bufferSize, ~chainId=fetchState.chainId)
   Prometheus.IndexingBufferBlockNumber.set(
     ~blockNumber=latestFullyFetchedBlock.blockNumber,
     ~chainId=fetchState.chainId,
@@ -284,7 +285,7 @@ let updateInternal = (
     latestFullyFetchedBlock,
     indexingContracts,
     dcsToStore,
-    blockLag: fetchState.blockLag,
+    blockLag,
     queue,
   }
 }
@@ -717,13 +718,12 @@ let getNextQuery = (
   ~currentBlockHeight,
   ~stateId,
 ) => {
-  if currentBlockHeight === 0 {
+  let headBlock = currentBlockHeight - blockLag
+  if headBlock <= 0 {
     WaitingForNewBlock
   } else if concurrencyLimit === 0 {
     ReachedMaxConcurrency
   } else {
-    let headBlock = currentBlockHeight - blockLag->Option.getWithDefault(0)
-
     let fullPartitions = []
     let mergingPartitions = []
     let areMergingPartitionsFetching = ref(false)
@@ -823,14 +823,14 @@ let getNextQuery = (
         switch p->makePartitionQuery(
           ~indexingContracts,
           ~endBlock=switch blockLag {
-          | Some(_) =>
+          | 0 => endBlock
+          | _ =>
             switch endBlock {
             | Some(endBlock) => Some(Pervasives.min(headBlock, endBlock))
             // Force head block as an endBlock when blockLag is set
             // because otherwise HyperSync might return bigger range
             | None => Some(headBlock)
             }
-          | None => endBlock
           },
           ~mergeTarget,
         ) {
@@ -893,18 +893,6 @@ let queueItemBlockNumber = (queueItem: queueItem) => {
   }
 }
 
-let queueItemIsInReorgThreshold = (
-  queueItem: queueItem,
-  ~currentBlockHeight,
-  ~highestBlockBelowThreshold,
-) => {
-  if currentBlockHeight === 0 {
-    false
-  } else {
-    queueItem->queueItemBlockNumber > highestBlockBelowThreshold
-  }
-}
-
 /**
 Simple constructor for no item from partition
 */
@@ -969,7 +957,7 @@ let make = (
   ~contracts: array<indexingContract>,
   ~maxAddrInPartition,
   ~chainId,
-  ~blockLag=?,
+  ~blockLag=0,
 ): t => {
   let latestFetchedBlock = {
     blockTimestamp: 0,
@@ -1098,7 +1086,7 @@ let make = (
   }
 }
 
-let queueSize = ({queue}: t) => queue->Array.length
+let bufferSize = ({queue}: t) => queue->Array.length
 
 /**
 * Returns the latest block number fetched for the lowest fetcher queue (ie the earliest un-fetched dynamic contract)
@@ -1219,10 +1207,42 @@ let isActivelyIndexing = ({latestFullyFetchedBlock, endBlock} as fetchState: t)
   | Some(endBlock) =>
     let isPastEndblock = latestFullyFetchedBlock.blockNumber >= endBlock
     if isPastEndblock {
-      fetchState->queueSize > 0
+      fetchState->bufferSize > 0
     } else {
       true
     }
   | None => true
   }
 }
+
+let isReadyToEnterReorgThreshold = (
+  {latestFullyFetchedBlock, endBlock, blockLag, queue}: t,
+  ~currentBlockHeight,
+) => {
+  currentBlockHeight !== 0 &&
+  switch endBlock {
+  | Some(endBlock) if latestFullyFetchedBlock.blockNumber >= endBlock => true
+  | _ => latestFullyFetchedBlock.blockNumber >= currentBlockHeight - blockLag
+  } &&
+  queue->Utils.Array.isEmpty
+}
+
+let filterAndSortForUnorderedBatch = {
+  let hasBatchItem = ({queue, latestFullyFetchedBlock}: t) => {
+    switch queue->Utils.Array.last {
+    | Some(item) => item.blockNumber <= latestFullyFetchedBlock.blockNumber
+    | None => false
+    }
+  }
+
+  let compareUnorderedBatchChainPriority = (a: t, b: t) => {
+    // Use unsafe since we filtered out all queues without batch items
+    (a.queue->Utils.Array.lastUnsafe).timestamp - (b.queue->Utils.Array.lastUnsafe).timestamp
+  }
+
+  (fetchStates: array<t>) => {
+    fetchStates
+    ->Array.keepU(hasBatchItem)
+    ->Js.Array2.sortInPlaceWith(compareUnorderedBatchChainPriority)
+  }
+}

package/src/FetchState.res.js

@@ -127,12 +127,13 @@ function checkIsWithinSyncRange(latestFetchedBlock, currentBlockHeight) {
   return (currentBlockHeight - latestFetchedBlock.blockNumber) / currentBlockHeight <= 0.001;
 }
 
-function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexingContractsOpt, dcsToStoreOpt, currentBlockHeight, queueOpt) {
+function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexingContractsOpt, dcsToStoreOpt, currentBlockHeight, queueOpt, blockLagOpt) {
   var partitions = partitionsOpt !== undefined ? partitionsOpt : fetchState.partitions;
   var nextPartitionIndex = nextPartitionIndexOpt !== undefined ? nextPartitionIndexOpt : fetchState.nextPartitionIndex;
   var indexingContracts = indexingContractsOpt !== undefined ? indexingContractsOpt : fetchState.indexingContracts;
   var dcsToStore = dcsToStoreOpt !== undefined ? Caml_option.valFromOption(dcsToStoreOpt) : fetchState.dcsToStore;
   var queue = queueOpt !== undefined ? queueOpt : fetchState.queue;
+  var blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
   var firstPartition = partitions[0];
   var latestFullyFetchedBlock = firstPartition.latestFetchedBlock;
   for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
@@ -146,9 +147,9 @@ function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexi
   var isFetchingAtHead = currentBlockHeight !== undefined ? (
       latestFullyFetchedBlock$1.blockNumber >= currentBlockHeight ? true : fetchState.isFetchingAtHead && checkIsWithinSyncRange(latestFullyFetchedBlock$1, currentBlockHeight)
     ) : fetchState.isFetchingAtHead;
-  var queueSize = queue.length;
+  var bufferSize = queue.length;
   Prometheus.IndexingPartitions.set(partitions.length, fetchState.chainId);
-  Prometheus.IndexingBufferSize.set(queueSize, fetchState.chainId);
+  Prometheus.IndexingBufferSize.set(bufferSize, fetchState.chainId);
   Prometheus.IndexingBufferBlockNumber.set(latestFullyFetchedBlock$1.blockNumber, fetchState.chainId);
   var item = Utils.$$Array.last(queue);
   return {
@@ -164,7 +165,7 @@ function updateInternal(fetchState, partitionsOpt, nextPartitionIndexOpt, indexi
           dcsToStore: dcsToStore,
           chainId: fetchState.chainId,
           latestFullyFetchedBlock: latestFullyFetchedBlock$1,
-          blockLag: fetchState.blockLag,
+          blockLag: blockLag,
           queue: queue
         };
 }
@@ -336,7 +337,7 @@ function registerDynamicContracts(fetchState, dynamicContracts, currentBlockHeig
   }
   Prometheus.IndexingAddresses.set(Object.keys(fetchState.indexingContracts).length + dcsToStore.length | 0, fetchState.chainId);
   var existingDcs = fetchState.dcsToStore;
-  return updateInternal(fetchState, fetchState.partitions.concat(newPartitions), fetchState.nextPartitionIndex + newPartitions.length | 0, Object.assign(registeringContracts, indexingContracts), Caml_option.some(existingDcs !== undefined ? Belt_Array.concat(existingDcs, dcsToStore) : dcsToStore), currentBlockHeight, undefined);
+  return updateInternal(fetchState, fetchState.partitions.concat(newPartitions), fetchState.nextPartitionIndex + newPartitions.length | 0, Object.assign(registeringContracts, indexingContracts), Caml_option.some(existingDcs !== undefined ? Belt_Array.concat(existingDcs, dcsToStore) : dcsToStore), currentBlockHeight, undefined, undefined);
 }
 
 var UnexpectedPartitionNotFound = /* @__PURE__ */Caml_exceptions.create("FetchState.UnexpectedPartitionNotFound");
@@ -413,7 +414,7 @@ function handleQueryResult(fetchState, query, latestFetchedBlock, reversedNewIte
     };
   }
   return Belt_Result.map(tmp, (function (partitions) {
-                return updateInternal(fetchState, partitions, undefined, undefined, undefined, currentBlockHeight, mergeSortedEventList(reversedNewItems, fetchState.queue));
+                return updateInternal(fetchState, partitions, undefined, undefined, undefined, currentBlockHeight, mergeSortedEventList(reversedNewItems, fetchState.queue), undefined);
               }));
 }
 
@@ -501,19 +502,19 @@ function isFullPartition(p, maxAddrInPartition) {
 }
 
 function getNextQuery(param, concurrencyLimit, targetBufferSize, currentBlockHeight, stateId) {
-  if (currentBlockHeight === 0) {
-    return "WaitingForNewBlock";
-  }
-  if (concurrencyLimit === 0) {
-    return "ReachedMaxConcurrency";
-  }
   var queue = param.queue;
   var blockLag = param.blockLag;
   var indexingContracts = param.indexingContracts;
   var maxAddrInPartition = param.maxAddrInPartition;
   var endBlock = param.endBlock;
   var partitions = param.partitions;
-  var headBlock = currentBlockHeight - Belt_Option.getWithDefault(blockLag, 0) | 0;
+  var headBlock = currentBlockHeight - blockLag | 0;
+  if (headBlock <= 0) {
+    return "WaitingForNewBlock";
+  }
+  if (concurrencyLimit === 0) {
+    return "ReachedMaxConcurrency";
+  }
   var fullPartitions = [];
   var mergingPartitions = [];
   var areMergingPartitionsFetching = false;
@@ -575,7 +576,7 @@ function getNextQuery(param, concurrencyLimit, targetBufferSize, currentBlockHei
     if (!(!checkIsFetchingPartition(p) && p.latestFetchedBlock.blockNumber < maxQueryBlockNumber)) {
       return ;
     }
-    var q = makePartitionQuery(p, indexingContracts, blockLag !== undefined ? (
+    var q = makePartitionQuery(p, indexingContracts, blockLag !== 0 ? (
             endBlock !== undefined ? (
                 headBlock < endBlock ? headBlock : endBlock
               ) : headBlock
@@ -639,14 +640,6 @@ function queueItemBlockNumber(queueItem) {
   }
 }
 
-function queueItemIsInReorgThreshold(queueItem, currentBlockHeight, highestBlockBelowThreshold) {
-  if (currentBlockHeight === 0) {
-    return false;
-  } else {
-    return queueItemBlockNumber(queueItem) > highestBlockBelowThreshold;
-  }
-}
-
 function makeNoItem(param) {
   return {
           TAG: "NoItem",
@@ -698,7 +691,8 @@ function getEarliestEvent(param) {
   }
 }
 
-function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, blockLag) {
+function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, blockLagOpt) {
+  var blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
   var latestFetchedBlock_blockNumber = startBlock - 1 | 0;
   var latestFetchedBlock = {
     blockNumber: latestFetchedBlock_blockNumber,
@@ -810,7 +804,7 @@ function make(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition,
         };
 }
 
-function queueSize(param) {
+function bufferSize(param) {
   return param.queue.length;
 }
 
@@ -898,7 +892,7 @@ function rollback(fetchState, firstChangeEvent) {
   } else {
     tmp = undefined;
   }
-  return updateInternal(fetchState, partitions, undefined, indexingContracts, Caml_option.some(tmp), undefined, pruneQueueFromFirstChangeEvent(fetchState.queue, firstChangeEvent));
+  return updateInternal(fetchState, partitions, undefined, indexingContracts, Caml_option.some(tmp), undefined, pruneQueueFromFirstChangeEvent(fetchState.queue, firstChangeEvent), undefined);
 }
 
 function isActivelyIndexing(fetchState) {
@@ -908,12 +902,42 @@ function isActivelyIndexing(fetchState) {
   }
   var isPastEndblock = fetchState.latestFullyFetchedBlock.blockNumber >= endBlock;
   if (isPastEndblock) {
-    return queueSize(fetchState) > 0;
+    return bufferSize(fetchState) > 0;
   } else {
     return true;
   }
 }
 
+function isReadyToEnterReorgThreshold(param, currentBlockHeight) {
+  var blockLag = param.blockLag;
+  var latestFullyFetchedBlock = param.latestFullyFetchedBlock;
+  var endBlock = param.endBlock;
+  if (currentBlockHeight !== 0 && (
+      endBlock !== undefined && latestFullyFetchedBlock.blockNumber >= endBlock ? true : latestFullyFetchedBlock.blockNumber >= (currentBlockHeight - blockLag | 0)
+    )) {
+    return Utils.$$Array.isEmpty(param.queue);
+  } else {
+    return false;
+  }
+}
+
+function hasBatchItem(param) {
+  var item = Utils.$$Array.last(param.queue);
+  if (item !== undefined) {
+    return item.blockNumber <= param.latestFullyFetchedBlock.blockNumber;
+  } else {
+    return false;
+  }
+}
+
+function compareUnorderedBatchChainPriority(a, b) {
+  return Utils.$$Array.lastUnsafe(a.queue).timestamp - Utils.$$Array.lastUnsafe(b.queue).timestamp | 0;
+}
+
+function filterAndSortForUnorderedBatch(fetchStates) {
+  return Belt_Array.keepU(fetchStates, hasBatchItem).sort(compareUnorderedBatchChainPriority);
+}
+
 exports.copy = copy;
 exports.eventItemGt = eventItemGt;
 exports.mergeSortedEventList = mergeSortedEventList;
@@ -933,15 +957,16 @@ exports.addressesByContractNameGetAll = addressesByContractNameGetAll;
 exports.isFullPartition = isFullPartition;
 exports.getNextQuery = getNextQuery;
 exports.queueItemBlockNumber = queueItemBlockNumber;
-exports.queueItemIsInReorgThreshold = queueItemIsInReorgThreshold;
 exports.makeNoItem = makeNoItem;
 exports.qItemLt = qItemLt;
 exports.getEarliestEvent = getEarliestEvent;
 exports.make = make;
-exports.queueSize = queueSize;
+exports.bufferSize = bufferSize;
 exports.getLatestFullyFetchedBlock = getLatestFullyFetchedBlock;
 exports.pruneQueueFromFirstChangeEvent = pruneQueueFromFirstChangeEvent;
 exports.rollbackPartition = rollbackPartition;
 exports.rollback = rollback;
 exports.isActivelyIndexing = isActivelyIndexing;
+exports.isReadyToEnterReorgThreshold = isReadyToEnterReorgThreshold;
+exports.filterAndSortForUnorderedBatch = filterAndSortForUnorderedBatch;
 /* Utils Not a pure module */

package/src/Prometheus.res

@@ -472,6 +472,17 @@ module ReorgDetectionBlockNumber = {
   }
 }
 
+module ReorgThreshold = {
+  let gauge = PromClient.Gauge.makeGauge({
+    "name": "envio_reorg_threshold",
+    "help": "Whether indexing is currently within the reorg threshold",
+  })
+
+  let set = (~isInReorgThreshold) => {
+    gauge->PromClient.Gauge.set(isInReorgThreshold ? 1 : 0)
+  }
+}
+
 module RollbackEnabled = {
   let gauge = PromClient.Gauge.makeGauge({
     "name": "envio_rollback_enabled",

package/src/Prometheus.res.js

@@ -573,17 +573,31 @@ var ReorgDetectionBlockNumber = {
 };
 
 var gauge$14 = new PromClient.Gauge({
+      name: "envio_reorg_threshold",
+      help: "Whether indexing is currently within the reorg threshold"
+    });
+
+function set$14(isInReorgThreshold) {
+  gauge$14.set(isInReorgThreshold ? 1 : 0);
+}
+
+var ReorgThreshold = {
+  gauge: gauge$14,
+  set: set$14
+};
+
+var gauge$15 = new PromClient.Gauge({
       name: "envio_rollback_enabled",
       help: "Whether rollback on reorg is enabled"
     });
 
-function set$14(enabled) {
-  gauge$14.set(enabled ? 1 : 0);
+function set$15(enabled) {
+  gauge$15.set(enabled ? 1 : 0);
 }
 
 var RollbackEnabled = {
-  gauge: gauge$14,
-  set: set$14
+  gauge: gauge$15,
+  set: set$15
 };
 
 var histogram = new PromClient.Histogram({
@@ -606,62 +620,62 @@ var RollbackDuration = {
   startTimer: startTimer$1
 };
 
-var gauge$15 = makeOrThrow$1("envio_rollback_target_block_number", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
+var gauge$16 = makeOrThrow$1("envio_rollback_target_block_number", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
 
-function set$15(blockNumber, chain) {
-  handleInt$1(gauge$15, chain, blockNumber);
+function set$16(blockNumber, chain) {
+  handleInt$1(gauge$16, chain, blockNumber);
 }
 
 var RollbackTargetBlockNumber = {
-  gauge: gauge$15,
-  set: set$15
+  gauge: gauge$16,
+  set: set$16
 };
 
-var gauge$16 = makeOrThrow$1("envio_processing_block_number", "The latest item block number included in the currently processing batch for the chain.", chainIdLabelsSchema);
+var gauge$17 = makeOrThrow$1("envio_processing_block_number", "The latest item block number included in the currently processing batch for the chain.", chainIdLabelsSchema);
 
-function set$16(blockNumber, chainId) {
-  handleInt$1(gauge$16, chainId, blockNumber);
+function set$17(blockNumber, chainId) {
+  handleInt$1(gauge$17, chainId, blockNumber);
 }
 
 var ProcessingBlockNumber = {
-  gauge: gauge$16,
-  set: set$16
+  gauge: gauge$17,
+  set: set$17
 };
 
-var gauge$17 = makeOrThrow$1("envio_processing_batch_size", "The number of items included in the currently processing batch for the chain.", chainIdLabelsSchema);
+var gauge$18 = makeOrThrow$1("envio_processing_batch_size", "The number of items included in the currently processing batch for the chain.", chainIdLabelsSchema);
 
-function set$17(batchSize, chainId) {
-  handleInt$1(gauge$17, chainId, batchSize);
+function set$18(batchSize, chainId) {
+  handleInt$1(gauge$18, chainId, batchSize);
 }
 
 var ProcessingBatchSize = {
-  gauge: gauge$17,
-  set: set$17
+  gauge: gauge$18,
+  set: set$18
 };
 
-var gauge$18 = new PromClient.Gauge({
+var gauge$19 = new PromClient.Gauge({
       name: "envio_processing_max_batch_size",
       help: "The maximum number of items to process in a single batch."
     });
 
-function set$18(maxBatchSize) {
-  gauge$18.set(maxBatchSize);
+function set$19(maxBatchSize) {
+  gauge$19.set(maxBatchSize);
 }
 
 var ProcessingMaxBatchSize = {
-  gauge: gauge$18,
-  set: set$18
+  gauge: gauge$19,
+  set: set$19
 };
 
-var gauge$19 = makeOrThrow$1("envio_progress_block_number", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+var gauge$20 = makeOrThrow$1("envio_progress_block_number", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$19(blockNumber, chainId) {
-  handleInt$1(gauge$19, chainId, blockNumber);
+function set$20(blockNumber, chainId) {
+  handleInt$1(gauge$20, chainId, blockNumber);
 }
 
 var ProgressBlockNumber = {
-  gauge: gauge$19,
-  set: set$19
+  gauge: gauge$20,
+  set: set$20
 };
 
 var deprecatedGauge$1 = new PromClient.Gauge({
@@ -670,45 +684,45 @@ var deprecatedGauge$1 = new PromClient.Gauge({
       labelNames: ["chainId"]
     });
 
-var gauge$20 = makeOrThrow$1("envio_progress_events_count", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+var gauge$21 = makeOrThrow$1("envio_progress_events_count", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$20(processedCount, chainId) {
+function set$21(processedCount, chainId) {
   deprecatedGauge$1.labels({
           chainId: chainId
         }).set(processedCount);
-  handleInt$1(gauge$20, chainId, processedCount);
+  handleInt$1(gauge$21, chainId, processedCount);
 }
 
 var ProgressEventsCount = {
   deprecatedGauge: deprecatedGauge$1,
-  gauge: gauge$20,
-  set: set$20
+  gauge: gauge$21,
+  set: set$21
 };
 
 var effectLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("effect", S$RescriptSchema.string);
     });
 
-var gauge$21 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
+var gauge$22 = makeOrThrow$1("envio_effect_calls_count", "The number of calls to the effect. Including both handler execution and cache hits.", effectLabelsSchema);
 
-function set$21(callsCount, effectName) {
-  handleInt$1(gauge$21, effectName, callsCount);
+function set$22(callsCount, effectName) {
+  handleInt$1(gauge$22, effectName, callsCount);
 }
 
 var EffectCallsCount = {
-  gauge: gauge$21,
-  set: set$21
+  gauge: gauge$22,
+  set: set$22
 };
 
-var gauge$22 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
+var gauge$23 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$22(count, effectName) {
-  handleInt$1(gauge$22, effectName, count);
+function set$23(count, effectName) {
+  handleInt$1(gauge$23, effectName, count);
 }
 
 var EffectCacheCount = {
-  gauge: gauge$22,
-  set: set$22
+  gauge: gauge$23,
+  set: set$23
 };
 
 exports.loadEntitiesDurationCounter = loadEntitiesDurationCounter;
@@ -748,6 +762,7 @@ exports.SourceHeight = SourceHeight;
 exports.SourceGetHeightDuration = SourceGetHeightDuration;
 exports.ReorgCount = ReorgCount;
 exports.ReorgDetectionBlockNumber = ReorgDetectionBlockNumber;
+exports.ReorgThreshold = ReorgThreshold;
 exports.RollbackEnabled = RollbackEnabled;
 exports.RollbackDuration = RollbackDuration;
 exports.RollbackTargetBlockNumber = RollbackTargetBlockNumber;

package/src/Utils.res

@@ -250,6 +250,8 @@ Helper to check if a value exists in an array
 
   let last = (arr: array<'a>): option<'a> => arr->Belt.Array.get(arr->Array.length - 1)
 
+  let lastUnsafe = (arr: array<'a>): 'a => arr->Belt.Array.getUnsafe(arr->Array.length - 1)
+
   let findReverseWithIndex = (arr: array<'a>, fn: 'a => bool): option<('a, int)> => {
     let rec loop = (index: int) => {
       if index < 0 {

package/src/Utils.res.js

@@ -268,6 +268,10 @@ function last(arr) {
   return Belt_Array.get(arr, arr.length - 1 | 0);
 }
 
+function lastUnsafe(arr) {
+  return arr[arr.length - 1 | 0];
+}
+
 function findReverseWithIndex(arr, fn) {
   var _index = arr.length - 1 | 0;
   while(true) {
@@ -310,6 +314,7 @@ var $$Array$1 = {
   awaitEach: awaitEach,
   removeAtIndex: removeAtIndex,
   last: last,
+  lastUnsafe: lastUnsafe,
   findReverseWithIndex: findReverseWithIndex,
   interleave: interleave
 };