envio 3.1.1 → 3.2.0

package/src/EventConfigBuilder.res.mjs

@@ -288,6 +288,37 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
   };
 }
 
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeTransaction, includeLogs, includeTokenBalances, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+  let accounts = accountsOpt !== undefined ? accountsOpt : [];
+  let args = argsOpt !== undefined ? argsOpt : null;
+  let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
+  let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
+  return {
+    id: discriminator !== undefined ? discriminator : "none",
+    name: instructionName,
+    contractName: contractName,
+    isWildcard: isWildcard,
+    filterByAddresses: false,
+    dependsOnAddresses: !isWildcard,
+    handler: handler,
+    contractRegister: contractRegister,
+    paramsRawEventSchema: paramsSchema,
+    simulateParamsSchema: paramsSchema,
+    startBlock: startBlock,
+    programId: programId,
+    discriminator: discriminator,
+    discriminatorByteLen: discriminatorByteLen,
+    includeTransaction: includeTransaction,
+    includeLogs: includeLogs,
+    includeTokenBalances: includeTokenBalances,
+    accountFilters: accountFilters,
+    isInner: isInner,
+    accounts: accounts,
+    args: args,
+    definedTypes: definedTypes
+  };
+}
+
 function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, isWildcard, handler, contractRegister, startBlock) {
   let fuelKind;
   switch (kind) {
@@ -363,6 +394,7 @@ export {
   alwaysIncludedBlockFields,
   resolveFieldSelection,
   buildEvmEventConfig,
+  buildSvmInstructionEventConfig,
   buildFuelEventConfig,
 }
 /* paramMetaSchema Not a pure module */

package/src/EventUtils.res

@@ -45,8 +45,8 @@ let packEventIndex = (~blockNumber, ~logIndex) => {
 //   let logIndexMask = 65535->BigInt.fromInt
 //   let logIndex = packedEventIndex->BigInt.bitwiseAnd(logIndexMask)
 //   {
-//     blockNumber: blockNumber->BigInt.toString->Belt.Int.fromString->Belt.Option.getUnsafe,
-//     logIndex: logIndex->BigInt.toString->Belt.Int.fromString->Belt.Option.getUnsafe,
+//     blockNumber: blockNumber->BigInt.toString->Int.fromString->Option.getUnsafe,
+//     logIndex: logIndex->BigInt.toString->Int.fromString->Option.getUnsafe,
 //   }
 // }
 

package/src/FetchState.res

@@ -336,7 +336,7 @@ module OptimizedPartitions = {
     let _ = newPartitions->Array.sort(ascSortFn)
 
     let partitionsCount = newPartitions->Array.length
-    let idsInAscOrder = Belt.Array.makeUninitializedUnsafe(partitionsCount)
+    let idsInAscOrder = Utils.Array.jsArrayCreate(partitionsCount)
     let entities = Dict.make()
     for idx in 0 to partitionsCount - 1 {
       let p = newPartitions->Array.getUnsafe(idx)
@@ -555,6 +555,63 @@ let blockItemLogIndex = 16777216
 
 let numAddresses = fetchState => fetchState.indexingAddresses->Utils.Dict.size
 
+// Appends Block items produced by the onBlock handlers for every block in
+// (fromBlock, maxBlockNumber] into mutItems and returns the new
+// latestOnBlockBlockNumber pointer. targetBufferSize bounds how many items
+// are generated at once to prevent OOM.
+let appendOnBlockItems = (
+  ~mutItems: array<Internal.item>,
+  ~onBlockConfigs: array<Internal.onBlockConfig>,
+  ~indexerStartBlock,
+  ~fromBlock,
+  ~maxBlockNumber,
+  ~targetBufferSize,
+) => {
+  let newItemsCounter = ref(0)
+  let latestOnBlockBlockNumber = ref(fromBlock)
+
+  // Simply iterate over every block
+  // could have a better algorithm to iterate over blocks in a more efficient way
+  // but raw loops are fast enough
+  while (
+    latestOnBlockBlockNumber.contents < maxBlockNumber &&
+      // Additional safeguard to prevent OOM
+      newItemsCounter.contents <= targetBufferSize
+  ) {
+    let blockNumber = latestOnBlockBlockNumber.contents + 1
+    latestOnBlockBlockNumber := blockNumber
+
+    for configIdx in 0 to onBlockConfigs->Array.length - 1 {
+      let onBlockConfig = onBlockConfigs->Array.getUnsafe(configIdx)
+
+      let handlerStartBlock = switch onBlockConfig.startBlock {
+      | Some(startBlock) => startBlock
+      | None => indexerStartBlock
+      }
+
+      if (
+        blockNumber >= handlerStartBlock &&
+        switch onBlockConfig.endBlock {
+        | Some(endBlock) => blockNumber <= endBlock
+        | None => true
+        } &&
+        (blockNumber - handlerStartBlock)->Pervasives.mod(onBlockConfig.interval) === 0
+      ) {
+        mutItems->Array.push(
+          Block({
+            onBlockConfig,
+            blockNumber,
+            logIndex: blockItemLogIndex + onBlockConfig.index,
+          }),
+        )
+        newItemsCounter := newItemsCounter.contents + 1
+      }
+    }
+  }
+
+  latestOnBlockBlockNumber.contents
+}
+
 /*
 Update fetchState, merge registers and recompute derived values.
 Runs partition optimization when partitions change.
@@ -582,7 +639,7 @@ let updateInternal = (
       let maxBlockNumber = switch switch mutItemsRef.contents {
       | Some(mutItems) => mutItems
       | None => fetchState.buffer
-      }->Belt.Array.get(fetchState.targetBufferSize - 1) {
+      }->Array.get(fetchState.targetBufferSize - 1) {
       | Some(item) => item->Internal.getItemBlockNumber
       | None =>
         switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
@@ -597,49 +654,14 @@ let updateInternal = (
       }
       mutItemsRef := Some(mutItems)
 
-      let newItemsCounter = ref(0)
-      let latestOnBlockBlockNumber = ref(fetchState.latestOnBlockBlockNumber)
-
-      // Simply iterate over every block
-      // could have a better algorithm to iterate over blocks in a more efficient way
-      // but raw loops are fast enough
-      while (
-        latestOnBlockBlockNumber.contents < maxBlockNumber &&
-          // Additional safeguard to prevent OOM
-          newItemsCounter.contents <= fetchState.targetBufferSize
-      ) {
-        let blockNumber = latestOnBlockBlockNumber.contents + 1
-        latestOnBlockBlockNumber := blockNumber
-
-        for configIdx in 0 to onBlockConfigs->Array.length - 1 {
-          let onBlockConfig = onBlockConfigs->Array.getUnsafe(configIdx)
-
-          let handlerStartBlock = switch onBlockConfig.startBlock {
-          | Some(startBlock) => startBlock
-          | None => fetchState.startBlock
-          }
-
-          if (
-            blockNumber >= handlerStartBlock &&
-            switch onBlockConfig.endBlock {
-            | Some(endBlock) => blockNumber <= endBlock
-            | None => true
-            } &&
-            (blockNumber - handlerStartBlock)->Pervasives.mod(onBlockConfig.interval) === 0
-          ) {
-            mutItems->Array.push(
-              Block({
-                onBlockConfig,
-                blockNumber,
-                logIndex: blockItemLogIndex + onBlockConfig.index,
-              }),
-            )
-            newItemsCounter := newItemsCounter.contents + 1
-          }
-        }
-      }
-
-      latestOnBlockBlockNumber.contents
+      appendOnBlockItems(
+        ~mutItems,
+        ~onBlockConfigs,
+        ~indexerStartBlock=fetchState.startBlock,
+        ~fromBlock=fetchState.latestOnBlockBlockNumber,
+        ~maxBlockNumber,
+        ~targetBufferSize=fetchState.targetBufferSize,
+      )
     }
   }
 
@@ -952,6 +974,10 @@ let registerDynamicContracts = (
   // so that later conflicting registrations are detected, and are persisted
   // to envio_addresses so they can be picked up on restart with updated config.
   let noEventsAddresses: dict<indexingAddress> = Dict.make()
+  // Batch-level view of all addresses registered so far (across contracts,
+  // including no-events ones), so two contracts registering the same address
+  // within one batch conflict the same way as against indexingAddresses.
+  let registeringAddresses: dict<indexingAddress> = Dict.make()
 
   for itemIdx in 0 to items->Array.length - 1 {
     let item = items->Array.getUnsafe(itemIdx)
@@ -999,9 +1025,7 @@ let registerDynamicContracts = (
             }
             shouldRemove := true
           | None =>
-            let registeringContracts =
-              registeringContractsByContract->Utils.Dict.getOrInsertEmptyDict(dc.contractName)
-            let shouldUpdate = switch registeringContracts->Utils.Dict.dangerouslyGetNonOption(
+            let shouldUpdate = switch registeringAddresses->Utils.Dict.dangerouslyGetNonOption(
               dc.address->Address.toString,
             ) {
             | Some(registeringContract) if registeringContract.contractName != dc.contractName =>
@@ -1024,7 +1048,10 @@ let registerDynamicContracts = (
                   earliestRegisteringEventBlockNumber.contents,
                   dcWithStartBlock.effectiveStartBlock,
                 )
-              registeringContracts->Dict.set(dc.address->Address.toString, dcWithStartBlock)
+              registeringContractsByContract
+              ->Utils.Dict.getOrInsertEmptyDict(dc.contractName)
+              ->Dict.set(dc.address->Address.toString, dcWithStartBlock)
+              registeringAddresses->Dict.set(dc.address->Address.toString, dcWithStartBlock)
             } else {
               shouldRemove := true
             }
@@ -1051,11 +1078,14 @@ let registerDynamicContracts = (
             }
             shouldRemove := true
           | None =>
-            switch noEventsAddresses->Utils.Dict.dangerouslyGetNonOption(
+            switch registeringAddresses->Utils.Dict.dangerouslyGetNonOption(
               dc.address->Address.toString,
             ) {
-            | Some(_) =>
-              // Already queued for persistence by an earlier item in this batch.
+            | Some(existingContract) =>
+              if existingContract.contractName != dc.contractName {
+                fetchState->warnDifferentContractType(~existingContract, ~dc=dcAsIndexingAddress)
+              }
+              // Otherwise already queued for persistence by an earlier item in this batch.
               shouldRemove := true
             | None =>
               let logger = Logging.createChild(
@@ -1070,6 +1100,7 @@ let registerDynamicContracts = (
               // skip partition registration since there's nothing to fetch.
               logger->Logging.childWarn(`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->Dict.set(dc.address->Address.toString, dcAsIndexingAddress)
+              registeringAddresses->Dict.set(dc.address->Address.toString, dcAsIndexingAddress)
             }
           }
         }
@@ -1486,7 +1517,7 @@ let getNextQuery = (
 }
 
 let hasReadyItem = ({buffer} as fetchState: t) => {
-  switch buffer->Belt.Array.get(0) {
+  switch buffer->Array.get(0) {
   | Some(item) => item->Internal.getItemBlockNumber <= fetchState->bufferBlockNumber
   | None => false
   }
@@ -1497,7 +1528,7 @@ let getReadyItemsCount = (fetchState: t, ~targetSize: int, ~fromItem) => {
   let acc = ref(0)
   let isFinished = ref(false)
   while !isFinished.contents {
-    switch fetchState.buffer->Belt.Array.get(fromItem + acc.contents) {
+    switch fetchState.buffer->Array.get(fromItem + acc.contents) {
     | Some(item) =>
       let itemBlockNumber = item->Internal.getItemBlockNumber
       if itemBlockNumber <= readyBlockNumber.contents {
@@ -1661,35 +1692,59 @@ let make = (
     )
   }
 
-  let numAddresses = indexingAddresses->Utils.Dict.size
-  Prometheus.IndexingAddresses.set(~addressesCount=numAddresses, ~chainId)
-  Prometheus.IndexingPartitions.set(
-    ~partitionsCount=optimizedPartitions->OptimizedPartitions.count,
-    ~chainId,
-  )
-  Prometheus.IndexingBufferSize.set(~bufferSize=0, ~chainId)
-  Prometheus.IndexingBufferBlockNumber.set(~blockNumber=latestFetchedBlock.blockNumber, ~chainId)
-  switch endBlock {
-  | Some(endBlock) => Prometheus.IndexingEndBlock.set(~endBlock, ~chainId)
-  | None => ()
+  // On resume knownHeight is restored from the DB but the buffer starts empty.
+  // For onBlock-only indexers (e.g. SVM onSlot) there are no partitions to drive
+  // fetching, so without seeding the buffer here getNextQuery would return
+  // NothingToQuery and the indexer would get stuck.
+  let buffer = []
+  let latestOnBlockBlockNumber = if knownHeight > 0 && onBlockConfigs->Utils.Array.notEmpty {
+    let maxBlockNumber = switch optimizedPartitions->OptimizedPartitions.getLatestFullyFetchedBlock {
+    | None => knownHeight
+    | Some(latestFullyFetchedBlock) => latestFullyFetchedBlock.blockNumber
+    }
+    appendOnBlockItems(
+      ~mutItems=buffer,
+      ~onBlockConfigs,
+      ~indexerStartBlock=startBlock,
+      ~fromBlock=progressBlockNumber,
+      ~maxBlockNumber,
+      ~targetBufferSize,
+    )
+  } else {
+    progressBlockNumber
   }
 
-  {
+  let fetchState = {
     optimizedPartitions,
     contractConfigs,
     chainId,
     startBlock,
     endBlock,
-    latestOnBlockBlockNumber: progressBlockNumber,
+    latestOnBlockBlockNumber,
     normalSelection,
     indexingAddresses,
     blockLag,
     onBlockConfigs,
     targetBufferSize,
     knownHeight,
-    buffer: [],
+    buffer,
     firstEventBlock,
   }
+
+  let numAddresses = indexingAddresses->Utils.Dict.size
+  Prometheus.IndexingAddresses.set(~addressesCount=numAddresses, ~chainId)
+  Prometheus.IndexingPartitions.set(
+    ~partitionsCount=optimizedPartitions->OptimizedPartitions.count,
+    ~chainId,
+  )
+  Prometheus.IndexingBufferSize.set(~bufferSize=buffer->Array.length, ~chainId)
+  Prometheus.IndexingBufferBlockNumber.set(~blockNumber=fetchState->bufferBlockNumber, ~chainId)
+  switch endBlock {
+  | Some(endBlock) => Prometheus.IndexingEndBlock.set(~endBlock, ~chainId)
+  | None => ()
+  }
+
+  fetchState
 }
 
 let bufferSize = ({buffer}: t) => buffer->Array.length
@@ -1905,7 +1960,7 @@ let isReadyToEnterReorgThreshold = ({endBlock, blockLag, buffer, knownHeight} as
 
 let sortForUnorderedBatch = {
   let hasFullBatch = ({buffer} as fetchState: t, ~batchSizeTarget) => {
-    switch buffer->Belt.Array.get(batchSizeTarget - 1) {
+    switch buffer->Array.get(batchSizeTarget - 1) {
     | Some(item) => item->Internal.getItemBlockNumber <= fetchState->bufferBlockNumber
     | None => false
     }
@@ -1920,7 +1975,7 @@ let sortForUnorderedBatch = {
       if totalRange <= 0 {
         0.
       } else {
-        let progress = switch fetchState.buffer->Belt.Array.get(0) {
+        let progress = switch fetchState.buffer->Array.get(0) {
         | Some(item) => item->Internal.getItemBlockNumber - firstEventBlock
         | None => fetchState->bufferBlockNumber - firstEventBlock
         }
@@ -1955,7 +2010,7 @@ let sortForUnorderedBatch = {
 
 let getProgressBlockNumberAt = ({buffer} as fetchState: t, ~index) => {
   let bufferBlockNumber = fetchState->bufferBlockNumber
-  switch buffer->Belt.Array.get(index) {
+  switch buffer->Array.get(index) {
   | Some(item) if bufferBlockNumber >= item->Internal.getItemBlockNumber =>
     item->Internal.getItemBlockNumber - 1
   | _ => bufferBlockNumber

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];
@@ -450,6 +449,35 @@ function numAddresses(fetchState) {
   return Utils.Dict.size(fetchState.indexingAddresses);
 }
 
+function appendOnBlockItems(mutItems, onBlockConfigs, indexerStartBlock, fromBlock, maxBlockNumber, targetBufferSize) {
+  let newItemsCounter = 0;
+  let latestOnBlockBlockNumber = fromBlock;
+  while (latestOnBlockBlockNumber < maxBlockNumber && newItemsCounter <= targetBufferSize) {
+    let blockNumber = latestOnBlockBlockNumber + 1 | 0;
+    latestOnBlockBlockNumber = blockNumber;
+    for (let configIdx = 0, configIdx_finish = onBlockConfigs.length; configIdx < configIdx_finish; ++configIdx) {
+      let onBlockConfig = onBlockConfigs[configIdx];
+      let startBlock = onBlockConfig.startBlock;
+      let handlerStartBlock = startBlock !== undefined ? startBlock : indexerStartBlock;
+      let tmp = false;
+      if (blockNumber >= handlerStartBlock) {
+        let endBlock = onBlockConfig.endBlock;
+        tmp = endBlock !== undefined ? blockNumber <= endBlock : true;
+      }
+      if (tmp && Primitive_int.mod_(blockNumber - handlerStartBlock | 0, onBlockConfig.interval) === 0) {
+        mutItems.push({
+          kind: 1,
+          onBlockConfig: onBlockConfig,
+          blockNumber: blockNumber,
+          logIndex: 16777216 + onBlockConfig.index | 0
+        });
+        newItemsCounter = newItemsCounter + 1 | 0;
+      }
+    }
+  };
+  return latestOnBlockBlockNumber;
+}
+
 function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt, mutItems, blockLagOpt, knownHeightOpt) {
   let optimizedPartitions = optimizedPartitionsOpt !== undefined ? optimizedPartitionsOpt : fetchState.optimizedPartitions;
   let indexingAddresses = indexingAddressesOpt !== undefined ? indexingAddressesOpt : fetchState.indexingAddresses;
@@ -460,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;
@@ -472,32 +502,7 @@ function updateInternal(fetchState, optimizedPartitionsOpt, indexingAddressesOpt
     let mutItems$2 = mutItemsRef;
     let mutItems$3 = mutItems$2 !== undefined ? mutItems$2 : fetchState.buffer.slice();
     mutItemsRef = mutItems$3;
-    let newItemsCounter = 0;
-    let latestOnBlockBlockNumber$1 = fetchState.latestOnBlockBlockNumber;
-    while (latestOnBlockBlockNumber$1 < maxBlockNumber && newItemsCounter <= fetchState.targetBufferSize) {
-      let blockNumber = latestOnBlockBlockNumber$1 + 1 | 0;
-      latestOnBlockBlockNumber$1 = blockNumber;
-      for (let configIdx = 0, configIdx_finish = onBlockConfigs.length; configIdx < configIdx_finish; ++configIdx) {
-        let onBlockConfig = onBlockConfigs[configIdx];
-        let startBlock = onBlockConfig.startBlock;
-        let handlerStartBlock = startBlock !== undefined ? startBlock : fetchState.startBlock;
-        let tmp = false;
-        if (blockNumber >= handlerStartBlock) {
-          let endBlock = onBlockConfig.endBlock;
-          tmp = endBlock !== undefined ? blockNumber <= endBlock : true;
-        }
-        if (tmp && Primitive_int.mod_(blockNumber - handlerStartBlock | 0, onBlockConfig.interval) === 0) {
-          mutItems$3.push({
-            kind: 1,
-            onBlockConfig: onBlockConfig,
-            blockNumber: blockNumber,
-            logIndex: 16777216 + onBlockConfig.index | 0
-          });
-          newItemsCounter = newItemsCounter + 1 | 0;
-        }
-      }
-    };
-    latestOnBlockBlockNumber = latestOnBlockBlockNumber$1;
+    latestOnBlockBlockNumber = appendOnBlockItems(mutItems$3, onBlockConfigs, fetchState.startBlock, fetchState.latestOnBlockBlockNumber, maxBlockNumber, fetchState.targetBufferSize);
   } else {
     latestOnBlockBlockNumber = knownHeight;
   }
@@ -722,6 +727,7 @@ function registerDynamicContracts(fetchState, items) {
   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;
@@ -757,8 +763,7 @@ function registerDynamicContracts(fetchState, items) {
             }
             shouldRemove = true;
           } else {
-            let registeringContracts = Utils.Dict.getOrInsertEmptyDict(registeringContractsByContract, dc.contractName);
-            let registeringContract = registeringContracts[dc.address];
+            let registeringContract = registeringAddresses[dc.address];
             let shouldUpdate;
             if (registeringContract !== undefined) {
               if (registeringContract.contractName !== dc.contractName) {
@@ -773,7 +778,8 @@ function registerDynamicContracts(fetchState, items) {
             }
             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;
             }
@@ -796,8 +802,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({
@@ -807,6 +816,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;
             }
           }
         }
@@ -884,8 +894,8 @@ 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);
@@ -1175,7 +1185,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 {
@@ -1188,7 +1198,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) {
@@ -1299,15 +1309,17 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
   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.`);
   }
-  let numAddresses = Utils.Dict.size(indexingAddresses);
-  Prometheus.IndexingAddresses.set(numAddresses, chainId);
-  Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, chainId);
-  Prometheus.IndexingBufferSize.set(0, chainId);
-  Prometheus.IndexingBufferBlockNumber.set(progressBlockNumber, chainId);
-  if (endBlock !== undefined) {
-    Prometheus.IndexingEndBlock.set(endBlock, chainId);
+  let buffer = [];
+  let latestOnBlockBlockNumber;
+  if (knownHeight > 0 && Utils.$$Array.notEmpty(onBlockConfigs)) {
+    let id = optimizedPartitions.idsInAscOrder[0];
+    let latestFullyFetchedBlock = id !== undefined ? optimizedPartitions.entities[id].latestFetchedBlock : undefined;
+    let maxBlockNumber = latestFullyFetchedBlock !== undefined ? latestFullyFetchedBlock.blockNumber : knownHeight;
+    latestOnBlockBlockNumber = appendOnBlockItems(buffer, onBlockConfigs, startBlock, progressBlockNumber, maxBlockNumber, targetBufferSize);
+  } else {
+    latestOnBlockBlockNumber = progressBlockNumber;
   }
-  return {
+  let fetchState = {
     optimizedPartitions: optimizedPartitions,
     startBlock: startBlock,
     endBlock: endBlock,
@@ -1315,14 +1327,23 @@ function make$1(startBlock, endBlock, eventConfigs, addresses, maxAddrInPartitio
     indexingAddresses: indexingAddresses,
     contractConfigs: contractConfigs,
     chainId: chainId,
-    latestOnBlockBlockNumber: progressBlockNumber,
+    latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
-    buffer: [],
+    buffer: buffer,
     targetBufferSize: targetBufferSize,
     onBlockConfigs: onBlockConfigs,
     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);
+  if (endBlock !== undefined) {
+    Prometheus.IndexingEndBlock.set(endBlock, chainId);
+  }
+  return fetchState;
 }
 
 function bufferSize(param) {
@@ -1529,7 +1550,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 {
@@ -1546,7 +1567,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;
 }
@@ -1578,7 +1599,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 {
@@ -1607,6 +1628,7 @@ export {
   compareBufferItem,
   blockItemLogIndex,
   numAddresses,
+  appendOnBlockItems,
   updateInternal,
   warnDifferentContractType,
   addressesByContractNameCount,