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

package/src/FetchState.res.mjs

@@ -1,40 +1,40 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Caml from "rescript/lib/es6/caml.js";
 import * as Utils from "./Utils.res.mjs";
-import * as Js_exn from "rescript/lib/es6/js_exn.js";
-import * as Js_dict from "rescript/lib/es6/js_dict.js";
-import * as Js_math from "rescript/lib/es6/js_math.js";
+import * as Js_math from "@rescript/runtime/lib/es6/Js_math.js";
 import * as Logging from "./Logging.res.mjs";
-import * as Belt_Int from "rescript/lib/es6/belt_Int.js";
-import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
-import * as Caml_int32 from "rescript/lib/es6/caml_int32.js";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Prometheus from "./Prometheus.res.mjs";
-import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.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 deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
+  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
+}
 
 function getMinHistoryRange(p) {
-  var match = p.prevQueryRange;
-  var match$1 = p.prevPrevQueryRange;
+  let match = p.prevQueryRange;
+  let match$1 = p.prevPrevQueryRange;
   if (match !== 0 && match$1 !== 0) {
     return match < match$1 ? match : match$1;
   }
-  
 }
 
 function getMinQueryRange(partitions) {
-  var min = 0;
-  for(var i = 0 ,i_finish = partitions.length; i < i_finish; ++i){
-    var p = partitions[i];
-    var a = p.prevQueryRange;
-    var b = p.prevPrevQueryRange;
+  let min = 0;
+  for (let i = 0, i_finish = partitions.length; i < i_finish; ++i) {
+    let p = partitions[i];
+    let a = p.prevQueryRange;
+    let b = p.prevPrevQueryRange;
     if (a > 0 && (min === 0 || a < min)) {
       min = a;
     }
     if (b > 0 && (min === 0 || b < min)) {
       min = b;
     }
-    
   }
   return min;
 }
@@ -44,52 +44,52 @@ function count(optimizedPartitions) {
 }
 
 function getOrThrow(optimizedPartitions, partitionId) {
-  var p = Js_dict.get(optimizedPartitions.entities, partitionId);
+  let p = optimizedPartitions.entities[partitionId];
   if (p !== undefined) {
     return p;
   } else {
-    return Js_exn.raiseError("Unexpected case: Couldn't find partition " + partitionId);
+    return Stdlib_JsError.throwWithMessage(`Unexpected case: Couldn't find partition ` + partitionId);
   }
 }
 
 function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAddrInPartition, nextPartitionIndexRef) {
-  var combinedAddresses = p1.addressesByContractName[contractName].concat(p2.addressesByContractName[contractName]);
-  var p1Below = p1.latestFetchedBlock.blockNumber < potentialMergeBlock;
-  var p2Below = p2.latestFetchedBlock.blockNumber < potentialMergeBlock;
-  var completed = [];
-  var continuingBase;
+  let combinedAddresses = p1.addressesByContractName[contractName].concat(p2.addressesByContractName[contractName]);
+  let p1Below = p1.latestFetchedBlock.blockNumber < potentialMergeBlock;
+  let p2Below = p2.latestFetchedBlock.blockNumber < potentialMergeBlock;
+  let completed = [];
+  let continuingBase;
   if (p1Below) {
-    completed.push({
-          id: p1.id,
-          latestFetchedBlock: p1.latestFetchedBlock,
-          selection: p1.selection,
-          addressesByContractName: p1.addressesByContractName,
-          mergeBlock: potentialMergeBlock,
-          dynamicContract: p1.dynamicContract,
-          mutPendingQueries: p1.mutPendingQueries,
-          prevQueryRange: p1.prevQueryRange,
-          prevPrevQueryRange: p1.prevPrevQueryRange,
-          latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
-        });
     if (p2Below) {
       completed.push({
-            id: p2.id,
-            latestFetchedBlock: p2.latestFetchedBlock,
-            selection: p2.selection,
-            addressesByContractName: p2.addressesByContractName,
-            mergeBlock: potentialMergeBlock,
-            dynamicContract: p2.dynamicContract,
-            mutPendingQueries: p2.mutPendingQueries,
-            prevQueryRange: p2.prevQueryRange,
-            prevPrevQueryRange: p2.prevPrevQueryRange,
-            latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
-          });
-      var newId = nextPartitionIndexRef.contents.toString();
+        id: p1.id,
+        latestFetchedBlock: p1.latestFetchedBlock,
+        selection: p1.selection,
+        addressesByContractName: p1.addressesByContractName,
+        mergeBlock: potentialMergeBlock,
+        dynamicContract: p1.dynamicContract,
+        mutPendingQueries: p1.mutPendingQueries,
+        prevQueryRange: p1.prevQueryRange,
+        prevPrevQueryRange: p1.prevPrevQueryRange,
+        latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
+      });
+      completed.push({
+        id: p2.id,
+        latestFetchedBlock: p2.latestFetchedBlock,
+        selection: p2.selection,
+        addressesByContractName: p2.addressesByContractName,
+        mergeBlock: potentialMergeBlock,
+        dynamicContract: p2.dynamicContract,
+        mutPendingQueries: p2.mutPendingQueries,
+        prevQueryRange: p2.prevQueryRange,
+        prevPrevQueryRange: p2.prevPrevQueryRange,
+        latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+      });
+      let newId = nextPartitionIndexRef.contents.toString();
       nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
-      var minRange = getMinQueryRange([
-            p1,
-            p2
-          ]);
+      let minRange = getMinQueryRange([
+        p1,
+        p2
+      ]);
       continuingBase = {
         id: newId,
         latestFetchedBlock: {
@@ -106,106 +106,119 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         latestBlockRangeUpdateBlock: 0
       };
     } else {
+      completed.push({
+        id: p1.id,
+        latestFetchedBlock: p1.latestFetchedBlock,
+        selection: p1.selection,
+        addressesByContractName: p1.addressesByContractName,
+        mergeBlock: potentialMergeBlock,
+        dynamicContract: p1.dynamicContract,
+        mutPendingQueries: p1.mutPendingQueries,
+        prevQueryRange: p1.prevQueryRange,
+        prevPrevQueryRange: p1.prevPrevQueryRange,
+        latestBlockRangeUpdateBlock: p1.latestBlockRangeUpdateBlock
+      });
       continuingBase = p2;
     }
   } else if (p2Below) {
     completed.push({
-          id: p2.id,
-          latestFetchedBlock: p2.latestFetchedBlock,
-          selection: p2.selection,
-          addressesByContractName: p2.addressesByContractName,
-          mergeBlock: potentialMergeBlock,
-          dynamicContract: p2.dynamicContract,
-          mutPendingQueries: p2.mutPendingQueries,
-          prevQueryRange: p2.prevQueryRange,
-          prevPrevQueryRange: p2.prevPrevQueryRange,
-          latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
-        });
+      id: p2.id,
+      latestFetchedBlock: p2.latestFetchedBlock,
+      selection: p2.selection,
+      addressesByContractName: p2.addressesByContractName,
+      mergeBlock: potentialMergeBlock,
+      dynamicContract: p2.dynamicContract,
+      mutPendingQueries: p2.mutPendingQueries,
+      prevQueryRange: p2.prevQueryRange,
+      prevPrevQueryRange: p2.prevPrevQueryRange,
+      latestBlockRangeUpdateBlock: p2.latestBlockRangeUpdateBlock
+    });
     continuingBase = p1;
   } else {
     continuingBase = p1;
   }
   if (combinedAddresses.length > maxAddrInPartition) {
-    var addressesFull = combinedAddresses.slice(0, maxAddrInPartition);
-    var addressesRest = combinedAddresses.slice(maxAddrInPartition);
-    var abcFull = {};
+    let addressesFull = combinedAddresses.slice(0, maxAddrInPartition);
+    let addressesRest = combinedAddresses.slice(maxAddrInPartition);
+    let abcFull = {};
     abcFull[contractName] = addressesFull;
-    var abcRest = {};
+    let abcRest = {};
     abcRest[contractName] = addressesRest;
     completed.push({
-          id: continuingBase.id,
-          latestFetchedBlock: continuingBase.latestFetchedBlock,
-          selection: continuingBase.selection,
-          addressesByContractName: abcFull,
-          mergeBlock: continuingBase.mergeBlock,
-          dynamicContract: continuingBase.dynamicContract,
-          mutPendingQueries: continuingBase.mutPendingQueries,
-          prevQueryRange: continuingBase.prevQueryRange,
-          prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-          latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
-        });
-    var restId = nextPartitionIndexRef.contents.toString();
+      id: continuingBase.id,
+      latestFetchedBlock: continuingBase.latestFetchedBlock,
+      selection: continuingBase.selection,
+      addressesByContractName: abcFull,
+      mergeBlock: continuingBase.mergeBlock,
+      dynamicContract: continuingBase.dynamicContract,
+      mutPendingQueries: continuingBase.mutPendingQueries,
+      prevQueryRange: continuingBase.prevQueryRange,
+      prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+      latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+    });
+    let restId = nextPartitionIndexRef.contents.toString();
     nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
     completed.push({
-          id: restId,
-          latestFetchedBlock: continuingBase.latestFetchedBlock,
-          selection: continuingBase.selection,
-          addressesByContractName: abcRest,
-          mergeBlock: continuingBase.mergeBlock,
-          dynamicContract: continuingBase.dynamicContract,
-          mutPendingQueries: [],
-          prevQueryRange: continuingBase.prevQueryRange,
-          prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-          latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
-        });
+      id: restId,
+      latestFetchedBlock: continuingBase.latestFetchedBlock,
+      selection: continuingBase.selection,
+      addressesByContractName: abcRest,
+      mergeBlock: continuingBase.mergeBlock,
+      dynamicContract: continuingBase.dynamicContract,
+      mutPendingQueries: [],
+      prevQueryRange: continuingBase.prevQueryRange,
+      prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+      latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+    });
     return completed;
   }
-  var abc = {};
+  let abc = {};
   abc[contractName] = combinedAddresses;
   completed.push({
-        id: continuingBase.id,
-        latestFetchedBlock: continuingBase.latestFetchedBlock,
-        selection: continuingBase.selection,
-        addressesByContractName: abc,
-        mergeBlock: continuingBase.mergeBlock,
-        dynamicContract: continuingBase.dynamicContract,
-        mutPendingQueries: continuingBase.mutPendingQueries,
-        prevQueryRange: continuingBase.prevQueryRange,
-        prevPrevQueryRange: continuingBase.prevPrevQueryRange,
-        latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
-      });
+    id: continuingBase.id,
+    latestFetchedBlock: continuingBase.latestFetchedBlock,
+    selection: continuingBase.selection,
+    addressesByContractName: abc,
+    mergeBlock: continuingBase.mergeBlock,
+    dynamicContract: continuingBase.dynamicContract,
+    mutPendingQueries: continuingBase.mutPendingQueries,
+    prevQueryRange: continuingBase.prevQueryRange,
+    prevPrevQueryRange: continuingBase.prevPrevQueryRange,
+    latestBlockRangeUpdateBlock: continuingBase.latestBlockRangeUpdateBlock
+  });
   return completed;
 }
 
 function ascSortFn(a, b) {
-  return a.latestFetchedBlock.blockNumber - b.latestFetchedBlock.blockNumber | 0;
+  return Primitive_int.compare(a.latestFetchedBlock.blockNumber, b.latestFetchedBlock.blockNumber);
 }
 
 function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContracts) {
-  var newPartitions = [];
-  var mergingPartitions = {};
-  var nextPartitionIndexRef = {
+  let newPartitions = [];
+  let mergingPartitions = {};
+  let nextPartitionIndexRef = {
     contents: nextPartitionIndex
   };
-  for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
-    var p = partitions[idx];
-    if (p.dynamicContract !== undefined && !(p.mergeBlock !== undefined || !p.selection.dependsOnAddresses)) {
-      var contractName = p.dynamicContract;
-      var pAddressesCount = p.addressesByContractName[contractName].length;
-      var match = Utils.$$Array.last(p.mutPendingQueries);
-      var potentialMergeBlock;
+  for (let idx = 0, idx_finish = partitions.length; idx < idx_finish; ++idx) {
+    let p = partitions[idx];
+    let exit = 0;
+    if (p.dynamicContract !== undefined && p.mergeBlock === undefined && p.selection.dependsOnAddresses) {
+      let contractName = p.dynamicContract;
+      let pAddressesCount = p.addressesByContractName[contractName].length;
+      let match = Utils.$$Array.last(p.mutPendingQueries);
+      let potentialMergeBlock;
       if (match !== undefined) {
-        var toBlock = match.toBlock;
+        let toBlock = match.toBlock;
         potentialMergeBlock = toBlock !== undefined && match.isChunk ? toBlock : undefined;
       } else {
         potentialMergeBlock = p.latestFetchedBlock.blockNumber;
       }
       if (potentialMergeBlock !== undefined && pAddressesCount < maxAddrInPartition) {
-        var partitionsByMergeBlock = Utils.Dict.getOrInsertEmptyDict(mergingPartitions, contractName);
-        var existingPartition = partitionsByMergeBlock[potentialMergeBlock];
+        let partitionsByMergeBlock = Utils.Dict.getOrInsertEmptyDict(mergingPartitions, contractName);
+        let existingPartition = partitionsByMergeBlock[potentialMergeBlock];
         if (existingPartition !== undefined) {
-          var result = mergePartitionsAtBlock(existingPartition, p, potentialMergeBlock, contractName, maxAddrInPartition, nextPartitionIndexRef);
-          for(var i = 0 ,i_finish = result.length - 2 | 0; i <= i_finish; ++i){
+          let result = mergePartitionsAtBlock(existingPartition, p, potentialMergeBlock, contractName, maxAddrInPartition, nextPartitionIndexRef);
+          for (let i = 0, i_finish = result.length - 2 | 0; i <= i_finish; ++i) {
             newPartitions.push(result[i]);
           }
           partitionsByMergeBlock[potentialMergeBlock] = Utils.$$Array.lastUnsafe(result);
@@ -216,34 +229,37 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
         newPartitions.push(p);
       }
     } else {
+      exit = 1;
+    }
+    if (exit === 1) {
       newPartitions.push(p);
     }
   }
-  var merginDynamicContracts = Object.keys(mergingPartitions);
-  for(var idx$1 = 0 ,idx_finish$1 = merginDynamicContracts.length; idx$1 < idx_finish$1; ++idx$1){
-    var contractName$1 = merginDynamicContracts[idx$1];
-    var partitionsByMergeBlock$1 = mergingPartitions[contractName$1];
-    var ascPartitionKeys = Object.keys(partitionsByMergeBlock$1);
+  let merginDynamicContracts = Object.keys(mergingPartitions);
+  for (let idx$1 = 0, idx_finish$1 = merginDynamicContracts.length; idx$1 < idx_finish$1; ++idx$1) {
+    let contractName$1 = merginDynamicContracts[idx$1];
+    let partitionsByMergeBlock$1 = mergingPartitions[contractName$1];
+    let ascPartitionKeys = Object.keys(partitionsByMergeBlock$1);
     if (ascPartitionKeys[ascPartitionKeys.length - 1 | 0] === "-1") {
-      ascPartitionKeys.unshift(Caml_option.undefined_to_opt(ascPartitionKeys.pop()));
+      ascPartitionKeys.unshift(ascPartitionKeys.pop());
     }
-    var currentPRef = partitionsByMergeBlock$1[Utils.$$Array.firstUnsafe(ascPartitionKeys)];
-    var currentPMergeBlockRef = Belt_Int.fromString(Utils.$$Array.firstUnsafe(ascPartitionKeys));
-    var nextJdx = 1;
-    while(nextJdx < ascPartitionKeys.length) {
-      var nextKey = ascPartitionKeys[nextJdx];
-      var currentP = currentPRef;
-      var nextP = partitionsByMergeBlock$1[nextKey];
-      var nextPMergeBlock = Belt_Int.fromString(nextKey);
-      var currentPMergeBlock = currentPMergeBlockRef;
-      var isTooFar = (currentPMergeBlock + 20000 | 0) < nextPMergeBlock;
+    let currentPRef = partitionsByMergeBlock$1[Utils.$$Array.firstUnsafe(ascPartitionKeys)];
+    let currentPMergeBlockRef = Stdlib_Int.fromString(Utils.$$Array.firstUnsafe(ascPartitionKeys), undefined);
+    let nextJdx = 1;
+    while (nextJdx < ascPartitionKeys.length) {
+      let nextKey = ascPartitionKeys[nextJdx];
+      let currentP = currentPRef;
+      let nextP = partitionsByMergeBlock$1[nextKey];
+      let nextPMergeBlock = Stdlib_Int.fromString(nextKey, undefined);
+      let currentPMergeBlock = currentPMergeBlockRef;
+      let isTooFar = (currentPMergeBlock + 20000 | 0) < nextPMergeBlock;
       if (isTooFar) {
         newPartitions.push(currentP);
         currentPRef = nextP;
         currentPMergeBlockRef = nextPMergeBlock;
       } else {
-        var result$1 = mergePartitionsAtBlock(nextP, currentP, nextPMergeBlock, contractName$1, maxAddrInPartition, nextPartitionIndexRef);
-        for(var i$1 = 0 ,i_finish$1 = result$1.length - 2 | 0; i$1 <= i_finish$1; ++i$1){
+        let result$1 = mergePartitionsAtBlock(nextP, currentP, nextPMergeBlock, contractName$1, maxAddrInPartition, nextPartitionIndexRef);
+        for (let i$1 = 0, i_finish$1 = result$1.length - 2 | 0; i$1 <= i_finish$1; ++i$1) {
           newPartitions.push(result$1[i$1]);
         }
         currentPRef = Utils.$$Array.lastUnsafe(result$1);
@@ -254,74 +270,72 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
     newPartitions.push(currentPRef);
   }
   newPartitions.sort(ascSortFn);
-  var partitionsCount = newPartitions.length;
-  var idsInAscOrder = new Array(partitionsCount);
-  var entities = {};
-  for(var idx$2 = 0; idx$2 < partitionsCount; ++idx$2){
-    var p$1 = newPartitions[idx$2];
+  let partitionsCount = newPartitions.length;
+  let idsInAscOrder = new Array(partitionsCount);
+  let entities = {};
+  for (let idx$2 = 0; idx$2 < partitionsCount; ++idx$2) {
+    let p$1 = newPartitions[idx$2];
     idsInAscOrder[idx$2] = p$1.id;
     entities[p$1.id] = p$1;
   }
   return {
-          idsInAscOrder: idsInAscOrder,
-          entities: entities,
-          maxAddrInPartition: maxAddrInPartition,
-          nextPartitionIndex: nextPartitionIndexRef.contents,
-          dynamicContracts: dynamicContracts
-        };
+    idsInAscOrder: idsInAscOrder,
+    entities: entities,
+    maxAddrInPartition: maxAddrInPartition,
+    nextPartitionIndex: nextPartitionIndexRef.contents,
+    dynamicContracts: dynamicContracts
+  };
 }
 
 function consumeFetchedQueries(mutPendingQueries, initialLatestFetchedBlock) {
-  var latestFetchedBlock = initialLatestFetchedBlock;
-  while((function () {
-          var tmp = false;
-          if (mutPendingQueries.length !== 0) {
-            var pq = Utils.$$Array.firstUnsafe(mutPendingQueries);
-            tmp = pq.fetchedBlock !== undefined && pq.fromBlock <= (latestFetchedBlock.blockNumber + 1 | 0);
-          }
-          return tmp;
-        })()) {
-    var removedQuery = mutPendingQueries.shift();
-    latestFetchedBlock = (
-      removedQuery === undefined ? undefined : Caml_option.some(removedQuery)
-    ).fetchedBlock;
+  let latestFetchedBlock = initialLatestFetchedBlock;
+  while ((() => {
+      let tmp = false;
+      if (mutPendingQueries.length !== 0) {
+        let pq = Utils.$$Array.firstUnsafe(mutPendingQueries);
+        tmp = pq.fetchedBlock !== undefined && pq.fromBlock <= (latestFetchedBlock.blockNumber + 1 | 0);
+      }
+      return tmp;
+    })()) {
+    let removedQuery = mutPendingQueries.shift();
+    latestFetchedBlock = removedQuery.fetchedBlock;
   };
   return latestFetchedBlock;
 }
 
 function getPendingQueryOrThrow(p, fromBlock) {
-  var idxRef = 0;
-  var pendingQueryRef;
-  while(idxRef < p.mutPendingQueries.length && pendingQueryRef === undefined) {
-    var pq = p.mutPendingQueries[idxRef];
+  let idxRef = 0;
+  let pendingQueryRef;
+  while (idxRef < p.mutPendingQueries.length && pendingQueryRef === undefined) {
+    let pq = p.mutPendingQueries[idxRef];
     if (pq.fromBlock === fromBlock) {
       pendingQueryRef = pq;
     }
     idxRef = idxRef + 1 | 0;
   };
-  var pq$1 = pendingQueryRef;
+  let pq$1 = pendingQueryRef;
   if (pq$1 !== undefined) {
     return pq$1;
   } else {
-    return Js_exn.raiseError("Pending query not found for partition " + p.id + " fromBlock " + String(fromBlock));
+    return Stdlib_JsError.throwWithMessage(`Pending query not found for partition ` + p.id + ` fromBlock ` + fromBlock.toString());
   }
 }
 
 function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetchedBlock) {
-  var partitionId = query.partitionId;
-  var p = Js_dict.get(optimizedPartitions.entities, partitionId);
-  var p$1 = p !== undefined ? p : Js_exn.raiseError("Unexpected case: Couldn't find partition " + partitionId);
-  var mutEntities = Utils.Dict.shallowCopy(optimizedPartitions.entities);
-  var pendingQuery = getPendingQueryOrThrow(p$1, query.fromBlock);
+  let partitionId = query.partitionId;
+  let p = optimizedPartitions.entities[partitionId];
+  let p$1 = p !== undefined ? p : Stdlib_JsError.throwWithMessage(`Unexpected case: Couldn't find partition ` + partitionId);
+  let mutEntities = Utils.Dict.shallowCopy(optimizedPartitions.entities);
+  let pendingQuery = getPendingQueryOrThrow(p$1, query.fromBlock);
   pendingQuery.fetchedBlock = latestFetchedBlock;
-  var blockRange = (latestFetchedBlock.blockNumber - query.fromBlock | 0) + 1 | 0;
-  var shouldUpdateBlockRange = false;
+  let blockRange = (latestFetchedBlock.blockNumber - query.fromBlock | 0) + 1 | 0;
+  let shouldUpdateBlockRange = false;
   if (latestFetchedBlock.blockNumber > p$1.latestBlockRangeUpdateBlock) {
-    var queryToBlock = query.toBlock;
-    var tmp;
+    let queryToBlock = query.toBlock;
+    let tmp;
     if (queryToBlock !== undefined) {
       if (latestFetchedBlock.blockNumber >= queryToBlock) {
-        var minHistoryRange = getMinHistoryRange(p$1);
+        let minHistoryRange = getMinHistoryRange(p$1);
         tmp = minHistoryRange !== undefined ? ((queryToBlock - query.fromBlock | 0) + 1 | 0) >= minHistoryRange : false;
       } else {
         tmp = true;
@@ -331,37 +345,35 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetc
     }
     shouldUpdateBlockRange = tmp;
   }
-  var updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p$1.prevQueryRange;
-  var updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p$1.prevQueryRange : p$1.prevPrevQueryRange;
-  var mutPendingQueries = p$1.mutPendingQueries;
-  var latestFetchedBlock$1 = p$1.latestFetchedBlock;
-  while((function () {
-          var tmp = false;
-          if (mutPendingQueries.length !== 0) {
-            var pq = Utils.$$Array.firstUnsafe(mutPendingQueries);
-            tmp = pq.fetchedBlock !== undefined && pq.fromBlock <= (latestFetchedBlock$1.blockNumber + 1 | 0);
-          }
-          return tmp;
-        })()) {
-    var removedQuery = mutPendingQueries.shift();
-    latestFetchedBlock$1 = (
-      removedQuery === undefined ? undefined : Caml_option.some(removedQuery)
-    ).fetchedBlock;
+  let updatedPrevQueryRange = shouldUpdateBlockRange ? blockRange : p$1.prevQueryRange;
+  let updatedPrevPrevQueryRange = shouldUpdateBlockRange ? p$1.prevQueryRange : p$1.prevPrevQueryRange;
+  let mutPendingQueries = p$1.mutPendingQueries;
+  let latestFetchedBlock$1 = p$1.latestFetchedBlock;
+  while ((() => {
+      let tmp = false;
+      if (mutPendingQueries.length !== 0) {
+        let pq = Utils.$$Array.firstUnsafe(mutPendingQueries);
+        tmp = pq.fetchedBlock !== undefined && pq.fromBlock <= (latestFetchedBlock$1.blockNumber + 1 | 0);
+      }
+      return tmp;
+    })()) {
+    let removedQuery = mutPendingQueries.shift();
+    latestFetchedBlock$1 = removedQuery.fetchedBlock;
   };
-  var updatedLatestFetchedBlock = latestFetchedBlock$1;
-  var mergeBlock = p$1.mergeBlock;
-  var partitionReachedMergeBlock = mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false;
+  let updatedLatestFetchedBlock = latestFetchedBlock$1;
+  let mergeBlock = p$1.mergeBlock;
+  let partitionReachedMergeBlock = mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false;
   if (partitionReachedMergeBlock) {
     Utils.Dict.deleteInPlace(mutEntities, p$1.id);
   } else {
-    var updatedMainPartition_id = p$1.id;
-    var updatedMainPartition_selection = p$1.selection;
-    var updatedMainPartition_addressesByContractName = p$1.addressesByContractName;
-    var updatedMainPartition_mergeBlock = p$1.mergeBlock;
-    var updatedMainPartition_dynamicContract = p$1.dynamicContract;
-    var updatedMainPartition_mutPendingQueries = p$1.mutPendingQueries;
-    var updatedMainPartition_latestBlockRangeUpdateBlock = shouldUpdateBlockRange ? latestFetchedBlock.blockNumber : p$1.latestBlockRangeUpdateBlock;
-    var updatedMainPartition = {
+    let updatedMainPartition_id = p$1.id;
+    let updatedMainPartition_selection = p$1.selection;
+    let updatedMainPartition_addressesByContractName = p$1.addressesByContractName;
+    let updatedMainPartition_mergeBlock = p$1.mergeBlock;
+    let updatedMainPartition_dynamicContract = p$1.dynamicContract;
+    let updatedMainPartition_mutPendingQueries = p$1.mutPendingQueries;
+    let updatedMainPartition_latestBlockRangeUpdateBlock = shouldUpdateBlockRange ? latestFetchedBlock.blockNumber : p$1.latestBlockRangeUpdateBlock;
+    let updatedMainPartition = {
       id: updatedMainPartition_id,
       latestFetchedBlock: updatedLatestFetchedBlock,
       selection: updatedMainPartition_selection,
@@ -375,18 +387,17 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, latestFetc
     };
     mutEntities[p$1.id] = updatedMainPartition;
   }
-  return make(Js_dict.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts);
+  return make(Object.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts);
 }
 
 function getLatestFullyFetchedBlock(optimizedPartitions) {
-  var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
+  let id = optimizedPartitions.idsInAscOrder[0];
   if (id !== undefined) {
     return optimizedPartitions.entities[id].latestFetchedBlock;
   }
-  
 }
 
-var OptimizedPartitions = {
+let OptimizedPartitions = {
   count: count,
   getOrThrow: getOrThrow,
   mergePartitionsAtBlock: mergePartitionsAtBlock,
@@ -400,10 +411,10 @@ var OptimizedPartitions = {
 };
 
 function bufferBlockNumber(param) {
-  var latestOnBlockBlockNumber = param.latestOnBlockBlockNumber;
-  var optimizedPartitions = param.optimizedPartitions;
-  var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
-  var latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+  let latestOnBlockBlockNumber = param.latestOnBlockBlockNumber;
+  let optimizedPartitions = param.optimizedPartitions;
+  let id = optimizedPartitions.idsInAscOrder[0];
+  let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
   if (latestFullyFetchedBlock !== undefined && latestOnBlockBlockNumber >= latestFullyFetchedBlock.blockNumber) {
     return latestFullyFetchedBlock.blockNumber;
   } else {
@@ -412,101 +423,100 @@ function bufferBlockNumber(param) {
 }
 
 function bufferBlock(param) {
-  var latestOnBlockBlockNumber = param.latestOnBlockBlockNumber;
-  var optimizedPartitions = param.optimizedPartitions;
-  var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
-  var latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+  let latestOnBlockBlockNumber = param.latestOnBlockBlockNumber;
+  let optimizedPartitions = param.optimizedPartitions;
+  let id = optimizedPartitions.idsInAscOrder[0];
+  let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
   if (latestFullyFetchedBlock !== undefined && latestOnBlockBlockNumber >= latestFullyFetchedBlock.blockNumber) {
     return latestFullyFetchedBlock;
   } else {
     return {
-            blockNumber: latestOnBlockBlockNumber,
-            blockTimestamp: 0
-          };
+      blockNumber: latestOnBlockBlockNumber,
+      blockTimestamp: 0
+    };
   }
 }
 
 function compareBufferItem(a, b) {
-  var blockDiff = a.blockNumber - b.blockNumber | 0;
-  if (blockDiff === 0) {
-    return a.logIndex - b.logIndex | 0;
+  let blockOrdering = Primitive_int.compare(a.blockNumber, b.blockNumber);
+  if (blockOrdering === 0) {
+    return Primitive_int.compare(a.logIndex, b.logIndex);
   } else {
-    return blockDiff;
+    return blockOrdering;
   }
 }
 
 function numAddresses(fetchState) {
-  return Object.keys(fetchState.indexingContracts).length;
+  return Utils.Dict.size(fetchState.indexingAddresses);
 }
 
-function updateInternal(fetchState, optimizedPartitionsOpt, indexingContractsOpt, mutItems, blockLagOpt, knownHeightOpt) {
-  var optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
-  var indexingContracts = indexingContractsOpt !== undefined ? indexingContractsOpt : fetchState.indexingContracts;
-  var blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
-  var knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
-  var mutItemsRef = mutItems;
-  var onBlockConfigs = fetchState.onBlockConfigs;
-  var latestOnBlockBlockNumber;
+function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt, mutItems, blockLagOpt, knownHeightOpt) {
+  let optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
+  let indexingAddresses = indexingAddressesOpt !== undefined ? indexingAddressesOpt : fetchState.indexingAddresses;
+  let blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
+  let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
+  let mutItemsRef = mutItems;
+  let onBlockConfigs = fetchState.onBlockConfigs;
+  let latestOnBlockBlockNumber;
   if (onBlockConfigs.length !== 0) {
-    var mutItems$1 = mutItemsRef;
-    var item = Belt_Array.get(mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer, fetchState.targetBufferSize - 1 | 0);
-    var maxBlockNumber;
+    let mutItems$1 = mutItemsRef;
+    let item = Belt_Array.get(mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer, fetchState.targetBufferSize - 1 | 0);
+    let maxBlockNumber;
     if (item !== undefined) {
       maxBlockNumber = item.blockNumber;
     } else {
-      var id = Belt_Array.get(optimizedPartitions.idsInAscOrder, 0);
-      var latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+      let id = optimizedPartitions.idsInAscOrder[0];
+      let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
       maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock.blockNumber : knownHeight;
     }
-    var mutItems$2 = mutItemsRef;
-    var mutItems$3 = mutItems$2 !== undefined ? mutItems$2 : fetchState.buffer.slice(0);
+    let mutItems$2 = mutItemsRef;
+    let mutItems$3 = mutItems$2 !== undefined ? mutItems$2 : fetchState.buffer.slice();
     mutItemsRef = mutItems$3;
-    var newItemsCounter = 0;
-    var latestOnBlockBlockNumber$1 = fetchState.latestOnBlockBlockNumber;
-    while(latestOnBlockBlockNumber$1 < maxBlockNumber && newItemsCounter <= fetchState.targetBufferSize) {
-      var blockNumber = latestOnBlockBlockNumber$1 + 1 | 0;
+    let newItemsCounter = 0;
+    let latestOnBlockBlockNumber$1 = fetchState.latestOnBlockBlockNumber;
+    while (latestOnBlockBlockNumber$1 < maxBlockNumber && newItemsCounter <= fetchState.targetBufferSize) {
+      let blockNumber = latestOnBlockBlockNumber$1 + 1 | 0;
       latestOnBlockBlockNumber$1 = blockNumber;
-      for(var configIdx = 0 ,configIdx_finish = onBlockConfigs.length; configIdx < configIdx_finish; ++configIdx){
-        var onBlockConfig = onBlockConfigs[configIdx];
-        var startBlock = onBlockConfig.startBlock;
-        var handlerStartBlock = startBlock !== undefined ? startBlock : fetchState.startBlock;
-        var tmp = false;
+      for (let configIdx = 0, configIdx_finish = onBlockConfigs.length; configIdx < configIdx_finish; ++configIdx) {
+        let onBlockConfig = onBlockConfigs[configIdx];
+        let startBlock = onBlockConfig.startBlock;
+        let handlerStartBlock = startBlock !== undefined ? startBlock : fetchState.startBlock;
+        let tmp = false;
         if (blockNumber >= handlerStartBlock) {
-          var endBlock = onBlockConfig.endBlock;
+          let endBlock = onBlockConfig.endBlock;
           tmp = endBlock !== undefined ? blockNumber <= endBlock : true;
         }
-        if (tmp && Caml_int32.mod_(blockNumber - handlerStartBlock | 0, onBlockConfig.interval) === 0) {
+        if (tmp && Primitive_int.mod_(blockNumber - handlerStartBlock | 0, onBlockConfig.interval) === 0) {
           mutItems$3.push({
-                kind: 1,
-                onBlockConfig: onBlockConfig,
-                blockNumber: blockNumber,
-                logIndex: 16777216 + onBlockConfig.index | 0
-              });
+            kind: 1,
+            onBlockConfig: onBlockConfig,
+            blockNumber: blockNumber,
+            logIndex: 16777216 + onBlockConfig.index | 0
+          });
           newItemsCounter = newItemsCounter + 1 | 0;
         }
-        
       }
     };
     latestOnBlockBlockNumber = latestOnBlockBlockNumber$1;
   } else {
     latestOnBlockBlockNumber = knownHeight;
   }
-  var mutItems$4 = mutItemsRef;
-  var updatedFetchState_startBlock = fetchState.startBlock;
-  var updatedFetchState_endBlock = fetchState.endBlock;
-  var updatedFetchState_normalSelection = fetchState.normalSelection;
-  var updatedFetchState_contractConfigs = fetchState.contractConfigs;
-  var updatedFetchState_chainId = fetchState.chainId;
-  var updatedFetchState_buffer = mutItems$4 !== undefined ? mutItems$4.sort(compareBufferItem) : fetchState.buffer;
-  var updatedFetchState_targetBufferSize = fetchState.targetBufferSize;
-  var updatedFetchState_onBlockConfigs = fetchState.onBlockConfigs;
-  var updatedFetchState_firstEventBlock = fetchState.firstEventBlock;
-  var updatedFetchState = {
+  let mutItems$4 = mutItemsRef;
+  let updatedFetchState_startBlock = fetchState.startBlock;
+  let updatedFetchState_endBlock = fetchState.endBlock;
+  let updatedFetchState_normalSelection = fetchState.normalSelection;
+  let updatedFetchState_contractConfigs = fetchState.contractConfigs;
+  let updatedFetchState_chainId = fetchState.chainId;
+  let updatedFetchState_buffer = mutItems$4 !== undefined ? (mutItems$4.sort(compareBufferItem), mutItems$4) : fetchState.buffer;
+  let updatedFetchState_targetBufferSize = fetchState.targetBufferSize;
+  let updatedFetchState_onBlockConfigs = fetchState.onBlockConfigs;
+  let updatedFetchState_firstEventBlock = fetchState.firstEventBlock;
+  let updatedFetchState = {
     optimizedPartitions: optimizedPartitions,
     startBlock: updatedFetchState_startBlock,
     endBlock: updatedFetchState_endBlock,
     normalSelection: updatedFetchState_normalSelection,
-    indexingContracts: indexingContracts,
+    indexingAddresses: indexingAddresses,
     contractConfigs: updatedFetchState_contractConfigs,
     chainId: updatedFetchState_chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
@@ -520,156 +530,154 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingContractsOpt
   Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, fetchState.chainId);
   Prometheus.IndexingBufferSize.set(updatedFetchState_buffer.length, fetchState.chainId);
   Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(updatedFetchState), fetchState.chainId);
-  if (indexingContracts !== fetchState.indexingContracts) {
-    Prometheus.IndexingAddresses.set(Object.keys(indexingContracts).length, fetchState.chainId);
+  if (indexingAddresses !== fetchState.indexingAddresses) {
+    Prometheus.IndexingAddresses.set(Utils.Dict.size(indexingAddresses), fetchState.chainId);
   }
   return updatedFetchState;
 }
 
 function warnDifferentContractType(fetchState, existingContract, dc) {
-  var logger = Logging.createChild({
-        chainId: fetchState.chainId,
-        contractAddress: dc.address,
-        existingContractType: existingContract.contractName,
-        newContractType: dc.contractName
-      });
-  Logging.childWarn(logger, "Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.");
+  let logger = Logging.createChild({
+    chainId: fetchState.chainId,
+    contractAddress: dc.address,
+    existingContractType: existingContract.contractName,
+    newContractType: dc.contractName
+  });
+  Logging.childWarn(logger, `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`);
 }
 
 function addressesByContractNameCount(addressesByContractName) {
-  var numAddresses = 0;
-  var contractNames = Object.keys(addressesByContractName);
-  for(var idx = 0 ,idx_finish = contractNames.length; idx < idx_finish; ++idx){
-    var contractName = contractNames[idx];
-    numAddresses = numAddresses + addressesByContractName[contractName].length | 0;
-  }
-  return numAddresses;
+  let numAddresses = {
+    contents: 0
+  };
+  Utils.Dict.forEach(addressesByContractName, addresses => {
+    numAddresses.contents = numAddresses.contents + addresses.length | 0;
+  });
+  return numAddresses.contents;
 }
 
 function addressesByContractNameGetAll(addressesByContractName) {
-  var all = [];
-  var contractNames = Object.keys(addressesByContractName);
-  for(var idx = 0 ,idx_finish = contractNames.length; idx < idx_finish; ++idx){
-    var contractName = contractNames[idx];
-    all = Belt_Array.concat(all, addressesByContractName[contractName]);
-  }
+  let all = [];
+  Utils.Dict.forEach(addressesByContractName, addresses => {
+    for (let idx = 0, idx_finish = addresses.length; idx < idx_finish; ++idx) {
+      all.push(addresses[idx]);
+    }
+  });
   return all;
 }
 
 function createPartitionsFromIndexingAddresses(registeringContractsByContract, contractConfigs, dynamicContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber) {
-  var nextPartitionIndexRef = nextPartitionIndex;
-  var dynamicPartitions = [];
-  var nonDynamicPartitions = [];
-  var contractNames = Object.keys(registeringContractsByContract);
-  for(var cIdx = 0 ,cIdx_finish = contractNames.length; cIdx < cIdx_finish; ++cIdx){
-    var contractName = contractNames[cIdx];
-    var registeringContracts = registeringContractsByContract[contractName];
-    var addresses = Object.keys(registeringContracts);
-    var contractConfig = contractConfigs[contractName];
-    var isDynamic = dynamicContracts.has(contractName);
-    var partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions;
-    var byStartBlock = {};
-    for(var jdx = 0 ,jdx_finish = addresses.length; jdx < jdx_finish; ++jdx){
-      var address = addresses[jdx];
-      var indexingContract = registeringContracts[address];
-      Utils.Dict.push(byStartBlock, String(indexingContract.startBlock), address);
+  let nextPartitionIndexRef = nextPartitionIndex;
+  let dynamicPartitions = [];
+  let nonDynamicPartitions = [];
+  let contractNames = Object.keys(registeringContractsByContract);
+  for (let cIdx = 0, cIdx_finish = contractNames.length; cIdx < cIdx_finish; ++cIdx) {
+    let contractName = contractNames[cIdx];
+    let registeringContracts = registeringContractsByContract[contractName];
+    let addresses = Object.keys(registeringContracts);
+    let contractConfig = contractConfigs[contractName];
+    let isDynamic = dynamicContracts.has(contractName);
+    let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions;
+    let byStartBlock = {};
+    for (let jdx = 0, jdx_finish = addresses.length; jdx < jdx_finish; ++jdx) {
+      let address = addresses[jdx];
+      let indexingContract = registeringContracts[address];
+      Utils.Dict.push(byStartBlock, indexingContract.effectiveStartBlock.toString(), address);
     }
-    var ascKeys = Object.keys(byStartBlock);
-    var initialKey = Utils.$$Array.firstUnsafe(ascKeys);
-    var startBlockRef = Belt_Int.fromString(initialKey);
-    var addressesRef = byStartBlock[initialKey];
-    for(var idx = 0 ,idx_finish = ascKeys.length; idx < idx_finish; ++idx){
-      var maybeNextStartBlockKey = ascKeys[idx + 1 | 0];
-      var shouldAllocateNewPartition;
+    let ascKeys = Object.keys(byStartBlock);
+    let initialKey = Utils.$$Array.firstUnsafe(ascKeys);
+    let startBlockRef = Stdlib_Int.fromString(initialKey, undefined);
+    let addressesRef = byStartBlock[initialKey];
+    for (let idx = 0, idx_finish = ascKeys.length; idx < idx_finish; ++idx) {
+      let maybeNextStartBlockKey = ascKeys[idx + 1 | 0];
+      let shouldAllocateNewPartition;
       if (contractConfig.filterByAddresses || maybeNextStartBlockKey === undefined) {
         shouldAllocateNewPartition = true;
       } else {
-        var nextStartBlock = Belt_Int.fromString(maybeNextStartBlockKey);
-        var shouldJoinCurrentStartBlock = (nextStartBlock - startBlockRef | 0) < 20000;
+        let nextStartBlock = Stdlib_Int.fromString(maybeNextStartBlockKey, undefined);
+        let shouldJoinCurrentStartBlock = (nextStartBlock - startBlockRef | 0) < 20000;
         if (shouldJoinCurrentStartBlock) {
-          addressesRef = Belt_Array.concat(addressesRef, byStartBlock[maybeNextStartBlockKey]);
+          addressesRef = addressesRef.concat(byStartBlock[maybeNextStartBlockKey]);
           shouldAllocateNewPartition = false;
         } else {
           shouldAllocateNewPartition = true;
         }
       }
       if (shouldAllocateNewPartition) {
-        var latestFetchedBlock_blockNumber = Caml.int_max(startBlockRef - 1 | 0, progressBlockNumber);
-        var latestFetchedBlock = {
+        let latestFetchedBlock_blockNumber = Primitive_int.max(startBlockRef - 1 | 0, progressBlockNumber);
+        let latestFetchedBlock = {
           blockNumber: latestFetchedBlock_blockNumber,
           blockTimestamp: 0
         };
-        while(addressesRef.length !== 0) {
-          var pAddresses = addressesRef.slice(0, maxAddrInPartition);
+        while (addressesRef.length !== 0) {
+          let pAddresses = addressesRef.slice(0, maxAddrInPartition);
           addressesRef = addressesRef.slice(maxAddrInPartition);
-          var addressesByContractName = {};
+          let addressesByContractName = {};
           addressesByContractName[contractName] = pAddresses;
           partitions.push({
-                id: String(nextPartitionIndexRef),
-                latestFetchedBlock: latestFetchedBlock,
-                selection: normalSelection,
-                addressesByContractName: addressesByContractName,
-                mergeBlock: undefined,
-                dynamicContract: isDynamic ? contractName : undefined,
-                mutPendingQueries: [],
-                prevQueryRange: 0,
-                prevPrevQueryRange: 0,
-                latestBlockRangeUpdateBlock: 0
-              });
+            id: nextPartitionIndexRef.toString(),
+            latestFetchedBlock: latestFetchedBlock,
+            selection: normalSelection,
+            addressesByContractName: addressesByContractName,
+            mergeBlock: undefined,
+            dynamicContract: isDynamic ? contractName : undefined,
+            mutPendingQueries: [],
+            prevQueryRange: 0,
+            prevPrevQueryRange: 0,
+            latestBlockRangeUpdateBlock: 0
+          });
           nextPartitionIndexRef = nextPartitionIndexRef + 1 | 0;
         };
         if (maybeNextStartBlockKey !== undefined) {
-          startBlockRef = Belt_Int.fromString(maybeNextStartBlockKey);
+          startBlockRef = Stdlib_Int.fromString(maybeNextStartBlockKey, undefined);
           addressesRef = byStartBlock[maybeNextStartBlockKey];
         }
-        
       }
-      
     }
   }
-  var mergedNonDynamic = [];
+  let mergedNonDynamic = [];
   if (nonDynamicPartitions.length !== 0) {
     nonDynamicPartitions.sort(ascSortFn);
-    var currentPRef = nonDynamicPartitions[0];
-    var nextIdx = 1;
-    while(nextIdx < nonDynamicPartitions.length) {
-      var nextP = nonDynamicPartitions[nextIdx];
-      var currentP = currentPRef;
-      var currentPBlock = currentP.latestFetchedBlock.blockNumber;
-      var nextPBlock = nextP.latestFetchedBlock.blockNumber;
-      var totalCount = addressesByContractNameCount(currentP.addressesByContractName) + addressesByContractNameCount(nextP.addressesByContractName) | 0;
+    let currentPRef = nonDynamicPartitions[0];
+    let nextIdx = 1;
+    while (nextIdx < nonDynamicPartitions.length) {
+      let nextP = nonDynamicPartitions[nextIdx];
+      let currentP = currentPRef;
+      let currentPBlock = currentP.latestFetchedBlock.blockNumber;
+      let nextPBlock = nextP.latestFetchedBlock.blockNumber;
+      let totalCount = addressesByContractNameCount(currentP.addressesByContractName) + addressesByContractNameCount(nextP.addressesByContractName) | 0;
       if (totalCount > maxAddrInPartition) {
         mergedNonDynamic.push(currentP);
         currentPRef = nextP;
       } else {
-        var mergedAddresses = Utils.Dict.shallowCopy(nextP.addressesByContractName);
-        var currentContractNames = Object.keys(currentP.addressesByContractName);
-        for(var jdx$1 = 0 ,jdx_finish$1 = currentContractNames.length; jdx$1 < jdx_finish$1; ++jdx$1){
-          var cn = currentContractNames[jdx$1];
-          var currentAddrs = currentP.addressesByContractName[cn];
-          var existingAddrs = mergedAddresses[cn];
+        let mergedAddresses = Utils.Dict.shallowCopy(nextP.addressesByContractName);
+        let currentContractNames = Object.keys(currentP.addressesByContractName);
+        for (let jdx$1 = 0, jdx_finish$1 = currentContractNames.length; jdx$1 < jdx_finish$1; ++jdx$1) {
+          let cn = currentContractNames[jdx$1];
+          let currentAddrs = currentP.addressesByContractName[cn];
+          let existingAddrs = mergedAddresses[cn];
           if (existingAddrs !== undefined) {
-            mergedAddresses[cn] = Belt_Array.concat(existingAddrs, currentAddrs);
+            mergedAddresses[cn] = existingAddrs.concat(currentAddrs);
           } else {
             mergedAddresses[cn] = currentAddrs;
           }
         }
-        var nextContractName = Utils.$$Array.firstUnsafe(Object.keys(nextP.addressesByContractName));
-        var hasFilterByAddresses = contractConfigs[nextContractName].filterByAddresses;
-        var isTooFar = (currentPBlock + 20000 | 0) < nextPBlock;
+        let nextContractName = Utils.$$Array.firstUnsafe(Object.keys(nextP.addressesByContractName));
+        let hasFilterByAddresses = contractConfigs[nextContractName].filterByAddresses;
+        let isTooFar = (currentPBlock + 20000 | 0) < nextPBlock;
         if (isTooFar || hasFilterByAddresses) {
           mergedNonDynamic.push({
-                id: currentP.id,
-                latestFetchedBlock: currentP.latestFetchedBlock,
-                selection: currentP.selection,
-                addressesByContractName: currentP.addressesByContractName,
-                mergeBlock: currentPBlock < nextPBlock ? nextPBlock : undefined,
-                dynamicContract: currentP.dynamicContract,
-                mutPendingQueries: currentP.mutPendingQueries,
-                prevQueryRange: currentP.prevQueryRange,
-                prevPrevQueryRange: currentP.prevPrevQueryRange,
-                latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
-              });
+            id: currentP.id,
+            latestFetchedBlock: currentP.latestFetchedBlock,
+            selection: currentP.selection,
+            addressesByContractName: currentP.addressesByContractName,
+            mergeBlock: currentPBlock < nextPBlock ? nextPBlock : undefined,
+            dynamicContract: currentP.dynamicContract,
+            mutPendingQueries: currentP.mutPendingQueries,
+            prevQueryRange: currentP.prevQueryRange,
+            prevPrevQueryRange: currentP.prevPrevQueryRange,
+            latestBlockRangeUpdateBlock: currentP.latestBlockRangeUpdateBlock
+          });
           currentPRef = {
             id: nextP.id,
             latestFetchedBlock: nextP.latestFetchedBlock,
@@ -701,49 +709,60 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, c
     };
     mergedNonDynamic.push(currentPRef);
   }
-  var mergedPartitions = mergedNonDynamic.concat(dynamicPartitions);
+  let mergedPartitions = mergedNonDynamic.concat(dynamicPartitions);
   return make(existingPartitions.concat(mergedPartitions), maxAddrInPartition, nextPartitionIndexRef, dynamicContracts);
 }
 
 function registerDynamicContracts(fetchState, items) {
   if (Utils.$$Array.isEmpty(fetchState.normalSelection.eventConfigs)) {
-    Js_exn.raiseError("Invalid configuration. No events to fetch for the dynamic contract registration.");
+    Stdlib_JsError.throwWithMessage("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
-  var indexingContracts = fetchState.indexingContracts;
-  var registeringContractsByContract = {};
-  var earliestRegisteringEventBlockNumber = Infinity;
-  var hasDCWithFilterByAddresses = false;
-  for(var itemIdx = 0 ,itemIdx_finish = items.length; itemIdx < itemIdx_finish; ++itemIdx){
-    var item = items[itemIdx];
-    var dcs = item.dcs;
+  let indexingAddresses = fetchState.indexingAddresses;
+  let registeringContractsByContract = {};
+  let earliestRegisteringEventBlockNumber = Infinity;
+  let hasDCWithFilterByAddresses = false;
+  let noEventsAddresses = {};
+  for (let itemIdx = 0, itemIdx_finish = items.length; itemIdx < itemIdx_finish; ++itemIdx) {
+    let item = items[itemIdx];
+    let dcs = item.dcs;
     if (dcs !== undefined) {
-      var idx = 0;
-      while(idx < dcs.length) {
-        var dc = dcs[idx];
-        var shouldRemove = false;
-        var match = fetchState.contractConfigs[dc.contractName];
+      let idx = 0;
+      while (idx < dcs.length) {
+        let dc = dcs[idx];
+        let shouldRemove = false;
+        let match = fetchState.contractConfigs[dc.contractName];
         if (match !== undefined) {
-          var existingContract = indexingContracts[dc.address];
+          let dcWithStartBlock_address = dc.address;
+          let dcWithStartBlock_contractName = dc.contractName;
+          let dcWithStartBlock_registrationBlock = dc.registrationBlock;
+          let dcWithStartBlock_effectiveStartBlock = deriveEffectiveStartBlock(dc.registrationBlock, match.startBlock);
+          let dcWithStartBlock = {
+            address: dcWithStartBlock_address,
+            contractName: dcWithStartBlock_contractName,
+            registrationBlock: dcWithStartBlock_registrationBlock,
+            effectiveStartBlock: dcWithStartBlock_effectiveStartBlock
+          };
+          let existingContract = indexingAddresses[dc.address];
           if (existingContract !== undefined) {
             if (existingContract.contractName !== dc.contractName) {
-              warnDifferentContractType(fetchState, existingContract, dc);
-            } else if (existingContract.startBlock > dc.startBlock) {
-              var logger = Logging.createChild({
-                    chainId: fetchState.chainId,
-                    contractAddress: dc.address,
-                    existingBlockNumber: existingContract.startBlock,
-                    newBlockNumber: dc.startBlock
-                  });
-              Logging.childWarn(logger, "Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.");
+              warnDifferentContractType(fetchState, existingContract, dcWithStartBlock);
+            } else if (existingContract.effectiveStartBlock > dcWithStartBlock_effectiveStartBlock) {
+              let logger = Logging.createChild({
+                chainId: fetchState.chainId,
+                contractAddress: dc.address,
+                existingBlockNumber: existingContract.effectiveStartBlock,
+                newBlockNumber: dcWithStartBlock_effectiveStartBlock
+              });
+              Logging.childWarn(logger, `Skipping contract registration: Contract address is already registered at a later block number. Currently registration of the same contract address is not supported by Envio. Reach out to us if it's a problem for you.`);
             }
             shouldRemove = true;
           } else {
-            var registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, dc.contractName);
-            var registeringContract = registeringContracts[dc.address];
-            var shouldUpdate;
+            let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, dc.contractName);
+            let registeringContract = registeringContracts[dc.address];
+            let shouldUpdate;
             if (registeringContract !== undefined) {
               if (registeringContract.contractName !== dc.contractName) {
-                warnDifferentContractType(fetchState, registeringContract, dc);
+                warnDifferentContractType(fetchState, registeringContract, dcWithStartBlock);
                 shouldUpdate = false;
               } else {
                 shouldUpdate = false;
@@ -753,20 +772,43 @@ function registerDynamicContracts(fetchState, items) {
               shouldUpdate = true;
             }
             if (shouldUpdate) {
-              earliestRegisteringEventBlockNumber = earliestRegisteringEventBlockNumber < dc.startBlock ? earliestRegisteringEventBlockNumber : dc.startBlock;
-              registeringContracts[dc.address] = dc;
+              earliestRegisteringEventBlockNumber = Primitive_int.min(earliestRegisteringEventBlockNumber, dcWithStartBlock_effectiveStartBlock);
+              registeringContracts[dc.address] = dcWithStartBlock;
             } else {
               shouldRemove = true;
             }
           }
         } else {
-          var logger$1 = Logging.createChild({
+          let dcAsIndexingAddress_address = dc.address;
+          let dcAsIndexingAddress_contractName = dc.contractName;
+          let dcAsIndexingAddress_registrationBlock = dc.registrationBlock;
+          let dcAsIndexingAddress_effectiveStartBlock = deriveEffectiveStartBlock(dc.registrationBlock, undefined);
+          let dcAsIndexingAddress = {
+            address: dcAsIndexingAddress_address,
+            contractName: dcAsIndexingAddress_contractName,
+            registrationBlock: dcAsIndexingAddress_registrationBlock,
+            effectiveStartBlock: dcAsIndexingAddress_effectiveStartBlock
+          };
+          let existingContract$1 = indexingAddresses[dc.address];
+          if (existingContract$1 !== undefined) {
+            if (existingContract$1.contractName !== dc.contractName) {
+              warnDifferentContractType(fetchState, existingContract$1, dcAsIndexingAddress);
+            }
+            shouldRemove = true;
+          } else {
+            let match$1 = noEventsAddresses[dc.address];
+            if (match$1 !== undefined) {
+              shouldRemove = true;
+            } else {
+              let logger$1 = Logging.createChild({
                 chainId: fetchState.chainId,
                 contractAddress: dc.address,
                 contractName: dc.contractName
               });
-          Logging.childWarn(logger$1, "Skipping contract registration: Contract doesn't have any events to fetch.");
-          shouldRemove = true;
+              Logging.childWarn(logger$1, `Persisting contract registration without fetching: Contract doesn't have any events to fetch. It'll be picked up on restart if you add events for the contract.`);
+              noEventsAddresses[dc.address] = dcAsIndexingAddress;
+            }
+          }
         }
         if (shouldRemove) {
           dcs.splice(idx, 1);
@@ -775,104 +817,108 @@ function registerDynamicContracts(fetchState, items) {
         }
       };
     }
-    
-  }
-  var dcContractNamesToStore = Object.keys(registeringContractsByContract);
-  if (dcContractNamesToStore.length === 0) {
-    return fetchState;
   }
-  var newPartitions = [];
-  var newIndexingContracts = Utils.Dict.shallowCopy(indexingContracts);
-  var dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
-  var mutExistingPartitions = Js_dict.values(fetchState.optimizedPartitions.entities);
-  for(var idx$1 = 0 ,idx_finish = dcContractNamesToStore.length; idx$1 < idx_finish; ++idx$1){
-    var contractName = dcContractNamesToStore[idx$1];
-    if (!dynamicContractsRef.has(contractName)) {
-      dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
-      for(var idx$2 = 0 ,idx_finish$1 = mutExistingPartitions.length; idx$2 < idx_finish$1; ++idx$2){
-        var p = mutExistingPartitions[idx$2];
-        var addresses = p.addressesByContractName[contractName];
-        if (addresses !== undefined && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
-          var allPartitionContractNames = Object.keys(p.addressesByContractName);
-          if (allPartitionContractNames.length !== 1) {
-            var isFetching = p.mutPendingQueries.length !== 0;
-            if (!isFetching) {
-              var newPartitionId = String(fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0);
-              var restAddressesByContractName = Utils.Dict.shallowCopy(p.addressesByContractName);
-              Utils.Dict.deleteInPlace(restAddressesByContractName, contractName);
+  let dcContractNamesToStore = Object.keys(registeringContractsByContract);
+  let hasNoEventsUpdates = !Utils.Dict.isEmpty(noEventsAddresses);
+  if (dcContractNamesToStore.length !== 0) {
+    let newPartitions = [];
+    let newIndexingAddresses = Utils.Dict.shallowCopy(indexingAddresses);
+    let dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
+    let mutExistingPartitions = Object.values(fetchState.optimizedPartitions.entities);
+    for (let idx$1 = 0, idx_finish = dcContractNamesToStore.length; idx$1 < idx_finish; ++idx$1) {
+      let contractName = dcContractNamesToStore[idx$1];
+      if (!dynamicContractsRef.has(contractName)) {
+        dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
+        for (let idx$2 = 0, idx_finish$1 = mutExistingPartitions.length; idx$2 < idx_finish$1; ++idx$2) {
+          let p = mutExistingPartitions[idx$2];
+          let addresses = p.addressesByContractName[contractName];
+          if (addresses !== undefined && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
+            let allPartitionContractNames = Object.keys(p.addressesByContractName);
+            if (allPartitionContractNames.length !== 1) {
+              let isFetching = p.mutPendingQueries.length !== 0;
+              if (!isFetching) {
+                let newPartitionId = (fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0).toString();
+                let restAddressesByContractName = Utils.Dict.shallowCopy(p.addressesByContractName);
+                Utils.Dict.deleteInPlace(restAddressesByContractName, contractName);
+                mutExistingPartitions[idx$2] = {
+                  id: p.id,
+                  latestFetchedBlock: p.latestFetchedBlock,
+                  selection: p.selection,
+                  addressesByContractName: restAddressesByContractName,
+                  mergeBlock: p.mergeBlock,
+                  dynamicContract: p.dynamicContract,
+                  mutPendingQueries: p.mutPendingQueries,
+                  prevQueryRange: p.prevQueryRange,
+                  prevPrevQueryRange: p.prevPrevQueryRange,
+                  latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+                };
+                let addressesByContractName = {};
+                addressesByContractName[contractName] = addresses;
+                newPartitions.push({
+                  id: newPartitionId,
+                  latestFetchedBlock: p.latestFetchedBlock,
+                  selection: fetchState.normalSelection,
+                  addressesByContractName: addressesByContractName,
+                  mergeBlock: undefined,
+                  dynamicContract: contractName,
+                  mutPendingQueries: p.mutPendingQueries,
+                  prevQueryRange: p.prevQueryRange,
+                  prevPrevQueryRange: p.prevPrevQueryRange,
+                  latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+                });
+              }
+            } else {
               mutExistingPartitions[idx$2] = {
                 id: p.id,
                 latestFetchedBlock: p.latestFetchedBlock,
                 selection: p.selection,
-                addressesByContractName: restAddressesByContractName,
+                addressesByContractName: p.addressesByContractName,
                 mergeBlock: p.mergeBlock,
-                dynamicContract: p.dynamicContract,
+                dynamicContract: contractName,
                 mutPendingQueries: p.mutPendingQueries,
                 prevQueryRange: p.prevQueryRange,
                 prevPrevQueryRange: p.prevPrevQueryRange,
                 latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
               };
-              var addressesByContractName = {};
-              addressesByContractName[contractName] = addresses;
-              newPartitions.push({
-                    id: newPartitionId,
-                    latestFetchedBlock: p.latestFetchedBlock,
-                    selection: fetchState.normalSelection,
-                    addressesByContractName: addressesByContractName,
-                    mergeBlock: undefined,
-                    dynamicContract: contractName,
-                    mutPendingQueries: p.mutPendingQueries,
-                    prevQueryRange: p.prevQueryRange,
-                    prevPrevQueryRange: p.prevPrevQueryRange,
-                    latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
-                  });
             }
-            
-          } else {
-            mutExistingPartitions[idx$2] = {
-              id: p.id,
-              latestFetchedBlock: p.latestFetchedBlock,
-              selection: p.selection,
-              addressesByContractName: p.addressesByContractName,
-              mergeBlock: p.mergeBlock,
-              dynamicContract: contractName,
-              mutPendingQueries: p.mutPendingQueries,
-              prevQueryRange: p.prevQueryRange,
-              prevPrevQueryRange: p.prevPrevQueryRange,
-              latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
-            };
           }
         }
-        
       }
+      let registeringContracts$1 = registeringContractsByContract[contractName];
+      Object.assign(newIndexingAddresses, registeringContracts$1);
     }
-    var registeringContracts$1 = registeringContractsByContract[contractName];
-    Object.assign(newIndexingContracts, registeringContracts$1);
+    Object.assign(newIndexingAddresses, noEventsAddresses);
+    let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, dynamicContractsRef, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
+    return updateInternal(fetchState, optimizedPartitions, newIndexingAddresses, undefined, undefined, undefined);
+  }
+  if (!hasNoEventsUpdates) {
+    return fetchState;
   }
-  var optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, dynamicContractsRef, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
-  return updateInternal(fetchState, optimizedPartitions, newIndexingContracts, undefined, undefined, undefined);
+  let newIndexingContracts = Utils.Dict.shallowCopy(indexingAddresses);
+  Object.assign(newIndexingContracts, noEventsAddresses);
+  return updateInternal(fetchState, undefined, newIndexingContracts, undefined, undefined, undefined);
 }
 
 function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
-  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, latestFetchedBlock), undefined, newItems.length !== 0 ? Belt_Array.concat(fetchState.buffer, newItems) : undefined, undefined, undefined);
+  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, latestFetchedBlock), undefined, newItems.length !== 0 ? fetchState.buffer.concat(newItems) : undefined, undefined, undefined);
 }
 
 function startFetchingQueries(param, queries) {
-  var optimizedPartitions = param.optimizedPartitions;
-  for(var qIdx = 0 ,qIdx_finish = queries.length; qIdx < qIdx_finish; ++qIdx){
-    var q = queries[qIdx];
-    var partitionId = q.partitionId;
-    var p = Js_dict.get(optimizedPartitions.entities, partitionId);
-    var p$1 = p !== undefined ? p : Js_exn.raiseError("Unexpected case: Couldn't find partition " + partitionId);
-    var pq = {
+  let optimizedPartitions = param.optimizedPartitions;
+  for (let qIdx = 0, qIdx_finish = queries.length; qIdx < qIdx_finish; ++qIdx) {
+    let q = queries[qIdx];
+    let partitionId = q.partitionId;
+    let p = optimizedPartitions.entities[partitionId];
+    let p$1 = p !== undefined ? p : Stdlib_JsError.throwWithMessage(`Unexpected case: Couldn't find partition ` + partitionId);
+    let pq = {
       fromBlock: q.fromBlock,
       toBlock: q.toBlock,
       isChunk: q.isChunk,
       fetchedBlock: undefined
     };
-    var inserted = false;
-    var i = 0;
-    while(i < p$1.mutPendingQueries.length && !inserted) {
+    let inserted = false;
+    let i = 0;
+    while (i < p$1.mutPendingQueries.length && !inserted) {
       if (p$1.mutPendingQueries[i].fromBlock > q.fromBlock) {
         p$1.mutPendingQueries.splice(i, 0, pq);
         inserted = true;
@@ -882,175 +928,170 @@ function startFetchingQueries(param, queries) {
     if (!inserted) {
       p$1.mutPendingQueries.push(pq);
     }
-    
   }
 }
 
-function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber, maybeChunkRange, selection, addressesByContractName, indexingContracts) {
+function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock, maxQueryBlockNumber, maybeChunkRange, selection, addressesByContractName, indexingAddresses) {
   if (rangeFromBlock > maxQueryBlockNumber) {
-    return ;
+    return;
   }
   if (rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock) {
-    return ;
+    return;
   }
   if (maybeChunkRange !== undefined) {
-    var maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
-    var chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
+    let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
+    let chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
     if (((rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0) <= maxBlock) {
       queries.push({
-            partitionId: partitionId,
-            fromBlock: rangeFromBlock,
-            toBlock: (rangeFromBlock + chunkSize | 0) - 1 | 0,
-            isChunk: true,
-            selection: selection,
-            addressesByContractName: addressesByContractName,
-            indexingContracts: indexingContracts
-          });
+        partitionId: partitionId,
+        fromBlock: rangeFromBlock,
+        toBlock: (rangeFromBlock + chunkSize | 0) - 1 | 0,
+        isChunk: true,
+        selection: selection,
+        addressesByContractName: addressesByContractName,
+        indexingAddresses: indexingAddresses
+      });
       queries.push({
-            partitionId: partitionId,
-            fromBlock: rangeFromBlock + chunkSize | 0,
-            toBlock: (rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0,
-            isChunk: true,
-            selection: selection,
-            addressesByContractName: addressesByContractName,
-            indexingContracts: indexingContracts
-          });
+        partitionId: partitionId,
+        fromBlock: rangeFromBlock + chunkSize | 0,
+        toBlock: (rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0,
+        isChunk: true,
+        selection: selection,
+        addressesByContractName: addressesByContractName,
+        indexingAddresses: indexingAddresses
+      });
     } else {
       queries.push({
-            partitionId: partitionId,
-            fromBlock: rangeFromBlock,
-            toBlock: rangeEndBlock,
-            isChunk: rangeEndBlock !== undefined,
-            selection: selection,
-            addressesByContractName: addressesByContractName,
-            indexingContracts: indexingContracts
-          });
-    }
-    return ;
-  }
-  queries.push({
         partitionId: partitionId,
         fromBlock: rangeFromBlock,
         toBlock: rangeEndBlock,
-        isChunk: false,
+        isChunk: rangeEndBlock !== undefined,
         selection: selection,
         addressesByContractName: addressesByContractName,
-        indexingContracts: indexingContracts
+        indexingAddresses: indexingAddresses
       });
+    }
+    return;
+  }
+  queries.push({
+    partitionId: partitionId,
+    fromBlock: rangeFromBlock,
+    toBlock: rangeEndBlock,
+    isChunk: false,
+    selection: selection,
+    addressesByContractName: addressesByContractName,
+    indexingAddresses: indexingAddresses
+  });
 }
 
 function getNextQuery(fetchState, concurrencyLimit) {
-  var knownHeight = fetchState.knownHeight;
-  var blockLag = fetchState.blockLag;
-  var indexingContracts = fetchState.indexingContracts;
-  var optimizedPartitions = fetchState.optimizedPartitions;
-  var headBlockNumber = knownHeight - blockLag | 0;
+  let knownHeight = fetchState.knownHeight;
+  let blockLag = fetchState.blockLag;
+  let indexingAddresses = fetchState.indexingAddresses;
+  let optimizedPartitions = fetchState.optimizedPartitions;
+  let headBlockNumber = knownHeight - blockLag | 0;
   if (headBlockNumber <= 0) {
     return "WaitingForNewBlock";
   }
   if (concurrencyLimit === 0) {
     return "ReachedMaxConcurrency";
   }
-  var isOnBlockBehindTheHead = fetchState.latestOnBlockBlockNumber < headBlockNumber;
-  var endBlock = fetchState.endBlock;
-  var shouldWaitForNewBlock = (
+  let isOnBlockBehindTheHead = fetchState.latestOnBlockBlockNumber < headBlockNumber;
+  let endBlock = fetchState.endBlock;
+  let shouldWaitForNewBlock = (
     endBlock !== undefined ? headBlockNumber < endBlock : true
   ) && !isOnBlockBehindTheHead;
-  var item = Belt_Array.get(fetchState.buffer, fetchState.targetBufferSize - 1 | 0);
-  var maxQueryBlockNumber = item !== undefined && item.blockNumber < knownHeight ? item.blockNumber : knownHeight;
-  var queries = [];
-  var partitionsCount = optimizedPartitions.idsInAscOrder.length;
-  var idxRef = 0;
-  while(idxRef < partitionsCount) {
-    var idx = idxRef;
-    var partitionId = optimizedPartitions.idsInAscOrder[idx];
-    var p = optimizedPartitions.entities[partitionId];
-    var isBehindTheHead = p.latestFetchedBlock.blockNumber < headBlockNumber;
-    var hasPendingQueries = Utils.$$Array.notEmpty(p.mutPendingQueries);
+  let item = fetchState.buffer[fetchState.targetBufferSize - 1 | 0];
+  let maxQueryBlockNumber = item !== undefined ? Primitive_int.min(item.blockNumber, knownHeight) : knownHeight;
+  let queries = [];
+  let partitionsCount = optimizedPartitions.idsInAscOrder.length;
+  let idxRef = 0;
+  while (idxRef < partitionsCount) {
+    let idx = idxRef;
+    let partitionId = optimizedPartitions.idsInAscOrder[idx];
+    let p = optimizedPartitions.entities[partitionId];
+    let isBehindTheHead = p.latestFetchedBlock.blockNumber < headBlockNumber;
+    let hasPendingQueries = Utils.$$Array.notEmpty(p.mutPendingQueries);
     if (hasPendingQueries || isBehindTheHead) {
       shouldWaitForNewBlock = false;
     }
-    var queryEndBlock = Utils.$$Math.minOptInt(fetchState.endBlock, p.mergeBlock);
-    var queryEndBlock$1 = blockLag !== 0 ? Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock) : queryEndBlock;
-    var match = maxQueryBlockNumber < knownHeight;
-    var queryEndBlock$2 = queryEndBlock$1 !== undefined ? (
-        match ? (
-            maxQueryBlockNumber < queryEndBlock$1 ? maxQueryBlockNumber : queryEndBlock$1
-          ) : queryEndBlock$1
+    let queryEndBlock = Utils.$$Math.minOptInt(fetchState.endBlock, p.mergeBlock);
+    let queryEndBlock$1 = blockLag !== 0 ? Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock) : queryEndBlock;
+    let match = maxQueryBlockNumber < knownHeight;
+    let queryEndBlock$2 = queryEndBlock$1 !== undefined ? (
+        match ? Primitive_int.min(maxQueryBlockNumber, queryEndBlock$1) : queryEndBlock$1
       ) : (
         match ? maxQueryBlockNumber : queryEndBlock$1
       );
-    var maybeChunkRange = getMinHistoryRange(p);
-    var cursor = p.latestFetchedBlock.blockNumber + 1 | 0;
-    var canContinue = true;
-    var pqIdx = 0;
-    while(pqIdx < p.mutPendingQueries.length && canContinue) {
-      var pq = p.mutPendingQueries[pqIdx];
+    let maybeChunkRange = getMinHistoryRange(p);
+    let cursor = p.latestFetchedBlock.blockNumber + 1 | 0;
+    let canContinue = true;
+    let pqIdx = 0;
+    while (pqIdx < p.mutPendingQueries.length && canContinue) {
+      let pq = p.mutPendingQueries[pqIdx];
       if (pq.fromBlock > cursor) {
-        var addressesByContractName = p.addressesByContractName;
-        var selection = p.selection;
-        var rangeEndBlock = Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock$2);
-        var rangeFromBlock = cursor;
+        let addressesByContractName = p.addressesByContractName;
+        let selection = p.selection;
+        let rangeEndBlock = Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock$2);
+        let rangeFromBlock = cursor;
         if (rangeFromBlock <= maxQueryBlockNumber) {
-          var exit = 0;
+          let exit = 0;
           if (!(rangeEndBlock !== undefined && rangeFromBlock > rangeEndBlock)) {
             exit = 1;
           }
           if (exit === 1) {
             if (maybeChunkRange !== undefined) {
-              var maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
-              var chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
+              let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : maxQueryBlockNumber;
+              let chunkSize = Js_math.ceil_int(maybeChunkRange * 1.8);
               if (((rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0) <= maxBlock) {
                 queries.push({
-                      partitionId: partitionId,
-                      fromBlock: rangeFromBlock,
-                      toBlock: (rangeFromBlock + chunkSize | 0) - 1 | 0,
-                      isChunk: true,
-                      selection: selection,
-                      addressesByContractName: addressesByContractName,
-                      indexingContracts: indexingContracts
-                    });
+                  partitionId: partitionId,
+                  fromBlock: rangeFromBlock,
+                  toBlock: (rangeFromBlock + chunkSize | 0) - 1 | 0,
+                  isChunk: true,
+                  selection: selection,
+                  addressesByContractName: addressesByContractName,
+                  indexingAddresses: indexingAddresses
+                });
                 queries.push({
-                      partitionId: partitionId,
-                      fromBlock: rangeFromBlock + chunkSize | 0,
-                      toBlock: (rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0,
-                      isChunk: true,
-                      selection: selection,
-                      addressesByContractName: addressesByContractName,
-                      indexingContracts: indexingContracts
-                    });
+                  partitionId: partitionId,
+                  fromBlock: rangeFromBlock + chunkSize | 0,
+                  toBlock: (rangeFromBlock + (chunkSize << 1) | 0) - 1 | 0,
+                  isChunk: true,
+                  selection: selection,
+                  addressesByContractName: addressesByContractName,
+                  indexingAddresses: indexingAddresses
+                });
               } else {
                 queries.push({
-                      partitionId: partitionId,
-                      fromBlock: rangeFromBlock,
-                      toBlock: rangeEndBlock,
-                      isChunk: rangeEndBlock !== undefined,
-                      selection: selection,
-                      addressesByContractName: addressesByContractName,
-                      indexingContracts: indexingContracts
-                    });
+                  partitionId: partitionId,
+                  fromBlock: rangeFromBlock,
+                  toBlock: rangeEndBlock,
+                  isChunk: rangeEndBlock !== undefined,
+                  selection: selection,
+                  addressesByContractName: addressesByContractName,
+                  indexingAddresses: indexingAddresses
+                });
               }
             } else {
               queries.push({
-                    partitionId: partitionId,
-                    fromBlock: rangeFromBlock,
-                    toBlock: rangeEndBlock,
-                    isChunk: false,
-                    selection: selection,
-                    addressesByContractName: addressesByContractName,
-                    indexingContracts: indexingContracts
-                  });
+                partitionId: partitionId,
+                fromBlock: rangeFromBlock,
+                toBlock: rangeEndBlock,
+                isChunk: false,
+                selection: selection,
+                addressesByContractName: addressesByContractName,
+                indexingAddresses: indexingAddresses
+              });
             }
           }
-          
         }
-        
       }
-      var toBlock = pq.toBlock;
+      let toBlock = pq.toBlock;
       if (toBlock !== undefined && pq.isChunk) {
-        var match$1 = pq.fetchedBlock;
+        let match$1 = pq.fetchedBlock;
         if (match$1 !== undefined) {
-          var blockNumber = match$1.blockNumber;
+          let blockNumber = match$1.blockNumber;
           cursor = blockNumber < toBlock ? blockNumber + 1 | 0 : toBlock + 1 | 0;
         } else {
           cursor = toBlock + 1 | 0;
@@ -1061,63 +1102,61 @@ function getNextQuery(fetchState, concurrencyLimit) {
       pqIdx = pqIdx + 1 | 0;
     };
     if (canContinue) {
-      var addressesByContractName$1 = p.addressesByContractName;
-      var selection$1 = p.selection;
-      var rangeFromBlock$1 = cursor;
+      let addressesByContractName$1 = p.addressesByContractName;
+      let selection$1 = p.selection;
+      let rangeFromBlock$1 = cursor;
       if (rangeFromBlock$1 <= maxQueryBlockNumber) {
-        var exit$1 = 0;
+        let exit$1 = 0;
         if (!(queryEndBlock$2 !== undefined && rangeFromBlock$1 > queryEndBlock$2)) {
           exit$1 = 1;
         }
         if (exit$1 === 1) {
           if (maybeChunkRange !== undefined) {
-            var maxBlock$1 = queryEndBlock$2 !== undefined ? queryEndBlock$2 : maxQueryBlockNumber;
-            var chunkSize$1 = Js_math.ceil_int(maybeChunkRange * 1.8);
+            let maxBlock$1 = queryEndBlock$2 !== undefined ? queryEndBlock$2 : maxQueryBlockNumber;
+            let chunkSize$1 = Js_math.ceil_int(maybeChunkRange * 1.8);
             if (((rangeFromBlock$1 + (chunkSize$1 << 1) | 0) - 1 | 0) <= maxBlock$1) {
               queries.push({
-                    partitionId: partitionId,
-                    fromBlock: rangeFromBlock$1,
-                    toBlock: (rangeFromBlock$1 + chunkSize$1 | 0) - 1 | 0,
-                    isChunk: true,
-                    selection: selection$1,
-                    addressesByContractName: addressesByContractName$1,
-                    indexingContracts: indexingContracts
-                  });
+                partitionId: partitionId,
+                fromBlock: rangeFromBlock$1,
+                toBlock: (rangeFromBlock$1 + chunkSize$1 | 0) - 1 | 0,
+                isChunk: true,
+                selection: selection$1,
+                addressesByContractName: addressesByContractName$1,
+                indexingAddresses: indexingAddresses
+              });
               queries.push({
-                    partitionId: partitionId,
-                    fromBlock: rangeFromBlock$1 + chunkSize$1 | 0,
-                    toBlock: (rangeFromBlock$1 + (chunkSize$1 << 1) | 0) - 1 | 0,
-                    isChunk: true,
-                    selection: selection$1,
-                    addressesByContractName: addressesByContractName$1,
-                    indexingContracts: indexingContracts
-                  });
+                partitionId: partitionId,
+                fromBlock: rangeFromBlock$1 + chunkSize$1 | 0,
+                toBlock: (rangeFromBlock$1 + (chunkSize$1 << 1) | 0) - 1 | 0,
+                isChunk: true,
+                selection: selection$1,
+                addressesByContractName: addressesByContractName$1,
+                indexingAddresses: indexingAddresses
+              });
             } else {
               queries.push({
-                    partitionId: partitionId,
-                    fromBlock: rangeFromBlock$1,
-                    toBlock: queryEndBlock$2,
-                    isChunk: queryEndBlock$2 !== undefined,
-                    selection: selection$1,
-                    addressesByContractName: addressesByContractName$1,
-                    indexingContracts: indexingContracts
-                  });
+                partitionId: partitionId,
+                fromBlock: rangeFromBlock$1,
+                toBlock: queryEndBlock$2,
+                isChunk: queryEndBlock$2 !== undefined,
+                selection: selection$1,
+                addressesByContractName: addressesByContractName$1,
+                indexingAddresses: indexingAddresses
+              });
             }
           } else {
             queries.push({
-                  partitionId: partitionId,
-                  fromBlock: rangeFromBlock$1,
-                  toBlock: queryEndBlock$2,
-                  isChunk: false,
-                  selection: selection$1,
-                  addressesByContractName: addressesByContractName$1,
-                  indexingContracts: indexingContracts
-                });
+              partitionId: partitionId,
+              fromBlock: rangeFromBlock$1,
+              toBlock: queryEndBlock$2,
+              isChunk: false,
+              selection: selection$1,
+              addressesByContractName: addressesByContractName$1,
+              indexingAddresses: indexingAddresses
+            });
           }
         }
-        
       }
-      
     }
     idxRef = idxRef + 1 | 0;
   };
@@ -1128,22 +1167,20 @@ function getNextQuery(fetchState, concurrencyLimit) {
       return "NothingToQuery";
     }
   }
-  var queries$1 = queries.length > concurrencyLimit ? (queries.sort(function (a, b) {
-            return a.fromBlock - b.fromBlock | 0;
-          }), queries.slice(0, concurrencyLimit)) : queries;
+  let queries$1 = queries.length > concurrencyLimit ? (queries.sort((a, b) => Primitive_int.compare(a.fromBlock, b.fromBlock)), queries.slice(0, concurrencyLimit)) : queries;
   return {
-          TAG: "Ready",
-          _0: queries$1
-        };
+    TAG: "Ready",
+    _0: queries$1
+  };
 }
 
 function getTimestampAt(fetchState, index) {
-  var match = Belt_Array.get(fetchState.buffer, index);
+  let match = Belt_Array.get(fetchState.buffer, index);
   if (match !== undefined) {
     if (match.kind === 0) {
       return match.timestamp;
     } else {
-      return Js_exn.raiseError("Block handlers are not supported for ordered multichain mode.");
+      return Stdlib_JsError.throwWithMessage("Block handlers are not supported for ordered multichain mode.");
     }
   } else {
     return bufferBlock(fetchState).blockTimestamp;
@@ -1151,7 +1188,7 @@ function getTimestampAt(fetchState, index) {
 }
 
 function hasReadyItem(fetchState) {
-  var item = Belt_Array.get(fetchState.buffer, 0);
+  let item = Belt_Array.get(fetchState.buffer, 0);
   if (item !== undefined) {
     return item.blockNumber <= bufferBlockNumber(fetchState);
   } else {
@@ -1160,19 +1197,18 @@ function hasReadyItem(fetchState) {
 }
 
 function getReadyItemsCount(fetchState, targetSize, fromItem) {
-  var readyBlockNumber = bufferBlockNumber(fetchState);
-  var acc = 0;
-  var isFinished = false;
-  while(!isFinished) {
-    var item = Belt_Array.get(fetchState.buffer, fromItem + acc | 0);
+  let readyBlockNumber = bufferBlockNumber(fetchState);
+  let acc = 0;
+  let isFinished = false;
+  while (!isFinished) {
+    let item = Belt_Array.get(fetchState.buffer, fromItem + acc | 0);
     if (item !== undefined) {
-      var itemBlockNumber = item.blockNumber;
+      let itemBlockNumber = item.blockNumber;
       if (itemBlockNumber <= readyBlockNumber) {
         acc = acc + 1 | 0;
         if (acc === targetSize) {
           readyBlockNumber = itemBlockNumber;
         }
-        
       } else {
         isFinished = true;
       }
@@ -1183,83 +1219,100 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartition, chainId, targetBufferSize, knownHeight, progressBlockNumberOpt, onBlockConfigsOpt, blockLagOpt, firstEventBlockOpt) {
-  var progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
-  var onBlockConfigs = onBlockConfigsOpt !== undefined ? onBlockConfigsOpt : [];
-  var blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
-  var firstEventBlock = firstEventBlockOpt !== undefined ? Caml_option.valFromOption(firstEventBlockOpt) : undefined;
-  var latestFetchedBlock = {
+function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartition, chainId, targetBufferSize, knownHeight, progressBlockNumberOpt, onBlockConfigsOpt, blockLagOpt, firstEventBlockOpt) {
+  let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
+  let onBlockConfigs = onBlockConfigsOpt !== undefined ? onBlockConfigsOpt : [];
+  let blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
+  let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
+  let latestFetchedBlock = {
     blockNumber: progressBlockNumber,
     blockTimestamp: 0
   };
-  var notDependingOnAddresses = [];
-  var normalEventConfigs = [];
-  var contractNamesWithNormalEvents = new Set();
-  var indexingContracts = {};
-  var contractConfigs = {};
-  Belt_Array.forEach(eventConfigs, (function (ec) {
-          var match = contractConfigs[ec.contractName];
-          if (match !== undefined) {
-            contractConfigs[ec.contractName] = {
-              filterByAddresses: match.filterByAddresses || ec.filterByAddresses
-            };
-          } else {
-            contractConfigs[ec.contractName] = {
-              filterByAddresses: ec.filterByAddresses
-            };
-          }
-          if (ec.dependsOnAddresses) {
-            normalEventConfigs.push(ec);
-            contractNamesWithNormalEvents.add(ec.contractName);
-          } else {
-            notDependingOnAddresses.push(ec);
-          }
-        }));
-  var partitions = [];
+  let notDependingOnAddresses = [];
+  let normalEventConfigs = [];
+  let contractNamesWithNormalEvents = new Set();
+  let indexingAddresses = {};
+  let contractConfigs = {};
+  eventConfigs.forEach(ec => {
+    let match = contractConfigs[ec.contractName];
+    if (match !== undefined) {
+      let startBlock = match.startBlock;
+      let match$1 = ec.startBlock;
+      contractConfigs[ec.contractName] = {
+        filterByAddresses: match.filterByAddresses || ec.filterByAddresses,
+        startBlock: startBlock !== undefined ? (
+            match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
+          ) : (
+            match$1 !== undefined ? match$1 : undefined
+          )
+      };
+    } else {
+      contractConfigs[ec.contractName] = {
+        filterByAddresses: ec.filterByAddresses,
+        startBlock: ec.startBlock
+      };
+    }
+    if (ec.dependsOnAddresses) {
+      normalEventConfigs.push(ec);
+      contractNamesWithNormalEvents.add(ec.contractName);
+    } else {
+      notDependingOnAddresses.push(ec);
+    }
+  });
+  let partitions = [];
   if (notDependingOnAddresses.length !== 0) {
     partitions.push({
-          id: String(partitions.length),
-          latestFetchedBlock: latestFetchedBlock,
-          selection: {
-            eventConfigs: notDependingOnAddresses,
-            dependsOnAddresses: false
-          },
-          addressesByContractName: {},
-          mergeBlock: undefined,
-          dynamicContract: undefined,
-          mutPendingQueries: [],
-          prevQueryRange: 0,
-          prevPrevQueryRange: 0,
-          latestBlockRangeUpdateBlock: 0
-        });
+      id: partitions.length.toString(),
+      latestFetchedBlock: latestFetchedBlock,
+      selection: {
+        eventConfigs: notDependingOnAddresses,
+        dependsOnAddresses: false
+      },
+      addressesByContractName: {},
+      mergeBlock: undefined,
+      dynamicContract: undefined,
+      mutPendingQueries: [],
+      prevQueryRange: 0,
+      prevPrevQueryRange: 0,
+      latestBlockRangeUpdateBlock: 0
+    });
   }
-  var normalSelection = {
+  let normalSelection = {
     eventConfigs: normalEventConfigs,
     dependsOnAddresses: true
   };
-  var registeringContractsByContract = {};
-  var dynamicContracts = new Set();
-  if (normalEventConfigs.length !== 0) {
-    Belt_Array.forEach(contracts, (function (contract) {
-            var contractName = contract.contractName;
-            if (!contractNamesWithNormalEvents.has(contractName)) {
-              return ;
-            }
-            var registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
-            registeringContracts[contract.address] = contract;
-            indexingContracts[contract.address] = contract;
-            if (contract.registrationBlock !== undefined) {
-              dynamicContracts.add(contractName);
-              return ;
-            }
-            
-          }));
-  }
-  var optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, contractConfigs, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
+  let registeringContractsByContract = {};
+  let dynamicContracts = new Set();
+  addresses.forEach(contract => {
+    let contractName = contract.contractName;
+    let match = contractConfigs[contractName];
+    let contractStartBlock = match !== undefined ? match.startBlock : undefined;
+    let ia_address = contract.address;
+    let ia_contractName = contract.contractName;
+    let ia_registrationBlock = contract.registrationBlock;
+    let ia_effectiveStartBlock = deriveEffectiveStartBlock(contract.registrationBlock, contractStartBlock);
+    let ia = {
+      address: ia_address,
+      contractName: ia_contractName,
+      registrationBlock: ia_registrationBlock,
+      effectiveStartBlock: ia_effectiveStartBlock
+    };
+    indexingAddresses[contract.address] = ia;
+    if (!contractNamesWithNormalEvents.has(contractName)) {
+      return;
+    }
+    let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
+    registeringContracts[contract.address] = ia;
+    if (contract.registrationBlock !== -1) {
+      dynamicContracts.add(contractName);
+      return;
+    }
+  });
+  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, contractConfigs, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
   if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockConfigs)) {
-    Js_exn.raiseError("Invalid configuration: Nothing to fetch. Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.");
+    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + chainId.toString() + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`eventConfigs=` + eventConfigs.length.toString() + `, `) + (`normalEventConfigs=` + normalEventConfigs.length.toString() + `. `) + `Make sure that you provided at least one contract address to index, or have events with Wildcard mode enabled, or have onBlock handlers.`);
   }
-  var numAddresses = Object.keys(indexingContracts).length;
+  let numAddresses = Utils.Dict.size(indexingAddresses);
   Prometheus.IndexingAddresses.set(numAddresses, chainId);
   Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, chainId);
   Prometheus.IndexingBufferSize.set(0, chainId);
@@ -1268,21 +1321,21 @@ function make$1(startBlock, endBlock, eventConfigs, contracts, maxAddrInPartitio
     Prometheus.IndexingEndBlock.set(endBlock, chainId);
   }
   return {
-          optimizedPartitions: optimizedPartitions,
-          startBlock: startBlock,
-          endBlock: endBlock,
-          normalSelection: normalSelection,
-          indexingContracts: indexingContracts,
-          contractConfigs: contractConfigs,
-          chainId: chainId,
-          latestOnBlockBlockNumber: progressBlockNumber,
-          blockLag: blockLag,
-          buffer: [],
-          targetBufferSize: targetBufferSize,
-          onBlockConfigs: onBlockConfigs,
-          knownHeight: knownHeight,
-          firstEventBlock: firstEventBlock
-        };
+    optimizedPartitions: optimizedPartitions,
+    startBlock: startBlock,
+    endBlock: endBlock,
+    normalSelection: normalSelection,
+    indexingAddresses: indexingAddresses,
+    contractConfigs: contractConfigs,
+    chainId: chainId,
+    latestOnBlockBlockNumber: progressBlockNumber,
+    blockLag: blockLag,
+    buffer: [],
+    targetBufferSize: targetBufferSize,
+    onBlockConfigs: onBlockConfigs,
+    knownHeight: knownHeight,
+    firstEventBlock: firstEventBlock
+  };
 }
 
 function bufferSize(param) {
@@ -1290,149 +1343,139 @@ function bufferSize(param) {
 }
 
 function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
-  var adjusted = [];
-  for(var qIdx = 0 ,qIdx_finish = mutPendingQueries.length; qIdx < qIdx_finish; ++qIdx){
-    var pq = mutPendingQueries[qIdx];
+  let adjusted = [];
+  for (let qIdx = 0, qIdx_finish = mutPendingQueries.length; qIdx < qIdx_finish; ++qIdx) {
+    let pq = mutPendingQueries[qIdx];
     if (pq.fromBlock <= targetBlockNumber) {
-      var match = pq.fetchedBlock;
+      let match = pq.fetchedBlock;
       if (match !== undefined) {
         if (match.blockNumber > targetBlockNumber) {
           adjusted.push({
-                fromBlock: pq.fromBlock,
-                toBlock: pq.toBlock,
-                isChunk: pq.isChunk,
-                fetchedBlock: {
-                  blockNumber: targetBlockNumber,
-                  blockTimestamp: 0
-                }
-              });
+            fromBlock: pq.fromBlock,
+            toBlock: pq.toBlock,
+            isChunk: pq.isChunk,
+            fetchedBlock: {
+              blockNumber: targetBlockNumber,
+              blockTimestamp: 0
+            }
+          });
         } else {
           adjusted.push(pq);
         }
       } else {
-        Js_exn.raiseError("Internal error: Must not have a fetching query during rollback");
+        Stdlib_JsError.throwWithMessage("Internal error: Must not have a fetching query during rollback");
       }
     }
-    
   }
   return adjusted;
 }
 
 function rollback(fetchState, targetBlockNumber) {
-  var addressesToRemove = new Set();
-  var indexingContracts = {};
-  Belt_Array.forEach(Object.keys(fetchState.indexingContracts), (function (address) {
-          var indexingContract = fetchState.indexingContracts[address];
-          var registrationBlock = indexingContract.registrationBlock;
-          if (registrationBlock !== undefined && registrationBlock > targetBlockNumber) {
-            addressesToRemove.add(address);
-          } else {
-            indexingContracts[address] = indexingContract;
-          }
-        }));
-  var keptPartitions = [];
-  var nextKeptIdRef = 0;
-  var registeringContractsByContract = {};
-  var partitions = Js_dict.values(fetchState.optimizedPartitions.entities);
-  for(var idx = 0 ,idx_finish = partitions.length; idx < idx_finish; ++idx){
-    var p = partitions[idx];
+  let addressesToRemove = new Set();
+  let indexingAddresses = {};
+  Object.keys(fetchState.indexingAddresses).forEach(address => {
+    let indexingContract = fetchState.indexingAddresses[address];
+    if (indexingContract.registrationBlock > targetBlockNumber) {
+      addressesToRemove.add(address);
+    } else {
+      indexingAddresses[address] = indexingContract;
+    }
+  });
+  let keptPartitions = [];
+  let nextKeptIdRef = 0;
+  let registeringContractsByContract = {};
+  let partitions = Object.values(fetchState.optimizedPartitions.entities);
+  for (let idx = 0, idx_finish = partitions.length; idx < idx_finish; ++idx) {
+    let p = partitions[idx];
     if (p.selection.dependsOnAddresses) {
       if (p.latestFetchedBlock.blockNumber > targetBlockNumber) {
-        Utils.Dict.forEachWithKey(p.addressesByContractName, (function (addresses, contractName) {
-                Belt_Array.forEach(addresses, (function (address) {
-                        if (!(!addressesToRemove.has(address) && Belt_Option.isSome(indexingContracts[address]))) {
-                          return ;
-                        }
-                        var registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
-                        registeringContracts[address] = indexingContracts[address];
-                      }));
-              }));
-      } else {
-        var mergeBlock = p.mergeBlock;
-        var mergeBlock$1 = mergeBlock !== undefined && mergeBlock > targetBlockNumber ? targetBlockNumber : mergeBlock;
-        var rollbackedAddressesByContractName = {};
-        Utils.Dict.forEachWithKey(p.addressesByContractName, (function(rollbackedAddressesByContractName){
-            return function (addresses, contractName) {
-              var keptAddresses = Belt_Array.keep(addresses, (function (address) {
-                      return !addressesToRemove.has(address);
-                    }));
-              if (keptAddresses.length !== 0) {
-                rollbackedAddressesByContractName[contractName] = keptAddresses;
-                return ;
-              }
-              
+        Utils.Dict.forEachWithKey(p.addressesByContractName, (addresses, contractName) => {
+          addresses.forEach(address => {
+            if (!(!addressesToRemove.has(address) && Stdlib_Option.isSome(indexingAddresses[address]))) {
+              return;
             }
-            }(rollbackedAddressesByContractName)));
-        if (Object.keys(rollbackedAddressesByContractName).length !== 0) {
-          var id = String(nextKeptIdRef);
+            let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
+            registeringContracts[address] = indexingAddresses[address];
+          });
+        });
+      } else {
+        let mergeBlock = p.mergeBlock;
+        let mergeBlock$1 = mergeBlock !== undefined && mergeBlock > targetBlockNumber ? targetBlockNumber : mergeBlock;
+        let rollbackedAddressesByContractName = {};
+        Utils.Dict.forEachWithKey(p.addressesByContractName, (addresses, contractName) => {
+          let keptAddresses = addresses.filter(address => !addressesToRemove.has(address));
+          if (keptAddresses.length !== 0) {
+            rollbackedAddressesByContractName[contractName] = keptAddresses;
+            return;
+          }
+        });
+        if (!Utils.Dict.isEmpty(rollbackedAddressesByContractName)) {
+          let id = nextKeptIdRef.toString();
           nextKeptIdRef = nextKeptIdRef + 1 | 0;
           keptPartitions.push({
-                id: id,
-                latestFetchedBlock: p.latestFetchedBlock,
-                selection: p.selection,
-                addressesByContractName: rollbackedAddressesByContractName,
-                mergeBlock: mergeBlock$1,
-                dynamicContract: p.dynamicContract,
-                mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
-                prevQueryRange: p.prevQueryRange,
-                prevPrevQueryRange: p.prevPrevQueryRange,
-                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
-              });
-        }
-        
-      }
-    } else {
-      var id$1 = String(nextKeptIdRef);
-      nextKeptIdRef = nextKeptIdRef + 1 | 0;
-      keptPartitions.push({
-            id: id$1,
-            latestFetchedBlock: p.latestFetchedBlock.blockNumber > targetBlockNumber ? ({
-                  blockNumber: targetBlockNumber,
-                  blockTimestamp: 0
-                }) : p.latestFetchedBlock,
+            id: id,
+            latestFetchedBlock: p.latestFetchedBlock,
             selection: p.selection,
-            addressesByContractName: p.addressesByContractName,
-            mergeBlock: p.mergeBlock,
+            addressesByContractName: rollbackedAddressesByContractName,
+            mergeBlock: mergeBlock$1,
             dynamicContract: p.dynamicContract,
             mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
             prevQueryRange: p.prevQueryRange,
             prevPrevQueryRange: p.prevPrevQueryRange,
             latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
           });
+        }
+      }
+    } else {
+      let id$1 = nextKeptIdRef.toString();
+      nextKeptIdRef = nextKeptIdRef + 1 | 0;
+      keptPartitions.push({
+        id: id$1,
+        latestFetchedBlock: p.latestFetchedBlock.blockNumber > targetBlockNumber ? ({
+            blockNumber: targetBlockNumber,
+            blockTimestamp: 0
+          }) : p.latestFetchedBlock,
+        selection: p.selection,
+        addressesByContractName: p.addressesByContractName,
+        mergeBlock: p.mergeBlock,
+        dynamicContract: p.dynamicContract,
+        mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
+        prevQueryRange: p.prevQueryRange,
+        prevPrevQueryRange: p.prevPrevQueryRange,
+        latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+      });
     }
   }
-  var optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, fetchState.optimizedPartitions.dynamicContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber);
+  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, fetchState.optimizedPartitions.dynamicContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber);
   return updateInternal({
-              optimizedPartitions: fetchState.optimizedPartitions,
-              startBlock: fetchState.startBlock,
-              endBlock: fetchState.endBlock,
-              normalSelection: fetchState.normalSelection,
-              indexingContracts: fetchState.indexingContracts,
-              contractConfigs: fetchState.contractConfigs,
-              chainId: fetchState.chainId,
-              latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber < targetBlockNumber ? fetchState.latestOnBlockBlockNumber : targetBlockNumber,
-              blockLag: fetchState.blockLag,
-              buffer: fetchState.buffer,
-              targetBufferSize: fetchState.targetBufferSize,
-              onBlockConfigs: fetchState.onBlockConfigs,
-              knownHeight: fetchState.knownHeight,
-              firstEventBlock: fetchState.firstEventBlock
-            }, optimizedPartitions, indexingContracts, Belt_Array.keep(fetchState.buffer, (function (item) {
-                    var tmp;
-                    tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
-                    return tmp <= targetBlockNumber;
-                  })), undefined, undefined);
+    optimizedPartitions: fetchState.optimizedPartitions,
+    startBlock: fetchState.startBlock,
+    endBlock: fetchState.endBlock,
+    normalSelection: fetchState.normalSelection,
+    indexingAddresses: fetchState.indexingAddresses,
+    contractConfigs: fetchState.contractConfigs,
+    chainId: fetchState.chainId,
+    latestOnBlockBlockNumber: Primitive_int.min(fetchState.latestOnBlockBlockNumber, targetBlockNumber),
+    blockLag: fetchState.blockLag,
+    buffer: fetchState.buffer,
+    targetBufferSize: fetchState.targetBufferSize,
+    onBlockConfigs: fetchState.onBlockConfigs,
+    knownHeight: fetchState.knownHeight,
+    firstEventBlock: fetchState.firstEventBlock
+  }, optimizedPartitions, indexingAddresses, fetchState.buffer.filter(item => {
+    let tmp;
+    tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
+    return tmp <= targetBlockNumber;
+  }), undefined, undefined);
 }
 
 function resetPendingQueries(fetchState) {
-  var newEntities = Utils.Dict.shallowCopy(fetchState.optimizedPartitions.entities);
-  for(var idx = 0 ,idx_finish = fetchState.optimizedPartitions.idsInAscOrder.length; idx < idx_finish; ++idx){
-    var partitionId = fetchState.optimizedPartitions.idsInAscOrder[idx];
-    var partition = fetchState.optimizedPartitions.entities[partitionId];
+  let newEntities = Utils.Dict.shallowCopy(fetchState.optimizedPartitions.entities);
+  for (let idx = 0, idx_finish = fetchState.optimizedPartitions.idsInAscOrder.length; idx < idx_finish; ++idx) {
+    let partitionId = fetchState.optimizedPartitions.idsInAscOrder[idx];
+    let partition = fetchState.optimizedPartitions.entities[partitionId];
     if (partition.mutPendingQueries.length !== 0) {
-      var kept = Belt_Array.keep(partition.mutPendingQueries, (function (pq) {
-              return pq.fetchedBlock !== undefined;
-            }));
+      let kept = partition.mutPendingQueries.filter(pq => pq.fetchedBlock !== undefined);
       newEntities[partitionId] = {
         id: partition.id,
         latestFetchedBlock: partition.latestFetchedBlock,
@@ -1446,39 +1489,38 @@ function resetPendingQueries(fetchState) {
         latestBlockRangeUpdateBlock: partition.latestBlockRangeUpdateBlock
       };
     }
-    
   }
-  var init = fetchState.optimizedPartitions;
+  let init = fetchState.optimizedPartitions;
   return {
-          optimizedPartitions: {
-            idsInAscOrder: init.idsInAscOrder,
-            entities: newEntities,
-            maxAddrInPartition: init.maxAddrInPartition,
-            nextPartitionIndex: init.nextPartitionIndex,
-            dynamicContracts: init.dynamicContracts
-          },
-          startBlock: fetchState.startBlock,
-          endBlock: fetchState.endBlock,
-          normalSelection: fetchState.normalSelection,
-          indexingContracts: fetchState.indexingContracts,
-          contractConfigs: fetchState.contractConfigs,
-          chainId: fetchState.chainId,
-          latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
-          blockLag: fetchState.blockLag,
-          buffer: fetchState.buffer,
-          targetBufferSize: fetchState.targetBufferSize,
-          onBlockConfigs: fetchState.onBlockConfigs,
-          knownHeight: fetchState.knownHeight,
-          firstEventBlock: fetchState.firstEventBlock
-        };
+    optimizedPartitions: {
+      idsInAscOrder: init.idsInAscOrder,
+      entities: newEntities,
+      maxAddrInPartition: init.maxAddrInPartition,
+      nextPartitionIndex: init.nextPartitionIndex,
+      dynamicContracts: init.dynamicContracts
+    },
+    startBlock: fetchState.startBlock,
+    endBlock: fetchState.endBlock,
+    normalSelection: fetchState.normalSelection,
+    indexingAddresses: fetchState.indexingAddresses,
+    contractConfigs: fetchState.contractConfigs,
+    chainId: fetchState.chainId,
+    latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
+    blockLag: fetchState.blockLag,
+    buffer: fetchState.buffer,
+    targetBufferSize: fetchState.targetBufferSize,
+    onBlockConfigs: fetchState.onBlockConfigs,
+    knownHeight: fetchState.knownHeight,
+    firstEventBlock: fetchState.firstEventBlock
+  };
 }
 
 function isActivelyIndexing(fetchState) {
-  var endBlock = fetchState.endBlock;
+  let endBlock = fetchState.endBlock;
   if (endBlock === undefined) {
     return true;
   }
-  var isPastEndblock = bufferBlockNumber(fetchState) >= endBlock;
+  let isPastEndblock = bufferBlockNumber(fetchState) >= endBlock;
   if (isPastEndblock) {
     return bufferSize(fetchState) > 0;
   } else {
@@ -1487,10 +1529,10 @@ function isActivelyIndexing(fetchState) {
 }
 
 function isReadyToEnterReorgThreshold(fetchState) {
-  var knownHeight = fetchState.knownHeight;
-  var blockLag = fetchState.blockLag;
-  var endBlock = fetchState.endBlock;
-  var bufferBlockNumber$1 = bufferBlockNumber(fetchState);
+  let knownHeight = fetchState.knownHeight;
+  let blockLag = fetchState.blockLag;
+  let endBlock = fetchState.endBlock;
+  let bufferBlockNumber$1 = bufferBlockNumber(fetchState);
   if (knownHeight !== 0 && (
       endBlock !== undefined && bufferBlockNumber$1 >= endBlock ? true : bufferBlockNumber$1 >= (knownHeight - blockLag | 0)
     )) {
@@ -1501,7 +1543,7 @@ function isReadyToEnterReorgThreshold(fetchState) {
 }
 
 function hasFullBatch(fetchState, batchSizeTarget) {
-  var item = Belt_Array.get(fetchState.buffer, batchSizeTarget - 1 | 0);
+  let item = Belt_Array.get(fetchState.buffer, batchSizeTarget - 1 | 0);
   if (item !== undefined) {
     return item.blockNumber <= bufferBlockNumber(fetchState);
   } else {
@@ -1510,46 +1552,47 @@ function hasFullBatch(fetchState, batchSizeTarget) {
 }
 
 function getProgressPercentage(fetchState) {
-  var firstEventBlock = fetchState.firstEventBlock;
+  let firstEventBlock = fetchState.firstEventBlock;
   if (firstEventBlock === undefined) {
     return 0;
   }
-  var totalRange = fetchState.knownHeight - firstEventBlock | 0;
+  let totalRange = fetchState.knownHeight - firstEventBlock | 0;
   if (totalRange <= 0) {
     return 0;
   }
-  var item = Belt_Array.get(fetchState.buffer, 0);
-  var progress = item !== undefined ? item.blockNumber - firstEventBlock | 0 : bufferBlockNumber(fetchState) - firstEventBlock | 0;
+  let item = Belt_Array.get(fetchState.buffer, 0);
+  let progress = item !== undefined ? item.blockNumber - firstEventBlock | 0 : bufferBlockNumber(fetchState) - firstEventBlock | 0;
   return progress / totalRange;
 }
 
 function sortForUnorderedBatch(fetchStates, batchSizeTarget) {
-  return fetchStates.slice(0).sort(function (a, b) {
-              var match = hasFullBatch(a, batchSizeTarget);
-              var match$1 = hasFullBatch(b, batchSizeTarget);
-              if (match) {
-                if (!match$1) {
-                  return -1;
-                }
-                
-              } else if (match$1) {
-                return 1;
-              }
-              var aProgress = getProgressPercentage(a);
-              var bProgress = getProgressPercentage(b);
-              if (aProgress < bProgress) {
-                return -1;
-              } else if (aProgress > bProgress) {
-                return 1;
-              } else {
-                return 0;
-              }
-            });
+  let copied = fetchStates.slice();
+  copied.sort((a, b) => {
+    let match = hasFullBatch(a, batchSizeTarget);
+    let match$1 = hasFullBatch(b, batchSizeTarget);
+    if (match) {
+      if (!match$1) {
+        return -1;
+      }
+    } else if (match$1) {
+      return 1;
+    }
+    let aProgress = getProgressPercentage(a);
+    let bProgress = getProgressPercentage(b);
+    if (aProgress < bProgress) {
+      return -1;
+    } else if (aProgress > bProgress) {
+      return 1;
+    } else {
+      return 0;
+    }
+  });
+  return copied;
 }
 
 function getUnorderedMultichainProgressBlockNumberAt(fetchState, index) {
-  var bufferBlockNumber$1 = bufferBlockNumber(fetchState);
-  var item = Belt_Array.get(fetchState.buffer, index);
+  let bufferBlockNumber$1 = bufferBlockNumber(fetchState);
+  let item = Belt_Array.get(fetchState.buffer, index);
   if (item !== undefined && bufferBlockNumber$1 >= item.blockNumber) {
     return item.blockNumber - 1 | 0;
   } else {
@@ -1566,39 +1609,40 @@ function updateKnownHeight(fetchState, knownHeight) {
   }
 }
 
-var blockItemLogIndex = 16777216;
+let blockItemLogIndex = 16777216;
 
 export {
-  getMinHistoryRange ,
-  getMinQueryRange ,
-  OptimizedPartitions ,
-  bufferBlockNumber ,
-  bufferBlock ,
-  compareBufferItem ,
-  blockItemLogIndex ,
-  numAddresses ,
-  updateInternal ,
-  warnDifferentContractType ,
-  addressesByContractNameCount ,
-  addressesByContractNameGetAll ,
-  createPartitionsFromIndexingAddresses ,
-  registerDynamicContracts ,
-  handleQueryResult ,
-  startFetchingQueries ,
-  pushQueriesForRange ,
-  getNextQuery ,
-  getTimestampAt ,
-  hasReadyItem ,
-  getReadyItemsCount ,
+  deriveEffectiveStartBlock,
+  getMinHistoryRange,
+  getMinQueryRange,
+  OptimizedPartitions,
+  bufferBlockNumber,
+  bufferBlock,
+  compareBufferItem,
+  blockItemLogIndex,
+  numAddresses,
+  updateInternal,
+  warnDifferentContractType,
+  addressesByContractNameCount,
+  addressesByContractNameGetAll,
+  createPartitionsFromIndexingAddresses,
+  registerDynamicContracts,
+  handleQueryResult,
+  startFetchingQueries,
+  pushQueriesForRange,
+  getNextQuery,
+  getTimestampAt,
+  hasReadyItem,
+  getReadyItemsCount,
   make$1 as make,
-  bufferSize ,
-  rollbackPendingQueries ,
-  rollback ,
-  resetPendingQueries ,
-  isActivelyIndexing ,
-  isReadyToEnterReorgThreshold ,
-  sortForUnorderedBatch ,
-  getUnorderedMultichainProgressBlockNumberAt ,
-  updateKnownHeight ,
+  bufferSize,
+  rollbackPendingQueries,
+  rollback,
+  resetPendingQueries,
+  isActivelyIndexing,
+  isReadyToEnterReorgThreshold,
+  sortForUnorderedBatch,
+  getUnorderedMultichainProgressBlockNumberAt,
+  updateKnownHeight,
 }
 /* Utils Not a pure module */