envio 3.5.0-alpha.2 → 3.5.0-rc.0

package/src/FetchState.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
 import * as Js_math from "@rescript/runtime/lib/es6/Js_math.js";
 import * as Logging from "./Logging.res.mjs";
 import * as AddressSet from "./sources/AddressSet.res.mjs";
@@ -14,6 +15,38 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
+function deriveSelectionStartBlock(onEventRegistrations) {
+  let earliest;
+  let idx = 0;
+  let unrestricted = Utils.$$Array.isEmpty(onEventRegistrations);
+  while (!unrestricted && idx < onEventRegistrations.length) {
+    let startBlock = onEventRegistrations[idx].startBlock;
+    if (startBlock !== undefined) {
+      let current = earliest;
+      if (!(current !== undefined && current <= startBlock)) {
+        earliest = startBlock;
+      }
+    } else {
+      unrestricted = true;
+    }
+    idx = idx + 1 | 0;
+  };
+  if (unrestricted) {
+    return;
+  } else {
+    return earliest;
+  }
+}
+
+function makeSelection(onEventRegistrations, dependsOnAddresses, clientFilteredContracts) {
+  return {
+    onEventRegistrations: onEventRegistrations,
+    dependsOnAddresses: dependsOnAddresses,
+    clientFilteredContracts: clientFilteredContracts,
+    startBlock: deriveSelectionStartBlock(onEventRegistrations)
+  };
+}
+
 function withAddresses(p, addresses) {
   return {
     id: p.id,
@@ -30,6 +63,26 @@ function withAddresses(p, addresses) {
   };
 }
 
+function narrowSelectionToRange(selection, toBlock) {
+  if (toBlock === undefined) {
+    return selection;
+  }
+  let inRange = selection.onEventRegistrations.filter(reg => {
+    let startBlock = reg.startBlock;
+    if (startBlock !== undefined) {
+      return startBlock <= toBlock;
+    } else {
+      return true;
+    }
+  });
+  let length = inRange.length;
+  if (length !== 0 && length !== selection.onEventRegistrations.length) {
+    return makeSelection(inRange, selection.dependsOnAddresses, selection.clientFilteredContracts);
+  } else {
+    return selection;
+  }
+}
+
 function densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock) {
   return Primitive_int.max(1, Math.ceil(((Stdlib_Option.getOr(toBlock, chainTargetBlock) - fromBlock | 0) + 1 | 0) * density) | 0);
 }
@@ -46,6 +99,10 @@ function getTrustedDensity(p) {
   return p.eventDensity;
 }
 
+function isFetching(p) {
+  return p.mutPendingQueries.some(pq => pq.fetchedBlock === undefined);
+}
+
 function getMinQueryRange(partitions) {
   let min = 0;
   for (let i = 0, i_finish = partitions.length; i < i_finish; ++i) {
@@ -200,16 +257,92 @@ function ascSortFn(a, b) {
   return Primitive_int.compare(a.latestFetchedBlock.blockNumber, b.latestFetchedBlock.blockNumber);
 }
 
+function anchoredContracts(partitions) {
+  let set = new Set();
+  partitions.forEach(p => {
+    let match = p.mergeBlock;
+    let match$1 = p.selection.clientFilteredContracts;
+    if (match !== undefined || match$1 === undefined) {
+      return;
+    } else {
+      match$1.forEach(name => {
+        set.add(name);
+      });
+      return;
+    }
+  });
+  return set;
+}
+
+function getAnchorSafeBlock(p) {
+  let safeRef = {
+    contents: p.latestFetchedBlock.blockNumber
+  };
+  p.mutPendingQueries.forEach(pq => {
+    let match = safeRef.contents;
+    if (match === undefined) {
+      return;
+    }
+    let toBlock = pq.toBlock;
+    let match$1 = pq.fetchedBlock;
+    if (match$1 === undefined) {
+      if (toBlock !== undefined) {
+        if (toBlock > match) {
+          safeRef.contents = toBlock;
+          return;
+        } else {
+          return;
+        }
+      } else {
+        safeRef.contents = undefined;
+        return;
+      }
+    }
+    let blockNumber = match$1.blockNumber;
+    if (blockNumber > match) {
+      safeRef.contents = blockNumber;
+      return;
+    }
+  });
+  return safeRef.contents;
+}
+
 function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContracts, clientFilteredContracts) {
   let newPartitions = [];
   let mergingPartitions = {};
   let nextPartitionIndexRef = {
     contents: nextPartitionIndex
   };
+  let anchorSafeBlocks = {};
+  let anchoredContractsSet = new Set();
+  if (clientFilteredContracts.size > 0) {
+    partitions.forEach(p => {
+      let match = p.mergeBlock;
+      let match$1 = p.selection.clientFilteredContracts;
+      if (match !== undefined) {
+        return;
+      }
+      if (match$1 === undefined) {
+        return;
+      }
+      let safeBlock = getAnchorSafeBlock(p);
+      match$1.forEach(name => {
+        anchoredContractsSet.add(name);
+        if (safeBlock !== undefined) {
+          anchorSafeBlocks[name] = safeBlock;
+          return;
+        }
+      });
+    });
+  }
   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 mergeBlock = p.mergeBlock;
+    if (mergeBlock !== undefined) {
+      if (p.latestFetchedBlock.blockNumber < mergeBlock || isFetching(p)) {
+        newPartitions.push(p);
+      }
+    } else if (p.dynamicContract !== undefined && p.selection.dependsOnAddresses) {
       let contractName = p.dynamicContract;
       let pAddressesCount = p.addresses.countFor(contractName);
       let match = Utils.$$Array.last(p.mutPendingQueries);
@@ -236,9 +369,6 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
         newPartitions.push(p);
       }
     } else {
-      exit = 1;
-    }
-    if (exit === 1) {
       newPartitions.push(p);
     }
   }
@@ -276,12 +406,72 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
     };
     newPartitions.push(currentPRef);
   }
-  newPartitions.sort(ascSortFn);
-  let partitionsCount = newPartitions.length;
+  let finalPartitions;
+  if (anchoredContractsSet.size === 0) {
+    finalPartitions = newPartitions;
+  } else {
+    let anchored = [];
+    newPartitions.forEach(p => {
+      if (p.mergeBlock !== undefined) {
+        anchored.push(p);
+        return;
+      }
+      let contractName = p.dynamicContract;
+      if (contractName !== undefined) {
+        if (anchoredContractsSet.has(contractName)) {
+          let anchorSafeBlock = anchorSafeBlocks[contractName];
+          if (anchorSafeBlock !== undefined) {
+            if (p.latestFetchedBlock.blockNumber < anchorSafeBlock) {
+              anchored.push({
+                id: p.id,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: p.selection,
+                addresses: p.addresses,
+                mergeBlock: anchorSafeBlock,
+                dynamicContract: p.dynamicContract,
+                mutPendingQueries: p.mutPendingQueries,
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+              });
+              return;
+            } else if (isFetching(p)) {
+              anchored.push({
+                id: p.id,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: p.selection,
+                addresses: p.addresses,
+                mergeBlock: p.latestFetchedBlock.blockNumber,
+                dynamicContract: p.dynamicContract,
+                mutPendingQueries: p.mutPendingQueries,
+                sourceRangeCapacity: p.sourceRangeCapacity,
+                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+                eventDensity: p.eventDensity,
+                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+              });
+              return;
+            } else {
+              return;
+            }
+          } else {
+            anchored.push(p);
+            return;
+          }
+        }
+        anchored.push(p);
+        return;
+      }
+      anchored.push(p);
+    });
+    finalPartitions = anchored;
+  }
+  finalPartitions.sort(ascSortFn);
+  let partitionsCount = finalPartitions.length;
   let idsInAscOrder = Array(partitionsCount);
   let entities = {};
   for (let idx$2 = 0; idx$2 < partitionsCount; ++idx$2) {
-    let p$1 = newPartitions[idx$2];
+    let p$1 = finalPartitions[idx$2];
     idsInAscOrder[idx$2] = p$1.id;
     entities[p$1.id] = p$1;
   }
@@ -387,7 +577,9 @@ function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHei
   }
   let updatedLatestFetchedBlock = latestFetchedBlock$1;
   let mergeBlock = p.mergeBlock;
-  let partitionReachedMergeBlock = mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false;
+  let partitionReachedMergeBlock = (
+    mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false
+  ) && !isFetching(p);
   if (partitionReachedMergeBlock) {
     Utils.Dict.deleteInPlace(mutEntities, p.id);
     return make(Object.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts, optimizedPartitions.clientFilteredContracts);
@@ -454,12 +646,9 @@ function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHei
 }
 
 function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount, latestFetchedBlock) {
-  let p = optimizedPartitions.entities[query.partitionId];
-  if (p !== undefined) {
-    return handleQueryResponseForPartition(optimizedPartitions, p, query, knownHeight, itemsCount, latestFetchedBlock);
-  } else {
-    return optimizedPartitions;
-  }
+  let partitionId = query.partitionId;
+  let p = optimizedPartitions.entities[partitionId];
+  return handleQueryResponseForPartition(optimizedPartitions, p !== undefined ? p : Stdlib_JsError.throwWithMessage(`Unexpected case: Couldn't find partition ` + partitionId), query, knownHeight, itemsCount, latestFetchedBlock);
 }
 
 function getLatestFullyFetchedBlock(optimizedPartitions) {
@@ -475,6 +664,8 @@ let OptimizedPartitions = {
   mergePartitionsAtBlock: mergePartitionsAtBlock,
   tooFarBlockRange: 20000,
   ascSortFn: ascSortFn,
+  anchoredContracts: anchoredContracts,
+  getAnchorSafeBlock: getAnchorSafeBlock,
   make: make,
   consumeFetchedQueries: consumeFetchedQueries,
   getPendingQueryOrThrow: getPendingQueryOrThrow,
@@ -683,14 +874,17 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
   };
 }
 
-function addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, threshold) {
+function addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, threshold, shouldLogOpt) {
+  let shouldLog = shouldLogOpt !== undefined ? shouldLogOpt : true;
   clientFilteredContracts.add(contractName);
-  Logging.childTrace(Logging.createChild({
-    chainId: chainId,
-    contractName: contractName,
-    addressCount: addressCount,
-    threshold: threshold
-  }), "Switching contract to client-side address filtering: registered address count crossed the server-side threshold.");
+  if (shouldLog) {
+    return Logging.childTrace(Logging.createChild({
+      chainId: chainId,
+      contractName: contractName,
+      addressCount: addressCount,
+      threshold: threshold
+    }), "Switching contract to client-side address filtering: registered address count crossed the server-side threshold.");
+  }
 }
 
 function claimedFetchedBlock(p, knownHeight) {
@@ -700,7 +894,8 @@ function claimedFetchedBlock(p, knownHeight) {
   });
 }
 
-function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, knownHeight) {
+function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, clientFilteredFrontiersOpt, knownHeight) {
+  let clientFilteredFrontiers = clientFilteredFrontiersOpt !== undefined ? clientFilteredFrontiersOpt : [];
   if (clientFilteredContracts.size === 0) {
     return partitions;
   }
@@ -711,31 +906,65 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   let backfills = [];
   let absorbedPartitions = [];
   let strippedFrontiers = [];
+  let anchoredContracts$1 = anchoredContracts(partitions);
+  let retire = p => ({
+    id: p.id,
+    latestFetchedBlock: p.latestFetchedBlock,
+    selection: p.selection,
+    addresses: p.addresses,
+    mergeBlock: p.latestFetchedBlock.blockNumber,
+    dynamicContract: p.dynamicContract,
+    mutPendingQueries: p.mutPendingQueries,
+    sourceRangeCapacity: p.sourceRangeCapacity,
+    prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+    eventDensity: p.eventDensity,
+    latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+  });
+  let absorb = p => {
+    absorbedPartitions.push(p);
+    if (isFetching(p)) {
+      kept.push(retire(p));
+      return;
+    }
+  };
   partitions.forEach(p => {
     if (!p.selection.dependsOnAddresses) {
       if (p.mergeBlock !== undefined) {
         backfills.push(p);
+        if (isFetching(p)) {
+          kept.push(retire(p));
+          return;
+        } else {
+          return;
+        }
       } else if (Stdlib_Option.isNone(standingRef.contents)) {
         standingRef.contents = p;
+        return;
       } else {
-        absorbedPartitions.push(p);
+        return absorb(p);
       }
-      return;
     }
     let contractNames = p.addresses.contractNames();
     let serverSideNames = contractNames.filter(c => !clientFilteredContracts.has(c));
     if (serverSideNames.length === contractNames.length) {
       kept.push(p);
+      return;
+    }
+    let contractName = p.dynamicContract;
+    if (contractName !== undefined ? anchoredContracts$1.has(contractName) : false) {
+      kept.push(p);
+      return;
     } else if (Utils.$$Array.isEmpty(serverSideNames)) {
-      absorbedPartitions.push(p);
+      return absorb(p);
     } else {
       strippedFrontiers.push(p.latestFetchedBlock);
       kept.push(withAddresses(p, p.addresses.filterByContracts(serverSideNames)));
+      return;
     }
   });
   let standing = standingRef.contents;
   let selectionChanged = standing !== undefined ? Stdlib_Option.mapOr(standing.selection.clientFilteredContracts, 0, prim => prim.length) !== clientFilteredContracts.size : true;
-  if (Utils.$$Array.isEmpty(absorbedPartitions) && Utils.$$Array.isEmpty(strippedFrontiers) && !selectionChanged) {
+  if (Utils.$$Array.isEmpty(absorbedPartitions) && Utils.$$Array.isEmpty(strippedFrontiers) && Utils.$$Array.isEmpty(clientFilteredFrontiers) && !selectionChanged) {
     return partitions;
   }
   let minFrontierRef = {
@@ -753,6 +982,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   absorbedPartitions.forEach(p => considerFrontier(p.latestFetchedBlock));
   backfills.forEach(p => considerFrontier(p.latestFetchedBlock));
   strippedFrontiers.forEach(considerFrontier);
+  clientFilteredFrontiers.forEach(considerFrontier);
   let regByIndex = {};
   let addRegs = regs => {
     regs.forEach(reg => {
@@ -769,19 +999,16 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
     }
   });
   addRegs(normalSelection.onEventRegistrations.filter(reg => clientFilteredContracts.has(reg.eventConfig.contractName)));
-  let newSelection_onEventRegistrations = Object.values(regByIndex);
-  let newSelection_clientFilteredContracts = Array.from(clientFilteredContracts);
-  let newSelection = {
-    onEventRegistrations: newSelection_onEventRegistrations,
-    dependsOnAddresses: false,
-    clientFilteredContracts: newSelection_clientFilteredContracts
-  };
+  let newSelection = makeSelection(Object.values(regByIndex), false, Array.from(clientFilteredContracts));
   let standing$2 = standingRef.contents;
   if (standing$2 !== undefined) {
     let standingOut;
     if (selectionChanged) {
       let id = nextPartitionIndexRef.contents.toString();
       nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+      if (isFetching(standing$2)) {
+        kept.push(retire(standing$2));
+      }
       standingOut = {
         id: id,
         latestFetchedBlock: standing$2.latestFetchedBlock,
@@ -843,65 +1070,115 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   return kept;
 }
 
+function warnAddressRegistration(chainId, contractAddress, params, message) {
+  Logging.childWarn(Logging.createChild({
+    chainId: chainId,
+    contractAddress: contractAddress,
+    details: params
+  }), message);
+}
+
+function warnRejectedRegistration(verdict, chainId, contractAddress, contractName) {
+  if (typeof verdict !== "object") {
+    return warnAddressRegistration(chainId, contractAddress, {
+      contractName: contractName
+    }, `Skipping contract registration: Not a valid address for this chain's ecosystem.`);
+  }
+  switch (verdict.TAG) {
+    case "Added" :
+    case "NoEvents" :
+      return;
+    case "Duplicate" :
+      let existingEffectiveStartBlock = verdict.existingEffectiveStartBlock;
+      let effectiveStartBlock = verdict.effectiveStartBlock;
+      if (existingEffectiveStartBlock > effectiveStartBlock) {
+        return warnAddressRegistration(chainId, contractAddress, {
+          existingBlockNumber: existingEffectiveStartBlock,
+          newBlockNumber: effectiveStartBlock
+        }, `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.`);
+      } else {
+        return;
+      }
+    case "Conflict" :
+      return warnAddressRegistration(chainId, contractAddress, {
+        existingContractType: verdict.existingContractName,
+        newContractType: contractName
+      }, `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`);
+  }
+}
+
 function createPartitions(registeringSetsByContract, addressStore, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber, knownHeight) {
   let nextPartitionIndexRef = {
     contents: nextPartitionIndex
   };
   let dynamicPartitions = [];
   let nonDynamicPartitions = [];
+  let clientFilteredFrontiers = [];
+  let anchoredContracts$1 = anchoredContracts(existingPartitions);
   let contractNames = Object.keys(registeringSetsByContract);
   for (let cIdx = 0, cIdx_finish = contractNames.length; cIdx < cIdx_finish; ++cIdx) {
     let contractName = contractNames[cIdx];
     let contractSet = registeringSetsByContract[contractName];
-    let isDynamic = dynamicContracts.has(contractName);
+    let isAnchored = anchoredContracts$1.has(contractName);
+    let isDynamic = dynamicContracts.has(contractName) || isAnchored;
     let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions;
     let groups = contractSet.startBlockGroups();
-    let offsetRef = 0;
-    let groupIdx = 0;
-    while (groupIdx < groups.length) {
-      let startBlock = groups[groupIdx].startBlock;
-      let countRef = 0;
-      let nextIdx = groupIdx;
-      let joining = true;
-      while (joining && nextIdx < groups.length) {
-        let group = groups[nextIdx];
-        if ((group.startBlock - startBlock | 0) < 20000) {
-          countRef = countRef + group.count | 0;
-          nextIdx = nextIdx + 1 | 0;
-        } else {
-          joining = false;
-        }
-      };
-      let latestFetchedBlock_blockNumber = Primitive_int.max(startBlock - 1 | 0, progressBlockNumber);
-      let latestFetchedBlock = {
-        blockNumber: latestFetchedBlock_blockNumber,
-        blockTimestamp: 0
-      };
-      let remainingRef = countRef;
-      let chunkOffsetRef = offsetRef;
-      while (remainingRef > 0) {
-        let take = Primitive_int.min(remainingRef, maxAddrInPartition);
-        let pAddresses = contractSet.slice(chunkOffsetRef, take);
-        partitions.push({
-          id: nextPartitionIndexRef.contents.toString(),
-          latestFetchedBlock: latestFetchedBlock,
-          selection: normalSelection,
-          addresses: pAddresses,
-          mergeBlock: undefined,
-          dynamicContract: isDynamic ? contractName : undefined,
-          mutPendingQueries: [],
-          sourceRangeCapacity: 0,
-          prevSourceRangeCapacity: 0,
-          eventDensity: undefined,
-          latestSourceRangeCapacityUpdateBlock: 0
+    if (clientFilteredContracts.has(contractName) && !isAnchored) {
+      let match = groups[0];
+      if (match !== undefined) {
+        clientFilteredFrontiers.push({
+          blockNumber: Primitive_int.max(match.startBlock - 1 | 0, progressBlockNumber),
+          blockTimestamp: 0
         });
-        nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
-        chunkOffsetRef = chunkOffsetRef + take | 0;
-        remainingRef = remainingRef - take | 0;
+      }
+    } else {
+      let offsetRef = 0;
+      let groupIdx = 0;
+      while (groupIdx < groups.length) {
+        let startBlock = groups[groupIdx].startBlock;
+        let countRef = 0;
+        let nextIdx = groupIdx;
+        let joining = true;
+        while (joining && nextIdx < groups.length) {
+          let group = groups[nextIdx];
+          if ((group.startBlock - startBlock | 0) < 20000) {
+            countRef = countRef + group.count | 0;
+            nextIdx = nextIdx + 1 | 0;
+          } else {
+            joining = false;
+          }
+        };
+        let latestFetchedBlock_blockNumber = Primitive_int.max(startBlock - 1 | 0, progressBlockNumber);
+        let latestFetchedBlock = {
+          blockNumber: latestFetchedBlock_blockNumber,
+          blockTimestamp: 0
+        };
+        let remainingRef = countRef;
+        let chunkOffsetRef = offsetRef;
+        while (remainingRef > 0) {
+          let take = Primitive_int.min(remainingRef, maxAddrInPartition);
+          let pAddresses = contractSet.slice(chunkOffsetRef, take);
+          partitions.push({
+            id: nextPartitionIndexRef.contents.toString(),
+            latestFetchedBlock: latestFetchedBlock,
+            selection: normalSelection,
+            addresses: pAddresses,
+            mergeBlock: undefined,
+            dynamicContract: isDynamic ? contractName : undefined,
+            mutPendingQueries: [],
+            sourceRangeCapacity: 0,
+            prevSourceRangeCapacity: 0,
+            eventDensity: undefined,
+            latestSourceRangeCapacityUpdateBlock: 0
+          });
+          nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+          chunkOffsetRef = chunkOffsetRef + take | 0;
+          remainingRef = remainingRef - take | 0;
+        };
+        offsetRef = offsetRef + countRef | 0;
+        groupIdx = nextIdx;
       };
-      offsetRef = offsetRef + countRef | 0;
-      groupIdx = nextIdx;
-    };
+    }
   }
   let mergedNonDynamic = [];
   if (nonDynamicPartitions.length !== 0) {
@@ -944,7 +1221,7 @@ function createPartitions(registeringSetsByContract, addressStore, dynamicContra
     mergedNonDynamic.push(currentPRef);
   }
   let mergedPartitions = mergedNonDynamic.concat(dynamicPartitions);
-  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, knownHeight);
+  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, clientFilteredFrontiers, knownHeight);
   return make(allPartitions, maxAddrInPartition, nextPartitionIndexRef.contents, dynamicContracts, clientFilteredContracts);
 }
 
@@ -973,25 +1250,17 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
   }
   let idCursor = addressStore.nextId();
   let verdicts = AddressStore.registerBatch(addressStore, registrations);
-  let warn = (contractAddress, params, message) => Logging.childWarn(Logging.createChild({
-    chainId: fetchState.chainId,
-    contractAddress: contractAddress,
-    details: params
-  }), message);
   let registeringContractNames = [];
   let hasNoEventsUpdatesRef = false;
   for (let idx = 0, idx_finish = verdicts.length; idx < idx_finish; ++idx) {
     let registration = registrations[idx];
-    let contractAddress = registration.address;
-    let match = verdicts[idx];
+    let verdict = verdicts[idx];
     let keep;
-    if (typeof match !== "object") {
-      warn(contractAddress, {
-        contractName: registration.contractName
-      }, `Skipping contract registration: Not a valid address for this chain's ecosystem.`);
-      keep = false;
+    let exit = 0;
+    if (typeof verdict !== "object") {
+      exit = 1;
     } else {
-      switch (match.TAG) {
+      switch (verdict.TAG) {
         case "Added" :
           if (!registeringContractNames.includes(registration.contractName)) {
             registeringContractNames.push(registration.contractName);
@@ -1000,31 +1269,19 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
           break;
         case "NoEvents" :
           hasNoEventsUpdatesRef = true;
-          warn(contractAddress, {
+          warnAddressRegistration(fetchState.chainId, registration.address, {
             contractName: registration.contractName
           }, `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.`);
           keep = true;
           break;
-        case "Duplicate" :
-          let existingEffectiveStartBlock = match.existingEffectiveStartBlock;
-          let effectiveStartBlock = match.effectiveStartBlock;
-          if (existingEffectiveStartBlock > effectiveStartBlock) {
-            warn(contractAddress, {
-              existingBlockNumber: existingEffectiveStartBlock,
-              newBlockNumber: effectiveStartBlock
-            }, `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.`);
-          }
-          keep = false;
-          break;
-        case "Conflict" :
-          warn(contractAddress, {
-            existingContractType: match.existingContractName,
-            newContractType: registration.contractName
-          }, `Skipping contract registration: Contract address is already registered for one contract and cannot be registered for another contract.`);
-          keep = false;
-          break;
+        default:
+          exit = 1;
       }
     }
+    if (exit === 1) {
+      warnRejectedRegistration(verdict, fetchState.chainId, registration.address, registration.contractName);
+      keep = false;
+    }
     if (!keep) {
       sourceIndexes[idx] = -1 - sourceIndexes[idx] | 0;
     }
@@ -1047,8 +1304,8 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
       dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
       for (let idx$3 = 0, idx_finish$2 = mutExistingPartitions.length; idx$3 < idx_finish$2; ++idx$3) {
         let p = mutExistingPartitions[idx$3];
-        let match$1 = p.addresses.countFor(contractName);
-        if (match$1 !== 0 && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
+        let match = p.addresses.countFor(contractName);
+        if (match !== 0 && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
           let allPartitionContractNames = p.addresses.contractNames();
           if (allPartitionContractNames.length !== 1) {
             let isFetching = p.mutPendingQueries.length !== 0;
@@ -1097,7 +1354,7 @@ function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, ite
     Array.from(dynamicContractsRef).forEach(contractName => {
       let addressCount = addressStore.contractCount(contractName);
       if (!clientFilteredContracts$1.has(contractName) && addressCount > threshold) {
-        return addClientFilteredContract(clientFilteredContracts$1, contractName, fetchState.chainId, addressCount, threshold);
+        return addClientFilteredContract(clientFilteredContracts$1, contractName, fetchState.chainId, addressCount, threshold, undefined);
       }
     });
     clientFilteredContracts = clientFilteredContracts$1;
@@ -1245,11 +1502,19 @@ function walkPartitionPending(p, partitionId, inFlightCount, candidates, headBlo
     }
     pqIdx = pqIdx + 1 | 0;
   };
+  let startBlock = p.selection.startBlock;
+  let cursor$1;
+  if (startBlock !== undefined && startBlock > cursor) {
+    let reachable = Utils.$$Math.minOptInt(headBlockNumber, queryEndBlock);
+    cursor$1 = reachable !== undefined && startBlock <= reachable ? startBlock : cursor;
+  } else {
+    cursor$1 = cursor;
+  }
   if (canContinue) {
     return {
       partitionId: partitionId,
       p: p,
-      cursor: cursor,
+      cursor: cursor$1,
       chunksUsedThisCall: chunksUsedThisCall,
       inFlightCount: inFlightCount,
       queryEndBlock: queryEndBlock,
@@ -1482,12 +1747,13 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt) {
+function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt, isResumedOpt) {
   let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
   let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
   let clientFilterAddressThreshold = clientFilterAddressThresholdOpt !== undefined ? Primitive_option.valFromOption(clientFilterAddressThresholdOpt) : undefined;
+  let isResumed = isResumedOpt !== undefined ? isResumedOpt : false;
   let latestFetchedBlock = {
     blockNumber: progressBlockNumber,
     blockTimestamp: 0
@@ -1508,10 +1774,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     partitions.push({
       id: partitions.length.toString(),
       latestFetchedBlock: latestFetchedBlock,
-      selection: {
-        onEventRegistrations: notDependingOnAddresses,
-        dependsOnAddresses: false
-      },
+      selection: makeSelection(notDependingOnAddresses, false, undefined),
       addresses: addressStore.emptySet(),
       mergeBlock: undefined,
       dynamicContract: undefined,
@@ -1522,15 +1785,15 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
       latestSourceRangeCapacityUpdateBlock: 0
     });
   }
-  let normalSelection = {
-    onEventRegistrations: normalRegistrations,
-    dependsOnAddresses: true
-  };
+  let normalSelection = makeSelection(normalRegistrations, true, undefined);
   AddressStore.registerBatch(addressStore, addresses.map(contract => ({
     address: contract.address,
     contractName: contract.contractName,
     registrationBlock: contract.registrationBlock
-  })));
+  }))).forEach((verdict, idx) => {
+    let contract = addresses[idx];
+    warnRejectedRegistration(verdict, chainId, contract.address, contract.contractName);
+  });
   let dynamicContracts = new Set();
   let clientFilteredContracts = new Set();
   let registeringSetsByContract = {};
@@ -1552,13 +1815,13 @@ function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addres
     Utils.Dict.forEachWithKey(registeringSetsByContract, (set, contractName) => {
       let addressCount = set.size();
       if (addressCount > clientFilterAddressThreshold) {
-        return addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, clientFilterAddressThreshold);
+        return addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, clientFilterAddressThreshold, !isResumed);
       }
     });
   }
   let optimizedPartitions = createPartitions(registeringSetsByContract, addressStore, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber, knownHeight);
   if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockRegistrations)) {
-    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + chainId.toString() + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.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.`);
+    Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + ChainId.toString(chainId) + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`onEventRegistrations=` + onEventRegistrations.length.toString() + `, `) + (`normalRegistrations=` + normalRegistrations.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.`);
   }
   let buffer = [];
   let latestOnBlockBlockNumber;
@@ -1669,6 +1932,7 @@ function rollback(fetchState, addressStore, targetBlockNumber) {
     } else {
       let id$1 = nextKeptIdRef.toString();
       nextKeptIdRef = nextKeptIdRef + 1 | 0;
+      let mergeBlock$2 = p.mergeBlock;
       keptPartitions.push({
         id: id$1,
         latestFetchedBlock: p.latestFetchedBlock.blockNumber > targetBlockNumber ? ({
@@ -1677,7 +1941,7 @@ function rollback(fetchState, addressStore, targetBlockNumber) {
           }) : p.latestFetchedBlock,
         selection: p.selection,
         addresses: p.addresses,
-        mergeBlock: p.mergeBlock,
+        mergeBlock: mergeBlock$2 !== undefined && mergeBlock$2 > targetBlockNumber ? targetBlockNumber : mergeBlock$2,
         dynamicContract: p.dynamicContract,
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
         sourceRangeCapacity: p.sourceRangeCapacity,
@@ -1874,10 +2138,14 @@ let maxChainConcurrency = Env.maxChainConcurrency;
 let chunkRangeGrowthFactor = 1.8;
 
 export {
+  deriveSelectionStartBlock,
+  makeSelection,
   withAddresses,
+  narrowSelectionToRange,
   densityItemsTarget,
   getMinHistoryRange,
   getTrustedDensity,
+  isFetching,
   getMinQueryRange,
   OptimizedPartitions,
   bufferBlockNumber,
@@ -1892,6 +2160,8 @@ export {
   addClientFilteredContract,
   claimedFetchedBlock,
   collapseClientFilteredContracts,
+  warnAddressRegistration,
+  warnRejectedRegistration,
   createPartitions,
   registerDynamicContracts,
   handleQueryResult,