envio 3.1.2 → 3.2.1

package/src/FetchState.res.mjs

@@ -3,7 +3,6 @@
 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 Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
@@ -271,7 +270,7 @@ function make(partitions, maxAddrInPartition, nextPartitionIndex, dynamicContrac
   }
   newPartitions.sort(ascSortFn);
   let partitionsCount = newPartitions.length;
-  let idsInAscOrder = new Array(partitionsCount);
+  let idsInAscOrder = Array(partitionsCount);
   let entities = {};
   for (let idx$2 = 0; idx$2 < partitionsCount; ++idx$2) {
     let p$1 = newPartitions[idx$2];
@@ -489,7 +488,9 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt
   let latestOnBlockBlockNumber;
   if (onBlockConfigs.length !== 0) {
     let mutItems$1 = mutItemsRef;
-    let item = Belt_Array.get(mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer, fetchState.targetBufferSize - 1 | 0);
+    let item = (
+        mutItems$1 !== undefined ? mutItems$1 : fetchState.buffer
+      )[fetchState.targetBufferSize - 1 | 0];
     let maxBlockNumber;
     if (item !== undefined) {
       maxBlockNumber = item.blockNumber;
@@ -570,7 +571,7 @@ function addressesByContractNameGetAll(addressesByContractName) {
   return all;
 }
 
-function createPartitionsFromIndexingAddresses(registeringContractsByContract, contractConfigs, dynamicContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber) {
+function createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, normalSelection, maxAddrInPartition, nextPartitionIndex, existingPartitions, progressBlockNumber) {
   let nextPartitionIndexRef = nextPartitionIndex;
   let dynamicPartitions = [];
   let nonDynamicPartitions = [];
@@ -579,7 +580,6 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, c
     let contractName = contractNames[cIdx];
     let registeringContracts = registeringContractsByContract[contractName];
     let addresses = Object.keys(registeringContracts);
-    let contractConfig = contractConfigs[contractName];
     let isDynamic = dynamicContracts.has(contractName);
     let partitions = isDynamic ? dynamicPartitions : nonDynamicPartitions;
     let byStartBlock = {};
@@ -595,9 +595,7 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, c
     for (let idx = 0, idx_finish = ascKeys.length; idx < idx_finish; ++idx) {
       let maybeNextStartBlockKey = ascKeys[idx + 1 | 0];
       let shouldAllocateNewPartition;
-      if (contractConfig.filterByAddresses || maybeNextStartBlockKey === undefined) {
-        shouldAllocateNewPartition = true;
-      } else {
+      if (maybeNextStartBlockKey !== undefined) {
         let nextStartBlock = Stdlib_Int.fromString(maybeNextStartBlockKey, undefined);
         let shouldJoinCurrentStartBlock = (nextStartBlock - startBlockRef | 0) < 20000;
         if (shouldJoinCurrentStartBlock) {
@@ -606,6 +604,8 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, c
         } else {
           shouldAllocateNewPartition = true;
         }
+      } else {
+        shouldAllocateNewPartition = true;
       }
       if (shouldAllocateNewPartition) {
         let latestFetchedBlock_blockNumber = Primitive_int.max(startBlockRef - 1 | 0, progressBlockNumber);
@@ -666,10 +666,8 @@ function createPartitionsFromIndexingAddresses(registeringContractsByContract, c
             mergedAddresses[cn] = currentAddrs;
           }
         }
-        let nextContractName = Utils.$$Array.firstUnsafe(Object.keys(nextP.addressesByContractName));
-        let hasFilterByAddresses = contractConfigs[nextContractName].filterByAddresses;
         let isTooFar = (currentPBlock + 20000 | 0) < nextPBlock;
-        if (isTooFar || hasFilterByAddresses) {
+        if (isTooFar) {
           mergedNonDynamic.push({
             id: currentP.id,
             latestFetchedBlock: currentP.latestFetchedBlock,
@@ -724,8 +722,8 @@ function registerDynamicContracts(fetchState, items) {
   let indexingAddresses = fetchState.indexingAddresses;
   let registeringContractsByContract = {};
   let earliestRegisteringEventBlockNumber = Infinity;
-  let hasDCWithFilterByAddresses = false;
   let noEventsAddresses = {};
+  let registeringAddresses = {};
   for (let itemIdx = 0, itemIdx_finish = items.length; itemIdx < itemIdx_finish; ++itemIdx) {
     let item = items[itemIdx];
     let dcs = item.dcs;
@@ -761,23 +759,14 @@ function registerDynamicContracts(fetchState, items) {
             }
             shouldRemove = true;
           } else {
-            let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, dc.contractName);
-            let registeringContract = registeringContracts[dc.address];
-            let shouldUpdate;
-            if (registeringContract !== undefined) {
-              if (registeringContract.contractName !== dc.contractName) {
-                warnDifferentContractType(fetchState, registeringContract, dcWithStartBlock);
-                shouldUpdate = false;
-              } else {
-                shouldUpdate = false;
-              }
-            } else {
-              hasDCWithFilterByAddresses = hasDCWithFilterByAddresses || match.filterByAddresses;
-              shouldUpdate = true;
-            }
+            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);
-              registeringContracts[dc.address] = dcWithStartBlock;
+              Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, dc.contractName)[dc.address] = dcWithStartBlock;
+              registeringAddresses[dc.address] = dcWithStartBlock;
             } else {
               shouldRemove = true;
             }
@@ -800,8 +789,11 @@ function registerDynamicContracts(fetchState, items) {
             }
             shouldRemove = true;
           } else {
-            let match$1 = noEventsAddresses[dc.address];
-            if (match$1 !== undefined) {
+            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({
@@ -811,6 +803,7 @@ function registerDynamicContracts(fetchState, items) {
               });
               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;
             }
           }
         }
@@ -888,11 +881,11 @@ function registerDynamicContracts(fetchState, items) {
           }
         }
       }
-      let registeringContracts$1 = registeringContractsByContract[contractName];
-      Object.assign(newIndexingAddresses, registeringContracts$1);
+      let registeringContracts = registeringContractsByContract[contractName];
+      Object.assign(newIndexingAddresses, registeringContracts);
     }
     Object.assign(newIndexingAddresses, noEventsAddresses);
-    let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, dynamicContractsRef, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, fetchState.optimizedPartitions.nextPartitionIndex + newPartitions.length | 0, mutExistingPartitions.concat(newPartitions), 0);
+    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) {
@@ -904,7 +897,18 @@ function registerDynamicContracts(fetchState, items) {
 }
 
 function handleQueryResult(fetchState, query, latestFetchedBlock, newItems) {
-  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, latestFetchedBlock), undefined, newItems.length !== 0 ? fetchState.buffer.concat(newItems) : undefined, undefined, undefined);
+  let newItems$1 = newItems.filter(item => {
+    if (item.kind !== 0) {
+      return true;
+    }
+    let filter = item.eventConfig.clientAddressFilter;
+    if (filter !== undefined) {
+      return filter(item.event, item.blockNumber, fetchState.indexingAddresses);
+    } else {
+      return true;
+    }
+  });
+  return updateInternal(fetchState, handleQueryResponse(fetchState.optimizedPartitions, query, fetchState.knownHeight, latestFetchedBlock), undefined, newItems$1.length !== 0 ? fetchState.buffer.concat(newItems$1) : undefined, undefined, undefined);
 }
 
 function startFetchingQueries(param, queries) {
@@ -1179,7 +1183,7 @@ function getNextQuery(fetchState, concurrencyLimit) {
 }
 
 function hasReadyItem(fetchState) {
-  let item = Belt_Array.get(fetchState.buffer, 0);
+  let item = fetchState.buffer[0];
   if (item !== undefined) {
     return item.blockNumber <= bufferBlockNumber(fetchState);
   } else {
@@ -1192,7 +1196,7 @@ function getReadyItemsCount(fetchState, targetSize, fromItem) {
   let acc = 0;
   let isFinished = false;
   while (!isFinished) {
-    let item = Belt_Array.get(fetchState.buffer, fromItem + acc | 0);
+    let item = fetchState.buffer[fromItem + acc | 0];
     if (item !== undefined) {
       let itemBlockNumber = item.blockNumber;
       if (itemBlockNumber <= readyBlockNumber) {
@@ -1230,7 +1234,6 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
       let startBlock = match.startBlock;
       let match$1 = ec.startBlock;
       contractConfigs[ec.contractName] = {
-        filterByAddresses: match.filterByAddresses || ec.filterByAddresses,
         startBlock: startBlock !== undefined ? (
             match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
           ) : (
@@ -1239,7 +1242,6 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
       };
     } else {
       contractConfigs[ec.contractName] = {
-        filterByAddresses: ec.filterByAddresses,
         startBlock: ec.startBlock
       };
     }
@@ -1299,7 +1301,7 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
       return;
     }
   });
-  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, contractConfigs, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
+  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, dynamicContracts, normalSelection, maxAddrInPartition, partitions.length, partitions, progressBlockNumber);
   if (optimizedPartitions.idsInAscOrder.length === 0 && Utils.$$Array.isEmpty(onBlockConfigs)) {
     Stdlib_JsError.throwWithMessage(`Invalid configuration: Nothing to fetch on chain ` + chainId.toString() + `. ` + (`addresses=` + addresses.length.toString() + `, `) + (`eventConfigs=` + eventConfigs.length.toString() + `, `) + (`normalEventConfigs=` + normalEventConfigs.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.`);
   }
@@ -1447,7 +1449,7 @@ function rollback(fetchState, targetBlockNumber) {
       });
     }
   }
-  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.contractConfigs, fetchState.optimizedPartitions.dynamicContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber);
+  let optimizedPartitions = createPartitionsFromIndexingAddresses(registeringContractsByContract, fetchState.optimizedPartitions.dynamicContracts, fetchState.normalSelection, fetchState.optimizedPartitions.maxAddrInPartition, nextKeptIdRef, keptPartitions, targetBlockNumber);
   return updateInternal({
     optimizedPartitions: fetchState.optimizedPartitions,
     startBlock: fetchState.startBlock,
@@ -1544,7 +1546,7 @@ function isReadyToEnterReorgThreshold(fetchState) {
 }
 
 function hasFullBatch(fetchState, batchSizeTarget) {
-  let item = Belt_Array.get(fetchState.buffer, batchSizeTarget - 1 | 0);
+  let item = fetchState.buffer[batchSizeTarget - 1 | 0];
   if (item !== undefined) {
     return item.blockNumber <= bufferBlockNumber(fetchState);
   } else {
@@ -1561,7 +1563,7 @@ function getProgressPercentage(fetchState) {
   if (totalRange <= 0) {
     return 0;
   }
-  let item = Belt_Array.get(fetchState.buffer, 0);
+  let item = fetchState.buffer[0];
   let progress = item !== undefined ? item.blockNumber - firstEventBlock | 0 : bufferBlockNumber(fetchState) - firstEventBlock | 0;
   return progress / totalRange;
 }
@@ -1593,7 +1595,7 @@ function sortForUnorderedBatch(fetchStates, batchSizeTarget) {
 
 function getProgressBlockNumberAt(fetchState, index) {
   let bufferBlockNumber$1 = bufferBlockNumber(fetchState);
-  let item = Belt_Array.get(fetchState.buffer, index);
+  let item = fetchState.buffer[index];
   if (item !== undefined && bufferBlockNumber$1 >= item.blockNumber) {
     return item.blockNumber - 1 | 0;
   } else {