envio 3.3.0-alpha.4 → 3.3.0-alpha.5

package/src/FetchState.res.mjs

@@ -9,10 +9,7 @@ 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";
-
-function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
-  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
-}
+import * as IndexingAddresses from "./IndexingAddresses.res.mjs";
 
 let deriveContractNameByAddress = Utils.$$WeakMap.memoize(addressesByContractName => {
   let result = {};
@@ -464,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) {
@@ -473,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;
@@ -506,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;
@@ -549,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,
@@ -563,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;
 }
 
@@ -747,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 = {};
@@ -769,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);
@@ -807,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);
@@ -849,101 +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,
-                  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,
-                  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,
+                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) {
@@ -1048,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;
@@ -1265,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;
@@ -1277,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);
@@ -1330,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);
@@ -1372,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,
@@ -1383,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);
@@ -1398,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) {
@@ -1443,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 = {};
@@ -1463,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 {
@@ -1475,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;
@@ -1526,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),
@@ -1536,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;
@@ -1577,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,
@@ -1707,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;
   }
@@ -1720,7 +1663,6 @@ let blockItemLogIndex = 16777216;
 let maxPendingChunksPerPartition = 10;
 
 export {
-  deriveEffectiveStartBlock,
   deriveContractNameByAddress,
   defaultEstResponseSize,
   calculateEstResponseSize,
@@ -1729,9 +1671,9 @@ export {
   OptimizedPartitions,
   bufferBlockNumber,
   bufferBlock,
+  bufferReadyCount,
   compareBufferItem,
   blockItemLogIndex,
-  numAddresses,
   appendOnBlockItems,
   updateInternal,
   warnDifferentContractType,
@@ -1748,7 +1690,6 @@ export {
   getReadyItemsCount,
   make$1 as make,
   bufferSize,
-  bufferReadyCount,
   rollbackPendingQueries,
   rollback,
   resetPendingQueries,

package/src/IndexingAddresses.res

@@ -0,0 +1,105 @@
+type indexingAddress = Internal.indexingContract
+
+type contractConfig = {startBlock: option<int>}
+
+type t = dict<indexingAddress>
+
+let deriveEffectiveStartBlock = (~registrationBlock: int, ~contractStartBlock: option<int>) => {
+  Pervasives.max(Pervasives.max(registrationBlock, 0), contractStartBlock->Option.getOr(0))
+}
+
+let makeContractConfigs = (~eventConfigs: array<Internal.eventConfig>): dict<contractConfig> => {
+  let contractConfigs: dict<contractConfig> = Dict.make()
+  eventConfigs->Array.forEach(ec => {
+    switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(ec.contractName) {
+    | Some({startBlock}) =>
+      contractConfigs->Dict.set(
+        ec.contractName,
+        {
+          startBlock: switch (startBlock, ec.startBlock) {
+          | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
+          | (Some(_) as s, None) | (None, Some(_) as s) => s
+          | (None, None) => None
+          },
+        },
+      )
+    | None =>
+      contractConfigs->Dict.set(
+        ec.contractName,
+        {
+          startBlock: ec.startBlock,
+        },
+      )
+    }
+  })
+  contractConfigs
+}
+
+let makeIndexingAddress = (
+  ~contract: Internal.indexingAddress,
+  ~contractConfigs: dict<contractConfig>,
+): indexingAddress => {
+  let contractStartBlock = switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(
+    contract.contractName,
+  ) {
+  | Some({startBlock}) => startBlock
+  | None => None
+  }
+  {
+    address: contract.address,
+    contractName: contract.contractName,
+    registrationBlock: contract.registrationBlock,
+    effectiveStartBlock: deriveEffectiveStartBlock(
+      ~registrationBlock=contract.registrationBlock,
+      ~contractStartBlock,
+    ),
+  }
+}
+
+let make = (
+  ~contractConfigs: dict<contractConfig>,
+  ~addresses: array<Internal.indexingAddress>,
+): t => {
+  let indexingAddresses = Dict.make()
+  addresses->Array.forEach(contract => {
+    indexingAddresses->Dict.set(
+      contract.address->Address.toString,
+      makeIndexingAddress(~contract, ~contractConfigs),
+    )
+  })
+  indexingAddresses
+}
+
+let get = (indexingAddresses: t, address) =>
+  indexingAddresses->Utils.Dict.dangerouslyGetNonOption(address)
+
+let size = (indexingAddresses: t) => indexingAddresses->Utils.Dict.size
+
+let getContractAddresses = (indexingAddresses: t, ~contractName): array<Address.t> => {
+  let addresses = []
+  indexingAddresses->Utils.Dict.forEach(ia => {
+    if ia.contractName === contractName {
+      addresses->Array.push(ia.address)
+    }
+  })
+  addresses
+}
+
+// Underlying dict for the precompiled `clientAddressFilter` only — it does raw
+// `indexingAddresses[srcAddress]` access in generated JS and can't take the opaque
+// type. Don't reach for this elsewhere; use the domain accessors above.
+let rawForFilter = (indexingAddresses: t): dict<indexingAddress> => indexingAddresses
+
+let register = (indexingAddresses: t, additions: dict<indexingAddress>) => {
+  let _ = Utils.Dict.mergeInPlace(indexingAddresses, additions)
+}
+
+let rollbackInPlace = (indexingAddresses: t, ~targetBlockNumber: int): unit => {
+  // forEachWithKey is a `for..in`, so deleting the key currently being visited is
+  // safe — it doesn't affect enumeration of the remaining keys.
+  indexingAddresses->Utils.Dict.forEachWithKey((indexingContract, address) => {
+    if indexingContract.registrationBlock > targetBlockNumber {
+      indexingAddresses->Utils.Dict.deleteInPlace(address)
+    }
+  })
+}