envio 3.5.0-alpha.1 → 3.5.0-alpha.3

package/src/FetchState.res.mjs

@@ -4,24 +4,31 @@ import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.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";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as AddressStore from "./sources/AddressStore.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.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_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as IndexingAddresses from "./IndexingAddresses.res.mjs";
 
-let deriveContractNameByAddress = Utils.$$WeakMap.memoize(addressesByContractName => {
-  let result = {};
-  Utils.Dict.forEachWithKey(addressesByContractName, (addresses, contractName) => {
-    for (let i = 0, i_finish = addresses.length; i < i_finish; ++i) {
-      result[addresses[i]] = contractName;
-    }
-  });
-  return result;
-});
+function withAddresses(p, addresses) {
+  return {
+    id: p.id,
+    latestFetchedBlock: p.latestFetchedBlock,
+    selection: p.selection,
+    addresses: addresses,
+    mergeBlock: p.mergeBlock,
+    dynamicContract: p.dynamicContract,
+    mutPendingQueries: p.mutPendingQueries,
+    sourceRangeCapacity: p.sourceRangeCapacity,
+    prevSourceRangeCapacity: p.prevSourceRangeCapacity,
+    eventDensity: p.eventDensity,
+    latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+  };
+}
 
 function densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock) {
   return Primitive_int.max(1, Math.ceil(((Stdlib_Option.getOr(toBlock, chainTargetBlock) - fromBlock | 0) + 1 | 0) * density) | 0);
@@ -69,7 +76,7 @@ function getOrThrow(optimizedPartitions, partitionId) {
 }
 
 function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAddrInPartition, nextPartitionIndexRef) {
-  let combinedAddresses = p1.addressesByContractName[contractName].concat(p2.addressesByContractName[contractName]);
+  let combinedAddresses = p1.addresses.merge(p2.addresses);
   let p1Below = p1.latestFetchedBlock.blockNumber < potentialMergeBlock;
   let p2Below = p2.latestFetchedBlock.blockNumber < potentialMergeBlock;
   let completed = [];
@@ -80,7 +87,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         id: p1.id,
         latestFetchedBlock: p1.latestFetchedBlock,
         selection: p1.selection,
-        addressesByContractName: p1.addressesByContractName,
+        addresses: p1.addresses,
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
@@ -93,7 +100,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         id: p2.id,
         latestFetchedBlock: p2.latestFetchedBlock,
         selection: p2.selection,
-        addressesByContractName: p2.addressesByContractName,
+        addresses: p2.addresses,
         mergeBlock: potentialMergeBlock,
         dynamicContract: p2.dynamicContract,
         mutPendingQueries: p2.mutPendingQueries,
@@ -122,7 +129,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
           blockTimestamp: 0
         },
         selection: p1.selection,
-        addressesByContractName: {},
+        addresses: p1.addresses,
         mergeBlock: undefined,
         dynamicContract: contractName,
         mutPendingQueries: [],
@@ -136,7 +143,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         id: p1.id,
         latestFetchedBlock: p1.latestFetchedBlock,
         selection: p1.selection,
-        addressesByContractName: p1.addressesByContractName,
+        addresses: p1.addresses,
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
@@ -152,7 +159,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       id: p2.id,
       latestFetchedBlock: p2.latestFetchedBlock,
       selection: p2.selection,
-      addressesByContractName: p2.addressesByContractName,
+      addresses: p2.addresses,
       mergeBlock: potentialMergeBlock,
       dynamicContract: p2.dynamicContract,
       mutPendingQueries: p2.mutPendingQueries,
@@ -165,58 +172,27 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
   } else {
     continuingBase = p1;
   }
-  if (combinedAddresses.length > maxAddrInPartition) {
-    let addressesFull = combinedAddresses.slice(0, maxAddrInPartition);
-    let addressesRest = combinedAddresses.slice(maxAddrInPartition);
-    let abcFull = {};
-    abcFull[contractName] = addressesFull;
-    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,
-      sourceRangeCapacity: continuingBase.sourceRangeCapacity,
-      prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
-      eventDensity: continuingBase.eventDensity,
-      latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
-    });
+  if (combinedAddresses.size() > maxAddrInPartition) {
+    completed.push(withAddresses(continuingBase, combinedAddresses.slice(0, maxAddrInPartition)));
     let restId = nextPartitionIndexRef.contents.toString();
     nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+    let init = withAddresses(continuingBase, combinedAddresses.slice(maxAddrInPartition, undefined));
     completed.push({
       id: restId,
-      latestFetchedBlock: continuingBase.latestFetchedBlock,
-      selection: continuingBase.selection,
-      addressesByContractName: abcRest,
-      mergeBlock: continuingBase.mergeBlock,
-      dynamicContract: continuingBase.dynamicContract,
+      latestFetchedBlock: init.latestFetchedBlock,
+      selection: init.selection,
+      addresses: init.addresses,
+      mergeBlock: init.mergeBlock,
+      dynamicContract: init.dynamicContract,
       mutPendingQueries: [],
-      sourceRangeCapacity: continuingBase.sourceRangeCapacity,
-      prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
-      eventDensity: continuingBase.eventDensity,
-      latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
+      sourceRangeCapacity: init.sourceRangeCapacity,
+      prevSourceRangeCapacity: init.prevSourceRangeCapacity,
+      eventDensity: init.eventDensity,
+      latestSourceRangeCapacityUpdateBlock: init.latestSourceRangeCapacityUpdateBlock
     });
     return completed;
   }
-  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,
-    sourceRangeCapacity: continuingBase.sourceRangeCapacity,
-    prevSourceRangeCapacity: continuingBase.prevSourceRangeCapacity,
-    eventDensity: continuingBase.eventDensity,
-    latestSourceRangeCapacityUpdateBlock: continuingBase.latestSourceRangeCapacityUpdateBlock
-  });
+  completed.push(withAddresses(continuingBase, combinedAddresses));
   return completed;
 }
 
@@ -224,18 +200,94 @@ 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) {
+        newPartitions.push(p);
+      }
+    } else if (p.dynamicContract !== undefined && p.selection.dependsOnAddresses) {
       let contractName = p.dynamicContract;
-      let pAddressesCount = p.addressesByContractName[contractName].length;
+      let pAddressesCount = p.addresses.countFor(contractName);
       let match = Utils.$$Array.last(p.mutPendingQueries);
       let potentialMergeBlock;
       if (match !== undefined) {
@@ -260,9 +312,6 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
         newPartitions.push(p);
       }
     } else {
-      exit = 1;
-    }
-    if (exit === 1) {
       newPartitions.push(p);
     }
   }
@@ -300,12 +349,57 @@ 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 {
+              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;
   }
@@ -418,7 +512,7 @@ function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHei
   }
   let updatedMainPartition_id = p.id;
   let updatedMainPartition_selection = p.selection;
-  let updatedMainPartition_addressesByContractName = p.addressesByContractName;
+  let updatedMainPartition_addresses = p.addresses;
   let updatedMainPartition_mergeBlock = p.mergeBlock;
   let updatedMainPartition_dynamicContract = p.dynamicContract;
   let updatedMainPartition_mutPendingQueries = p.mutPendingQueries;
@@ -427,7 +521,7 @@ function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHei
     id: updatedMainPartition_id,
     latestFetchedBlock: updatedLatestFetchedBlock,
     selection: updatedMainPartition_selection,
-    addressesByContractName: updatedMainPartition_addressesByContractName,
+    addresses: updatedMainPartition_addresses,
     mergeBlock: updatedMainPartition_mergeBlock,
     dynamicContract: updatedMainPartition_dynamicContract,
     mutPendingQueries: updatedMainPartition_mutPendingQueries,
@@ -499,6 +593,8 @@ let OptimizedPartitions = {
   mergePartitionsAtBlock: mergePartitionsAtBlock,
   tooFarBlockRange: 20000,
   ascSortFn: ascSortFn,
+  anchoredContracts: anchoredContracts,
+  getAnchorSafeBlock: getAnchorSafeBlock,
   make: make,
   consumeFetchedQueries: consumeFetchedQueries,
   getPendingQueryOrThrow: getPendingQueryOrThrow,
@@ -695,7 +791,6 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
@@ -708,47 +803,28 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
   };
 }
 
-function warnDifferentContractType(fetchState, existingContract, dc) {
-  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) {
-  let numAddresses = {
-    contents: 0
-  };
-  Utils.Dict.forEach(addressesByContractName, addresses => {
-    numAddresses.contents = numAddresses.contents + addresses.length | 0;
-  });
-  return numAddresses.contents;
+function addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, threshold, shouldLogOpt) {
+  let shouldLog = shouldLogOpt !== undefined ? shouldLogOpt : true;
+  clientFilteredContracts.add(contractName);
+  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 addressesByContractNameGetAll(addressesByContractName) {
-  let all = [];
-  Utils.Dict.forEach(addressesByContractName, addresses => {
-    for (let idx = 0, idx_finish = addresses.length; idx < idx_finish; ++idx) {
-      all.push(addresses[idx]);
-    }
+function claimedFetchedBlock(p, knownHeight) {
+  return Stdlib_Array.reduce(p.mutPendingQueries, p.latestFetchedBlock.blockNumber, (max, q) => {
+    let match = q.fetchedBlock;
+    return Primitive_int.max(max, match !== undefined ? match.blockNumber : Stdlib_Option.getOr(q.toBlock, knownHeight));
   });
-  return all;
 }
 
-function addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, threshold) {
-  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.");
-}
-
-function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef) {
+function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, clientFilteredFrontiersOpt, knownHeight) {
+  let clientFilteredFrontiers = clientFilteredFrontiersOpt !== undefined ? clientFilteredFrontiersOpt : [];
   if (clientFilteredContracts.size === 0) {
     return partitions;
   }
@@ -759,6 +835,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   let backfills = [];
   let absorbedPartitions = [];
   let strippedFrontiers = [];
+  let anchoredContracts$1 = anchoredContracts(partitions);
   partitions.forEach(p => {
     if (!p.selection.dependsOnAddresses) {
       if (p.mergeBlock !== undefined) {
@@ -770,36 +847,25 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
       }
       return;
     }
-    let contractNames = Object.keys(p.addressesByContractName);
-    let clientFilteredNames = contractNames.filter(c => clientFilteredContracts.has(c));
-    if (Utils.$$Array.isEmpty(clientFilteredNames)) {
+    let contractNames = p.addresses.contractNames();
+    let serverSideNames = contractNames.filter(c => !clientFilteredContracts.has(c));
+    if (serverSideNames.length === contractNames.length) {
       kept.push(p);
       return;
     }
-    if (clientFilteredNames.length === contractNames.length) {
+    let contractName = p.dynamicContract;
+    if (contractName !== undefined ? anchoredContracts$1.has(contractName) : false) {
+      kept.push(p);
+    } else if (Utils.$$Array.isEmpty(serverSideNames)) {
       absorbedPartitions.push(p);
-      return;
+    } else {
+      strippedFrontiers.push(p.latestFetchedBlock);
+      kept.push(withAddresses(p, p.addresses.filterByContracts(serverSideNames)));
     }
-    let stripped = Utils.Dict.shallowCopy(p.addressesByContractName);
-    clientFilteredNames.forEach(c => Utils.Dict.deleteInPlace(stripped, c));
-    strippedFrontiers.push(p.latestFetchedBlock);
-    kept.push({
-      id: p.id,
-      latestFetchedBlock: p.latestFetchedBlock,
-      selection: p.selection,
-      addressesByContractName: stripped,
-      mergeBlock: p.mergeBlock,
-      dynamicContract: p.dynamicContract,
-      mutPendingQueries: p.mutPendingQueries,
-      sourceRangeCapacity: p.sourceRangeCapacity,
-      prevSourceRangeCapacity: p.prevSourceRangeCapacity,
-      eventDensity: p.eventDensity,
-      latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
-    });
   });
   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 = {
@@ -817,6 +883,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 => {
@@ -850,7 +917,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
         id: id,
         latestFetchedBlock: standing$2.latestFetchedBlock,
         selection: newSelection,
-        addressesByContractName: standing$2.addressesByContractName,
+        addresses: standing$2.addresses,
         mergeBlock: standing$2.mergeBlock,
         dynamicContract: standing$2.dynamicContract,
         mutPendingQueries: [],
@@ -863,16 +930,17 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
       standingOut = standing$2;
     }
     kept.push(standingOut);
+    let catchUpToBlock = claimedFetchedBlock(standingOut, knownHeight);
     let minFrontier = minFrontierRef.contents;
-    if (minFrontier !== undefined && minFrontier.blockNumber < standing$2.latestFetchedBlock.blockNumber) {
+    if (minFrontier !== undefined && minFrontier.blockNumber < catchUpToBlock) {
       let id$1 = nextPartitionIndexRef.contents.toString();
       nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
       kept.push({
         id: id$1,
         latestFetchedBlock: minFrontier,
         selection: newSelection,
-        addressesByContractName: {},
-        mergeBlock: standing$2.latestFetchedBlock.blockNumber,
+        addresses: addressStore.emptySet(),
+        mergeBlock: catchUpToBlock,
         dynamicContract: undefined,
         mutPendingQueries: [],
         sourceRangeCapacity: standing$2.sourceRangeCapacity,
@@ -894,7 +962,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
     id: id$2,
     latestFetchedBlock: minFrontier$1,
     selection: newSelection,
-    addressesByContractName: {},
+    addresses: addressStore.emptySet(),
     mergeBlock: undefined,
     dynamicContract: undefined,
     mutPendingQueries: [],
@@ -906,60 +974,62 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
   return kept;
 }
 
-function createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber) {
+function createPartitions(registeringSetsByContract, addressStore, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber, knownHeight) {
   let nextPartitionIndexRef = {
     contents: nextPartitionIndex
   };
   let dynamicPartitions = [];
   let nonDynamicPartitions = [];
-  let contractNames = Object.keys(registeringContractsByContract);
+  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 registeringContracts = registeringContractsByContract[contractName];
-    let addresses = Object.keys(registeringContracts);
-    let isDynamic = dynamicContracts.has(contractName);
+    let contractSet = registeringSetsByContract[contractName];
+    let isAnchored = anchoredContracts$1.has(contractName);
+    let isDynamic = dynamicContracts.has(contractName) || isAnchored;
     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);
-    }
-    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 (maybeNextStartBlockKey !== undefined) {
-        let nextStartBlock = Stdlib_Int.fromString(maybeNextStartBlockKey, undefined);
-        let shouldJoinCurrentStartBlock = (nextStartBlock - startBlockRef | 0) < 20000;
-        if (shouldJoinCurrentStartBlock) {
-          addressesRef = addressesRef.concat(byStartBlock[maybeNextStartBlockKey]);
-          shouldAllocateNewPartition = false;
-        } else {
-          shouldAllocateNewPartition = true;
-        }
-      } else {
-        shouldAllocateNewPartition = true;
+    let groups = contractSet.startBlockGroups();
+    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
+        });
       }
-      if (shouldAllocateNewPartition) {
-        let latestFetchedBlock_blockNumber = Primitive_int.max(startBlockRef - 1 | 0, progressBlockNumber);
+    } 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
         };
-        while (addressesRef.length !== 0) {
-          let pAddresses = addressesRef.slice(0, maxAddrInPartition);
-          addressesRef = addressesRef.slice(maxAddrInPartition);
-          let addressesByContractName = {};
-          addressesByContractName[contractName] = pAddresses;
+        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,
-            addressesByContractName: addressesByContractName,
+            addresses: pAddresses,
             mergeBlock: undefined,
             dynamicContract: isDynamic ? contractName : undefined,
             mutPendingQueries: [],
@@ -969,48 +1039,37 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             latestSourceRangeCapacityUpdateBlock: 0
           });
           nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+          chunkOffsetRef = chunkOffsetRef + take | 0;
+          remainingRef = remainingRef - take | 0;
         };
-        if (maybeNextStartBlockKey !== undefined) {
-          startBlockRef = Stdlib_Int.fromString(maybeNextStartBlockKey, undefined);
-          addressesRef = byStartBlock[maybeNextStartBlockKey];
-        }
-      }
+        offsetRef = offsetRef + countRef | 0;
+        groupIdx = nextIdx;
+      };
     }
   }
   let mergedNonDynamic = [];
   if (nonDynamicPartitions.length !== 0) {
     nonDynamicPartitions.sort(ascSortFn);
     let currentPRef = nonDynamicPartitions[0];
-    let nextIdx = 1;
-    while (nextIdx < nonDynamicPartitions.length) {
-      let nextP = nonDynamicPartitions[nextIdx];
+    let nextIdx$1 = 1;
+    while (nextIdx$1 < nonDynamicPartitions.length) {
+      let nextP = nonDynamicPartitions[nextIdx$1];
       let currentP = currentPRef;
       let currentPBlock = currentP.latestFetchedBlock.blockNumber;
       let nextPBlock = nextP.latestFetchedBlock.blockNumber;
-      let totalCount = addressesByContractNameCount(currentP.addressesByContractName) + addressesByContractNameCount(nextP.addressesByContractName) | 0;
+      let totalCount = currentP.addresses.size() + nextP.addresses.size() | 0;
       if (totalCount > maxAddrInPartition) {
         mergedNonDynamic.push(currentP);
         currentPRef = nextP;
       } else {
-        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] = existingAddrs.concat(currentAddrs);
-          } else {
-            mergedAddresses[cn] = currentAddrs;
-          }
-        }
+        let mergedAddresses = nextP.addresses.merge(currentP.addresses);
         let isTooFar = (currentPBlock + 20000 | 0) < nextPBlock;
         if (isTooFar) {
           mergedNonDynamic.push({
             id: currentP.id,
             latestFetchedBlock: currentP.latestFetchedBlock,
             selection: currentP.selection,
-            addressesByContractName: currentP.addressesByContractName,
+            addresses: currentP.addresses,
             mergeBlock: currentPBlock < nextPBlock ? nextPBlock : undefined,
             dynamicContract: currentP.dynamicContract,
             mutPendingQueries: currentP.mutPendingQueries,
@@ -1019,191 +1078,134 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             eventDensity: currentP.eventDensity,
             latestSourceRangeCapacityUpdateBlock: currentP.latestSourceRangeCapacityUpdateBlock
           });
-          currentPRef = {
-            id: nextP.id,
-            latestFetchedBlock: nextP.latestFetchedBlock,
-            selection: nextP.selection,
-            addressesByContractName: mergedAddresses,
-            mergeBlock: nextP.mergeBlock,
-            dynamicContract: nextP.dynamicContract,
-            mutPendingQueries: nextP.mutPendingQueries,
-            sourceRangeCapacity: nextP.sourceRangeCapacity,
-            prevSourceRangeCapacity: nextP.prevSourceRangeCapacity,
-            eventDensity: nextP.eventDensity,
-            latestSourceRangeCapacityUpdateBlock: nextP.latestSourceRangeCapacityUpdateBlock
-          };
+          currentPRef = withAddresses(nextP, mergedAddresses);
         } else {
-          currentPRef = {
-            id: currentP.id,
-            latestFetchedBlock: currentP.latestFetchedBlock,
-            selection: currentP.selection,
-            addressesByContractName: mergedAddresses,
-            mergeBlock: currentP.mergeBlock,
-            dynamicContract: currentP.dynamicContract,
-            mutPendingQueries: currentP.mutPendingQueries,
-            sourceRangeCapacity: currentP.sourceRangeCapacity,
-            prevSourceRangeCapacity: currentP.prevSourceRangeCapacity,
-            eventDensity: currentP.eventDensity,
-            latestSourceRangeCapacityUpdateBlock: currentP.latestSourceRangeCapacityUpdateBlock
-          };
+          currentPRef = withAddresses(currentP, mergedAddresses);
         }
       }
-      nextIdx = nextIdx + 1 | 0;
+      nextIdx$1 = nextIdx$1 + 1 | 0;
     };
     mergedNonDynamic.push(currentPRef);
   }
   let mergedPartitions = mergedNonDynamic.concat(dynamicPartitions);
-  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef);
+  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, clientFilteredFrontiers, knownHeight);
   return make(allPartitions, maxAddrInPartition, nextPartitionIndexRef.contents, dynamicContracts, clientFilteredContracts);
 }
 
-function registerDynamicContracts(fetchState, indexingAddresses, items) {
+function registerDynamicContracts(fetchState, addressStore, claimCeilingOpt, items) {
+  let claimCeiling = claimCeilingOpt !== undefined ? claimCeilingOpt : fetchState.knownHeight;
   if (Utils.$$Array.isEmpty(fetchState.normalSelection.onEventRegistrations)) {
     Stdlib_JsError.throwWithMessage("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
-  let registeringContractsByContract = {};
-  let earliestRegisteringEventBlockNumber = Infinity;
-  let noEventsAddresses = {};
-  let registeringAddresses = {};
+  let registrations = [];
+  let sourceDcs = [];
+  let sourceIndexes = [];
   for (let itemIdx = 0, itemIdx_finish = items.length; itemIdx < itemIdx_finish; ++itemIdx) {
-    let item = items[itemIdx];
-    let dcs = item.dcs;
+    let dcs = items[itemIdx].dcs;
     if (dcs !== undefined) {
-      let idx = 0;
-      while (idx < dcs.length) {
-        let dc = dcs[idx];
-        let shouldRemove = false;
-        let match = fetchState.contractConfigs[dc.contractName];
-        if (match !== undefined) {
-          let dcWithStartBlock_address = dc.address;
-          let dcWithStartBlock_contractName = dc.contractName;
-          let dcWithStartBlock_registrationBlock = dc.registrationBlock;
-          let dcWithStartBlock_effectiveStartBlock = IndexingAddresses.deriveEffectiveStartBlock(dc.registrationBlock, match.startBlock);
-          let dcWithStartBlock = {
-            address: dcWithStartBlock_address,
-            contractName: dcWithStartBlock_contractName,
-            registrationBlock: dcWithStartBlock_registrationBlock,
-            effectiveStartBlock: dcWithStartBlock_effectiveStartBlock
-          };
-          let existingContract = IndexingAddresses.get(indexingAddresses, dc.address);
-          if (existingContract !== undefined) {
-            if (existingContract.contractName !== dc.contractName) {
-              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 {
-            let registeringContract = registeringAddresses[dc.address];
-            let shouldUpdate = registeringContract !== undefined ? (
-                registeringContract.contractName !== dc.contractName ? (warnDifferentContractType(fetchState, registeringContract, dcWithStartBlock), false) : false
-              ) : true;
-            if (shouldUpdate) {
-              earliestRegisteringEventBlockNumber = Primitive_int.min(earliestRegisteringEventBlockNumber, dcWithStartBlock_effectiveStartBlock);
-              Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, dc.contractName)[dc.address] = dcWithStartBlock;
-              registeringAddresses[dc.address] = dcWithStartBlock;
-            } else {
-              shouldRemove = true;
-            }
+      for (let dcIdx = 0, dcIdx_finish = dcs.length; dcIdx < dcIdx_finish; ++dcIdx) {
+        let dc = dcs[dcIdx];
+        registrations.push({
+          address: dc.address,
+          contractName: dc.contractName,
+          registrationBlock: dc.registrationBlock
+        });
+        sourceDcs.push(dcs);
+        sourceIndexes.push(dcIdx);
+      }
+    }
+  }
+  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 keep;
+    if (typeof match !== "object") {
+      warn(contractAddress, {
+        contractName: registration.contractName
+      }, `Skipping contract registration: Not a valid address for this chain's ecosystem.`);
+      keep = false;
+    } else {
+      switch (match.TAG) {
+        case "Added" :
+          if (!registeringContractNames.includes(registration.contractName)) {
+            registeringContractNames.push(registration.contractName);
           }
-        } else {
-          let dcAsIndexingAddress_address = dc.address;
-          let dcAsIndexingAddress_contractName = dc.contractName;
-          let dcAsIndexingAddress_registrationBlock = dc.registrationBlock;
-          let dcAsIndexingAddress_effectiveStartBlock = IndexingAddresses.deriveEffectiveStartBlock(dc.registrationBlock, undefined);
-          let dcAsIndexingAddress = {
-            address: dcAsIndexingAddress_address,
-            contractName: dcAsIndexingAddress_contractName,
-            registrationBlock: dcAsIndexingAddress_registrationBlock,
-            effectiveStartBlock: dcAsIndexingAddress_effectiveStartBlock
-          };
-          let existingContract$1 = IndexingAddresses.get(indexingAddresses, dc.address);
-          if (existingContract$1 !== undefined) {
-            if (existingContract$1.contractName !== dc.contractName) {
-              warnDifferentContractType(fetchState, existingContract$1, dcAsIndexingAddress);
-            }
-            shouldRemove = true;
-          } else {
-            let existingContract$2 = registeringAddresses[dc.address];
-            if (existingContract$2 !== undefined) {
-              if (existingContract$2.contractName !== dc.contractName) {
-                warnDifferentContractType(fetchState, existingContract$2, dcAsIndexingAddress);
-              }
-              shouldRemove = true;
-            } else {
-              let logger$1 = Logging.createChild({
-                chainId: fetchState.chainId,
-                contractAddress: dc.address,
-                contractName: dc.contractName
-              });
-              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;
-              registeringAddresses[dc.address] = dcAsIndexingAddress;
-            }
+          keep = true;
+          break;
+        case "NoEvents" :
+          hasNoEventsUpdatesRef = true;
+          warn(contractAddress, {
+            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.`);
           }
-        }
-        if (shouldRemove) {
-          dcs.splice(idx, 1);
-        } else {
-          idx = idx + 1 | 0;
-        }
-      };
+          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;
+      }
+    }
+    if (!keep) {
+      sourceIndexes[idx] = -1 - sourceIndexes[idx] | 0;
     }
   }
-  let dcContractNamesToStore = Object.keys(registeringContractsByContract);
-  let hasNoEventsUpdates = !Utils.Dict.isEmpty(noEventsAddresses);
-  if (dcContractNamesToStore.length === 0) {
-    if (hasNoEventsUpdates) {
-      IndexingAddresses.register(indexingAddresses, noEventsAddresses);
-      return fetchState;
-    } else {
-      return fetchState;
+  for (let idx$1 = verdicts.length - 1 | 0; idx$1 >= 0; --idx$1) {
+    let marked = sourceIndexes[idx$1];
+    if (marked < 0) {
+      sourceDcs[idx$1].splice(-1 - marked | 0, 1);
     }
   }
+  if (registeringContractNames.length === 0) {
+    return fetchState;
+  }
   let newPartitions = [];
   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];
+  for (let idx$2 = 0, idx_finish$1 = registeringContractNames.length; idx$2 < idx_finish$1; ++idx$2) {
+    let contractName = registeringContractNames[idx$2];
     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);
+      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 allPartitionContractNames = p.addresses.contractNames();
           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,
-                sourceRangeCapacity: p.sourceRangeCapacity,
-                prevSourceRangeCapacity: p.prevSourceRangeCapacity,
-                eventDensity: p.eventDensity,
-                latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
-              };
-              let addressesByContractName = {};
-              addressesByContractName[contractName] = addresses;
+              let restNames = allPartitionContractNames.filter(name => name !== contractName);
+              mutExistingPartitions[idx$3] = withAddresses(p, p.addresses.filterByContracts(restNames));
+              let splitAddresses = p.addresses.filterByContracts([contractName]);
               newPartitions.push({
                 id: newPartitionId,
                 latestFetchedBlock: p.latestFetchedBlock,
                 selection: fetchState.normalSelection,
-                addressesByContractName: addressesByContractName,
+                addresses: splitAddresses,
                 mergeBlock: undefined,
                 dynamicContract: contractName,
                 mutPendingQueries: p.mutPendingQueries,
@@ -1214,11 +1216,11 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
               });
             }
           } else {
-            mutExistingPartitions[idx$2] = {
+            mutExistingPartitions[idx$3] = {
               id: p.id,
               latestFetchedBlock: p.latestFetchedBlock,
               selection: p.selection,
-              addressesByContractName: p.addressesByContractName,
+              addresses: p.addresses,
               mergeBlock: p.mergeBlock,
               dynamicContract: contractName,
               mutPendingQueries: p.mutPendingQueries,
@@ -1231,41 +1233,29 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
         }
       }
     }
-    let registeringContracts = registeringContractsByContract[contractName];
-    IndexingAddresses.register(indexingAddresses, registeringContracts);
   }
-  IndexingAddresses.register(indexingAddresses, noEventsAddresses);
   let threshold = fetchState.clientFilterAddressThreshold;
   let clientFilteredContracts;
   if (threshold !== undefined) {
     let clientFilteredContracts$1 = new Set(Array.from(fetchState.optimizedPartitions.clientFilteredContracts));
     Array.from(dynamicContractsRef).forEach(contractName => {
-      let addressCount = IndexingAddresses.contractCount(indexingAddresses, 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;
   } else {
     clientFilteredContracts = fetchState.optimizedPartitions.clientFilteredContracts;
   }
-  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContractsRef, clientFilteredContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
-  return updateInternal(fetchState, optimizedPartitions, undefined, undefined, undefined, undefined);
-}
-
-function filterByClientAddress(items, indexingAddresses) {
-  return items.filter(item => {
-    if (item.kind !== 0) {
-      return true;
-    }
-    let reg = item.onEventRegistration;
-    let filter = reg.clientAddressFilter;
-    if (filter !== undefined) {
-      return filter(item.payload, item.blockNumber, IndexingAddresses.forContract(indexingAddresses, reg.eventConfig.contractName));
-    } else {
-      return true;
-    }
+  let registeringSetsByContract = {};
+  registeringContractNames.forEach(contractName => {
+    registeringSetsByContract[contractName] = AddressStore.makeSet(addressStore, contractName, {
+      minId: idCursor
+    });
   });
+  let optimizedPartitions = createPartitions(registeringSetsByContract, addressStore, dynamicContractsRef, clientFilteredContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0, Primitive_int.max(claimCeiling, fetchState.knownHeight));
+  return updateInternal(fetchState, optimizedPartitions, undefined, undefined, undefined, undefined);
 }
 
 function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
@@ -1302,7 +1292,7 @@ function startFetchingQueries(param, queries) {
   }
 }
 
-function pushDensityPricedQuery(queries, partitionId, fromBlock, toBlock, isChunk, density, chainTargetBlock, selection, addressesByContractName) {
+function pushDensityPricedQuery(queries, partitionId, fromBlock, toBlock, isChunk, density, chainTargetBlock, selection, addresses) {
   let itemsEst = densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock);
   queries.push({
     partitionId: partitionId,
@@ -1312,12 +1302,12 @@ function pushDensityPricedQuery(queries, partitionId, fromBlock, toBlock, isChun
     itemsTarget: toBlock !== undefined ? undefined : itemsEst,
     itemsEst: itemsEst,
     selection: selection,
-    addressesByContractName: addressesByContractName
+    addresses: addresses
   });
   return itemsEst;
 }
 
-function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock, headBlockNumber, chainTargetBlock, maybeChunkRange, maxChunks, partition, partitionBudget, selection, addressesByContractName) {
+function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock, headBlockNumber, chainTargetBlock, maybeChunkRange, maxChunks, partition, partitionBudget, selection, addresses) {
   if (!(rangeFromBlock <= Primitive_int.min(headBlockNumber, chainTargetBlock) && maxChunks > 0)) {
     return;
   }
@@ -1333,7 +1323,7 @@ function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock,
   if (exit === 1) {
     let maxBlock = rangeEndBlock !== undefined ? rangeEndBlock : chainTargetBlock;
     let pushSingleQuery = (density, isChunk) => {
-      pushDensityPricedQuery(queries, partitionId, rangeFromBlock, rangeEndBlock, isChunk, density, chainTargetBlock, selection, addressesByContractName);
+      pushDensityPricedQuery(queries, partitionId, rangeFromBlock, rangeEndBlock, isChunk, density, chainTargetBlock, selection, addresses);
     };
     let match = partition.eventDensity;
     let exit$1 = 0;
@@ -1348,7 +1338,7 @@ function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock,
           let chunkIdx = 0;
           while (chunkIdx < maxChunks && ((chunkFromBlock + chunkSize | 0) - 1 | 0) <= maxBlock) {
             let chunkToBlock = (chunkFromBlock + chunkSize | 0) - 1 | 0;
-            pushDensityPricedQuery(queries, partitionId, chunkFromBlock, chunkToBlock, true, match, chainTargetBlock, selection, addressesByContractName);
+            pushDensityPricedQuery(queries, partitionId, chunkFromBlock, chunkToBlock, true, match, chainTargetBlock, selection, addresses);
             chunkFromBlock = chunkToBlock + 1 | 0;
             chunkIdx = chunkIdx + 1 | 0;
           };
@@ -1382,7 +1372,7 @@ function walkPartitionPending(p, partitionId, inFlightCount, candidates, headBlo
     let pq = p.mutPendingQueries[pqIdx];
     if (pq.fromBlock > cursor) {
       let beforeLen = candidates.length;
-      pushGapFillQueries(candidates, partitionId, cursor, Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock), headBlockNumber, chainTargetBlock, maybeChunkRange, (12 - inFlightCount | 0) - chunksUsedThisCall | 0, p, partitionBudget, p.selection, p.addressesByContractName);
+      pushGapFillQueries(candidates, partitionId, cursor, Utils.$$Math.minOptInt(pq.fromBlock - 1 | 0, queryEndBlock), headBlockNumber, chainTargetBlock, maybeChunkRange, (12 - inFlightCount | 0) - chunksUsedThisCall | 0, p, partitionBudget, p.selection, p.addresses);
       chunksUsedThisCall = chunksUsedThisCall + (candidates.length - beforeLen | 0) | 0;
     }
     let toBlock = pq.toBlock;
@@ -1438,7 +1428,7 @@ function pushForwardCandidates(candidates, inRangeStates, inRangeCount, chainTar
       let generatedItems = 0;
       while (created < maxChunksRemaining && chunkFromBlock <= chunkStartCeiling && generatedItems <= freshBudget) {
         let chunkToBlock = Primitive_int.min((chunkFromBlock + chunkSize | 0) - 1 | 0, maxBlock);
-        let itemsEst = pushDensityPricedQuery(candidates, fs.partitionId, chunkFromBlock, chunkToBlock, true, match$1, chainTargetBlock, p.selection, p.addressesByContractName);
+        let itemsEst = pushDensityPricedQuery(candidates, fs.partitionId, chunkFromBlock, chunkToBlock, true, match$1, chainTargetBlock, p.selection, p.addresses);
         generatedItems = generatedItems + itemsEst;
         chunkFromBlock = chunkToBlock + 1 | 0;
         created = created + 1 | 0;
@@ -1454,7 +1444,7 @@ function pushForwardCandidates(candidates, inRangeStates, inRangeCount, chainTar
       itemsTarget: itemsEst$1,
       itemsEst: itemsEst$1,
       selection: p.selection,
-      addressesByContractName: p.addressesByContractName
+      addresses: p.addresses
     });
   });
 }
@@ -1636,12 +1626,13 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, 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
@@ -1666,7 +1657,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
         onEventRegistrations: notDependingOnAddresses,
         dependsOnAddresses: false
       },
-      addressesByContractName: {},
+      addresses: addressStore.emptySet(),
       mergeBlock: undefined,
       dynamicContract: undefined,
       mutPendingQueries: [],
@@ -1680,13 +1671,20 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
     onEventRegistrations: normalRegistrations,
     dependsOnAddresses: true
   };
-  let registeringContractsByContract = {};
+  AddressStore.registerBatch(addressStore, addresses.map(contract => ({
+    address: contract.address,
+    contractName: contract.contractName,
+    registrationBlock: contract.registrationBlock
+  })));
   let dynamicContracts = new Set();
   let clientFilteredContracts = new Set();
+  let registeringSetsByContract = {};
   addresses.forEach(contract => {
     let contractName = contract.contractName;
     if (contractNamesWithNormalEvents.has(contractName)) {
-      Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName)[contract.address] = IndexingAddresses.makeIndexingAddress(contract, contractConfigs);
+      if (!(contractName in registeringSetsByContract)) {
+        registeringSetsByContract[contractName] = AddressStore.makeSet(addressStore, contractName, undefined);
+      }
       if (contract.registrationBlock !== -1) {
         dynamicContracts.add(contractName);
         return;
@@ -1696,14 +1694,14 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
     }
   });
   if (clientFilterAddressThreshold !== undefined) {
-    Utils.Dict.forEachWithKey(registeringContractsByContract, (addrs, contractName) => {
-      let addressCount = Utils.Dict.size(addrs);
+    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 = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, clientFilteredContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
+  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.`);
   }
@@ -1722,7 +1720,6 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
     startBlock: startBlock,
     endBlock: endBlock,
     normalSelection: normalSelection,
-    contractConfigs: contractConfigs,
     chainId: chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
@@ -1773,58 +1770,51 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
   return adjusted;
 }
 
-function rollback(fetchState, indexingAddresses, targetBlockNumber) {
-  IndexingAddresses.rollbackInPlace(indexingAddresses, targetBlockNumber);
+function rollback(fetchState, addressStore, targetBlockNumber) {
+  addressStore.rollback(targetBlockNumber);
   let keptPartitions = [];
   let nextKeptIdRef = 0;
-  let registeringContractsByContract = {};
+  let registeringSetsByContract = {};
+  let collectForRecreation = set => {
+    set.contractNames().forEach(contractName => {
+      let contractSet = set.filterByContracts([contractName]);
+      let existing = registeringSetsByContract[contractName];
+      registeringSetsByContract[contractName] = existing !== undefined ? Primitive_option.valFromOption(existing).merge(contractSet) : contractSet;
+    });
+  };
   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, (addresses, contractName) => {
-          addresses.forEach(address => {
-            let indexingContract = IndexingAddresses.get(indexingAddresses, address);
-            if (indexingContract === undefined) {
-              return;
-            }
-            let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
-            registeringContracts[address] = indexingContract;
-          });
-        });
+        collectForRecreation(p.addresses.filterByRegistrationBlock(targetBlockNumber));
       } 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 => Stdlib_Option.isSome(IndexingAddresses.get(indexingAddresses, address)));
-          if (keptAddresses.length !== 0) {
-            rollbackedAddressesByContractName[contractName] = keptAddresses;
-            return;
-          }
-        });
-        if (!Utils.Dict.isEmpty(rollbackedAddressesByContractName)) {
+        let rollbackedAddresses = p.addresses.filterByRegistrationBlock(targetBlockNumber);
+        if (!AddressSet.isEmpty(rollbackedAddresses)) {
           let id = nextKeptIdRef.toString();
           nextKeptIdRef = nextKeptIdRef + 1 | 0;
+          let init = withAddresses(p, rollbackedAddresses);
           keptPartitions.push({
             id: id,
-            latestFetchedBlock: p.latestFetchedBlock,
-            selection: p.selection,
-            addressesByContractName: rollbackedAddressesByContractName,
+            latestFetchedBlock: init.latestFetchedBlock,
+            selection: init.selection,
+            addresses: init.addresses,
             mergeBlock: mergeBlock$1,
-            dynamicContract: p.dynamicContract,
+            dynamicContract: init.dynamicContract,
             mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
-            sourceRangeCapacity: p.sourceRangeCapacity,
-            prevSourceRangeCapacity: p.prevSourceRangeCapacity,
-            eventDensity: p.eventDensity,
-            latestSourceRangeCapacityUpdateBlock: p.latestSourceRangeCapacityUpdateBlock
+            sourceRangeCapacity: init.sourceRangeCapacity,
+            prevSourceRangeCapacity: init.prevSourceRangeCapacity,
+            eventDensity: init.eventDensity,
+            latestSourceRangeCapacityUpdateBlock: init.latestSourceRangeCapacityUpdateBlock
           });
         }
       }
     } 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 ? ({
@@ -1832,8 +1822,8 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
             blockTimestamp: 0
           }) : p.latestFetchedBlock,
         selection: p.selection,
-        addressesByContractName: p.addressesByContractName,
-        mergeBlock: p.mergeBlock,
+        addresses: p.addresses,
+        mergeBlock: mergeBlock$2 !== undefined && mergeBlock$2 > targetBlockNumber ? targetBlockNumber : mergeBlock$2,
         dynamicContract: p.dynamicContract,
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
         sourceRangeCapacity: p.sourceRangeCapacity,
@@ -1843,13 +1833,12 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
       });
     }
   }
-  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.optimizedPartitions.dynamicContracts, fetchState.optimizedPartitions.clientFilteredContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber);
+  let optimizedPartitions = createPartitions(registeringSetsByContract, addressStore, fetchState.optimizedPartitions.dynamicContracts, fetchState.optimizedPartitions.clientFilteredContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber, fetchState.knownHeight);
   return updateInternal({
     optimizedPartitions: fetchState.optimizedPartitions,
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: Primitive_int.min(fetchState.latestOnBlockBlockNumber, targetBlockNumber),
     blockLag: fetchState.blockLag,
@@ -1877,7 +1866,7 @@ function resetPendingQueries(fetchState) {
         id: partition.id,
         latestFetchedBlock: partition.latestFetchedBlock,
         selection: partition.selection,
-        addressesByContractName: partition.addressesByContractName,
+        addresses: partition.addresses,
         mergeBlock: partition.mergeBlock,
         dynamicContract: partition.dynamicContract,
         mutPendingQueries: kept,
@@ -1901,7 +1890,6 @@ function resetPendingQueries(fetchState) {
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
     blockLag: fetchState.blockLag,
@@ -2032,7 +2020,7 @@ let maxChainConcurrency = Env.maxChainConcurrency;
 let chunkRangeGrowthFactor = 1.8;
 
 export {
-  deriveContractNameByAddress,
+  withAddresses,
   densityItemsTarget,
   getMinHistoryRange,
   getTrustedDensity,
@@ -2047,14 +2035,11 @@ export {
   blockItemLogIndex,
   appendOnBlockItems,
   updateInternal,
-  warnDifferentContractType,
-  addressesByContractNameCount,
-  addressesByContractNameGetAll,
   addClientFilteredContract,
+  claimedFetchedBlock,
   collapseClientFilteredContracts,
-  createPartitionsFromIndexingAddresses,
+  createPartitions,
   registerDynamicContracts,
-  filterByClientAddress,
   handleQueryResult,
   startFetchingQueries,
   maxInFlightChunksPerPartition,
@@ -2082,4 +2067,4 @@ export {
   getProgressBlockNumberAt,
   updateKnownHeight,
 }
-/* deriveContractNameByAddress Not a pure module */
+/* Env Not a pure module */