envio 3.6.1 → 3.7.0-subgraph

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 */

package/src/sources/Fuel.res

@@ -1,5 +1,7 @@
 // Fuel's concrete item payload. Erased to `Internal.eventPayload` on the item
-// and recovered here via `toPayload`.
+// and recovered here via `toPayload`. The block lives raw in the per-chain
+// store and is written onto the payload at batch prep (like HyperSync EVM);
+// simulate builds it inline.
 type payload = {
   contractName: string,
   eventName: string,
@@ -8,11 +10,24 @@ type payload = {
   srcAddress: Address.t,
   logIndex: int,
   transaction: Internal.eventTransaction,
-  block: Internal.eventBlock,
+  block?: Internal.eventBlock,
 }
 external fromPayload: payload => Internal.eventPayload = "%identity"
 external toPayload: Internal.eventPayload => payload = "%identity"
 
+// Ordered block field names. The index of each is the field code shared with
+// the Rust store (`FuelBlockField`) — keep this order in sync.
+let blockFields = ["height", "id", "time"]
+
+// Fuel has no per-event block field selection: every event materialises the
+// full (height, time, id) trio, matching what the source always queries.
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields)
+
+// Fuel keeps the transaction inline on the event payload rather than in the
+// per-chain store, so there is nothing to select and no field code to hold.
+let transactionFields = []
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
+
 let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.id
     delete fields.height
@@ -24,7 +39,6 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   blockNumberName: "height",
   blockTimestampName: "time",
   blockHashName: "id",
-  cleanUpRawEventFieldsInPlace,
   onBlockMethodName: "onBlock",
   // Fuel filter shape: `{block: {height: {_gte?, _lte?, _every?}}}`.
   // Inner range chunk parsed by `blockRangeSchema` in `Main.res`.
@@ -56,7 +70,13 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     ),
   toRawEvent: eventItem => {
     let payload = eventItem.payload->toPayload
-    let header = payload.block->(Utils.magic: Internal.eventBlock => {"id": string, "time": int})
+    // Store-backed payloads get `block` written at batch prep and simulate
+    // carries it from the start, so it's present by the time a raw event is built.
+    let header = switch payload.block {
+    | Some(block) => block->(Utils.magic: Internal.eventBlock => {"id": string, "time": int})
+    | None =>
+      JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event")
+    }
     eventItem->RawEvent.make(
       ~block=payload.block,
       ~transaction=payload.transaction,

package/src/sources/Fuel.res.mjs

@@ -2,7 +2,23 @@
 
 import * as Logging from "../Logging.res.mjs";
 import * as RawEvent from "../RawEvent.res.mjs";
+import * as BlockStore from "./BlockStore.res.mjs";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as TransactionStore from "./TransactionStore.res.mjs";
+
+let blockFields = [
+  "height",
+  "id",
+  "time"
+];
+
+let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields);
+
+let transactionFields = [];
+
+let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields);
 
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.id
@@ -16,7 +32,6 @@ function make(logger) {
     blockNumberName: "height",
     blockTimestampName: "time",
     blockHashName: "id",
-    cleanUpRawEventFieldsInPlace: cleanUpRawEventFieldsInPlace,
     onBlockMethodName: "onBlock",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown))))),
     onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("height", S$RescriptSchema.unknown)))))),
@@ -32,14 +47,19 @@ function make(logger) {
     }),
     toRawEvent: eventItem => {
       let payload = eventItem.payload;
-      let header = payload.block;
+      let block = payload.block;
+      let header = block !== undefined ? Primitive_option.valFromOption(block) : Stdlib_JsError.throwWithMessage("Unexpected case: The event block is missing for a raw event");
       return RawEvent.make(eventItem, payload.block, payload.transaction, payload.params, payload.srcAddress, header.id, header.time, cleanUpRawEventFieldsInPlace);
     }
   };
 }
 
 export {
+  blockFields,
+  eventBlockFieldMask,
+  transactionFields,
+  eventTransactionFieldMask,
   cleanUpRawEventFieldsInPlace,
   make,
 }
-/* Logging Not a pure module */
+/* eventBlockFieldMask Not a pure module */

package/src/sources/FuelHyperSync.res

@@ -1,9 +1,11 @@
 type logsQueryPage = {
   items: array<FuelHyperSyncClient.EventItems.item>,
   // Blocks referenced by `items`, one per height.
-  blocks: array<FuelHyperSyncClient.EventItems.block>,
   nextBlock: int,
   archiveHeight: int,
+  // Page store owning this page's raw blocks (built on the Rust side); its ids
+  // drive reorg detection when merged into the chain store.
+  blockStore: BlockStore.t,
 }
 
 module GetLogs = {
@@ -53,7 +55,10 @@ module GetLogs = {
       clientFilteredContracts,
     }
 
-    let res = switch await client->FuelHyperSyncClient.getEventItems(query, addressSet) {
+    let (res, blockStore) = switch await client->FuelHyperSyncClient.getEventItems(
+      query,
+      addressSet,
+    ) {
     | res => res
     | exception exn =>
       switch exn->extractMissingParams {
@@ -67,9 +72,9 @@ module GetLogs = {
     }
     {
       items: res.items,
-      blocks: res.blocks,
       nextBlock: res.nextBlock,
       archiveHeight: res.archiveHeight->Option.getOr(0), // TODO: FIXME: Shouldn't have a default here
+      blockStore,
     }
   }
 }