envio 3.3.0-alpha.3 → 3.3.0-alpha.5

package/src/FetchState.res.mjs

@@ -9,12 +9,9 @@ import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as IndexingAddresses from "./IndexingAddresses.res.mjs";
 
-function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
-  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
-}
-
-function deriveContractNameByAddress(addressesByContractName) {
+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) {
@@ -22,7 +19,7 @@ function deriveContractNameByAddress(addressesByContractName) {
     }
   });
   return result;
-}
+});
 
 function calculateEstResponseSize(p, fromBlock, toBlock, maxQueryBlockNumber) {
   if (p.prevQueryRange <= 0) {
@@ -82,7 +79,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         latestFetchedBlock: p1.latestFetchedBlock,
         selection: p1.selection,
         addressesByContractName: p1.addressesByContractName,
-        contractNameByAddress: p1.contractNameByAddress,
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
@@ -96,7 +92,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         latestFetchedBlock: p2.latestFetchedBlock,
         selection: p2.selection,
         addressesByContractName: p2.addressesByContractName,
-        contractNameByAddress: p2.contractNameByAddress,
         mergeBlock: potentialMergeBlock,
         dynamicContract: p2.dynamicContract,
         mutPendingQueries: p2.mutPendingQueries,
@@ -119,7 +114,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         },
         selection: p1.selection,
         addressesByContractName: {},
-        contractNameByAddress: {},
         mergeBlock: undefined,
         dynamicContract: contractName,
         mutPendingQueries: [],
@@ -134,7 +128,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
         latestFetchedBlock: p1.latestFetchedBlock,
         selection: p1.selection,
         addressesByContractName: p1.addressesByContractName,
-        contractNameByAddress: p1.contractNameByAddress,
         mergeBlock: potentialMergeBlock,
         dynamicContract: p1.dynamicContract,
         mutPendingQueries: p1.mutPendingQueries,
@@ -151,7 +144,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       latestFetchedBlock: p2.latestFetchedBlock,
       selection: p2.selection,
       addressesByContractName: p2.addressesByContractName,
-      contractNameByAddress: p2.contractNameByAddress,
       mergeBlock: potentialMergeBlock,
       dynamicContract: p2.dynamicContract,
       mutPendingQueries: p2.mutPendingQueries,
@@ -176,7 +168,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       latestFetchedBlock: continuingBase.latestFetchedBlock,
       selection: continuingBase.selection,
       addressesByContractName: abcFull,
-      contractNameByAddress: continuingBase.contractNameByAddress,
       mergeBlock: continuingBase.mergeBlock,
       dynamicContract: continuingBase.dynamicContract,
       mutPendingQueries: continuingBase.mutPendingQueries,
@@ -192,7 +183,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
       latestFetchedBlock: continuingBase.latestFetchedBlock,
       selection: continuingBase.selection,
       addressesByContractName: abcRest,
-      contractNameByAddress: continuingBase.contractNameByAddress,
       mergeBlock: continuingBase.mergeBlock,
       dynamicContract: continuingBase.dynamicContract,
       mutPendingQueries: [],
@@ -210,7 +200,6 @@ function mergePartitionsAtBlock(p1, p2, potentialMergeBlock, contractName, maxAd
     latestFetchedBlock: continuingBase.latestFetchedBlock,
     selection: continuingBase.selection,
     addressesByContractName: abc,
-    contractNameByAddress: continuingBase.contractNameByAddress,
     mergeBlock: continuingBase.mergeBlock,
     dynamicContract: continuingBase.dynamicContract,
     mutPendingQueries: continuingBase.mutPendingQueries,
@@ -309,20 +298,7 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
   for (let idx$2 = 0; idx$2 < partitionsCount; ++idx$2) {
     let p$1 = newPartitions[idx$2];
     idsInAscOrder[idx$2] = p$1.id;
-    entities[p$1.id] = {
-      id: p$1.id,
-      latestFetchedBlock: p$1.latestFetchedBlock,
-      selection: p$1.selection,
-      addressesByContractName: p$1.addressesByContractName,
-      contractNameByAddress: deriveContractNameByAddress(p$1.addressesByContractName),
-      mergeBlock: p$1.mergeBlock,
-      dynamicContract: p$1.dynamicContract,
-      mutPendingQueries: p$1.mutPendingQueries,
-      prevQueryRange: p$1.prevQueryRange,
-      prevPrevQueryRange: p$1.prevPrevQueryRange,
-      prevRangeSize: p$1.prevRangeSize,
-      latestBlockRangeUpdateBlock: p$1.latestBlockRangeUpdateBlock
-    };
+    entities[p$1.id] = p$1;
   }
   return {
     idsInAscOrder: idsInAscOrder,
@@ -416,7 +392,6 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
     let updatedMainPartition_id = p$1.id;
     let updatedMainPartition_selection = p$1.selection;
     let updatedMainPartition_addressesByContractName = p$1.addressesByContractName;
-    let updatedMainPartition_contractNameByAddress = p$1.contractNameByAddress;
     let updatedMainPartition_mergeBlock = p$1.mergeBlock;
     let updatedMainPartition_dynamicContract = p$1.dynamicContract;
     let updatedMainPartition_mutPendingQueries = p$1.mutPendingQueries;
@@ -426,7 +401,6 @@ function handleQueryResponse(optimizedPartitions, query, knownHeight, itemsCount
       latestFetchedBlock: updatedLatestFetchedBlock,
       selection: updatedMainPartition_selection,
       addressesByContractName: updatedMainPartition_addressesByContractName,
-      contractNameByAddress: updatedMainPartition_contractNameByAddress,
       mergeBlock: updatedMainPartition_mergeBlock,
       dynamicContract: updatedMainPartition_dynamicContract,
       mutPendingQueries: updatedMainPartition_mutPendingQueries,
@@ -487,6 +461,22 @@ function bufferBlock(param) {
   }
 }
 
+function bufferReadyCount(fetchState) {
+  let frontier = bufferBlockNumber(fetchState);
+  let buffer = fetchState.buffer;
+  let lo = 0;
+  let hi = buffer.length;
+  while (lo < hi) {
+    let mid = (lo + hi | 0) / 2 | 0;
+    if (buffer[mid].blockNumber <= frontier) {
+      lo = mid + 1 | 0;
+    } else {
+      hi = mid;
+    }
+  };
+  return lo;
+}
+
 function compareBufferItem(a, b) {
   let blockOrdering = Primitive_int.compare(a.blockNumber, b.blockNumber);
   if (blockOrdering === 0) {
@@ -496,10 +486,6 @@ function compareBufferItem(a, b) {
   }
 }
 
-function numAddresses(fetchState) {
-  return Utils.Dict.size(fetchState.indexingAddresses);
-}
-
 function appendOnBlockItems(mutItems, onBlockConfigs, indexerStartBlock, fromBlock, maxBlockNumber, maxOnBlockBufferSize) {
   let newItemsCounter = 0;
   let latestOnBlockBlockNumber = fromBlock;
@@ -529,9 +515,8 @@ function appendOnBlockItems(mutItems, onBlockConfigs, indexerStartBlock, fromBlo
   return latestOnBlockBlockNumber;
 }
 
-function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt, mutItems, blockLagOpt, knownHeightOpt) {
+function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, blockLagOpt, knownHeightOpt) {
   let optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
-  let indexingAddresses = indexingAddressesOpt !== undefined ? indexingAddressesOpt : fetchState.indexingAddresses;
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : fetchState.blockLag;
   let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : fetchState.knownHeight;
   let mutItemsRef = mutItems;
@@ -572,7 +557,6 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt
     startBlock: updatedFetchState_startBlock,
     endBlock: updatedFetchState_endBlock,
     normalSelection: updatedFetchState_normalSelection,
-    indexingAddresses: indexingAddresses,
     contractConfigs: updatedFetchState_contractConfigs,
     chainId: updatedFetchState_chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
@@ -586,9 +570,6 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt
   Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, fetchState.chainId);
   Prometheus.IndexingBufferSize.set(updatedFetchState_buffer.length, fetchState.chainId);
   Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(updatedFetchState), fetchState.chainId);
-  if (indexingAddresses !== fetchState.indexingAddresses) {
-    Prometheus.IndexingAddresses.set(Utils.Dict.size(indexingAddresses), fetchState.chainId);
-  }
   return updatedFetchState;
 }
 
@@ -674,7 +655,6 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             latestFetchedBlock: latestFetchedBlock,
             selection: normalSelection,
             addressesByContractName: addressesByContractName,
-            contractNameByAddress: {},
             mergeBlock: undefined,
             dynamicContract: isDynamic ? contractName : undefined,
             mutPendingQueries: [],
@@ -726,7 +706,6 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             latestFetchedBlock: currentP.latestFetchedBlock,
             selection: currentP.selection,
             addressesByContractName: currentP.addressesByContractName,
-            contractNameByAddress: currentP.contractNameByAddress,
             mergeBlock: currentPBlock < nextPBlock ? nextPBlock : undefined,
             dynamicContract: currentP.dynamicContract,
             mutPendingQueries: currentP.mutPendingQueries,
@@ -740,7 +719,6 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             latestFetchedBlock: nextP.latestFetchedBlock,
             selection: nextP.selection,
             addressesByContractName: mergedAddresses,
-            contractNameByAddress: nextP.contractNameByAddress,
             mergeBlock: nextP.mergeBlock,
             dynamicContract: nextP.dynamicContract,
             mutPendingQueries: nextP.mutPendingQueries,
@@ -755,7 +733,6 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
             latestFetchedBlock: currentP.latestFetchedBlock,
             selection: currentP.selection,
             addressesByContractName: mergedAddresses,
-            contractNameByAddress: currentP.contractNameByAddress,
             mergeBlock: currentP.mergeBlock,
             dynamicContract: currentP.dynamicContract,
             mutPendingQueries: currentP.mutPendingQueries,
@@ -774,11 +751,10 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, d
   return make(existingPartitions.concat(mergedPartitions), maxAddrInPartition, nextPartitionIndexRef, dynamicContracts);
 }
 
-function registerDynamicContracts(fetchState, items) {
+function registerDynamicContracts(fetchState, indexingAddresses, items) {
   if (Utils.$$Array.isEmpty(fetchState.normalSelection.eventConfigs)) {
     Stdlib_JsError.throwWithMessage("Invalid configuration. No events to fetch for the dynamic contract registration.");
   }
-  let indexingAddresses = fetchState.indexingAddresses;
   let registeringContractsByContract = {};
   let earliestRegisteringEventBlockNumber = Infinity;
   let noEventsAddresses = {};
@@ -796,14 +772,14 @@ function registerDynamicContracts(fetchState, items) {
           let dcWithStartBlock_address = dc.address;
           let dcWithStartBlock_contractName = dc.contractName;
           let dcWithStartBlock_registrationBlock = dc.registrationBlock;
-          let dcWithStartBlock_effectiveStartBlock = deriveEffectiveStartBlock(dc.registrationBlock, match.startBlock);
+          let dcWithStartBlock_effectiveStartBlock = IndexingAddresses.deriveEffectiveStartBlock(dc.registrationBlock, match.startBlock);
           let dcWithStartBlock = {
             address: dcWithStartBlock_address,
             contractName: dcWithStartBlock_contractName,
             registrationBlock: dcWithStartBlock_registrationBlock,
             effectiveStartBlock: dcWithStartBlock_effectiveStartBlock
           };
-          let existingContract = indexingAddresses[dc.address];
+          let existingContract = IndexingAddresses.get(indexingAddresses, dc.address);
           if (existingContract !== undefined) {
             if (existingContract.contractName !== dc.contractName) {
               warnDifferentContractType(fetchState, existingContract, dcWithStartBlock);
@@ -834,14 +810,14 @@ function registerDynamicContracts(fetchState, items) {
           let dcAsIndexingAddress_address = dc.address;
           let dcAsIndexingAddress_contractName = dc.contractName;
           let dcAsIndexingAddress_registrationBlock = dc.registrationBlock;
-          let dcAsIndexingAddress_effectiveStartBlock = deriveEffectiveStartBlock(dc.registrationBlock, undefined);
+          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[dc.address];
+          let existingContract$1 = IndexingAddresses.get(indexingAddresses, dc.address);
           if (existingContract$1 !== undefined) {
             if (existingContract$1.contractName !== dc.contractName) {
               warnDifferentContractType(fetchState, existingContract$1, dcAsIndexingAddress);
@@ -876,104 +852,100 @@ function registerDynamicContracts(fetchState, items) {
   }
   let dcContractNamesToStore = Object.keys(registeringContractsByContract);
   let hasNoEventsUpdates = !Utils.Dict.isEmpty(noEventsAddresses);
-  if (dcContractNamesToStore.length !== 0) {
-    let newPartitions = [];
-    let newIndexingAddresses = Utils.Dict.shallowCopy(indexingAddresses);
-    let dynamicContractsRef = fetchState.optimizedPartitions.dynamicContracts;
-    let mutExistingPartitions = Object.values(fetchState.optimizedPartitions.entities);
-    for (let idx$1 = 0, idx_finish = dcContractNamesToStore.length; idx$1 < idx_finish; ++idx$1) {
-      let contractName = dcContractNamesToStore[idx$1];
-      if (!dynamicContractsRef.has(contractName)) {
-        dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
-        for (let idx$2 = 0, idx_finish$1 = mutExistingPartitions.length; idx$2 < idx_finish$1; ++idx$2) {
-          let p = mutExistingPartitions[idx$2];
-          let addresses = p.addressesByContractName[contractName];
-          if (addresses !== undefined && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
-            let allPartitionContractNames = Object.keys(p.addressesByContractName);
-            if (allPartitionContractNames.length !== 1) {
-              let isFetching = p.mutPendingQueries.length !== 0;
-              if (!isFetching) {
-                let newPartitionId = (fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0).toString();
-                let restAddressesByContractName = Utils.Dict.shallowCopy(p.addressesByContractName);
-                Utils.Dict.deleteInPlace(restAddressesByContractName, contractName);
-                mutExistingPartitions[idx$2] = {
-                  id: p.id,
-                  latestFetchedBlock: p.latestFetchedBlock,
-                  selection: p.selection,
-                  addressesByContractName: restAddressesByContractName,
-                  contractNameByAddress: p.contractNameByAddress,
-                  mergeBlock: p.mergeBlock,
-                  dynamicContract: p.dynamicContract,
-                  mutPendingQueries: p.mutPendingQueries,
-                  prevQueryRange: p.prevQueryRange,
-                  prevPrevQueryRange: p.prevPrevQueryRange,
-                  prevRangeSize: p.prevRangeSize,
-                  latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
-                };
-                let addressesByContractName = {};
-                addressesByContractName[contractName] = addresses;
-                newPartitions.push({
-                  id: newPartitionId,
-                  latestFetchedBlock: p.latestFetchedBlock,
-                  selection: fetchState.normalSelection,
-                  addressesByContractName: addressesByContractName,
-                  contractNameByAddress: {},
-                  mergeBlock: undefined,
-                  dynamicContract: contractName,
-                  mutPendingQueries: p.mutPendingQueries,
-                  prevQueryRange: p.prevQueryRange,
-                  prevPrevQueryRange: p.prevPrevQueryRange,
-                  prevRangeSize: p.prevRangeSize,
-                  latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
-                });
-              }
-            } else {
+  if (dcContractNamesToStore.length === 0) {
+    if (hasNoEventsUpdates) {
+      IndexingAddresses.register(indexingAddresses, noEventsAddresses);
+      return fetchState;
+    } else {
+      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];
+    if (!dynamicContractsRef.has(contractName)) {
+      dynamicContractsRef = Utils.$$Set.immutableAdd(dynamicContractsRef, contractName);
+      for (let idx$2 = 0, idx_finish$1 = mutExistingPartitions.length; idx$2 < idx_finish$1; ++idx$2) {
+        let p = mutExistingPartitions[idx$2];
+        let addresses = p.addressesByContractName[contractName];
+        if (addresses !== undefined && p.selection.dependsOnAddresses && p.mergeBlock === undefined) {
+          let allPartitionContractNames = Object.keys(p.addressesByContractName);
+          if (allPartitionContractNames.length !== 1) {
+            let isFetching = p.mutPendingQueries.length !== 0;
+            if (!isFetching) {
+              let newPartitionId = (fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0).toString();
+              let restAddressesByContractName = Utils.Dict.shallowCopy(p.addressesByContractName);
+              Utils.Dict.deleteInPlace(restAddressesByContractName, contractName);
               mutExistingPartitions[idx$2] = {
                 id: p.id,
                 latestFetchedBlock: p.latestFetchedBlock,
                 selection: p.selection,
-                addressesByContractName: p.addressesByContractName,
-                contractNameByAddress: p.contractNameByAddress,
+                addressesByContractName: restAddressesByContractName,
                 mergeBlock: p.mergeBlock,
-                dynamicContract: contractName,
+                dynamicContract: p.dynamicContract,
                 mutPendingQueries: p.mutPendingQueries,
                 prevQueryRange: p.prevQueryRange,
                 prevPrevQueryRange: p.prevPrevQueryRange,
                 prevRangeSize: p.prevRangeSize,
                 latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
               };
+              let addressesByContractName = {};
+              addressesByContractName[contractName] = addresses;
+              newPartitions.push({
+                id: newPartitionId,
+                latestFetchedBlock: p.latestFetchedBlock,
+                selection: fetchState.normalSelection,
+                addressesByContractName: addressesByContractName,
+                mergeBlock: undefined,
+                dynamicContract: contractName,
+                mutPendingQueries: p.mutPendingQueries,
+                prevQueryRange: p.prevQueryRange,
+                prevPrevQueryRange: p.prevPrevQueryRange,
+                prevRangeSize: p.prevRangeSize,
+                latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+              });
             }
+          } else {
+            mutExistingPartitions[idx$2] = {
+              id: p.id,
+              latestFetchedBlock: p.latestFetchedBlock,
+              selection: p.selection,
+              addressesByContractName: p.addressesByContractName,
+              mergeBlock: p.mergeBlock,
+              dynamicContract: contractName,
+              mutPendingQueries: p.mutPendingQueries,
+              prevQueryRange: p.prevQueryRange,
+              prevPrevQueryRange: p.prevPrevQueryRange,
+              prevRangeSize: p.prevRangeSize,
+              latestBlockRangeUpdateBlock: p.latestBlockRangeUpdateBlock
+            };
           }
         }
       }
-      let registeringContracts = registeringContractsByContract[contractName];
-      Object.assign(newIndexingAddresses, registeringContracts);
     }
-    Object.assign(newIndexingAddresses, 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, newIndexingAddresses, undefined, undefined, undefined);
-  }
-  if (!hasNoEventsUpdates) {
-    return fetchState;
+    let registeringContracts = registeringContractsByContract[contractName];
+    IndexingAddresses.register(indexingAddresses, registeringContracts);
   }
-  let newIndexingContracts = Utils.Dict.shallowCopy(indexingAddresses);
-  Object.assign(newIndexingContracts, noEventsAddresses);
-  return updateInternal(fetchState, undefined, newIndexingContracts, undefined, undefined, undefined);
+  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);
 }
 
-function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
+function handleQueryResult(fetchState, indexingAddresses, query, latestFetchedBlock, newItems) {
   let newItems$1 = newItems.filter(item => {
     if (item.kind !== 0) {
       return true;
     }
     let filter = item.eventConfig.clientAddressFilter;
     if (filter !== undefined) {
-      return filter(item.payload, item.blockNumber, fetchState.indexingAddresses);
+      return filter(item.payload, item.blockNumber, IndexingAddresses.rawForFilter(indexingAddresses));
     } else {
       return true;
     }
   });
-  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems$1.length, latestFetchedBlock), undefined, newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
+  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, newItems$1.length, latestFetchedBlock), newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
 }
 
 function startFetchingQueries(param, queries) {
@@ -1029,8 +1001,7 @@ function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock
           chainId: 0,
           progress: 0,
           selection: selection,
-          addressesByContractName: addressesByContractName,
-          contractNameByAddress: partition.contractNameByAddress
+          addressesByContractName: addressesByContractName
         });
         chunkFromBlock = chunkToBlock + 1 | 0;
         chunkIdx = chunkIdx + 1 | 0;
@@ -1046,8 +1017,7 @@ function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock
       chainId: 0,
       progress: 0,
       selection: selection,
-      addressesByContractName: addressesByContractName,
-      contractNameByAddress: partition.contractNameByAddress
+      addressesByContractName: addressesByContractName
     });
     return;
   }
@@ -1060,8 +1030,7 @@ function pushQueriesForRange(queries, partitionId, rangeFromBlock, rangeEndBlock
     chainId: 0,
     progress: 0,
     selection: selection,
-    addressesByContractName: addressesByContractName,
-    contractNameByAddress: partition.contractNameByAddress
+    addressesByContractName: addressesByContractName
   });
 }
 
@@ -1081,7 +1050,7 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
   let shouldWaitForNewBlock = (
     endBlock !== undefined ? headBlockNumber < endBlock : true
   ) && !isOnBlockBehindTheHead;
-  let item = fetchState.buffer[(budget + (chainPendingBudget | 0) | 0) - 1 | 0];
+  let item = fetchState.buffer[((bufferReadyCount(fetchState) + budget | 0) + (chainPendingBudget | 0) | 0) - 1 | 0];
   let maxQueryBlockNumber = item !== undefined ? Primitive_int.min(item.blockNumber, knownHeight) : knownHeight;
   let queries = [];
   let partitionsCount = optimizedPartitions.idsInAscOrder.length;
@@ -1140,8 +1109,7 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
                     chainId: 0,
                     progress: 0,
                     selection: selection,
-                    addressesByContractName: addressesByContractName,
-                    contractNameByAddress: p.contractNameByAddress
+                    addressesByContractName: addressesByContractName
                   });
                   chunkFromBlock = chunkToBlock + 1 | 0;
                   chunkIdx = chunkIdx + 1 | 0;
@@ -1156,8 +1124,7 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
                   chainId: 0,
                   progress: 0,
                   selection: selection,
-                  addressesByContractName: addressesByContractName,
-                  contractNameByAddress: p.contractNameByAddress
+                  addressesByContractName: addressesByContractName
                 });
               }
             } else {
@@ -1170,8 +1137,7 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
                 chainId: 0,
                 progress: 0,
                 selection: selection,
-                addressesByContractName: addressesByContractName,
-                contractNameByAddress: p.contractNameByAddress
+                addressesByContractName: addressesByContractName
               });
             }
           }
@@ -1219,8 +1185,7 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
                   chainId: 0,
                   progress: 0,
                   selection: selection$1,
-                  addressesByContractName: addressesByContractName$1,
-                  contractNameByAddress: p.contractNameByAddress
+                  addressesByContractName: addressesByContractName$1
                 });
                 chunkFromBlock$1 = chunkToBlock$1 + 1 | 0;
                 chunkIdx$1 = chunkIdx$1 + 1 | 0;
@@ -1235,8 +1200,7 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
                 chainId: 0,
                 progress: 0,
                 selection: selection$1,
-                addressesByContractName: addressesByContractName$1,
-                contractNameByAddress: p.contractNameByAddress
+                addressesByContractName: addressesByContractName$1
               });
             }
           } else {
@@ -1249,8 +1213,7 @@ function getNextQuery(fetchState, budget, chainPendingBudget) {
               chainId: 0,
               progress: 0,
               selection: selection$1,
-              addressesByContractName: addressesByContractName$1,
-              contractNameByAddress: p.contractNameByAddress
+              addressesByContractName: addressesByContractName$1
             });
           }
         }
@@ -1304,7 +1267,7 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   return acc;
 }
 
-function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockConfigsOpt, blockLagOpt, firstEventBlockOpt) {
+function make$1(startBlock, endBlock, eventConfigs, contractConfigs, addresses, maxAddrInPartition, chainId, maxOnBlockBufferSize, knownHeight, progressBlockNumberOpt, onBlockConfigsOpt, blockLagOpt, firstEventBlockOpt) {
   let progressBlockNumber = progressBlockNumberOpt !== undefined ? progressBlockNumberOpt : startBlock - 1 | 0;
   let onBlockConfigs = onBlockConfigsOpt !== undefined ? onBlockConfigsOpt : [];
   let blockLag = blockLagOpt !== undefined ? blockLagOpt : 0;
@@ -1316,25 +1279,7 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
   let notDependingOnAddresses = [];
   let normalEventConfigs = [];
   let contractNamesWithNormalEvents = new Set();
-  let indexingAddresses = {};
-  let contractConfigs = {};
   eventConfigs.forEach(ec => {
-    let match = contractConfigs[ec.contractName];
-    if (match !== undefined) {
-      let startBlock = match.startBlock;
-      let match$1 = ec.startBlock;
-      contractConfigs[ec.contractName] = {
-        startBlock: startBlock !== undefined ? (
-            match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
-          ) : (
-            match$1 !== undefined ? match$1 : undefined
-          )
-      };
-    } else {
-      contractConfigs[ec.contractName] = {
-        startBlock: ec.startBlock
-      };
-    }
     if (ec.dependsOnAddresses) {
       normalEventConfigs.push(ec);
       contractNamesWithNormalEvents.add(ec.contractName);
@@ -1352,7 +1297,6 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
         dependsOnAddresses: false
       },
       addressesByContractName: {},
-      contractNameByAddress: {},
       mergeBlock: undefined,
       dynamicContract: undefined,
       mutPendingQueries: [],
@@ -1370,27 +1314,14 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
   let dynamicContracts = new Set();
   addresses.forEach(contract => {
     let contractName = contract.contractName;
-    let match = contractConfigs[contractName];
-    let contractStartBlock = match !== undefined ? match.startBlock : undefined;
-    let ia_address = contract.address;
-    let ia_contractName = contract.contractName;
-    let ia_registrationBlock = contract.registrationBlock;
-    let ia_effectiveStartBlock = deriveEffectiveStartBlock(contract.registrationBlock, contractStartBlock);
-    let ia = {
-      address: ia_address,
-      contractName: ia_contractName,
-      registrationBlock: ia_registrationBlock,
-      effectiveStartBlock: ia_effectiveStartBlock
-    };
-    indexingAddresses[contract.address] = ia;
-    if (!contractNamesWithNormalEvents.has(contractName)) {
-      return;
-    }
-    let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
-    registeringContracts[contract.address] = ia;
-    if (contract.registrationBlock !== -1) {
-      dynamicContracts.add(contractName);
-      return;
+    if (contractNamesWithNormalEvents.has(contractName)) {
+      Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName)[contract.address] = IndexingAddresses.makeIndexingAddress(contract, contractConfigs);
+      if (contract.registrationBlock !== -1) {
+        dynamicContracts.add(contractName);
+        return;
+      } else {
+        return;
+      }
     }
   });
   let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
@@ -1412,7 +1343,6 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
     startBlock: startBlock,
     endBlock: endBlock,
     normalSelection: normalSelection,
-    indexingAddresses: indexingAddresses,
     contractConfigs: contractConfigs,
     chainId: chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
@@ -1423,8 +1353,6 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
     knownHeight: knownHeight,
     firstEventBlock: firstEventBlock
   };
-  let numAddresses = Utils.Dict.size(indexingAddresses);
-  Prometheus.IndexingAddresses.set(numAddresses, chainId);
   Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, chainId);
   Prometheus.IndexingBufferSize.set(buffer.length, chainId);
   Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(fetchState), chainId);
@@ -1438,22 +1366,6 @@ function bufferSize(param) {
   return param.buffer.length;
 }
 
-function bufferReadyCount(fetchState) {
-  let frontier = bufferBlockNumber(fetchState);
-  let buffer = fetchState.buffer;
-  let lo = 0;
-  let hi = buffer.length;
-  while (lo < hi) {
-    let mid = (lo + hi | 0) / 2 | 0;
-    if (buffer[mid].blockNumber <= frontier) {
-      lo = mid + 1 | 0;
-    } else {
-      hi = mid;
-    }
-  };
-  return lo;
-}
-
 function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
   let adjusted = [];
   for (let qIdx = 0, qIdx_finish = mutPendingQueries.length; qIdx < qIdx_finish; ++qIdx) {
@@ -1483,16 +1395,8 @@ function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
   return adjusted;
 }
 
-function rollback(fetchState, targetBlockNumber) {
-  let addressesToRemove = new Set();
-  let indexingAddresses = {};
-  Utils.Dict.forEachWithKey(fetchState.indexingAddresses, (indexingContract, address) => {
-    if (indexingContract.registrationBlock > targetBlockNumber) {
-      addressesToRemove.add(address);
-    } else {
-      indexingAddresses[address] = indexingContract;
-    }
-  });
+function rollback(fetchState, indexingAddresses, targetBlockNumber) {
+  IndexingAddresses.rollbackInPlace(indexingAddresses, targetBlockNumber);
   let keptPartitions = [];
   let nextKeptIdRef = 0;
   let registeringContractsByContract = {};
@@ -1503,11 +1407,12 @@ function rollback(fetchState, targetBlockNumber) {
       if (p.latestFetchedBlock.blockNumber > targetBlockNumber) {
         Utils.Dict.forEachWithKey(p.addressesByContractName, (addresses, contractName) => {
           addresses.forEach(address => {
-            if (!(!addressesToRemove.has(address) && Stdlib_Option.isSome(indexingAddresses[address]))) {
+            let indexingContract = IndexingAddresses.get(indexingAddresses, address);
+            if (indexingContract === undefined) {
               return;
             }
             let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, contractName);
-            registeringContracts[address] = indexingAddresses[address];
+            registeringContracts[address] = indexingContract;
           });
         });
       } else {
@@ -1515,7 +1420,7 @@ function rollback(fetchState, targetBlockNumber) {
         let mergeBlock$1 = mergeBlock !== undefined && mergeBlock > targetBlockNumber ? targetBlockNumber : mergeBlock;
         let rollbackedAddressesByContractName = {};
         Utils.Dict.forEachWithKey(p.addressesByContractName, (addresses, contractName) => {
-          let keptAddresses = addresses.filter(address => !addressesToRemove.has(address));
+          let keptAddresses = addresses.filter(address => Stdlib_Option.isSome(IndexingAddresses.get(indexingAddresses, address)));
           if (keptAddresses.length !== 0) {
             rollbackedAddressesByContractName[contractName] = keptAddresses;
             return;
@@ -1529,7 +1434,6 @@ function rollback(fetchState, targetBlockNumber) {
             latestFetchedBlock: p.latestFetchedBlock,
             selection: p.selection,
             addressesByContractName: rollbackedAddressesByContractName,
-            contractNameByAddress: p.contractNameByAddress,
             mergeBlock: mergeBlock$1,
             dynamicContract: p.dynamicContract,
             mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
@@ -1551,7 +1455,6 @@ function rollback(fetchState, targetBlockNumber) {
           }) : p.latestFetchedBlock,
         selection: p.selection,
         addressesByContractName: p.addressesByContractName,
-        contractNameByAddress: p.contractNameByAddress,
         mergeBlock: p.mergeBlock,
         dynamicContract: p.dynamicContract,
         mutPendingQueries: rollbackPendingQueries(p.mutPendingQueries, targetBlockNumber),
@@ -1568,7 +1471,6 @@ function rollback(fetchState, targetBlockNumber) {
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    indexingAddresses: fetchState.indexingAddresses,
     contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: Primitive_int.min(fetchState.latestOnBlockBlockNumber, targetBlockNumber),
@@ -1578,7 +1480,7 @@ function rollback(fetchState, targetBlockNumber) {
     onBlockConfigs: fetchState.onBlockConfigs,
     knownHeight: fetchState.knownHeight,
     firstEventBlock: fetchState.firstEventBlock
-  }, optimizedPartitions, indexingAddresses, fetchState.buffer.filter(item => {
+  }, optimizedPartitions, fetchState.buffer.filter(item => {
     let tmp;
     tmp = item.kind === 0 ? item.blockNumber : item.blockNumber;
     return tmp <= targetBlockNumber;
@@ -1597,7 +1499,6 @@ function resetPendingQueries(fetchState) {
         latestFetchedBlock: partition.latestFetchedBlock,
         selection: partition.selection,
         addressesByContractName: partition.addressesByContractName,
-        contractNameByAddress: partition.contractNameByAddress,
         mergeBlock: partition.mergeBlock,
         dynamicContract: partition.dynamicContract,
         mutPendingQueries: kept,
@@ -1620,7 +1521,6 @@ function resetPendingQueries(fetchState) {
     startBlock: fetchState.startBlock,
     endBlock: fetchState.endBlock,
     normalSelection: fetchState.normalSelection,
-    indexingAddresses: fetchState.indexingAddresses,
     contractConfigs: fetchState.contractConfigs,
     chainId: fetchState.chainId,
     latestOnBlockBlockNumber: fetchState.latestOnBlockBlockNumber,
@@ -1750,7 +1650,7 @@ function getProgressBlockNumberAt(fetchState, index) {
 function updateKnownHeight(fetchState, knownHeight) {
   if (knownHeight > fetchState.knownHeight) {
     Prometheus.IndexingKnownHeight.set(knownHeight, fetchState.chainId);
-    return updateInternal(fetchState, undefined, undefined, undefined, undefined, knownHeight);
+    return updateInternal(fetchState, undefined, undefined, undefined, knownHeight);
   } else {
     return fetchState;
   }
@@ -1763,7 +1663,6 @@ let blockItemLogIndex = 16777216;
 let maxPendingChunksPerPartition = 10;
 
 export {
-  deriveEffectiveStartBlock,
   deriveContractNameByAddress,
   defaultEstResponseSize,
   calculateEstResponseSize,
@@ -1772,9 +1671,9 @@ export {
   OptimizedPartitions,
   bufferBlockNumber,
   bufferBlock,
+  bufferReadyCount,
   compareBufferItem,
   blockItemLogIndex,
-  numAddresses,
   appendOnBlockItems,
   updateInternal,
   warnDifferentContractType,
@@ -1791,7 +1690,6 @@ export {
   getReadyItemsCount,
   make$1 as make,
   bufferSize,
-  bufferReadyCount,
   rollbackPendingQueries,
   rollback,
   resetPendingQueries,
@@ -1804,4 +1702,4 @@ export {
   getProgressBlockNumberAt,
   updateKnownHeight,
 }
-/* Utils Not a pure module */
+/* deriveContractNameByAddress Not a pure module */