envio 3.0.2-svm-alpha.1 → 3.0.2-svm-alpha.2

package/README.md

@@ -70,7 +70,6 @@ A few things already running in production:
 **Multichain indexing**
 - Index EVM, SVM, and Fuel blockchains from a single indexer
 - 70+ EVM chains with native HyperSync support, plus any EVM chain via RPC
-- Unordered multichain mode for maximum throughput across chains
 - Real-time indexing with reorg handling built in
 
 **Developer experience**

package/evm.schema.json

@@ -356,6 +356,13 @@
           "format": "uint64",
           "minimum": 0
         },
+        "skip": {
+          "description": "Excludes the chain from indexing and migrations. Code generation is unaffected. For testing, prefer using a test framework instead.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
         "rpc": {
           "description": "RPC configuration for your indexer. If not specified otherwise, for chains supported by HyperSync, RPC serves as a fallback for added reliability. For others, it acts as the primary data-source. HyperSync offers significant performance improvements, up to a 1000x faster than traditional RPC.",
           "anyOf": [

package/fuel.schema.json

@@ -230,6 +230,13 @@
           "format": "uint64",
           "minimum": 0
         },
+        "skip": {
+          "description": "Excludes the chain from indexing and migrations. Code generation is unaffected. For testing, prefer using a test framework instead.",
+          "type": [
+            "boolean",
+            "null"
+          ]
+        },
         "start_block": {
           "description": "The block at which the indexer should start ingesting data",
           "type": "integer",

package/index.d.ts

@@ -299,8 +299,6 @@ type IndexerConfig = {
   description?: string;
   /** Path to handlers directory for auto-loading (default: "src/handlers"). */
   handlers?: string;
-  /** Multichain mode: ordered or unordered (default: "unordered"). */
-  multichain?: "ordered" | "unordered";
   /** Target batch size for event processing (default: 5000). */
   fullBatchSize?: number;
   /** Whether to rollback on chain reorg (default: true). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.0.2-svm-alpha.1",
+  "version": "3.0.2-svm-alpha.2",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -70,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.0.2-svm-alpha.1",
-    "envio-linux-x64-musl": "3.0.2-svm-alpha.1",
-    "envio-linux-arm64": "3.0.2-svm-alpha.1",
-    "envio-darwin-x64": "3.0.2-svm-alpha.1",
-    "envio-darwin-arm64": "3.0.2-svm-alpha.1"
+    "envio-linux-x64": "3.0.2-svm-alpha.2",
+    "envio-linux-x64-musl": "3.0.2-svm-alpha.2",
+    "envio-linux-arm64": "3.0.2-svm-alpha.2",
+    "envio-darwin-x64": "3.0.2-svm-alpha.2",
+    "envio-darwin-arm64": "3.0.2-svm-alpha.2"
   }
 }

package/src/Batch.res

@@ -31,50 +31,7 @@ type t = {
   checkpointEventsProcessed: array<int>,
 }
 
-/**
- It either returnes an earliest item among all chains, or None if no chains are actively indexing
- */
-let getOrderedNextChain = (fetchStates: ChainMap.t<FetchState.t>, ~batchSizePerChain) => {
-  let earliestChain: ref<option<FetchState.t>> = ref(None)
-  let earliestChainTimestamp = ref(0)
-  let chainKeys = fetchStates->ChainMap.keys
-  for idx in 0 to chainKeys->Array.length - 1 {
-    let chain = chainKeys->Array.getUnsafe(idx)
-    let fetchState = fetchStates->ChainMap.get(chain)
-    if fetchState->FetchState.isActivelyIndexing {
-      let timestamp = fetchState->FetchState.getTimestampAt(
-        ~index=switch batchSizePerChain->Utils.Dict.dangerouslyGetByIntNonOption(
-          chain->ChainMap.Chain.toChainId,
-        ) {
-        | Some(batchSize) => batchSize
-        | None => 0
-        },
-      )
-      switch earliestChain.contents {
-      | Some(earliestChain)
-        if timestamp > earliestChainTimestamp.contents ||
-          (timestamp === earliestChainTimestamp.contents &&
-            chain->ChainMap.Chain.toChainId > earliestChain.chainId) => ()
-      | _ => {
-          earliestChain := Some(fetchState)
-          earliestChainTimestamp := timestamp
-        }
-      }
-    }
-  }
-  earliestChain.contents
-}
-
-// Save overhead of recreating the dict every time
-let immutableEmptyBatchSizePerChain: dict<int> = Dict.make()
-let hasOrderedReadyItem = (fetchStates: ChainMap.t<FetchState.t>) => {
-  switch fetchStates->getOrderedNextChain(~batchSizePerChain=immutableEmptyBatchSizePerChain) {
-  | Some(fetchState) => fetchState->FetchState.hasReadyItem
-  | None => false
-  }
-}
-
-let hasUnorderedReadyItem = (fetchStates: ChainMap.t<FetchState.t>) => {
+let hasReadyItem = (fetchStates: ChainMap.t<FetchState.t>) => {
   fetchStates
   ->ChainMap.values
   ->Array.some(fetchState => {
@@ -82,16 +39,6 @@ let hasUnorderedReadyItem = (fetchStates: ChainMap.t<FetchState.t>) => {
   })
 }
 
-let hasMultichainReadyItem = (
-  fetchStates: ChainMap.t<FetchState.t>,
-  ~multichain: Config.multichain,
-) => {
-  switch multichain {
-  | Ordered => hasOrderedReadyItem(fetchStates)
-  | Unordered => hasUnorderedReadyItem(fetchStates)
-  }
-}
-
 let getProgressedChainsById = {
   let getChainAfterBatchIfProgressed = (
     ~chainBeforeBatch: chainBeforeBatch,
@@ -214,154 +161,7 @@ let addReorgCheckpoints = (
   }
 }
 
-let prepareOrderedBatch = (
-  ~checkpointIdBeforeBatch,
-  ~chainsBeforeBatch: ChainMap.t<chainBeforeBatch>,
-  ~batchSizeTarget,
-) => {
-  let totalBatchSize = ref(0)
-  let isFinished = ref(false)
-  let prevCheckpointId = ref(checkpointIdBeforeBatch)
-  let mutBatchSizePerChain = Dict.make()
-  let mutProgressBlockNumberPerChain = Dict.make()
-
-  let fetchStates = chainsBeforeBatch->ChainMap.map(chainBeforeBatch => chainBeforeBatch.fetchState)
-
-  let items = []
-  let checkpointIds = []
-  let checkpointChainIds = []
-  let checkpointBlockNumbers = []
-  let checkpointBlockHashes = []
-  let checkpointEventsProcessed = []
-
-  while totalBatchSize.contents < batchSizeTarget && !isFinished.contents {
-    switch fetchStates->getOrderedNextChain(~batchSizePerChain=mutBatchSizePerChain) {
-    | Some(fetchState) => {
-        let chainBeforeBatch =
-          chainsBeforeBatch->ChainMap.get(ChainMap.Chain.makeUnsafe(~chainId=fetchState.chainId))
-        let itemsCountBefore = switch mutBatchSizePerChain->Utils.Dict.dangerouslyGetByIntNonOption(
-          fetchState.chainId,
-        ) {
-        | Some(batchSize) => batchSize
-        | None => 0
-        }
-
-        let prevBlockNumber = switch mutProgressBlockNumberPerChain->Utils.Dict.dangerouslyGetByIntNonOption(
-          fetchState.chainId,
-        ) {
-        | Some(progressBlockNumber) => progressBlockNumber
-        | None => chainBeforeBatch.progressBlockNumber
-        }
-
-        let newItemsCount = fetchState->FetchState.getReadyItemsCount(
-          // We should get items only for a single block
-          // Since for the ordered mode next block could be after another chain's block
-          ~targetSize=1,
-          ~fromItem=itemsCountBefore,
-        )
-
-        if newItemsCount > 0 {
-          let item0 = fetchState.buffer->Array.getUnsafe(itemsCountBefore)
-          let blockNumber = item0->Internal.getItemBlockNumber
-
-          prevCheckpointId :=
-            addReorgCheckpoints(
-              ~chainId=fetchState.chainId,
-              ~reorgDetection=chainBeforeBatch.reorgDetection,
-              ~prevCheckpointId=prevCheckpointId.contents,
-              ~fromBlockExclusive=prevBlockNumber,
-              ~toBlockExclusive=blockNumber,
-              ~mutCheckpointIds=checkpointIds,
-              ~mutCheckpointChainIds=checkpointChainIds,
-              ~mutCheckpointBlockNumbers=checkpointBlockNumbers,
-              ~mutCheckpointBlockHashes=checkpointBlockHashes,
-              ~mutCheckpointEventsProcessed=checkpointEventsProcessed,
-            )
-
-          let checkpointId = prevCheckpointId.contents->BigInt.add(1n)
-
-          items
-          ->Array.push(item0)
-          ->ignore
-          for idx in 1 to newItemsCount - 1 {
-            items
-            ->Array.push(fetchState.buffer->Belt.Array.getUnsafe(itemsCountBefore + idx))
-            ->ignore
-          }
-
-          checkpointIds
-          ->Array.push(checkpointId)
-          ->ignore
-          checkpointChainIds
-          ->Array.push(fetchState.chainId)
-          ->ignore
-          checkpointBlockNumbers
-          ->Array.push(blockNumber)
-          ->ignore
-          checkpointBlockHashes
-          ->Array.push(
-            chainBeforeBatch.reorgDetection->ReorgDetection.getHashByBlockNumber(~blockNumber),
-          )
-          ->ignore
-          checkpointEventsProcessed
-          ->Array.push(newItemsCount)
-          ->ignore
-
-          prevCheckpointId := checkpointId
-          totalBatchSize := totalBatchSize.contents + newItemsCount
-          mutBatchSizePerChain->Utils.Dict.setByInt(
-            fetchState.chainId,
-            itemsCountBefore + newItemsCount,
-          )
-          mutProgressBlockNumberPerChain->Utils.Dict.setByInt(fetchState.chainId, blockNumber)
-        } else {
-          let blockNumberAfterBatch = fetchState->FetchState.bufferBlockNumber
-
-          prevCheckpointId :=
-            addReorgCheckpoints(
-              ~chainId=fetchState.chainId,
-              ~reorgDetection=chainBeforeBatch.reorgDetection,
-              ~prevCheckpointId=prevCheckpointId.contents,
-              ~fromBlockExclusive=prevBlockNumber,
-              ~toBlockExclusive=blockNumberAfterBatch + 1, // Make it inclusive
-              ~mutCheckpointIds=checkpointIds,
-              ~mutCheckpointChainIds=checkpointChainIds,
-              ~mutCheckpointBlockNumbers=checkpointBlockNumbers,
-              ~mutCheckpointBlockHashes=checkpointBlockHashes,
-              ~mutCheckpointEventsProcessed=checkpointEventsProcessed,
-            )
-
-          // Since the chain was chosen as next
-          // the fact that it doesn't have new items means that it reached the buffer block number
-          mutProgressBlockNumberPerChain->Utils.Dict.setByInt(
-            fetchState.chainId,
-            blockNumberAfterBatch,
-          )
-          isFinished := true
-        }
-      }
-
-    | None => isFinished := true
-    }
-  }
-
-  {
-    totalBatchSize: totalBatchSize.contents,
-    items,
-    progressedChainsById: getProgressedChainsById(
-      ~chainsBeforeBatch,
-      ~batchSizePerChain=mutBatchSizePerChain,
-      ~progressBlockNumberPerChain=mutProgressBlockNumberPerChain,
-    ),
-    checkpointIds,
-    checkpointChainIds,
-    checkpointBlockNumbers,
-    checkpointBlockHashes,
-    checkpointEventsProcessed,
-  }
-}
-
-let prepareUnorderedBatch = (
+let prepareBatch = (
   ~checkpointIdBeforeBatch,
   ~chainsBeforeBatch: ChainMap.t<chainBeforeBatch>,
   ~batchSizeTarget,
@@ -454,7 +254,7 @@ let prepareUnorderedBatch = (
     }
 
     let progressBlockNumberAfterBatch =
-      fetchState->FetchState.getUnorderedMultichainProgressBlockNumberAt(~index=chainBatchSize)
+      fetchState->FetchState.getProgressBlockNumberAt(~index=chainBatchSize)
 
     prevCheckpointId :=
       addReorgCheckpoints(
@@ -497,19 +297,9 @@ let prepareUnorderedBatch = (
 let make = (
   ~checkpointIdBeforeBatch,
   ~chainsBeforeBatch: ChainMap.t<chainBeforeBatch>,
-  ~multichain: Config.multichain,
   ~batchSizeTarget,
 ) => {
-  if (
-    switch multichain {
-    | Unordered => true
-    | Ordered => chainsBeforeBatch->ChainMap.size === 1
-    }
-  ) {
-    prepareUnorderedBatch(~checkpointIdBeforeBatch, ~chainsBeforeBatch, ~batchSizeTarget)
-  } else {
-    prepareOrderedBatch(~checkpointIdBeforeBatch, ~chainsBeforeBatch, ~batchSizeTarget)
-  }
+  prepareBatch(~checkpointIdBeforeBatch, ~chainsBeforeBatch, ~batchSizeTarget)
 }
 
 let findFirstEventBlockNumber = (batch: t, ~chainId) => {

package/src/Batch.res.mjs

@@ -5,38 +5,7 @@ import * as ChainMap from "./ChainMap.res.mjs";
 import * as FetchState from "./FetchState.res.mjs";
 import * as ReorgDetection from "./ReorgDetection.res.mjs";
 
-function getOrderedNextChain(fetchStates, batchSizePerChain) {
-  let earliestChain;
-  let earliestChainTimestamp = 0;
-  let chainKeys = ChainMap.keys(fetchStates);
-  for (let idx = 0, idx_finish = chainKeys.length - 1; idx <= idx_finish; ++idx) {
-    let chain = chainKeys[idx];
-    let fetchState = ChainMap.get(fetchStates, chain);
-    if (FetchState.isActivelyIndexing(fetchState)) {
-      let batchSize = batchSizePerChain[chain];
-      let timestamp = FetchState.getTimestampAt(fetchState, batchSize !== undefined ? batchSize : 0);
-      let earliestChain$1 = earliestChain;
-      if (!(earliestChain$1 !== undefined && (timestamp > earliestChainTimestamp || timestamp === earliestChainTimestamp && chain > earliestChain$1.chainId))) {
-        earliestChain = fetchState;
-        earliestChainTimestamp = timestamp;
-      }
-    }
-  }
-  return earliestChain;
-}
-
-let immutableEmptyBatchSizePerChain = {};
-
-function hasOrderedReadyItem(fetchStates) {
-  let fetchState = getOrderedNextChain(fetchStates, immutableEmptyBatchSizePerChain);
-  if (fetchState !== undefined) {
-    return FetchState.hasReadyItem(fetchState);
-  } else {
-    return false;
-  }
-}
-
-function hasUnorderedReadyItem(fetchStates) {
+function hasReadyItem(fetchStates) {
   return ChainMap.values(fetchStates).some(fetchState => {
     if (FetchState.isActivelyIndexing(fetchState)) {
       return FetchState.hasReadyItem(fetchState);
@@ -46,14 +15,6 @@ function hasUnorderedReadyItem(fetchStates) {
   });
 }
 
-function hasMultichainReadyItem(fetchStates, multichain) {
-  if (multichain === "ordered") {
-    return hasOrderedReadyItem(fetchStates);
-  } else {
-    return hasUnorderedReadyItem(fetchStates);
-  }
-}
-
 function getChainAfterBatchIfProgressed(chainBeforeBatch, progressBlockNumberAfterBatch, fetchStateAfterBatch, batchSize) {
   if (chainBeforeBatch.progressBlockNumber < progressBlockNumberAfterBatch) {
     return {
@@ -109,114 +70,7 @@ function addReorgCheckpoints(prevCheckpointId, reorgDetection, fromBlockExclusiv
   return prevCheckpointId$1;
 }
 
-function prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget) {
-  let totalBatchSize = 0;
-  let isFinished = false;
-  let prevCheckpointId = checkpointIdBeforeBatch;
-  let mutBatchSizePerChain = {};
-  let mutProgressBlockNumberPerChain = {};
-  let fetchStates = ChainMap.map(chainsBeforeBatch, chainBeforeBatch => chainBeforeBatch.fetchState);
-  let items = [];
-  let checkpointIds = [];
-  let checkpointChainIds = [];
-  let checkpointBlockNumbers = [];
-  let checkpointBlockHashes = [];
-  let checkpointEventsProcessed = [];
-  while (totalBatchSize < batchSizeTarget && !isFinished) {
-    let fetchState = getOrderedNextChain(fetchStates, mutBatchSizePerChain);
-    if (fetchState !== undefined) {
-      let chainBeforeBatch = ChainMap.get(chainsBeforeBatch, ChainMap.Chain.makeUnsafe(fetchState.chainId));
-      let batchSize = mutBatchSizePerChain[fetchState.chainId];
-      let itemsCountBefore = batchSize !== undefined ? batchSize : 0;
-      let progressBlockNumber = mutProgressBlockNumberPerChain[fetchState.chainId];
-      let prevBlockNumber = progressBlockNumber !== undefined ? progressBlockNumber : chainBeforeBatch.progressBlockNumber;
-      let newItemsCount = FetchState.getReadyItemsCount(fetchState, 1, itemsCountBefore);
-      if (newItemsCount > 0) {
-        let item0 = fetchState.buffer[itemsCountBefore];
-        let blockNumber = item0.blockNumber;
-        let chainId = fetchState.chainId;
-        let reorgDetection = chainBeforeBatch.reorgDetection;
-        let prevCheckpointId$1 = prevCheckpointId;
-        let tmp;
-        if (reorgDetection.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection.dataByBlockNumber)) {
-          let prevCheckpointId$2 = prevCheckpointId$1;
-          for (let blockNumber$1 = prevBlockNumber + 1, blockNumber_finish = blockNumber - 1; blockNumber$1 <= blockNumber_finish; ++blockNumber$1) {
-            let hash = ReorgDetection.getHashByBlockNumber(reorgDetection, blockNumber$1);
-            if (hash !== null) {
-              let checkpointId = prevCheckpointId$2 + 1n;
-              prevCheckpointId$2 = checkpointId;
-              checkpointIds.push(checkpointId);
-              checkpointChainIds.push(chainId);
-              checkpointBlockNumbers.push(blockNumber$1);
-              checkpointBlockHashes.push(hash);
-              checkpointEventsProcessed.push(0);
-            }
-          }
-          tmp = prevCheckpointId$2;
-        } else {
-          tmp = prevCheckpointId$1;
-        }
-        prevCheckpointId = tmp;
-        let checkpointId$1 = prevCheckpointId + 1n;
-        items.push(item0);
-        for (let idx = 1, idx_finish = newItemsCount - 1; idx <= idx_finish; ++idx) {
-          items.push(fetchState.buffer[itemsCountBefore + idx]);
-        }
-        checkpointIds.push(checkpointId$1);
-        checkpointChainIds.push(fetchState.chainId);
-        checkpointBlockNumbers.push(blockNumber);
-        checkpointBlockHashes.push(ReorgDetection.getHashByBlockNumber(chainBeforeBatch.reorgDetection, blockNumber));
-        checkpointEventsProcessed.push(newItemsCount);
-        prevCheckpointId = checkpointId$1;
-        totalBatchSize = totalBatchSize + newItemsCount;
-        mutBatchSizePerChain[fetchState.chainId] = itemsCountBefore + newItemsCount;
-        mutProgressBlockNumberPerChain[fetchState.chainId] = blockNumber;
-      } else {
-        let blockNumberAfterBatch = FetchState.bufferBlockNumber(fetchState);
-        let chainId$1 = fetchState.chainId;
-        let toBlockExclusive = blockNumberAfterBatch + 1;
-        let reorgDetection$1 = chainBeforeBatch.reorgDetection;
-        let prevCheckpointId$3 = prevCheckpointId;
-        let tmp$1;
-        if (reorgDetection$1.shouldRollbackOnReorg && !Utils.Dict.isEmpty(reorgDetection$1.dataByBlockNumber)) {
-          let prevCheckpointId$4 = prevCheckpointId$3;
-          for (let blockNumber$2 = prevBlockNumber + 1, blockNumber_finish$1 = toBlockExclusive - 1; blockNumber$2 <= blockNumber_finish$1; ++blockNumber$2) {
-            let hash$1 = ReorgDetection.getHashByBlockNumber(reorgDetection$1, blockNumber$2);
-            if (hash$1 !== null) {
-              let checkpointId$2 = prevCheckpointId$4 + 1n;
-              prevCheckpointId$4 = checkpointId$2;
-              checkpointIds.push(checkpointId$2);
-              checkpointChainIds.push(chainId$1);
-              checkpointBlockNumbers.push(blockNumber$2);
-              checkpointBlockHashes.push(hash$1);
-              checkpointEventsProcessed.push(0);
-            }
-          }
-          tmp$1 = prevCheckpointId$4;
-        } else {
-          tmp$1 = prevCheckpointId$3;
-        }
-        prevCheckpointId = tmp$1;
-        mutProgressBlockNumberPerChain[fetchState.chainId] = blockNumberAfterBatch;
-        isFinished = true;
-      }
-    } else {
-      isFinished = true;
-    }
-  };
-  return {
-    totalBatchSize: totalBatchSize,
-    items: items,
-    progressedChainsById: getProgressedChainsById(chainsBeforeBatch, mutBatchSizePerChain, mutProgressBlockNumberPerChain),
-    checkpointIds: checkpointIds,
-    checkpointChainIds: checkpointChainIds,
-    checkpointBlockNumbers: checkpointBlockNumbers,
-    checkpointBlockHashes: checkpointBlockHashes,
-    checkpointEventsProcessed: checkpointEventsProcessed
-  };
-}
-
-function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget) {
+function prepareBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget) {
   let preparedFetchStates = FetchState.sortForUnorderedBatch(ChainMap.values(chainsBeforeBatch).map(chainBeforeBatch => chainBeforeBatch.fetchState), batchSizeTarget);
   let chainIdx = 0;
   let preparedNumber = preparedFetchStates.length;
@@ -281,7 +135,7 @@ function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batch
       totalBatchSize = totalBatchSize + chainBatchSize;
       mutBatchSizePerChain[fetchState.chainId] = chainBatchSize;
     }
-    let progressBlockNumberAfterBatch = FetchState.getUnorderedMultichainProgressBlockNumberAt(fetchState, chainBatchSize);
+    let progressBlockNumberAfterBatch = FetchState.getProgressBlockNumberAt(fetchState, chainBatchSize);
     let chainId$1 = fetchState.chainId;
     let toBlockExclusive = progressBlockNumberAfterBatch + 1;
     let fromBlockExclusive$1 = prevBlockNumber;
@@ -322,15 +176,7 @@ function prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batch
   };
 }
 
-function make(checkpointIdBeforeBatch, chainsBeforeBatch, multichain, batchSizeTarget) {
-  let tmp;
-  tmp = multichain === "ordered" ? ChainMap.size(chainsBeforeBatch) === 1 : true;
-  if (tmp) {
-    return prepareUnorderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget);
-  } else {
-    return prepareOrderedBatch(checkpointIdBeforeBatch, chainsBeforeBatch, batchSizeTarget);
-  }
-}
+let make = prepareBatch;
 
 function findFirstEventBlockNumber(batch, chainId) {
   let idx = 0;
@@ -362,15 +208,10 @@ function findLastEventItem(batch, chainId) {
 }
 
 export {
-  getOrderedNextChain,
-  immutableEmptyBatchSizePerChain,
-  hasOrderedReadyItem,
-  hasUnorderedReadyItem,
-  hasMultichainReadyItem,
+  hasReadyItem,
   getProgressedChainsById,
   addReorgCheckpoints,
-  prepareOrderedBatch,
-  prepareUnorderedBatch,
+  prepareBatch,
   make,
   findFirstEventBlockNumber,
   findLastEventItem,

package/src/ChainFetcher.res

@@ -51,6 +51,7 @@ let make = (
   ~reorgCheckpoints: array<Internal.reorgCheckpoint>,
   ~maxReorgDepth,
   ~knownHeight=0,
+  ~reducedPollingInterval=?,
 ): t => {
   // We don't need the router itself, but only validation logic,
   // since now event router is created for selection of events
@@ -210,10 +211,6 @@ let make = (
         Utils.magic: array<Internal.eventConfig> => array<Internal.evmEventConfig>
       ),
     })
-    // Collect all event signatures from contracts
-    let allEventSignatures =
-      chainConfig.contracts->Array.flatMap(contract => contract.eventSignatures)
-    // Convert rpcs to EvmChain.rpc format
     let evmRpcs: array<EvmChain.rpc> = rpcs->Array.map((rpc): EvmChain.rpc => {
       let syncConfig = rpc.syncConfig
       let ws = rpc.ws
@@ -228,7 +225,6 @@ let make = (
       ~chain,
       ~contracts=evmContracts,
       ~hyperSync=hypersync,
-      ~allEventSignatures,
       ~rpcs=evmRpcs,
       ~lowercaseAddresses,
     )
@@ -269,6 +265,7 @@ let make = (
       ~sources,
       ~maxPartitionConcurrency=Env.maxPartitionConcurrency,
       ~isRealtime,
+      ~reducedPollingInterval?,
     ),
     reorgDetection: ReorgDetection.make(
       ~chainReorgCheckpoints,
@@ -329,6 +326,7 @@ let makeFromDbState = (
   ~config,
   ~registrations,
   ~targetBufferSize,
+  ~reducedPollingInterval=?,
 ) => {
   let chainId = chainConfig.id
   let logger = Logging.createChild(~params={"chainId": chainId})
@@ -361,6 +359,7 @@ let makeFromDbState = (
     ~isInReorgThreshold,
     ~isRealtime,
     ~knownHeight=resumedChainState.sourceBlockNumber,
+    ~reducedPollingInterval?,
   )
 }
 

package/src/ChainFetcher.res.mjs

@@ -38,7 +38,7 @@ function configAddresses(chainConfig) {
   return addresses;
 }
 
-function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBlockOpt, progressBlockNumber, config, registrations, targetBufferSize, logger, timestampCaughtUpToHeadOrEndblock, numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, maxReorgDepth, knownHeightOpt) {
+function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBlockOpt, progressBlockNumber, config, registrations, targetBufferSize, logger, timestampCaughtUpToHeadOrEndblock, numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, maxReorgDepth, knownHeightOpt, reducedPollingInterval) {
   let firstEventBlock = firstEventBlockOpt !== undefined ? Primitive_option.valFromOption(firstEventBlockOpt) : undefined;
   let knownHeight = knownHeightOpt !== undefined ? knownHeightOpt : 0;
   let eventRouter = EventRouter.empty();
@@ -114,7 +114,6 @@ function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBl
         abi: contract.abi,
         events: contract.events
       }));
-      let allEventSignatures = chainConfig.contracts.flatMap(contract => contract.eventSignatures);
       let evmRpcs = sources.rpcs.map(rpc => {
         let syncConfig = rpc.syncConfig;
         let ws = rpc.ws;
@@ -125,7 +124,7 @@ function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBl
           ws: ws
         };
       });
-      sources$1 = EvmChain.makeSources(chain, evmContracts, sources.hypersync, allEventSignatures, evmRpcs, lowercaseAddresses);
+      sources$1 = EvmChain.makeSources(chain, evmContracts, sources.hypersync, evmRpcs, lowercaseAddresses);
       break;
     case "FuelSourceConfig" :
       sources$1 = [HyperFuelSource.make({
@@ -160,7 +159,7 @@ function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBl
   return {
     logger: logger,
     fetchState: fetchState,
-    sourceManager: SourceManager.make(sources$1, Env.maxPartitionConcurrency, isRealtime, undefined, undefined, undefined, undefined, undefined, undefined),
+    sourceManager: SourceManager.make(sources$1, Env.maxPartitionConcurrency, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined),
     chainConfig: chainConfig,
     isProgressAtHead: false,
     timestampCaughtUpToHeadOrEndblock: timestampCaughtUpToHeadOrEndblock,
@@ -175,17 +174,17 @@ function makeFromConfig(chainConfig, config, registrations, targetBufferSize, kn
   let logger = Logging.createChild({
     chainId: chainConfig.id
   });
-  return make(chainConfig, configAddresses(chainConfig), chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrations, targetBufferSize, logger, undefined, 0, false, false, [], chainConfig.maxReorgDepth, knownHeight);
+  return make(chainConfig, configAddresses(chainConfig), chainConfig.startBlock, chainConfig.endBlock, undefined, -1, config, registrations, targetBufferSize, logger, undefined, 0, false, false, [], chainConfig.maxReorgDepth, knownHeight, undefined);
 }
 
-function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrations, targetBufferSize) {
+function makeFromDbState(chainConfig, resumedChainState, reorgCheckpoints, isInReorgThreshold, isRealtime, config, registrations, targetBufferSize, reducedPollingInterval) {
   let chainId = chainConfig.id;
   let logger = Logging.createChild({
     chainId: chainId
   });
   Prometheus.ProgressEventsCount.set(resumedChainState.numEventsProcessed, chainId);
   let progressBlockNumber = resumedChainState.progressBlockNumber >= 0 ? resumedChainState.progressBlockNumber : resumedChainState.startBlock - 1 | 0;
-  return make(chainConfig, resumedChainState.indexingAddresses, resumedChainState.startBlock, resumedChainState.endBlock, Primitive_option.some(resumedChainState.firstEventBlockNumber), progressBlockNumber, config, registrations, targetBufferSize, logger, Env.updateSyncTimeOnRestart ? undefined : resumedChainState.timestampCaughtUpToHeadOrEndblock, resumedChainState.numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, resumedChainState.maxReorgDepth, resumedChainState.sourceBlockNumber);
+  return make(chainConfig, resumedChainState.indexingAddresses, resumedChainState.startBlock, resumedChainState.endBlock, Primitive_option.some(resumedChainState.firstEventBlockNumber), progressBlockNumber, config, registrations, targetBufferSize, logger, Env.updateSyncTimeOnRestart ? undefined : resumedChainState.timestampCaughtUpToHeadOrEndblock, resumedChainState.numEventsProcessed, isInReorgThreshold, isRealtime, reorgCheckpoints, resumedChainState.maxReorgDepth, resumedChainState.sourceBlockNumber, reducedPollingInterval);
 }
 
 async function runContractRegistersOrThrow(itemsWithContractRegister, config) {