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

package/src/FetchState.res.mjs

@@ -1,26 +1,34 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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);
@@ -68,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 = [];
@@ -79,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,
@@ -92,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,
@@ -121,7 +129,7 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
           blockTimestamp: 0
         },
         selection: p1.selection,
-        addressesByContractName: {},
+        addresses: p1.addresses,
         mergeBlock: undefined,
         dynamicContract: contractName,
         mutPendingQueries: [],
@@ -135,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,
@@ -151,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,
@@ -164,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;
 }
 
@@ -223,7 +200,7 @@ function ascSortFn(a, b) {
   return Primitive_int.compare(a.latestFetchedBlock.blockNumber, b.latestFetchedBlock.blockNumber);
 }
 
-function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContracts) {
+function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContracts, clientFilteredContracts) {
   let newPartitions = [];
   let mergingPartitions = {};
   let nextPartitionIndexRef = {
@@ -234,7 +211,7 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
     let exit = 0;
     if (p.dynamicContract !== undefined && p.mergeBlock === 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) {
@@ -313,7 +290,8 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
     entities: entities,
     maxAddrInPartition: maxAddrInPartition,
     nextPartitionIndex: nextPartitionIndexRef.contents,
-    dynamicContracts: dynamicContracts
+    dynamicContracts: dynamicContracts,
+    clientFilteredContracts: clientFilteredContracts
   };
 }
 
@@ -359,26 +337,24 @@ function getPendingQueryOrThrow(p, fromBlock) {
   }
 }
 
-function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount, latestFetchedBlock) {
-  let partitionId = query.partitionId;
-  let p = optimizedPartitions.entities[partitionId];
-  let p$1 = p !== undefined ? p : Stdlib_JsError.throwWithMessage(`Unexpected case: Couldn't find partition ` + partitionId);
+function handleQueryResponseForPartition(optimizedPartitions, p, query, knownHeight, itemsCount, latestFetchedBlock) {
   let mutEntities = Utils.Dict.shallowCopy(optimizedPartitions.entities);
-  let pendingQuery = getPendingQueryOrThrow(p$1, query.fromBlock);
+  let pendingQuery = getPendingQueryOrThrow(p, query.fromBlock);
   pendingQuery.fetchedBlock = latestFetchedBlock;
   let blockRange = (latestFetchedBlock.blockNumber - query.fromBlock | 0) + 1 | 0;
   let observedEventDensity = itemsCount / blockRange;
-  let eventDensity = p$1.eventDensity;
+  let eventDensity = p.eventDensity;
   let updatedEventDensity = eventDensity !== undefined ? (eventDensity + observedEventDensity) / 2 : observedEventDensity;
   let shouldUpdateSourceRangeCapacity = false;
-  if (latestFetchedBlock.blockNumber > p$1.latestSourceRangeCapacityUpdateBlock) {
+  if (latestFetchedBlock.blockNumber > p.latestSourceRangeCapacityUpdateBlock) {
     let queryToBlock = query.toBlock;
     let tmp;
     if (queryToBlock !== undefined) {
       if (latestFetchedBlock.blockNumber < queryToBlock) {
-        tmp = itemsCount < query.itemsTarget;
+        let itemsTarget = query.itemsTarget;
+        tmp = itemsTarget !== undefined ? itemsCount < itemsTarget : true;
       } else {
-        let minHistoryRange = getMinHistoryRange(p$1);
+        let minHistoryRange = getMinHistoryRange(p);
         tmp = minHistoryRange !== undefined ? ((queryToBlock - query.fromBlock | 0) + 1 | 0) >= minHistoryRange : false;
       }
     } else {
@@ -386,10 +362,10 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     }
     shouldUpdateSourceRangeCapacity = tmp;
   }
-  let updatedSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? blockRange : p$1.sourceRangeCapacity;
-  let updatedPrevSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? p$1.sourceRangeCapacity : p$1.prevSourceRangeCapacity;
-  let mutPendingQueries = p$1.mutPendingQueries;
-  let latestFetchedBlock$1 = p$1.latestFetchedBlock;
+  let updatedSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? blockRange : p.sourceRangeCapacity;
+  let updatedPrevSourceRangeCapacity = shouldUpdateSourceRangeCapacity ? p.sourceRangeCapacity : p.prevSourceRangeCapacity;
+  let mutPendingQueries = p.mutPendingQueries;
+  let latestFetchedBlock$1 = p.latestFetchedBlock;
   let consumedCount = 0;
   let canContinue = true;
   while (canContinue) {
@@ -410,24 +386,24 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     mutPendingQueries.splice(0, consumedCount);
   }
   let updatedLatestFetchedBlock = latestFetchedBlock$1;
-  let mergeBlock = p$1.mergeBlock;
+  let mergeBlock = p.mergeBlock;
   let partitionReachedMergeBlock = mergeBlock !== undefined ? updatedLatestFetchedBlock.blockNumber >= mergeBlock : false;
   if (partitionReachedMergeBlock) {
-    Utils.Dict.deleteInPlace(mutEntities, p$1.id);
-    return make(Object.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts);
-  }
-  let updatedMainPartition_id = p$1.id;
-  let updatedMainPartition_selection = p$1.selection;
-  let updatedMainPartition_addressesByContractName = p$1.addressesByContractName;
-  let updatedMainPartition_mergeBlock = p$1.mergeBlock;
-  let updatedMainPartition_dynamicContract = p$1.dynamicContract;
-  let updatedMainPartition_mutPendingQueries = p$1.mutPendingQueries;
-  let updatedMainPartition_latestSourceRangeCapacityUpdateBlock = shouldUpdateSourceRangeCapacity ? latestFetchedBlock.blockNumber : p$1.latestSourceRangeCapacityUpdateBlock;
+    Utils.Dict.deleteInPlace(mutEntities, p.id);
+    return make(Object.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts, optimizedPartitions.clientFilteredContracts);
+  }
+  let updatedMainPartition_id = p.id;
+  let updatedMainPartition_selection = p.selection;
+  let updatedMainPartition_addresses = p.addresses;
+  let updatedMainPartition_mergeBlock = p.mergeBlock;
+  let updatedMainPartition_dynamicContract = p.dynamicContract;
+  let updatedMainPartition_mutPendingQueries = p.mutPendingQueries;
+  let updatedMainPartition_latestSourceRangeCapacityUpdateBlock = shouldUpdateSourceRangeCapacity ? latestFetchedBlock.blockNumber : p.latestSourceRangeCapacityUpdateBlock;
   let updatedMainPartition = {
     id: updatedMainPartition_id,
     latestFetchedBlock: updatedLatestFetchedBlock,
     selection: updatedMainPartition_selection,
-    addressesByContractName: updatedMainPartition_addressesByContractName,
+    addresses: updatedMainPartition_addresses,
     mergeBlock: updatedMainPartition_mergeBlock,
     dynamicContract: updatedMainPartition_dynamicContract,
     mutPendingQueries: updatedMainPartition_mutPendingQueries,
@@ -436,13 +412,13 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     eventDensity: updatedEventDensity,
     latestSourceRangeCapacityUpdateBlock: updatedMainPartition_latestSourceRangeCapacityUpdateBlock
   };
-  mutEntities[p$1.id] = updatedMainPartition;
+  mutEntities[p.id] = updatedMainPartition;
   if (optimizedPartitions.dynamicContracts.size !== 0) {
-    return make(Object.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts);
+    return make(Object.values(mutEntities), optimizedPartitions.maxAddrInPartition, optimizedPartitions.nextPartitionIndex, optimizedPartitions.dynamicContracts, optimizedPartitions.clientFilteredContracts);
   }
   let ids = optimizedPartitions.idsInAscOrder;
   let count = ids.length;
-  let idx = ids.indexOf(p$1.id);
+  let idx = ids.indexOf(p.id);
   let isAfter = jdx => {
     if (jdx < count) {
       return mutEntities[ids[jdx]].latestFetchedBlock.blockNumber < updatedLatestFetchedBlock.blockNumber;
@@ -456,7 +432,8 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
       entities: mutEntities,
       maxAddrInPartition: optimizedPartitions.maxAddrInPartition,
       nextPartitionIndex: optimizedPartitions.nextPartitionIndex,
-      dynamicContracts: optimizedPartitions.dynamicContracts
+      dynamicContracts: optimizedPartitions.dynamicContracts,
+      clientFilteredContracts: optimizedPartitions.clientFilteredContracts
     };
   }
   let reordered = ids.slice();
@@ -465,16 +442,26 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     reordered[jdx] = ids[jdx + 1 | 0];
     jdx = jdx + 1 | 0;
   };
-  reordered[jdx] = p$1.id;
+  reordered[jdx] = p.id;
   return {
     idsInAscOrder: reordered,
     entities: mutEntities,
     maxAddrInPartition: optimizedPartitions.maxAddrInPartition,
     nextPartitionIndex: optimizedPartitions.nextPartitionIndex,
-    dynamicContracts: optimizedPartitions.dynamicContracts
+    dynamicContracts: optimizedPartitions.dynamicContracts,
+    clientFilteredContracts: optimizedPartitions.clientFilteredContracts
   };
 }
 
+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;
+  }
+}
+
 function getLatestFullyFetchedBlock(optimizedPartitions) {
   let id = optimizedPartitions.idsInAscOrder[0];
   if (id !== undefined) {
@@ -492,6 +479,7 @@ let OptimizedPartitions = {
   consumeFetchedQueries: consumeFetchedQueries,
   getPendingQueryOrThrow: getPendingQueryOrThrow,
   handleQueryResponse: handleQueryResponse,
+  handleQueryResponseForPartition: handleQueryResponseForPartition,
   getLatestFullyFetchedBlock: getLatestFullyFetchedBlock
 };
 
@@ -683,7 +671,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,
@@ -691,143 +678,254 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
     onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: knownHeight,
-    firstEventBlock: fetchState.firstEventBlock
+    firstEventBlock: fetchState.firstEventBlock,
+    clientFilterAddressThreshold: fetchState.clientFilterAddressThreshold
   };
 }
 
-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 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 addressesByContractNameCount(addressesByContractName) {
-  let numAddresses = {
-    contents: 0
-  };
-  Utils.Dict.forEach(addressesByContractName, addresses => {
-    numAddresses.contents = numAddresses.contents + addresses.length | 0;
+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 numAddresses.contents;
 }
 
-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 collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, knownHeight) {
+  if (clientFilteredContracts.size === 0) {
+    return partitions;
+  }
+  let kept = [];
+  let standingRef = {
+    contents: undefined
+  };
+  let backfills = [];
+  let absorbedPartitions = [];
+  let strippedFrontiers = [];
+  partitions.forEach(p => {
+    if (!p.selection.dependsOnAddresses) {
+      if (p.mergeBlock !== undefined) {
+        backfills.push(p);
+      } else if (Stdlib_Option.isNone(standingRef.contents)) {
+        standingRef.contents = p;
+      } else {
+        absorbedPartitions.push(p);
+      }
+      return;
+    }
+    let contractNames = p.addresses.contractNames();
+    let serverSideNames = contractNames.filter(c => !clientFilteredContracts.has(c));
+    if (serverSideNames.length === contractNames.length) {
+      kept.push(p);
+    } else if (Utils.$$Array.isEmpty(serverSideNames)) {
+      absorbedPartitions.push(p);
+    } else {
+      strippedFrontiers.push(p.latestFetchedBlock);
+      kept.push(withAddresses(p, p.addresses.filterByContracts(serverSideNames)));
+    }
+  });
+  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) {
+    return partitions;
+  }
+  let minFrontierRef = {
+    contents: undefined
+  };
+  let considerFrontier = b => {
+    let m = minFrontierRef.contents;
+    if (m !== undefined && m.blockNumber <= b.blockNumber) {
+      return;
+    } else {
+      minFrontierRef.contents = b;
+      return;
+    }
+  };
+  absorbedPartitions.forEach(p => considerFrontier(p.latestFetchedBlock));
+  backfills.forEach(p => considerFrontier(p.latestFetchedBlock));
+  strippedFrontiers.forEach(considerFrontier);
+  let regByIndex = {};
+  let addRegs = regs => {
+    regs.forEach(reg => {
+      regByIndex[reg.index.toString()] = reg;
+    });
+  };
+  let standing$1 = standingRef.contents;
+  if (standing$1 !== undefined) {
+    addRegs(standing$1.selection.onEventRegistrations);
+  }
+  absorbedPartitions.forEach(p => {
+    if (!p.selection.dependsOnAddresses) {
+      return addRegs(p.selection.onEventRegistrations);
+    }
+  });
+  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 standing$2 = standingRef.contents;
+  if (standing$2 !== undefined) {
+    let standingOut;
+    if (selectionChanged) {
+      let id = nextPartitionIndexRef.contents.toString();
+      nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+      standingOut = {
+        id: id,
+        latestFetchedBlock: standing$2.latestFetchedBlock,
+        selection: newSelection,
+        addresses: standing$2.addresses,
+        mergeBlock: standing$2.mergeBlock,
+        dynamicContract: standing$2.dynamicContract,
+        mutPendingQueries: [],
+        sourceRangeCapacity: standing$2.sourceRangeCapacity,
+        prevSourceRangeCapacity: standing$2.prevSourceRangeCapacity,
+        eventDensity: standing$2.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: standing$2.latestSourceRangeCapacityUpdateBlock
+      };
+    } else {
+      standingOut = standing$2;
+    }
+    kept.push(standingOut);
+    let catchUpToBlock = claimedFetchedBlock(standingOut, knownHeight);
+    let minFrontier = minFrontierRef.contents;
+    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,
+        addresses: addressStore.emptySet(),
+        mergeBlock: catchUpToBlock,
+        dynamicContract: undefined,
+        mutPendingQueries: [],
+        sourceRangeCapacity: standing$2.sourceRangeCapacity,
+        prevSourceRangeCapacity: standing$2.prevSourceRangeCapacity,
+        eventDensity: standing$2.eventDensity,
+        latestSourceRangeCapacityUpdateBlock: 0
+      });
     }
+    return kept;
+  }
+  let minFrontier$1 = minFrontierRef.contents;
+  if (minFrontier$1 === undefined) {
+    return kept;
+  }
+  let minRange = getMinQueryRange(absorbedPartitions);
+  let id$2 = nextPartitionIndexRef.contents.toString();
+  nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
+  kept.push({
+    id: id$2,
+    latestFetchedBlock: minFrontier$1,
+    selection: newSelection,
+    addresses: addressStore.emptySet(),
+    mergeBlock: undefined,
+    dynamicContract: undefined,
+    mutPendingQueries: [],
+    sourceRangeCapacity: minRange,
+    prevSourceRangeCapacity: minRange,
+    eventDensity: undefined,
+    latestSourceRangeCapacityUpdateBlock: 0
   });
-  return all;
+  return kept;
 }
 
-function createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber) {
-  let nextPartitionIndexRef = nextPartitionIndex;
+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 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 contractSet = registeringSetsByContract[contractName];
     let isDynamic = dynamicContracts.has(contractName);
     let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions;
-    let byStartBlock = {};
-    for (let jdx = 0, jdx_finish = addresses.length; jdx < jdx_finish; ++jdx) {
-      let address = addresses[jdx];
-      let indexingContract = registeringContracts[address];
-      Utils.Dict.push(byStartBlock, indexingContract.effectiveStartBlock.toString(), address);
-    }
-    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;
+    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 {
-          shouldAllocateNewPartition = true;
-        }
-      } else {
-        shouldAllocateNewPartition = true;
-      }
-      if (shouldAllocateNewPartition) {
-        let latestFetchedBlock_blockNumber = Primitive_int.max(startBlockRef - 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;
-          partitions.push({
-            id: nextPartitionIndexRef.toString(),
-            latestFetchedBlock: latestFetchedBlock,
-            selection: normalSelection,
-            addressesByContractName: addressesByContractName,
-            mergeBlock: undefined,
-            dynamicContract: isDynamic ? contractName : undefined,
-            mutPendingQueries: [],
-            sourceRangeCapacity: 0,
-            prevSourceRangeCapacity: 0,
-            eventDensity: undefined,
-            latestSourceRangeCapacityUpdateBlock: 0
-          });
-          nextPartitionIndexRef = nextPartitionIndexRef + 1 | 0;
-        };
-        if (maybeNextStartBlockKey !== undefined) {
-          startBlockRef = Stdlib_Int.fromString(maybeNextStartBlockKey, undefined);
-          addressesRef = byStartBlock[maybeNextStartBlockKey];
+          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;
+    };
   }
   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,
@@ -836,190 +934,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);
-  return make(existingPartitions.concat(mergedPartitions), maxAddrInPartition, nextPartitionIndexRef, dynamicContracts);
+  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, 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,
@@ -1030,11 +1072,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,
@@ -1047,26 +1089,29 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
         }
       }
     }
-    let registeringContracts = registeringContractsByContract[contractName];
-    IndexingAddresses.register(indexingAddresses, registeringContracts);
   }
-  IndexingAddresses.register(indexingAddresses, noEventsAddresses);
-  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContractsRef, 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 filter = item.onEventRegistration.clientAddressFilter;
-    if (filter !== undefined) {
-      return filter(item.payload, item.blockNumber, IndexingAddresses.rawForFilter(indexingAddresses));
-    } else {
-      return true;
-    }
+  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 = addressStore.contractCount(contractName);
+      if (!clientFilteredContracts$1.has(contractName) && addressCount > threshold) {
+        return addClientFilteredContract(clientFilteredContracts$1, contractName, fetchState.chainId, addressCount, threshold);
+      }
+    });
+    clientFilteredContracts = clientFilteredContracts$1;
+  } else {
+    clientFilteredContracts = fetchState.optimizedPartitions.clientFilteredContracts;
+  }
+  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) {
@@ -1103,23 +1148,22 @@ function startFetchingQueries(param, queries) {
   }
 }
 
-function pushDensityPricedQuery(queries, partitionId, fromBlock, toBlock, isChunk, density, chunkItemsMultiplier, chainTargetBlock, itemsTargetFloor, selection, addressesByContractName) {
+function pushDensityPricedQuery(queries, partitionId, fromBlock, toBlock, isChunk, density, chainTargetBlock, selection, addresses) {
   let itemsEst = densityItemsTarget(density, fromBlock, toBlock, chainTargetBlock);
-  let itemsTarget = densityItemsTarget(density * chunkItemsMultiplier, fromBlock, toBlock, chainTargetBlock);
   queries.push({
     partitionId: partitionId,
     fromBlock: fromBlock,
     toBlock: toBlock,
     isChunk: isChunk,
-    itemsTarget: toBlock !== undefined ? Primitive_int.max(itemsTarget, itemsTargetFloor) : itemsTarget,
+    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, chunkItemsMultiplier, itemsTargetFloor, 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;
   }
@@ -1135,7 +1179,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, chunkItemsMultiplier, chainTargetBlock, itemsTargetFloor, selection, addressesByContractName);
+      pushDensityPricedQuery(queries, partitionId, rangeFromBlock, rangeEndBlock, isChunk, density, chainTargetBlock, selection, addresses);
     };
     let match = partition.eventDensity;
     let exit$1 = 0;
@@ -1150,7 +1194,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, chunkItemsMultiplier, chainTargetBlock, itemsTargetFloor, selection, addressesByContractName);
+            pushDensityPricedQuery(queries, partitionId, chunkFromBlock, chunkToBlock, true, match, chainTargetBlock, selection, addresses);
             chunkFromBlock = chunkToBlock + 1 | 0;
             chunkIdx = chunkIdx + 1 | 0;
           };
@@ -1173,7 +1217,7 @@ function pushGapFillQueries(queries, partitionId, rangeFromBlock, rangeEndBlock,
   }
 }
 
-function walkPartitionPending(p, partitionId, inFlightCount, candidates, headBlockNumber, chainTargetBlock, chunkItemsMultiplier, itemsTargetFloor, partitionBudget, queryEndBlock) {
+function walkPartitionPending(p, partitionId, inFlightCount, candidates, headBlockNumber, chainTargetBlock, partitionBudget, queryEndBlock) {
   let maybeChunkRange = getMinHistoryRange(p);
   let pendingCount = p.mutPendingQueries.length;
   let cursor = p.latestFetchedBlock.blockNumber + 1 | 0;
@@ -1184,7 +1228,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, chunkItemsMultiplier, itemsTargetFloor, 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;
@@ -1214,7 +1258,7 @@ function walkPartitionPending(p, partitionId, inFlightCount, candidates, headBlo
   }
 }
 
-function pushForwardCandidates(candidates, inRangeStates, inRangeCount, chainTargetBlock, freshBudget, chunkItemsMultiplier, itemsTargetFloor) {
+function pushForwardCandidates(candidates, inRangeStates, inRangeCount, chainTargetBlock, freshBudget) {
   let probeShare = inRangeCount === 0 ? 0 : freshBudget / inRangeCount;
   let frontierCursor = Stdlib_Array.reduce(inRangeStates, chainTargetBlock, (min, fs) => {
     if (fs.cursor < min) {
@@ -1240,23 +1284,23 @@ 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, chunkItemsMultiplier, chainTargetBlock, itemsTargetFloor, 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;
       };
       return;
     }
-    let itemsTarget = rangeToTarget > 0 ? Primitive_int.max(1, Math.round(rangeTargetDensity * ((chainTargetBlock - fs.cursor | 0) + 1 | 0) / inRangeCount) | 0) : Primitive_int.max(1, Math.round(probeShare) | 0);
+    let itemsEst$1 = rangeToTarget > 0 ? Primitive_int.max(1, Math.round(rangeTargetDensity * ((chainTargetBlock - fs.cursor | 0) + 1 | 0) / inRangeCount) | 0) : Primitive_int.max(1, Math.round(probeShare) | 0);
     candidates.push({
       partitionId: fs.partitionId,
       fromBlock: fs.cursor,
       toBlock: fs.queryEndBlock,
       isChunk: false,
-      itemsTarget: itemsTarget,
-      itemsEst: itemsTarget,
+      itemsTarget: itemsEst$1,
+      itemsEst: itemsEst$1,
       selection: p.selection,
-      addressesByContractName: p.addressesByContractName
+      addresses: p.addresses
     });
   });
 }
@@ -1300,7 +1344,7 @@ function acceptCandidates(candidates, reservations, chainTargetItems, partitionI
   let remainingBudget = chainTargetItems;
   let acceptIdx = 0;
   let usedConcurrency = reservations.length;
-  while (remainingBudget > 0 && acceptIdx < streamCount && usedConcurrency < 100) {
+  while (remainingBudget > 0 && acceptIdx < streamCount && usedConcurrency < Env.maxChainConcurrency) {
     let match = acceptanceStream[acceptIdx];
     let maybeQuery = match[2];
     if (maybeQuery !== undefined) {
@@ -1313,12 +1357,10 @@ function acceptCandidates(candidates, reservations, chainTargetItems, partitionI
   };
 }
 
-function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star, $staropt$star$1) {
+function getNextQuery(param, chainTargetBlock, chainTargetItems) {
   let blockLag = param.blockLag;
   let endBlock = param.endBlock;
   let optimizedPartitions = param.optimizedPartitions;
-  let chunkItemsMultiplier = $staropt$star !== undefined ? $staropt$star : 1;
-  let itemsTargetFloor = $staropt$star$1 !== undefined ? $staropt$star$1 : 0;
   let headBlockNumber = param.knownHeight - blockLag | 0;
   if (headBlockNumber <= 0) {
     return "WaitingForNewBlock";
@@ -1353,7 +1395,7 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star,
       shouldWaitForNewBlock = false;
     }
   }
-  let availableConcurrency = 100 - reservations.length | 0;
+  let availableConcurrency = Env.maxChainConcurrency - reservations.length | 0;
   let partitionsCount$1 = chainTargetItems <= 0 || shouldWaitForNewBlock || availableConcurrency <= 0 ? 0 : partitionsCount;
   let queriesByPartitionIndex = Stdlib_Array.fromInitializer(partitionsCount$1, param => []);
   let computeQueryEndBlock = p => {
@@ -1370,7 +1412,7 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star,
   for (let idx$1 = 0; idx$1 < partitionsCount$1; ++idx$1) {
     let partitionId$1 = optimizedPartitions.idsInAscOrder[idx$1];
     let p$1 = optimizedPartitions.entities[partitionId$1];
-    let fillState = walkPartitionPending(p$1, partitionId$1, inFlightCounts[idx$1], candidates, headBlockNumber, chainTargetBlock, chunkItemsMultiplier, itemsTargetFloor, partitionBudget, computeQueryEndBlock(p$1));
+    let fillState = walkPartitionPending(p$1, partitionId$1, inFlightCounts[idx$1], candidates, headBlockNumber, chainTargetBlock, partitionBudget, computeQueryEndBlock(p$1));
     if (fillState !== undefined) {
       fillStates.push(fillState);
     }
@@ -1391,7 +1433,7 @@ function getNextQuery(param, chainTargetBlock, chainTargetItems, $staropt$star,
   let inRangeStates = fillStates.filter(isInRange);
   let inRangeCount = inRangeStates.length;
   let inRangeStates$1 = inRangeCount > availableConcurrency ? (inRangeStates.sort((a, b) => Primitive_int.compare(a.cursor, b.cursor)), inRangeStates.slice(0, availableConcurrency)) : inRangeStates;
-  pushForwardCandidates(candidates, inRangeStates$1, inRangeCount, chainTargetBlock, freshBudget, chunkItemsMultiplier, itemsTargetFloor);
+  pushForwardCandidates(candidates, inRangeStates$1, inRangeCount, chainTargetBlock, freshBudget);
   acceptCandidates(candidates, reservations, chainTargetItems, partitionIndexById, queriesByPartitionIndex);
   let queries = queriesByPartitionIndex.flat();
   if (Utils.$$Array.isEmpty(queries)) {
@@ -1440,11 +1482,12 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt) {
+function make$1(startBlock, endBlock, onEventRegistrations, addressStore, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockRegistrationsOpt, blockLagOpt, firstEventBlockOpt, clientFilterAddressThresholdOpt) {
   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 latestFetchedBlock = {
     blockNumber: progressBlockNumber,
     blockTimestamp: 0
@@ -1469,7 +1512,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
         onEventRegistrations: notDependingOnAddresses,
         dependsOnAddresses: false
       },
-      addressesByContractName: {},
+      addresses: addressStore.emptySet(),
       mergeBlock: undefined,
       dynamicContract: undefined,
       mutPendingQueries: [],
@@ -1483,12 +1526,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;
@@ -1497,7 +1548,15 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
       }
     }
   });
-  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
+  if (clientFilterAddressThreshold !== undefined) {
+    Utils.Dict.forEachWithKey(registeringSetsByContract, (set, contractName) => {
+      let addressCount = set.size();
+      if (addressCount > clientFilterAddressThreshold) {
+        return addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, clientFilterAddressThreshold);
+      }
+    });
+  }
+  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.`);
   }
@@ -1516,7 +1575,6 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
     startBlock: startBlock,
     endBlock: endBlock,
     normalSelection: normalSelection,
-    contractConfigs: contractConfigs,
     chainId: chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
@@ -1524,7 +1582,8 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
     maxOnBlockBufferSize: maxOnBlockBufferSize,
     onBlockRegistrations: onBlockRegistrations,
     knownHeight: knownHeight,
-    firstEventBlock: firstEventBlock
+    firstEventBlock: firstEventBlock,
+    clientFilterAddressThreshold: clientFilterAddressThreshold
   };
 }
 
@@ -1566,52 +1625,44 @@ 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
           });
         }
       }
@@ -1625,7 +1676,7 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
             blockTimestamp: 0
           }) : p.latestFetchedBlock,
         selection: p.selection,
-        addressesByContractName: p.addressesByContractName,
+        addresses: p.addresses,
         mergeBlock: p.mergeBlock,
         dynamicContract: p.dynamicContract,
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
@@ -1636,13 +1687,12 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
       });
     }
   }
-  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.optimizedPartitions.dynamicContracts, 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,
@@ -1650,7 +1700,8 @@ function rollback(fetchState, indexingAddresses, targetBlockNumber) {
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
     onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
-    firstEventBlock: fetchState.firstEventBlock
+    firstEventBlock: fetchState.firstEventBlock,
+    clientFilterAddressThreshold: fetchState.clientFilterAddressThreshold
   }, optimizedPartitions, fetchState.buffer.filter(item => {
     let tmp;
     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
@@ -1669,7 +1720,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,
@@ -1687,12 +1738,12 @@ function resetPendingQueries(fetchState) {
       entities: newEntities,
       maxAddrInPartition: init.maxAddrInPartition,
       nextPartitionIndex: init.nextPartitionIndex,
-      dynamicContracts: init.dynamicContracts
+      dynamicContracts: init.dynamicContracts,
+      clientFilteredContracts: init.clientFilteredContracts
     },
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
     blockLag: fetchState.blockLag,
@@ -1700,7 +1751,8 @@ function resetPendingQueries(fetchState) {
     maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
     onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: fetchState.knownHeight,
-    firstEventBlock: fetchState.firstEventBlock
+    firstEventBlock: fetchState.firstEventBlock,
+    clientFilterAddressThreshold: fetchState.clientFilterAddressThreshold
   };
 }
 
@@ -1817,12 +1869,12 @@ let blockItemLogIndex = 16777216;
 
 let maxInFlightChunksPerPartition = 12;
 
-let maxChainConcurrency = 100;
+let maxChainConcurrency = Env.maxChainConcurrency;
 
 let chunkRangeGrowthFactor = 1.8;
 
 export {
-  deriveContractNameByAddress,
+  withAddresses,
   densityItemsTarget,
   getMinHistoryRange,
   getTrustedDensity,
@@ -1837,12 +1889,11 @@ export {
   blockItemLogIndex,
   appendOnBlockItems,
   updateInternal,
-  warnDifferentContractType,
-  addressesByContractNameCount,
-  addressesByContractNameGetAll,
-  createPartitionsFromIndexingAddresses,
+  addClientFilteredContract,
+  claimedFetchedBlock,
+  collapseClientFilteredContracts,
+  createPartitions,
   registerDynamicContracts,
-  filterByClientAddress,
   handleQueryResult,
   startFetchingQueries,
   maxInFlightChunksPerPartition,
@@ -1870,4 +1921,4 @@ export {
   getProgressBlockNumberAt,
   updateKnownHeight,
 }
-/* deriveContractNameByAddress Not a pure module */
+/* Env Not a pure module */