envio 3.0.2 → 3.1.0-rc.0

package/src/sources/HyperSyncSource.res

@@ -5,13 +5,9 @@ type selectionConfig = {
     ~addressesByContractName: dict<array<Address.t>>,
   ) => array<LogSelection.t>,
   fieldSelection: HyperSyncClient.QueryTypes.fieldSelection,
-  nonOptionalBlockFieldNames: array<string>,
-  nonOptionalTransactionFieldNames: array<string>,
 }
 
 let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
-  let nonOptionalBlockFieldNames = Utils.Set.make()
-  let nonOptionalTransactionFieldNames = Utils.Set.make()
   let capitalizedBlockFields = Utils.Set.make()
   let capitalizedTransactionFields = Utils.Set.make()
 
@@ -33,22 +29,18 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
   }) => {
     selectedBlockFields
     ->Utils.Set.toArray
-    ->Array.forEach(name => {
-      let nameStr = (name :> string)
-      if !(Internal.evmNullableBlockFields->Utils.Set.has(name)) {
-        nonOptionalBlockFieldNames->Utils.Set.add(nameStr)->ignore
-      }
-      capitalizedBlockFields->Utils.Set.add(nameStr->Utils.String.capitalize)->ignore
-    })
+    ->Array.forEach(name =>
+      capitalizedBlockFields
+      ->Utils.Set.add((name :> string)->Utils.String.capitalize)
+      ->ignore
+    )
     selectedTransactionFields
     ->Utils.Set.toArray
-    ->Array.forEach(name => {
-      let nameStr = (name :> string)
-      if !(Internal.evmNullableTransactionFields->Utils.Set.has(name)) {
-        nonOptionalTransactionFieldNames->Utils.Set.add(nameStr)->ignore
-      }
-      capitalizedTransactionFields->Utils.Set.add(nameStr->Utils.String.capitalize)->ignore
-    })
+    ->Array.forEach(name =>
+      capitalizedTransactionFields
+      ->Utils.Set.add((name :> string)->Utils.String.capitalize)
+      ->ignore
+    )
 
     let eventFilters = getEventFiltersOrThrow(chain)
     if dependsOnAddresses {
@@ -130,8 +122,6 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
   {
     getLogSelectionOrThrow,
     fieldSelection,
-    nonOptionalBlockFieldNames: nonOptionalBlockFieldNames->Utils.Set.toArray,
-    nonOptionalTransactionFieldNames: nonOptionalTransactionFieldNames->Utils.Set.toArray,
   }
 }
 
@@ -141,7 +131,7 @@ let memoGetSelectionConfig = (~chain) =>
 type options = {
   chain: ChainMap.Chain.t,
   endpointUrl: string,
-  allEventSignatures: array<string>,
+  allEventParams: array<HyperSyncClient.Decoder.eventParamsInput>,
   eventRouter: EventRouter.t<Internal.evmEventConfig>,
   apiToken: option<string>,
   clientMaxRetries: int,
@@ -149,13 +139,14 @@ type options = {
   lowercaseAddresses: bool,
   serializationFormat: HyperSyncClient.serializationFormat,
   enableQueryCaching: bool,
+  logLevel: HyperSyncClient.logLevel,
 }
 
 let make = (
   {
     chain,
     endpointUrl,
-    allEventSignatures,
+    allEventParams,
     eventRouter,
     apiToken,
     clientMaxRetries,
@@ -163,6 +154,7 @@ let make = (
     lowercaseAddresses,
     serializationFormat,
     enableQueryCaching,
+    logLevel,
   }: options,
 ): t => {
   let name = "HyperSync"
@@ -177,45 +169,32 @@ Set the ENVIO_API_TOKEN environment variable in your .env file.
 Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
   }
 
-  let client = HyperSyncClient.make(
+  let client = switch HyperSyncClient.make(
     ~url=endpointUrl,
     ~apiToken,
     ~maxNumRetries=clientMaxRetries,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
+    ~eventParams=allEventParams,
     ~enableChecksumAddresses=!lowercaseAddresses,
     ~serializationFormat,
     ~enableQueryCaching,
-  )
-
-  let hscDecoder: ref<option<HyperSyncClient.Decoder.t>> = ref(None)
-  let getHscDecoder = () => {
-    switch hscDecoder.contents {
-    | Some(decoder) => decoder
-    | None =>
-      switch HyperSyncClient.Decoder.fromSignatures(allEventSignatures) {
-      | exception exn =>
-        exn->ErrorHandling.mkLogAndRaise(
-          ~msg="Failed to instantiate a decoder from hypersync client, please double check your ABI",
-        )
-      | decoder =>
-        if lowercaseAddresses {
-          decoder.disableChecksummedAddresses()
-        } else {
-          decoder.enableChecksummedAddresses()
-        }
-        decoder
-      }
-    }
+    ~logLevel,
+  ) {
+  | client => client
+  | exception exn =>
+    exn->ErrorHandling.mkLogAndRaise(
+      ~msg="Failed to instantiate the hypersync client, please double check your ABI",
+    )
   }
 
   exception UndefinedValue
 
   let makeEventBatchQueueItem = (
-    item: HyperSync.logsQueryPageItem,
+    item: HyperSyncClient.EventItems.item,
     ~params: Internal.eventParams,
     ~eventConfig: Internal.evmEventConfig,
   ): Internal.item => {
-    let {block, log, transaction} = item
+    let {block, transaction, logIndex, srcAddress} = item
     let chainId = chain->ChainMap.Chain.toChainId
 
     Internal.Event({
@@ -223,7 +202,7 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
       timestamp: block.timestamp->Belt.Option.getUnsafe,
       chain,
       blockNumber: block.number->Belt.Option.getUnsafe,
-      logIndex: log.logIndex,
+      logIndex,
       event: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
@@ -231,8 +210,8 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
         params,
         transaction,
         block: block->(Utils.magic: HyperSyncClient.ResponseTypes.block => Internal.eventBlock),
-        srcAddress: log.address,
-        logIndex: log.logIndex,
+        srcAddress,
+        logIndex,
       }->Internal.fromGenericEvent,
     })
   }
@@ -248,7 +227,6 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
     ~retry,
     ~logger,
   ) => {
-    let mkLogAndRaise = ErrorHandling.mkLogAndRaise(~logger, ...)
     let totalTimeRef = Hrtime.makeTimer()
 
     let selectionConfig = selection->getSelectionConfig
@@ -272,8 +250,6 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
       ~toBlock,
       ~logSelections,
       ~fieldSelection=selectionConfig.fieldSelection,
-      ~nonOptionalBlockFieldNames=selectionConfig.nonOptionalBlockFieldNames,
-      ~nonOptionalTransactionFieldNames=selectionConfig.nonOptionalTransactionFieldNames,
     ) catch {
     | HyperSync.GetLogs.Error(error) =>
       throw(
@@ -329,64 +305,6 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
     //In the query
     let heighestBlockQueried = pageUnsafe.nextBlock - 1
 
-    let lastBlockQueriedPromise = switch pageUnsafe.rollbackGuard {
-    //In the case a rollbackGuard is returned (this only happens at the head for unconfirmed blocks)
-    //use these values
-    | Some({blockNumber, timestamp, hash}) =>
-      (
-        {
-          blockNumber,
-          blockTimestamp: timestamp,
-          blockHash: hash,
-        }: ReorgDetection.blockDataWithTimestamp
-      )->Promise.resolve
-    | None =>
-      //The optional block and timestamp of the last item returned by the query
-      //(Optional in the case that there are no logs returned in the query)
-      switch pageUnsafe.items->Belt.Array.get(pageUnsafe.items->Belt.Array.length - 1) {
-      | Some({block}) if block.number->Belt.Option.getUnsafe == heighestBlockQueried =>
-        //If the last log item in the current page is equal to the
-        //heighest block acounted for in the query. Simply return this
-        //value without making an extra query
-
-        (
-          {
-            blockNumber: block.number->Belt.Option.getUnsafe,
-            blockTimestamp: block.timestamp->Belt.Option.getUnsafe,
-            blockHash: block.hash->Belt.Option.getUnsafe,
-          }: ReorgDetection.blockDataWithTimestamp
-        )->Promise.resolve
-      //If it does not match it means that there were no matching logs in the last
-      //block so we should fetch the block data
-      | Some(_)
-      | None =>
-        //If there were no logs at all in the current page query then fetch the
-        //timestamp of the heighest block accounted for
-        HyperSync.queryBlockData(
-          ~client,
-          ~blockNumber=heighestBlockQueried,
-          ~sourceName=name,
-          ~chainId=chain->ChainMap.Chain.toChainId,
-          ~logger,
-        )->Promise.thenResolve(res =>
-          switch res {
-          | Ok(Some(blockData)) => blockData
-          | Ok(None) =>
-            mkLogAndRaise(
-              Not_found,
-              ~msg=`Failure, blockData for block ${heighestBlockQueried->Int.toString} unexpectedly returned None`,
-            )
-          | Error(e) =>
-            HyperSync.queryErrorToMsq(e)
-            ->Obj.magic
-            ->mkLogAndRaise(
-              ~msg=`Failed to query blockData for block ${heighestBlockQueried->Int.toString}`,
-            )
-          }
-        )
-      }
-    }
-
     let parsingTimeRef = Hrtime.makeTimer()
 
     //Parse page items into queue items
@@ -417,47 +335,29 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
       }
     }
 
-    //Parse page items into queue items
-    let parsedEvents = switch await getHscDecoder().decodeEvents(pageUnsafe.events) {
-    | exception exn =>
-      exn->mkLogAndRaise(
-        ~msg="Failed to parse events using hypersync client, please double check your ABI.",
-      )
-    | parsedEvents => parsedEvents
-    }
-
-    pageUnsafe.items->Belt.Array.forEachWithIndex((index, item) => {
-      let {block, log} = item
+    pageUnsafe.items->Belt.Array.forEach(item => {
       let chainId = chain->ChainMap.Chain.toChainId
-      let topic0 = log.topics->Utils.Array.firstUnsafe
       let maybeEventConfig =
         eventRouter->EventRouter.get(
           ~tag=EventRouter.getEvmEventId(
-            ~sighash=topic0->EvmTypes.Hex.toString,
-            ~topicCount=log.topics->Array.length,
+            ~sighash=item.topic0->EvmTypes.Hex.toString,
+            ~topicCount=item.topicCount,
           ),
           ~indexingAddresses,
-          ~contractAddress=log.address,
-          ~blockNumber=block.number->Belt.Option.getUnsafe,
+          ~contractAddress=item.srcAddress,
+          ~blockNumber=item.block.number->Belt.Option.getUnsafe,
         )
-      let maybeDecodedEvent = parsedEvents->Array.getUnsafe(index)
 
-      switch (maybeEventConfig, maybeDecodedEvent) {
+      switch (maybeEventConfig, item.params) {
       | (Some(eventConfig), Value(decoded)) =>
         parsedQueueItems
-        ->Array.push(
-          makeEventBatchQueueItem(
-            item,
-            ~params=decoded->eventConfig.convertHyperSyncEventArgs,
-            ~eventConfig,
-          ),
-        )
+        ->Array.push(makeEventBatchQueueItem(item, ~params=decoded, ~eventConfig))
         ->ignore
       | (Some(eventConfig), Null | Undefined) =>
         handleDecodeFailure(
           ~eventConfig,
-          ~logIndex=log.logIndex,
-          ~blockNumber=block.number->Belt.Option.getUnsafe,
+          ~logIndex=item.logIndex,
+          ~blockNumber=item.block.number->Belt.Option.getUnsafe,
           ~chainId,
           ~exn=UndefinedValue,
         )
@@ -467,14 +367,43 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
 
     let parsingTimeElapsed = parsingTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
 
-    let rangeLastBlock = await lastBlockQueriedPromise
+    // Collect (blockNumber, blockHash) pairs we already have from the response —
+    // one per item's block plus, when present, the rollbackGuard's head block
+    // and the parent of the range's first block. Duplicates are allowed; reorg
+    // detection notices same-block-number-different-hash collisions itself.
+    let blockHashes = []
+    pageUnsafe.items->Belt.Array.forEach(({block}) => {
+      switch (block.number, block.hash) {
+      | (Some(blockNumber), Some(blockHash)) =>
+        blockHashes->Array.push({ReorgDetection.blockNumber, blockHash})->ignore
+      | _ => ()
+      }
+    })
+    switch pageUnsafe.rollbackGuard {
+    | None => ()
+    | Some({blockNumber, hash, firstBlockNumber, firstParentHash}) => {
+        blockHashes->Array.push({ReorgDetection.blockNumber, blockHash: hash})->ignore
+        blockHashes
+        ->Array.push({
+          ReorgDetection.blockNumber: firstBlockNumber - 1,
+          blockHash: firstParentHash,
+        })
+        ->ignore
+      }
+    }
 
-    let reorgGuard: ReorgDetection.reorgGuard = {
-      rangeLastBlock: rangeLastBlock->ReorgDetection.generalizeBlockDataWithTimestamp,
-      prevRangeLastBlock: pageUnsafe.rollbackGuard->Option.map(v => {
-        ReorgDetection.blockHash: v.firstParentHash,
-        blockNumber: v.firstBlockNumber - 1,
-      }),
+    // Best-effort timestamp for the queried-range head: prefer the rollbackGuard
+    // (set at the head for unconfirmed blocks), otherwise the last item if it
+    // happens to be in the range's last block. 0 is a tolerated placeholder
+    // when neither is available (FetchState already uses 0 in several spots).
+    let latestFetchedBlockTimestamp = switch pageUnsafe.rollbackGuard {
+    | Some({timestamp}) => timestamp
+    | None =>
+      switch pageUnsafe.items->Belt.Array.get(pageUnsafe.items->Belt.Array.length - 1) {
+      | Some({block}) if block.number->Belt.Option.getUnsafe == heighestBlockQueried =>
+        block.timestamp->Belt.Option.getUnsafe
+      | _ => 0
+      }
     }
 
     let totalTimeElapsed = totalTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
@@ -486,12 +415,12 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`)
     }
 
     {
-      latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
+      latestFetchedBlockTimestamp,
       parsedQueueItems,
-      latestFetchedBlockNumber: rangeLastBlock.blockNumber,
+      latestFetchedBlockNumber: heighestBlockQueried,
       stats,
       knownHeight,
-      reorgGuard,
+      blockHashes,
       fromBlockQueried: fromBlock,
     }
   }

package/src/sources/HyperSyncSource.res.mjs

@@ -5,7 +5,6 @@ import * as Utils from "../Utils.res.mjs";
 import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as Internal from "../Internal.res.mjs";
 import * as HyperSync from "./HyperSync.res.mjs";
 import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Prometheus from "../Prometheus.res.mjs";
@@ -20,8 +19,6 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 import * as HyperSyncHeightStream from "./HyperSyncHeightStream.res.mjs";
 
 function getSelectionConfig(selection, chain) {
-  let nonOptionalBlockFieldNames = new Set();
-  let nonOptionalTransactionFieldNames = new Set();
   let capitalizedBlockFields = new Set();
   let capitalizedTransactionFields = new Set();
   let staticTopicSelectionsByContract = {};
@@ -32,15 +29,9 @@ function getSelectionConfig(selection, chain) {
   selection.eventConfigs.forEach(param => {
     let contractName = param.contractName;
     Array.from(param.selectedBlockFields).forEach(name => {
-      if (!Internal.evmNullableBlockFields.has(name)) {
-        nonOptionalBlockFieldNames.add(name);
-      }
       capitalizedBlockFields.add(Utils.$$String.capitalize(name));
     });
     Array.from(param.selectedTransactionFields).forEach(name => {
-      if (!Internal.evmNullableTransactionFields.has(name)) {
-        nonOptionalTransactionFieldNames.add(name);
-      }
       capitalizedTransactionFields.add(Utils.$$String.capitalize(name));
     });
     let eventFilters = param.getEventFiltersOrThrow(chain);
@@ -104,9 +95,7 @@ function getSelectionConfig(selection, chain) {
   };
   return {
     getLogSelectionOrThrow: getLogSelectionOrThrow,
-    fieldSelection: fieldSelection,
-    nonOptionalBlockFieldNames: Array.from(nonOptionalBlockFieldNames),
-    nonOptionalTransactionFieldNames: Array.from(nonOptionalTransactionFieldNames)
+    fieldSelection: fieldSelection
   };
 }
 
@@ -115,10 +104,8 @@ function memoGetSelectionConfig(chain) {
 }
 
 function make(param) {
-  let lowercaseAddresses = param.lowercaseAddresses;
   let apiToken = param.apiToken;
   let eventRouter = param.eventRouter;
-  let allEventSignatures = param.allEventSignatures;
   let endpointUrl = param.endpointUrl;
   let chain = param.chain;
   let name = "HyperSync";
@@ -126,54 +113,37 @@ function make(param) {
   let apiToken$1 = apiToken !== undefined ? apiToken : Stdlib_JsError.throwWithMessage(`An API token is required for using HyperSync as a data-source.
 Set the ENVIO_API_TOKEN environment variable in your .env file.
 Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
-  let client = HyperSyncClient.make(endpointUrl, apiToken$1, param.clientTimeoutMillis, param.clientMaxRetries, !lowercaseAddresses, param.serializationFormat, param.enableQueryCaching, undefined, undefined, undefined);
-  let hscDecoder = {
-    contents: undefined
-  };
-  let getHscDecoder = () => {
-    let decoder = hscDecoder.contents;
-    if (decoder !== undefined) {
-      return decoder;
-    }
-    let decoder$1;
-    try {
-      decoder$1 = HyperSyncClient.Decoder.fromSignatures(allEventSignatures);
-    } catch (raw_exn) {
-      let exn = Primitive_exceptions.internalToException(raw_exn);
-      return ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate a decoder from hypersync client, please double check your ABI", exn);
-    }
-    if (lowercaseAddresses) {
-      decoder$1.disableChecksummedAddresses();
-    } else {
-      decoder$1.enableChecksummedAddresses();
-    }
-    return decoder$1;
-  };
+  let client;
+  try {
+    client = HyperSyncClient.make(endpointUrl, apiToken$1, param.clientTimeoutMillis, param.clientMaxRetries, param.allEventParams, !param.lowercaseAddresses, param.serializationFormat, param.enableQueryCaching, undefined, undefined, undefined, param.logLevel);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    client = ErrorHandling.mkLogAndRaise(undefined, "Failed to instantiate the hypersync client, please double check your ABI", exn);
+  }
   let UndefinedValue = /* @__PURE__ */Primitive_exceptions.create("UndefinedValue");
   let makeEventBatchQueueItem = (item, params, eventConfig) => {
     let block = item.block;
-    let log = item.log;
+    let logIndex = item.logIndex;
     return {
       kind: 0,
       eventConfig: eventConfig,
       timestamp: block.timestamp,
       chain: chain,
       blockNumber: block.number,
-      logIndex: log.logIndex,
+      logIndex: logIndex,
       event: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
         params: params,
         chainId: chain,
-        srcAddress: log.address,
-        logIndex: log.logIndex,
+        srcAddress: item.srcAddress,
+        logIndex: logIndex,
         transaction: item.transaction,
         block: block
       }
     };
   };
   let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, indexingAddresses, knownHeight, param, selection, retry, logger) => {
-    let mkLogAndRaise = (extra, extra$1) => ErrorHandling.mkLogAndRaise(logger, extra, extra$1);
     let totalTimeRef = Hrtime.makeTimer();
     let selectionConfig = getSelectionConfig(selection);
     let logSelections;
@@ -187,7 +157,7 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     Prometheus.SourceRequestCount.increment(name, chain, "getLogs");
     let pageUnsafe;
     try {
-      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, logSelections, selectionConfig.fieldSelection, selectionConfig.nonOptionalBlockFieldNames, selectionConfig.nonOptionalTransactionFieldNames);
+      pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, logSelections, selectionConfig.fieldSelection);
     } catch (raw_error) {
       let error = Primitive_exceptions.internalToException(raw_error);
       if (error.RE_EXN_ID === HyperSync.GetLogs.$$Error) {
@@ -235,73 +205,22 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     let pageFetchTime = Hrtime.toSecondsFloat(Hrtime.timeSince(startFetchingBatchTimeRef));
     let knownHeight$1 = pageUnsafe.archiveHeight;
     let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
-    let match = pageUnsafe.rollbackGuard;
-    let lastBlockQueriedPromise;
-    if (match !== undefined) {
-      lastBlockQueriedPromise = Promise.resolve({
-        blockHash: match.hash,
-        blockNumber: match.blockNumber,
-        blockTimestamp: match.timestamp
-      });
-    } else {
-      let match$1 = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
-      let exit = 0;
-      if (match$1 !== undefined) {
-        let block = match$1.block;
-        if (block.number === heighestBlockQueried) {
-          lastBlockQueriedPromise = Promise.resolve({
-            blockHash: block.hash,
-            blockNumber: block.number,
-            blockTimestamp: block.timestamp
-          });
-        } else {
-          exit = 1;
-        }
-      } else {
-        exit = 1;
-      }
-      if (exit === 1) {
-        lastBlockQueriedPromise = HyperSync.queryBlockData(client, heighestBlockQueried, name, chain, logger).then(res => {
-          if (res.TAG !== "Ok") {
-            return mkLogAndRaise(`Failed to query blockData for block ` + heighestBlockQueried.toString(), HyperSync.queryErrorToMsq(res._0));
-          }
-          let blockData = res._0;
-          if (blockData !== undefined) {
-            return blockData;
-          } else {
-            return mkLogAndRaise(`Failure, blockData for block ` + heighestBlockQueried.toString() + ` unexpectedly returned None`, {
-              RE_EXN_ID: "Not_found"
-            });
-          }
-        });
-      }
-    }
     let parsingTimeRef = Hrtime.makeTimer();
     let parsedQueueItems = [];
-    let parsedEvents;
-    try {
-      parsedEvents = await getHscDecoder().decodeEvents(pageUnsafe.events);
-    } catch (raw_exn$1) {
-      let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
-      parsedEvents = mkLogAndRaise("Failed to parse events using hypersync client, please double check your ABI.", exn$1);
-    }
-    Belt_Array.forEachWithIndex(pageUnsafe.items, (index, item) => {
-      let block = item.block;
-      let log = item.log;
-      let topic0 = Utils.$$Array.firstUnsafe(log.topics);
-      let maybeEventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), log.address, block.number, indexingAddresses);
-      let maybeDecodedEvent = parsedEvents[index];
+    Belt_Array.forEach(pageUnsafe.items, item => {
+      let maybeEventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(item.topic0, item.topicCount), item.srcAddress, item.block.number, indexingAddresses);
+      let match = item.params;
       if (maybeEventConfig === undefined) {
         return;
       }
-      if (maybeDecodedEvent == null) {
-        maybeDecodedEvent === null;
+      if (match == null) {
+        match === null;
       } else {
-        parsedQueueItems.push(makeEventBatchQueueItem(item, maybeEventConfig.convertHyperSyncEventArgs(maybeDecodedEvent), maybeEventConfig));
+        parsedQueueItems.push(makeEventBatchQueueItem(item, match, maybeEventConfig));
         return;
       }
-      let logIndex = log.logIndex;
-      let blockNumber = block.number;
+      let logIndex = item.logIndex;
+      let blockNumber = item.block.number;
       let exn = {
         RE_EXN_ID: UndefinedValue
       };
@@ -318,15 +237,43 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
       ErrorHandling.mkLogAndRaise(logger$1, msg, exn);
     });
     let parsingTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(parsingTimeRef));
-    let rangeLastBlock = await lastBlockQueriedPromise;
-    let reorgGuard_prevRangeLastBlock = Stdlib_Option.map(pageUnsafe.rollbackGuard, v => ({
-      blockHash: v.firstParentHash,
-      blockNumber: v.firstBlockNumber - 1 | 0
-    }));
-    let reorgGuard = {
-      rangeLastBlock: rangeLastBlock,
-      prevRangeLastBlock: reorgGuard_prevRangeLastBlock
-    };
+    let blockHashes = [];
+    Belt_Array.forEach(pageUnsafe.items, param => {
+      let block = param.block;
+      let match = block.number;
+      let match$1 = block.hash;
+      if (match !== undefined && match$1 !== undefined) {
+        blockHashes.push({
+          blockHash: match$1,
+          blockNumber: match
+        });
+        return;
+      }
+    });
+    let match = pageUnsafe.rollbackGuard;
+    if (match !== undefined) {
+      blockHashes.push({
+        blockHash: match.hash,
+        blockNumber: match.blockNumber
+      });
+      blockHashes.push({
+        blockHash: match.firstParentHash,
+        blockNumber: match.firstBlockNumber - 1 | 0
+      });
+    }
+    let match$1 = pageUnsafe.rollbackGuard;
+    let latestFetchedBlockTimestamp;
+    if (match$1 !== undefined) {
+      latestFetchedBlockTimestamp = match$1.timestamp;
+    } else {
+      let match$2 = Belt_Array.get(pageUnsafe.items, pageUnsafe.items.length - 1 | 0);
+      if (match$2 !== undefined) {
+        let block = match$2.block;
+        latestFetchedBlockTimestamp = block.number === heighestBlockQueried ? block.timestamp : 0;
+      } else {
+        latestFetchedBlockTimestamp = 0;
+      }
+    }
     let totalTimeElapsed = Hrtime.toSecondsFloat(Hrtime.timeSince(totalTimeRef));
     let stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
     let stats_page$unknownfetch$unknowntime$unknown$lpars$rpar = pageFetchTime;
@@ -337,11 +284,11 @@ Learn more or get a free API token at: https://envio.dev/app/api-tokens`);
     };
     return {
       knownHeight: knownHeight$1,
-      reorgGuard: reorgGuard,
+      blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       fromBlockQueried: fromBlock,
-      latestFetchedBlockNumber: rangeLastBlock.blockNumber,
-      latestFetchedBlockTimestamp: rangeLastBlock.blockTimestamp,
+      latestFetchedBlockNumber: heighestBlockQueried,
+      latestFetchedBlockTimestamp: latestFetchedBlockTimestamp,
       stats: stats
     };
   };