envio 3.5.0-alpha.1 → 3.5.0-alpha.2

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;
 }
 
@@ -235,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) {
@@ -418,7 +394,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 +403,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,
@@ -695,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,
@@ -708,36 +683,6 @@ 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 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]);
-    }
-  });
-  return all;
-}
-
 function addClientFilteredContract(clientFilteredContracts, contractName, chainId, addressCount, threshold) {
   clientFilteredContracts.add(contractName);
   Logging.childTrace(Logging.createChild({
@@ -748,7 +693,14 @@ function addClientFilteredContract(clientFilteredContracts, contractName, chainI
   }), "Switching contract to client-side address filtering: registered address count crossed the server-side threshold.");
 }
 
-function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef) {
+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));
+  });
+}
+
+function collapseClientFilteredContracts(partitions, clientFilteredContracts, normalSelection, nextPartitionIndexRef, addressStore, knownHeight) {
   if (clientFilteredContracts.size === 0) {
     return partitions;
   }
@@ -770,32 +722,16 @@ 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) {
+    } 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;
@@ -850,7 +786,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 +799,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 +831,7 @@ function collapseClientFilteredContracts(partitions, clientFilteredContracts, no
     id: id$2,
     latestFetchedBlock: minFrontier$1,
     selection: newSelection,
-    addressesByContractName: {},
+    addresses: addressStore.emptySet(),
     mergeBlock: undefined,
     dynamicContract: undefined,
     mutPendingQueries: [],
@@ -906,111 +843,89 @@ 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 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;
+          joining = false;
         }
-      } 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.contents.toString(),
-            latestFetchedBlock: latestFetchedBlock,
-            selection: normalSelection,
-            addressesByContractName: addressesByContractName,
-            mergeBlock: undefined,
-            dynamicContract: isDynamic ? contractName : undefined,
-            mutPendingQueries: [],
-            sourceRangeCapacity: 0,
-            prevSourceRangeCapacity: 0,
-            eventDensity: undefined,
-            latestSourceRangeCapacityUpdateBlock: 0
-          });
-          nextPartitionIndexRef.contents = nextPartitionIndexRef.contents + 1 | 0;
-        };
-        if (maybeNextStartBlockKey !== undefined) {
-          startBlockRef = Stdlib_Int.fromString(maybeNextStartBlockKey, undefined);
-          addressesRef = byStartBlock[maybeNextStartBlockKey];
-        }
-      }
-    }
+      };
+      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,
@@ -1019,191 +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);
-  let allPartitions = collapseClientFilteredContracts(existingPartitions.concat(mergedPartitions), clientFilteredContracts, normalSelection, nextPartitionIndexRef);
+  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,
@@ -1214,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,
@@ -1231,16 +1089,13 @@ 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);
       }
@@ -1249,23 +1104,14 @@ function registerDynamicContracts(fetchState, indexingAddresses, items) {
   } 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 +1148,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 +1158,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 +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, chainTargetBlock, selection, addressesByContractName);
+      pushDensityPricedQuery(queries, partitionId, rangeFromBlock, rangeEndBlock, isChunk, density, chainTargetBlock, selection, addresses);
     };
     let match = partition.eventDensity;
     let exit$1 = 0;
@@ -1348,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, chainTargetBlock, selection, addressesByContractName);
+            pushDensityPricedQuery(queries, partitionId, chunkFromBlock, chunkToBlock, true, match, chainTargetBlock, selection, addresses);
             chunkFromBlock = chunkToBlock + 1 | 0;
             chunkIdx = chunkIdx + 1 | 0;
           };
@@ -1382,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, 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 +1284,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 +1300,7 @@ function pushForwardCandidates(candidates, inRangeStates, inRangeCount, chainTar
       itemsTarget: itemsEst$1,
       itemsEst: itemsEst$1,
       selection: p.selection,
-      addressesByContractName: p.addressesByContractName
+      addresses: p.addresses
     });
   });
 }
@@ -1636,7 +1482,7 @@ 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) {
   let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   let onBlockRegistrations = onBlockRegistrationsOpt !== undefined ? onBlockRegistrationsOpt : [];
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
@@ -1666,7 +1512,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
         onEventRegistrations: notDependingOnAddresses,
         dependsOnAddresses: false
       },
-      addressesByContractName: {},
+      addresses: addressStore.emptySet(),
       mergeBlock: undefined,
       dynamicContract: undefined,
       mutPendingQueries: [],
@@ -1680,13 +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;
@@ -1696,14 +1549,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);
       }
     });
   }
-  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 +1575,6 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
     startBlock: startBlock,
     endBlock: endBlock,
     normalSelection: normalSelection,
-    contractConfigs: contractConfigs,
     chainId: chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
@@ -1773,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
           });
         }
       }
@@ -1832,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),
@@ -1843,13 +1687,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 +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,
@@ -1901,7 +1744,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 +1874,7 @@ let maxChainConcurrency = Env.maxChainConcurrency;
 let chunkRangeGrowthFactor = 1.8;
 
 export {
-  deriveContractNameByAddress,
+  withAddresses,
   densityItemsTarget,
   getMinHistoryRange,
   getTrustedDensity,
@@ -2047,14 +1889,11 @@ export {
   blockItemLogIndex,
   appendOnBlockItems,
   updateInternal,
-  warnDifferentContractType,
-  addressesByContractNameCount,
-  addressesByContractNameGetAll,
   addClientFilteredContract,
+  claimedFetchedBlock,
   collapseClientFilteredContracts,
-  createPartitionsFromIndexingAddresses,
+  createPartitions,
   registerDynamicContracts,
-  filterByClientAddress,
   handleQueryResult,
   startFetchingQueries,
   maxInFlightChunksPerPartition,
@@ -2082,4 +1921,4 @@ export {
   getProgressBlockNumberAt,
   updateKnownHeight,
 }
-/* deriveContractNameByAddress Not a pure module */
+/* Env Not a pure module */