envio 3.6.1 → 3.7.0

package/src/bindings/ClickHouse.res

@@ -14,8 +14,13 @@ type execParams = {query: string}
 @module("@clickhouse/client")
 external createClient: clientConfig => client = "createClient"
 
+// `command`, not `exec`: exec hands its response stream to the caller and holds
+// the socket until it is consumed, which nothing here does. The pool is 10
+// sockets wide, so a schema whose DDL needs more than that — initialize issues
+// 2N+3 statements for N entities — stalled every statement past the tenth until
+// the 30s request timeout freed one. command destroys the stream for us.
 @send
-external exec: (client, execParams) => promise<unit> = "exec"
+external command: (client, execParams) => promise<unit> = "command"
 
 @send
 external close: client => promise<unit> = "close"
@@ -628,21 +633,21 @@ let initialize = async (
       // CLUSTER removes the database from every node — the engine's own log
       // can't replicate the drop of the database it lives in — and SYNC waits
       // for the drop to finish before the CREATE below.
-      await client->exec({
+      await client->command({
         query: `DROP DATABASE IF EXISTS ${database} ON CLUSTER '{cluster}' SYNC`,
       })
     } else {
-      await client->exec({
+      await client->command({
         query: `TRUNCATE DATABASE IF EXISTS ${database}${onClusterClause(~onCluster=ddlOnCluster)}`,
       })
     }
-    await client->exec({
+    await client->command({
       query: `CREATE DATABASE IF NOT EXISTS ${database}${databaseOnClusterClause}${databaseEngineClause}`,
     })
 
     await Promise.all(
       entities->Array.map(entityConfig =>
-        client->exec({
+        client->command({
           query: makeCreateHistoryTableQuery(
             ~entityConfig,
             ~database,
@@ -653,7 +658,7 @@ let initialize = async (
         })
       ),
     )->Utils.Promise.ignoreValue
-    await client->exec({
+    await client->command({
       query: makeCreateCheckpointsTableQuery(
         ~database,
         ~replicated,
@@ -670,14 +675,14 @@ let initialize = async (
     // caught up before creating the views. ON CLUSTER must precede the
     // database name in this command's grammar.
     if hasReplicatedDatabaseEngine {
-      await client->exec({
+      await client->command({
         query: `SYSTEM SYNC DATABASE REPLICA ON CLUSTER '{cluster}' ${database}`,
       })
     }
 
     await Promise.all(
       entities->Array.map(entityConfig =>
-        client->exec({
+        client->command({
           query: makeCreateViewQuery(~entityConfig, ~database, ~onCluster=ddlOnCluster),
         })
       ),
@@ -697,7 +702,7 @@ let resume = async (client, ~database: string, ~checkpointId: Internal.checkpoin
   try {
     // Try to use the database - will throw if it doesn't exist
     try {
-      await client->exec({query: `USE ${database}`})
+      await client->command({query: `USE ${database}`})
     } catch {
     | exn =>
       Logging.errorWithExn(
@@ -717,14 +722,14 @@ let resume = async (client, ~database: string, ~checkpointId: Internal.checkpoin
     await Promise.all(
       tables->Array.map(table => {
         let tableName = table["name"]
-        client->exec({
+        client->command({
           query: `ALTER TABLE ${database}.\`${tableName}\` DELETE WHERE \`${EntityHistory.checkpointIdFieldName}\` > ${checkpointId->BigInt.toString}`,
         })
       }),
     )->Utils.Promise.ignoreValue
 
     // Delete stale checkpoints
-    await client->exec({
+    await client->command({
       query: `DELETE FROM ${database}.\`${InternalTable.Checkpoints.table.tableName}\` WHERE \`${Table.idFieldName}\` > ${checkpointId->BigInt.toString}`,
     })
   } catch {

package/src/bindings/ClickHouse.res.mjs

@@ -428,31 +428,31 @@ async function initialize(client, database, entities, param, chainIdModeOpt) {
       }
     }
     if (hasReplicatedDatabaseEngine) {
-      await client.exec({
+      await client.command({
         query: `DROP DATABASE IF EXISTS ` + database + ` ON CLUSTER '{cluster}' SYNC`
       });
     } else {
-      await client.exec({
+      await client.command({
         query: `TRUNCATE DATABASE IF EXISTS ` + database + (
           ddlOnCluster ? ` ON CLUSTER '{cluster}'` : ""
         )
       });
     }
-    await client.exec({
+    await client.command({
       query: `CREATE DATABASE IF NOT EXISTS ` + database + databaseOnClusterClause + databaseEngineClause
     });
-    await Promise.all(entities.map(entityConfig => client.exec({
+    await Promise.all(entities.map(entityConfig => client.command({
       query: makeCreateHistoryTableQuery(entityConfig, database, replicated, ddlOnCluster, chainIdMode)
     })));
-    await client.exec({
+    await client.command({
       query: makeCreateCheckpointsTableQuery(database, replicated, ddlOnCluster, chainIdMode)
     });
     if (hasReplicatedDatabaseEngine) {
-      await client.exec({
+      await client.command({
         query: `SYSTEM SYNC DATABASE REPLICA ON CLUSTER '{cluster}' ` + database
       });
     }
-    await Promise.all(entities.map(entityConfig => client.exec({
+    await Promise.all(entities.map(entityConfig => client.command({
       query: makeCreateViewQuery(entityConfig, database, ddlOnCluster)
     })));
     return Logging.trace("ClickHouse storage initialization completed successfully");
@@ -466,7 +466,7 @@ async function initialize(client, database, entities, param, chainIdModeOpt) {
 async function resume(client, database, checkpointId) {
   try {
     try {
-      await client.exec({
+      await client.command({
         query: `USE ` + database
       });
     } catch (raw_exn) {
@@ -480,11 +480,11 @@ async function resume(client, database, checkpointId) {
     let tables = (await tablesResult.json()).data;
     await Promise.all(tables.map(table => {
       let tableName = table.name;
-      return client.exec({
+      return client.command({
         query: `ALTER TABLE ` + database + `.\`` + tableName + `\` DELETE WHERE \`` + EntityHistory.checkpointIdFieldName + `\` > ` + checkpointId.toString()
       });
     }));
-    return await client.exec({
+    return await client.command({
       query: `DELETE FROM ` + database + `.\`` + InternalTable.Checkpoints.table.tableName + `\` WHERE \`` + Table.idFieldName + `\` > ` + checkpointId.toString()
     });
   } catch (raw_exn$1) {

package/src/bindings/Vitest.res

@@ -98,7 +98,7 @@ external afterEach: (unit => unit) => unit = "afterEach"
 // Async Module
 // ============================================================================
 
-type options = {retry?: int}
+type options = {retry?: int, timeout?: int}
 
 module Async = {
   @module("vitest")

package/src/sources/BlockStore.res

@@ -4,6 +4,12 @@
 // page that is merged in. At batch preparation the selected fields are
 // materialised in bulk, off the JS thread, in columnar form and zipped into
 // plain JS objects on the main thread.
+//
+// The store also owns response validation and reorg detection. A response page
+// records conflicts found while it is built; SourceManager rejects those pages
+// before the persistent store is touched. Merging a validated page compares
+// only persistent-vs-response hashes, and pruning keeps the hash of processed
+// blocks still inside the reorg threshold.
 type t
 
 @send external newEvm: (Core.blockStoreCtor, ~shouldChecksum: bool) => t = "newEvm"
@@ -26,8 +32,93 @@ let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool): t => {
 // with the Rust store, `EvmBlockField`).
 let makeMaskFn = FieldMask.makeMaskFn
 
-// Drain another store (a fetch-response page) into this one.
-@send external merge: (t, t) => unit = "merge"
+// Sparse JS blocks accepted by the `fromJs*` page constructors. Every field is
+// optional except the key, so a page can carry anything from a full block to a
+// hash-only reorg observation. The Rust side re-encodes them through the same
+// column fill as fetched blocks.
+type evmBlockInput = {number: int, hash?: string, timestamp?: int}
+type svmBlockInput = {slot: int, hash?: string, time?: int}
+type fuelBlockInput = {height: int, id?: string, time?: int}
+
+@send
+external fromJsEvm: (Core.blockStoreCtor, array<evmBlockInput>, bool) => t = "fromJsEvm"
+@send
+external fromJsSvm: (Core.blockStoreCtor, array<svmBlockInput>) => t = "fromJsSvm"
+@send
+external fromJsFuel: (Core.blockStoreCtor, array<fuelBlockInput>) => t = "fromJsFuel"
+
+// An ecosystem-agnostic (number, hash, timestamp) observation, mapped onto the
+// ecosystem's own field names when the page is built.
+type inputBlock = {blockNumber: int, blockHash?: string, blockTimestamp?: int}
+
+// Build a page from JS-observed blocks (RPC responses, stored reorg
+// checkpoints) for merging into the per-chain store.
+let fromJs = (blocks: array<inputBlock>, ~ecosystem: Ecosystem.name, ~shouldChecksum): t => {
+  let ctor = Core.getAddon().blockStore
+  switch ecosystem {
+  | Evm =>
+    ctor->fromJsEvm(
+      blocks->Array.map(b => {
+        number: b.blockNumber,
+        hash: ?b.blockHash,
+        timestamp: ?b.blockTimestamp,
+      }),
+      shouldChecksum,
+    )
+  | Svm =>
+    ctor->fromJsSvm(
+      blocks->Array.map(b => {
+        slot: b.blockNumber,
+        hash: ?b.blockHash,
+        time: ?b.blockTimestamp,
+      }),
+    )
+  | Fuel =>
+    ctor->fromJsFuel(
+      blocks->Array.map(b => {
+        height: b.blockNumber,
+        id: ?b.blockHash,
+        time: ?b.blockTimestamp,
+      }),
+    )
+  }
+}
+
+// The lowest merged block at or above the reorg threshold whose received hash
+// differed from the stored one.
+type hashMismatch = {
+  blockNumber: int,
+  storedHash: string,
+  receivedHash: string,
+}
+
+// Drain another store (a fetch-response page) into this one, comparing hashes
+// on the way. Blocks below `fromBlock` (outside the reorg threshold) or without
+// a hash on either side are merged without comparison. On a mismatch the page
+// is discarded - the stored hashes stay for the rollback comparison - unless
+// `reportOnly` is set (detect-only mode), which merges anyway so the same
+// mismatch doesn't re-report on every response.
+@send
+external merge: (t, t, ~fromBlock: int, ~reportOnly: bool) => Null.t<hashMismatch> = "merge"
+
+// Append a backend page to a logical response store. This always appends rows;
+// any conflict is retained as response metadata for SourceManager to validate.
+@send
+external appendPage: (t, t) => unit = "appendPage"
+
+// A conflict observed within the response itself. Such a response is
+// discarded and retried, rather than treated as a chain reorg.
+@send external responseConflict: t => Null.t<hashMismatch> = "responseConflict"
+
+// Requested block numbers not covered by this response. SVM gaps count as
+// covered when HyperSync's cursor has fully processed their half-open range;
+// parent slot/hash links are validated separately as response consistency.
+@send external missingHashes: (t, array<int>) => array<int> = "missingHashes"
+
+// Compare a validated response store against the persistent store in ascending
+// block order and stop at the first mismatch.
+@send
+external latestValidBlockFromStore: (t, t, array<int>) => Null.t<int> = "latestValidBlockFromStore"
 
 // Bulk-materialise blocks off the JS thread, one row per `blockNumbers[i]` key,
 // decoding only the fields set in that row's own `masks[i]`. Result is aligned
@@ -39,8 +130,27 @@ external materialize: (
   ~masks: array<float>,
 ) => promise<array<Internal.eventBlock>> = "materialize"
 
-// Drop blocks at or below the given block (already processed).
-@send external prune: (t, int) => unit = "prune"
+// Drop blocks at or below the given block (already processed), keeping the
+// hashes of blocks at or above `keepHashesFrom` for reorg detection.
+@send external prune: (t, int, ~keepHashesFrom: int) => unit = "prune"
 
-// Drop blocks above the given block (rolled back).
+// Drop blocks above the given block (rolled back), hashes included. The
+// rolled-back range is refetched, so keeping any of its hashes would compare
+// the refetch against a fork the rollback already disproved.
 @send external rollback: (t, int) => unit = "rollback"
+
+// Hash of a stored block, if the store still holds it.
+@send external getHash: (t, int) => Null.t<string> = "getHash"
+
+// Block numbers in `[fromBlock, belowBlock)` with a stored hash, ascending.
+@send
+external getHashedBlockNumbers: (t, ~fromBlock: int, ~belowBlock: int) => array<int> =
+  "getHashedBlockNumbers"
+
+// Every stored hash in `[fromBlock, belowBlock)` as two aligned columns,
+// ascending by block number - one crossing for what `getHash` would charge per
+// block.
+type hashedBlocks = {blockNumbers: array<int>, hashes: array<string>}
+
+@send
+external getHashes: (t, ~fromBlock: int, ~belowBlock: int) => hashedBlocks = "getHashes"

package/src/sources/BlockStore.res.mjs

@@ -15,10 +15,35 @@ function make(ecosystem, shouldChecksum) {
   }
 }
 
+function fromJs(blocks, ecosystem, shouldChecksum) {
+  let ctor = Core.getAddon().BlockStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.fromJsEvm(blocks.map(b => ({
+        number: b.blockNumber,
+        hash: b.blockHash,
+        timestamp: b.blockTimestamp
+      })), shouldChecksum);
+    case "fuel" :
+      return ctor.fromJsFuel(blocks.map(b => ({
+        height: b.blockNumber,
+        id: b.blockHash,
+        time: b.blockTimestamp
+      })));
+    case "svm" :
+      return ctor.fromJsSvm(blocks.map(b => ({
+        slot: b.blockNumber,
+        hash: b.blockHash,
+        time: b.blockTimestamp
+      })));
+  }
+}
+
 let makeMaskFn = FieldMask.makeMaskFn;
 
 export {
   make,
   makeMaskFn,
+  fromJs,
 }
 /* Core Not a pure module */

package/src/sources/Evm.res

@@ -76,7 +76,6 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   blockNumberName: "number",
   blockTimestampName: "timestamp",
   blockHashName: "hash",
-  cleanUpRawEventFieldsInPlace,
   onBlockMethodName: "onBlock",
   // EVM filter shape: `{block: {number: {_gte?, _lte?, _every?}}}`.
   // The inner range chunk is returned as raw `S.unknown` and parsed a

package/src/sources/Evm.res.mjs

@@ -55,7 +55,6 @@ function make(logger) {
     blockNumberName: "number",
     blockTimestampName: "timestamp",
     blockHashName: "hash",
-    cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
     onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown)))))),

package/src/sources/EvmHyperSyncSource.res

@@ -79,7 +79,7 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       payload: {
         contractName: onEventRegistration.eventConfig.contractName,
         eventName: onEventRegistration.eventConfig.name,
-        chainId: chainId,
+        chainId,
         params: item.params,
         srcAddress,
         logIndex,
@@ -112,33 +112,23 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
       ~addressSet,
       ~clientFilteredContracts=selection.clientFilteredContracts,
     ) catch {
-    | HyperSync.GetLogs.Error(error) =>
+    | HyperSync.GetLogs.Error(WrongInstance) =>
+      throw(Source.SourceBehindHead({blockNumber: fromBlock, requestStats: []}))
+    | HyperSync.GetLogs.Error(UnexpectedMissingParams({missingParams})) =>
       throw(
         Source.GetItemsError(
           Source.FailedGettingItems({
             exn: %raw(`null`),
             attemptedToBlock: toBlock->Option.getOr(knownHeight),
-            retry: switch error {
-            | WrongInstance =>
-              let backoffMillis = switch retry {
-              | 0 => 100
-              | _ => 500 * retry
-              }
-              WithBackoff({
-                message: `Block #${fromBlock->Int.toString} not found in HyperSync. HyperSync has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ${backoffMillis->Int.toString}ms.`,
-                backoffMillis,
-              })
-            | UnexpectedMissingParams({missingParams}) =>
-              ImpossibleForTheQuery({
-                message: `Source returned invalid data with missing required fields: ${missingParams->Array.joinUnsafe(
-                    ", ",
-                  )}`,
-              })
-            },
+            retry: ImpossibleForTheQuery({
+              message: `Source returned invalid data with missing required fields: ${missingParams->Array.joinUnsafe(
+                  ", ",
+                )}`,
+            }),
           }),
         ),
       )
-    | Source.RateLimited(_) as exn => throw(exn)
+    | (Source.RateLimited(_) | Source.SourceBehindHead(_)) as exn => throw(exn)
     | exn =>
       throw(
         Source.GetItemsError(
@@ -173,13 +163,6 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     //Parse page items into queue items
     let parsedQueueItems = []
 
-    // Block headers are returned once per number; items reference them by blockNumber.
-    let blocksByNumber = Utils.Map.make()
-    pageUnsafe.blocks->Array.forEach(block => {
-      blocksByNumber->Utils.Map.set(block.number, block)->ignore
-    })
-    let getBlock = blockNumber => blocksByNumber->Utils.Map.unsafeGet(blockNumber)
-
     pageUnsafe.items->Array.forEach(item => {
       let onEventRegistration = onEventRegistrations->Array.getUnsafe(item.onEventRegistrationIndex)
       parsedQueueItems
@@ -189,43 +172,6 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
 
     let parsingTimeElapsed = parsingTimeRef->Performance.secondsSince
 
-    // Collect (blockNumber, blockHash) pairs we already have from the response —
-    // one per returned 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.blocks->Array.forEach(block => {
-      blockHashes
-      ->Array.push({ReorgDetection.blockNumber: block.number, blockHash: block.hash})
-      ->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
-      }
-    }
-
-    // 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->Array.get(pageUnsafe.items->Array.length - 1) {
-      | Some(item) if item.blockNumber == heighestBlockQueried =>
-        getBlock(item.blockNumber).timestamp
-      | _ => 0
-      }
-    }
-
     let totalTimeElapsed = totalTimeRef->Performance.secondsSince
 
     let stats = {
@@ -235,30 +181,24 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     }
 
     {
-      latestFetchedBlockTimestamp,
       parsedQueueItems,
       transactionStore: Some(pageUnsafe.transactionStore),
-      blockStore: Some(pageUnsafe.blockStore),
+      // The page store also carries the rollbackGuard's blocks (head block and
+      // parent of the range's first block), inserted on the Rust side.
+      blockStore: pageUnsafe.blockStore,
       latestFetchedBlockNumber: heighestBlockQueried,
       stats,
       knownHeight,
-      blockHashes,
       fromBlockQueried: fromBlock,
       requestStats,
     }
   }
 
-  let getBlockHashes = (~blockNumbers, ~logger) =>
-    HyperSync.queryBlockDataMulti(
-      ~client,
-      ~blockNumbers,
-      ~sourceName=name,
-      ~chainId=chainId,
-      ~logger,
-    )->Promise.thenResolve(((queryRes, requestStats)) => {
-      Source.result: queryRes->HyperSync.mapExn,
-      requestStats,
-    })
+  // Called through the client rather than passed as a value: the client is a
+  // napi class, so a detached method reference loses the instance it belongs to.
+  let getBlockHashes = HyperSync.makeGetBlockHashes(
+    ~query=(~blockNumbers) => client.getBlockHashes(~blockNumbers),
+  )
 
   {
     name,
@@ -287,11 +227,6 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`)
     },
     getItemsOrThrow,
     createHeightSubscription: (~onHeight) =>
-      HyperSyncHeightStream.subscribe(
-        ~hyperSyncUrl=endpointUrl,
-        ~apiToken,
-        ~chainId=chainId,
-        ~onHeight,
-      ),
+      HyperSyncHeightStream.subscribe(~hyperSyncUrl=endpointUrl, ~apiToken, ~chainId, ~onHeight),
   }
 }

package/src/sources/EvmHyperSyncSource.res.mjs

@@ -22,7 +22,6 @@ function make(param) {
   let onEventRegistrations = param.onEventRegistrations;
   let endpointUrl = param.endpointUrl;
   let chainId = param.chainId;
-  let name = "HyperSync";
   let apiToken$1 = apiToken !== undefined ? apiToken : Stdlib_JsError.throwWithMessage(`An Envio 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 Envio API token at: https://envio.dev/app/api-tokens`);
@@ -58,22 +57,16 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
     let pageUnsafe;
     try {
       pageUnsafe = await HyperSync.GetLogs.query(client, fromBlock, toBlock, itemsTarget, selection.onEventRegistrations.map(reg => reg.index), addressSet, selection.clientFilteredContracts);
-    } catch (raw_error) {
-      let error = Primitive_exceptions.internalToException(raw_error);
-      if (error.RE_EXN_ID === HyperSync.GetLogs.$$Error) {
-        let error$1 = error._1;
-        let tmp;
-        if (typeof error$1 !== "object") {
-          let backoffMillis = retry !== 0 ? 500 * retry | 0 : 100;
-          tmp = {
-            TAG: "WithBackoff",
-            message: `Block #` + fromBlock.toString() + ` not found in HyperSync. HyperSync has multiple instances and it's possible that they drift independently slightly from the head. Indexing should continue correctly after retrying the query in ` + backoffMillis.toString() + `ms.`,
-            backoffMillis: backoffMillis
-          };
-        } else {
-          tmp = {
-            TAG: "ImpossibleForTheQuery",
-            message: `Source returned invalid data with missing required fields: ` + error$1.missingParams.join(", ")
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      if (exn.RE_EXN_ID === HyperSync.GetLogs.$$Error) {
+        let match = exn._1;
+        if (typeof match !== "object") {
+          throw {
+            RE_EXN_ID: Source.SourceBehindHead,
+            blockNumber: fromBlock,
+            requestStats: [],
+            Error: new Error()
           };
         }
         throw {
@@ -82,19 +75,25 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
             TAG: "FailedGettingItems",
             exn: null,
             attemptedToBlock: Stdlib_Option.getOr(toBlock, knownHeight),
-            retry: tmp
+            retry: {
+              TAG: "ImpossibleForTheQuery",
+              message: `Source returned invalid data with missing required fields: ` + match.missingParams.join(", ")
+            }
           },
           Error: new Error()
         };
       }
-      if (error.RE_EXN_ID === Source.RateLimited) {
-        throw error;
+      if (exn.RE_EXN_ID === Source.RateLimited) {
+        throw exn;
+      }
+      if (exn.RE_EXN_ID === Source.SourceBehindHead) {
+        throw exn;
       }
       throw {
         RE_EXN_ID: Source.GetItemsError,
         _1: {
           TAG: "FailedGettingItems",
-          exn: error,
+          exn: exn,
           attemptedToBlock: Stdlib_Option.getOr(toBlock, knownHeight),
           retry: {
             TAG: "WithBackoff",
@@ -114,41 +113,11 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
     let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
     let parsingTimeRef = Performance.now();
     let parsedQueueItems = [];
-    let blocksByNumber = new Map();
-    pageUnsafe.blocks.forEach(block => {
-      blocksByNumber.set(block.number, block);
-    });
     pageUnsafe.items.forEach(item => {
       let onEventRegistration = onEventRegistrations[item.onEventRegistrationIndex];
       parsedQueueItems.push(makeEventBatchQueueItem(item, onEventRegistration));
     });
     let parsingTimeElapsed = Performance.secondsSince(parsingTimeRef);
-    let blockHashes = [];
-    pageUnsafe.blocks.forEach(block => {
-      blockHashes.push({
-        blockHash: block.hash,
-        blockNumber: block.number
-      });
-    });
-    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 item = pageUnsafe.items[pageUnsafe.items.length - 1 | 0];
-      latestFetchedBlockTimestamp = item !== undefined && item.blockNumber === heighestBlockQueried ? blocksByNumber.get(item.blockNumber).timestamp : 0;
-    }
     let totalTimeElapsed = Performance.secondsSince(totalTimeRef);
     let stats_parsing$unknowntime$unknown$lpars$rpar = parsingTimeElapsed;
     let stats_page$unknownfetch$unknowntime$unknown$lpars$rpar = pageFetchTime;
@@ -159,23 +128,18 @@ Learn more or get a free Envio API token at: https://envio.dev/app/api-tokens`);
     };
     return {
       knownHeight: knownHeight$1,
-      blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       transactionStore: Primitive_option.some(pageUnsafe.transactionStore),
-      blockStore: Primitive_option.some(pageUnsafe.blockStore),
+      blockStore: pageUnsafe.blockStore,
       fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: heighestBlockQueried,
-      latestFetchedBlockTimestamp: latestFetchedBlockTimestamp,
       stats: stats,
       requestStats: requestStats
     };
   };
-  let getBlockHashes = (blockNumbers, logger) => HyperSync.queryBlockDataMulti(client, blockNumbers, name, chainId, logger).then(param => ({
-    result: HyperSync.mapExn(param[0]),
-    requestStats: param[1]
-  }));
+  let getBlockHashes = HyperSync.makeGetBlockHashes(blockNumbers => client.getBlockHashes(blockNumbers));
   return {
-    name: name,
+    name: "HyperSync",
     sourceFor: "Sync",
     chainId: chainId,
     poweredByHyperSync: true,
@@ -232,4 +196,4 @@ export {
   isUnauthorizedError,
   make,
 }
-/* Logging Not a pure module */
+/* Source Not a pure module */