envio 3.0.2 → 3.1.0-rc.1

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

@@ -4,6 +4,10 @@
   "description": "Schema for a YAML config for an envio indexer",
   "type": "object",
   "properties": {
+    "name": {
+      "description": "Name of the project",
+      "type": "string"
+    },
     "description": {
       "description": "Description of the project",
       "type": [
@@ -11,10 +15,6 @@
         "null"
       ]
     },
-    "name": {
-      "description": "Name of the project",
-      "type": "string"
-    },
     "schema": {
       "description": "Custom path to schema.graphql file",
       "type": [
@@ -67,7 +67,7 @@
         "null"
       ],
       "items": {
-        "$ref": "#/$defs/GlobalContract_for_ContractConfig"
+        "$ref": "#/$defs/GlobalContract"
       }
     },
     "chains": {
@@ -189,7 +189,7 @@
         "evm"
       ]
     },
-    "GlobalContract_for_ContractConfig": {
+    "GlobalContract": {
       "type": "object",
       "properties": {
         "name": {
@@ -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": [
@@ -418,7 +425,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/$defs/ChainContract_for_ContractConfig"
+            "$ref": "#/$defs/ChainContract"
           }
         }
       },
@@ -578,7 +585,7 @@
         "url"
       ]
     },
-    "ChainContract_for_ContractConfig": {
+    "ChainContract": {
       "type": "object",
       "properties": {
         "name": {

package/fuel.schema.json

@@ -4,6 +4,10 @@
   "description": "Schema for a YAML config for an envio indexer",
   "type": "object",
   "properties": {
+    "name": {
+      "description": "Name of the project",
+      "type": "string"
+    },
     "description": {
       "description": "Description of the project",
       "type": [
@@ -11,10 +15,6 @@
         "null"
       ]
     },
-    "name": {
-      "description": "Name of the project",
-      "type": "string"
-    },
     "schema": {
       "description": "Custom path to schema.graphql file",
       "type": [
@@ -60,7 +60,7 @@
         "null"
       ],
       "items": {
-        "$ref": "#/$defs/GlobalContract_for_ContractConfig"
+        "$ref": "#/$defs/GlobalContract"
       }
     },
     "chains": {
@@ -147,7 +147,7 @@
         "fuel"
       ]
     },
-    "GlobalContract_for_ContractConfig": {
+    "GlobalContract": {
       "type": "object",
       "properties": {
         "name": {
@@ -183,6 +183,10 @@
     "EventConfig": {
       "type": "object",
       "properties": {
+        "name": {
+          "description": "Name of the event in the HyperIndex generated code",
+          "type": "string"
+        },
         "type": {
           "description": "Explicitly set the event type you want to index. It's derived from the event name and fallbacks to LogData.",
           "anyOf": [
@@ -194,10 +198,6 @@
             }
           ]
         },
-        "name": {
-          "description": "Name of the event in the HyperIndex generated code",
-          "type": "string"
-        },
         "logId": {
           "description": "An identifier of a logged type from ABI. Used for indexing LogData receipts. The option can be omitted when the event name matches the logged struct/enum name.",
           "type": [
@@ -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",
@@ -281,7 +288,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/$defs/ChainContract_for_ContractConfig"
+            "$ref": "#/$defs/ChainContract"
           }
         }
       },
@@ -304,7 +311,7 @@
         "url"
       ]
     },
-    "ChainContract_for_ContractConfig": {
+    "ChainContract": {
       "type": "object",
       "properties": {
         "name": {

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",
+  "version": "3.1.0-rc.1",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -43,7 +43,6 @@
     "@clickhouse/client": "1.17.0",
     "@elastic/ecs-pino-format": "1.4.0",
     "@envio-dev/hyperfuel-client": "1.2.2",
-    "@envio-dev/hypersync-client": "1.3.0",
     "@fuel-ts/crypto": "0.96.1",
     "@fuel-ts/errors": "0.96.1",
     "@fuel-ts/hasher": "0.96.1",
@@ -71,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.0.2",
-    "envio-linux-x64-musl": "3.0.2",
-    "envio-linux-arm64": "3.0.2",
-    "envio-darwin-x64": "3.0.2",
-    "envio-darwin-arm64": "3.0.2"
+    "envio-linux-x64": "3.1.0-rc.1",
+    "envio-linux-x64-musl": "3.1.0-rc.1",
+    "envio-linux-arm64": "3.1.0-rc.1",
+    "envio-darwin-x64": "3.1.0-rc.1",
+    "envio-darwin-arm64": "3.1.0-rc.1"
   }
 }

package/rescript.json

@@ -18,6 +18,6 @@
   "dependencies": ["rescript-schema", "@rescript/react"],
   "compiler-flags": ["-open RescriptSchema"],
   "warnings": {
-    "error": "+3"
+    "error": "+a"
   }
 }

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,