envio 3.9.0 → 3.10.0-subgraph

package/src/sources/SvmHyperSyncClient.res

@@ -14,19 +14,14 @@ module Registration = {
     values: array<string>,
   }
 
-  // The full per-(instruction, chain) registration passed to the Rust client
-  // at construction: routing identity, the fetch state queries are built
-  // from, and the Borsh schema pieces the client builds decoders from.
+  // One `onInstruction`/`contractRegister` binding of an instruction on a
+  // chain: the handler-specific routing state and the fetch state queries are
+  // built from. Chain-scoped `index` is echoed back on routed items.
   type input = {
-    // Chain-scoped sequential registration index, echoed back on routed items.
     index: int,
-    instructionName: string,
-    contractName: string,
-    programId: string,
     isWildcard: bool,
     // Earliest slot this registration accepts; `None` is unrestricted.
     startBlock: option<int>,
-    discriminator?: string,
     isInner?: bool,
     // DNF: outer array is OR of AND-groups.
     accountFilters: array<array<accountFilter>>,
@@ -36,28 +31,73 @@ module Registration = {
     accountActivityFields: array<string>,
     logFields: array<string>,
     instructionFields: array<string>,
-    // Borsh schema pieces; empty accounts + absent argsJson = no schema.
-    accounts: array<string>,
+  }
+
+  // One config instruction: its identity (data prefix of any length; absent
+  // matches every instruction of the program) and Borsh layout, shared by
+  // every registration bound to it.
+  type instruction = {
+    name: string,
+    discriminator?: string,
     argsJson?: string,
+    registrations: array<input>,
+  }
+
+  type program = {
+    // The config's program name.
+    name: string,
+    programId: string,
     definedTypesJson?: string,
+    instructions: array<instruction>,
   }
 
+  // Groups a chain's registrations under the config instruction each was
+  // built from, so the Rust client holds one layout per instruction rather
+  // than a copy per registration.
   let fromOnEventRegistrations = (
     onEventRegistrations: array<Internal.svmOnEventRegistration>,
-  ): array<input> =>
-    onEventRegistrations->Array.map(reg => {
+  ): array<program> => {
+    let programs: array<program> = []
+    onEventRegistrations->Array.forEach(reg => {
       let eventConfig =
         reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
-      {
+      let program = switch programs->Array.find(p => p.name === eventConfig.contractName) {
+      | Some(program) => program
+      | None =>
+        let program = {
+          name: eventConfig.contractName,
+          programId: eventConfig.programId->SvmTypes.Pubkey.toString,
+          definedTypesJson: ?switch eventConfig.definedTypes {
+          | JSON.Null => None
+          | definedTypes => Some(definedTypes->JSON.stringify)
+          },
+          instructions: [],
+        }
+        programs->Array.push(program)->ignore
+        program
+      }
+      let instruction = switch program.instructions->Array.find(i => i.name === eventConfig.name) {
+      | Some(instruction) => instruction
+      | None =>
+        let instruction = {
+          name: eventConfig.name,
+          discriminator: ?eventConfig.discriminator,
+          argsJson: ?switch eventConfig.args {
+          | JSON.Null => None
+          | args => Some(args->JSON.stringify)
+          },
+          registrations: [],
+        }
+        program.instructions->Array.push(instruction)->ignore
+        instruction
+      }
+      instruction.registrations
+      ->Array.push({
         index: reg.index,
-        instructionName: eventConfig.name,
-        contractName: eventConfig.contractName,
-        programId: eventConfig.programId->SvmTypes.Pubkey.toString,
         isWildcard: reg.isWildcard,
         startBlock: reg.startBlock,
-        discriminator: ?eventConfig.discriminator,
-        isInner: ?eventConfig.isInner,
-        accountFilters: eventConfig.accountFilters->Array.map(group =>
+        isInner: ?reg.isInner,
+        accountFilters: reg.accountFilters->Array.map(group =>
           group->Array.map(
             (filter): accountFilter => {
               position: filter.position,
@@ -70,71 +110,10 @@ module Registration = {
         accountActivityFields: reg.fieldSelection.accountActivityFields->Utils.Set.toArray,
         logFields: reg.fieldSelection.logFields->Utils.Set.toArray,
         instructionFields: reg.fieldSelection.instructionFields->Utils.Set.toArray,
-        accounts: eventConfig.accounts,
-        argsJson: ?switch eventConfig.args {
-        | JSON.Null => None
-        | args => Some(args->JSON.stringify)
-        },
-        definedTypesJson: ?switch eventConfig.definedTypes {
-        | JSON.Null => None
-        | definedTypes => Some(definedTypes->JSON.stringify)
-        },
-      }
+      })
+      ->ignore
     })
-}
-
-module QueryTypes = {
-  type blockField =
-    | @as("slot") Slot
-    | @as("blockhash") Blockhash
-    | @as("parent_slot") ParentSlot
-    | @as("parent_blockhash") ParentBlockhash
-    | @as("block_time") BlockTime
-    | @as("block_height") BlockHeight
-
-  type transactionField =
-    | @as("slot") Slot
-    | @as("transaction_index") TransactionIndex
-    | @as("signatures") Signatures
-    | @as("fee_payer") FeePayer
-    | @as("success") Success
-    | @as("err") Err
-    | @as("fee") Fee
-    | @as("compute_units_consumed") ComputeUnitsConsumed
-    | @as("account_keys") AccountKeys
-    | @as("recent_blockhash") RecentBlockhash
-    | @as("version") Version
-    | @as("loaded_addresses_writable") LoadedAddressesWritable
-    | @as("loaded_addresses_readonly") LoadedAddressesReadonly
-
-  type fieldSelection = {block?: array<blockField>, transaction?: array<transactionField>}
-
-  /** Filter for selecting instruction calls. All non-empty fields are AND-ed:
-   an instruction must match at least one value in every non-empty field.
-
-   Discriminator filters (d1..d8) take hex-encoded byte prefixes ("0x" optional).
-   Account filters (a0..a9) take base58 pubkey strings. */
-  type instructionSelection = {
-    executingAccount?: array<string>,
-    d1?: array<string>,
-    d2?: array<string>,
-    d4?: array<string>,
-    d8?: array<string>,
-    isInner?: bool,
-    /** Success of the parent transaction; absent matches both. */
-    txSuccess?: bool,
-  }
-
-  // The `get` query surface, used only for block-data range queries; event
-  // fetching goes through `getEventItems`, which builds its query in Rust.
-  type query = {
-    fromSlot: int,
-    toSlot?: int,
-    instructionCalls?: array<instructionSelection>,
-    includeAllBlocks?: bool,
-    fields?: fieldSelection,
-    maxNumBlocks?: int,
-    maxNumInstructions?: int,
+    programs
   }
 }
 
@@ -146,37 +125,6 @@ module ResponseTypes = {
     blockhash: string,
     blockTime: Null.t<int>,
   }
-
-  type instructionCall = {
-    slot: int,
-    transactionIndex: int,
-    instructionAddress: array<int>,
-    /** The invoked program's account. */
-    executingAccount: string,
-    accountArguments: array<string>,
-    data: string,
-    d1: Null.t<string>,
-    d2: Null.t<string>,
-    d4: Null.t<string>,
-    d8: Null.t<string>,
-    isInner: bool,
-    /** Success of the parent transaction, not of this invocation. */
-    txSuccess: bool,
-    /** Per-invocation failure reason (e.g. "custom program error: 0x1"). */
-    error: Null.t<string>,
-    computeUnitsConsumed: Null.t<bigint>,
-  }
-
-  type queryResponseData = {
-    blocks: array<block>,
-    instructionCalls: array<instructionCall>,
-  }
-
-  type queryResponse = {
-    nextSlot: int,
-    responseBytes: int,
-    data: queryResponseData,
-  }
 }
 
 module EventItems = {
@@ -213,12 +161,12 @@ module EventItems = {
     path: array<int>,
     programId: string,
     accounts: array<string>,
-    data: string,
+    data: Uint8Array.t,
     isInner: bool,
-    // Borsh-decoded args as a JSON object literal, `{}` when the routed
-    // registration reads no args. An instruction the schema rejects is dropped
-    // in Rust, so a selected `args` is always decoded.
-    argsJson: string,
+    // Borsh-decoded args as a JS value tree (wide integers as bigint).
+    // Non-null exactly when the routed registration selected `args`: an
+    // instruction its layout rejects is dropped in Rust.
+    args: Null.t<unknown>,
     // Non-null only when the routed registration selected `fields.log`.
     logs: Null.t<array<log>>,
   }
@@ -234,16 +182,11 @@ module EventItems = {
   }
 }
 
-type query = QueryTypes.query
-type queryResponse = ResponseTypes.queryResponse
-
 type t = {
   getHeight: unit => promise<int>,
   // Block-hash query construction, pagination, and cursor-backed skipped-slot
   // coverage live in Rust.
   getBlockHashes: (~blockNumbers: array<int>) => promise<(BlockStore.t, array<RequestStat.t>)>,
-  // Block-data range queries only; the store pages it returns are empty.
-  get: (~query: query) => promise<(queryResponse, TransactionStore.t, BlockStore.t)>,
   // Returns the routed items plus pages of raw transactions and blocks (kept
   // in Rust), keyed by (slot, transactionIndex) / slot, materialised at batch
   // prep.
@@ -258,7 +201,7 @@ external classFromConfig: (
   Core.svmHyperSyncClientCtor,
   cfg,
   string,
-  array<Registration.input>,
+  array<Registration.program>,
   AddressStore.t,
 ) => t = "fromConfig"
 
@@ -268,7 +211,7 @@ let make = (
   ~httpReqTimeoutMillis=?,
   ~retryBaseMs=?,
   ~retryCeilingMs=?,
-  ~eventRegistrations=[],
+  ~programs=[],
   ~addressStore,
 ) => {
   let envioVersion = Utils.EnvioPackage.value.version
@@ -281,7 +224,7 @@ let make = (
       ?retryCeilingMs,
     },
     `hyperindex/${envioVersion}`,
-    eventRegistrations,
+    programs,
     addressStore,
   )
 }

package/src/sources/SvmHyperSyncClient.res.mjs

@@ -4,24 +4,55 @@ import * as Core from "../Core.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 
 function fromOnEventRegistrations(onEventRegistrations) {
-  return onEventRegistrations.map(reg => {
+  let programs = [];
+  onEventRegistrations.forEach(reg => {
     let eventConfig = reg.eventConfig;
-    let args = eventConfig.args;
-    let tmp;
-    tmp = args === null ? undefined : JSON.stringify(args);
-    let definedTypes = eventConfig.definedTypes;
-    let tmp$1;
-    tmp$1 = definedTypes === null ? undefined : JSON.stringify(definedTypes);
-    return {
+    let program = programs.find(p => p.name === eventConfig.contractName);
+    let program$1;
+    if (program !== undefined) {
+      program$1 = program;
+    } else {
+      let definedTypes = eventConfig.definedTypes;
+      let tmp;
+      tmp = definedTypes === null ? undefined : JSON.stringify(definedTypes);
+      let program_name = eventConfig.contractName;
+      let program_programId = eventConfig.programId;
+      let program_instructions = [];
+      let program$2 = {
+        name: program_name,
+        programId: program_programId,
+        definedTypesJson: tmp,
+        instructions: program_instructions
+      };
+      programs.push(program$2);
+      program$1 = program$2;
+    }
+    let instruction = program$1.instructions.find(i => i.name === eventConfig.name);
+    let instruction$1;
+    if (instruction !== undefined) {
+      instruction$1 = instruction;
+    } else {
+      let args = eventConfig.args;
+      let tmp$1;
+      tmp$1 = args === null ? undefined : JSON.stringify(args);
+      let instruction_name = eventConfig.name;
+      let instruction_discriminator = eventConfig.discriminator;
+      let instruction_registrations = [];
+      let instruction$2 = {
+        name: instruction_name,
+        discriminator: instruction_discriminator,
+        argsJson: tmp$1,
+        registrations: instruction_registrations
+      };
+      program$1.instructions.push(instruction$2);
+      instruction$1 = instruction$2;
+    }
+    instruction$1.registrations.push({
       index: reg.index,
-      instructionName: eventConfig.name,
-      contractName: eventConfig.contractName,
-      programId: eventConfig.programId,
       isWildcard: reg.isWildcard,
       startBlock: reg.startBlock,
-      discriminator: eventConfig.discriminator,
-      isInner: eventConfig.isInner,
-      accountFilters: eventConfig.accountFilters.map(group => group.map(filter => ({
+      isInner: reg.isInner,
+      accountFilters: reg.accountFilters.map(group => group.map(filter => ({
         position: filter.position,
         values: filter.values
       }))),
@@ -29,26 +60,22 @@ function fromOnEventRegistrations(onEventRegistrations) {
       blockFields: Array.from(reg.fieldSelection.blockFields),
       accountActivityFields: Array.from(reg.fieldSelection.accountActivityFields),
       logFields: Array.from(reg.fieldSelection.logFields),
-      instructionFields: Array.from(reg.fieldSelection.instructionFields),
-      accounts: eventConfig.accounts,
-      argsJson: tmp,
-      definedTypesJson: tmp$1
-    };
+      instructionFields: Array.from(reg.fieldSelection.instructionFields)
+    });
   });
+  return programs;
 }
 
 let Registration = {
   fromOnEventRegistrations: fromOnEventRegistrations
 };
 
-let QueryTypes = {};
-
 let ResponseTypes = {};
 
 let EventItems = {};
 
-function make(url, apiToken, httpReqTimeoutMillis, retryBaseMs, retryCeilingMs, eventRegistrationsOpt, addressStore) {
-  let eventRegistrations = eventRegistrationsOpt !== undefined ? eventRegistrationsOpt : [];
+function make(url, apiToken, httpReqTimeoutMillis, retryBaseMs, retryCeilingMs, programsOpt, addressStore) {
+  let programs = programsOpt !== undefined ? programsOpt : [];
   let envioVersion = Utils.EnvioPackage.value.version;
   return Core.getAddon().SvmHyperSyncClient.fromConfig({
     url: url,
@@ -56,12 +83,11 @@ function make(url, apiToken, httpReqTimeoutMillis, retryBaseMs, retryCeilingMs,
     httpReqTimeoutMillis: httpReqTimeoutMillis,
     retryBaseMs: retryBaseMs,
     retryCeilingMs: retryCeilingMs
-  }, `hyperindex/` + envioVersion, eventRegistrations, addressStore);
+  }, `hyperindex/` + envioVersion, programs, addressStore);
 }
 
 export {
   Registration,
-  QueryTypes,
   ResponseTypes,
   EventItems,
   make,

package/src/sources/SvmHyperSyncSource.res

@@ -10,10 +10,9 @@ type options = {
   addressStore: AddressStore.t,
 }
 
-let namedAccounts = (
-  ~idlNames: array<string>,
-  ~accountArguments: array<string>,
-): dict<Envio.svmInstructionAccount> => {
+let namedAccounts = (~idlNames: array<string>, ~accountArguments: array<string>): dict<
+  Envio.svmInstructionAccount,
+> => {
   let out = Dict.make()
   idlNames->Array.forEachWithIndex((name, i) =>
     switch accountArguments->Array.get(i) {
@@ -32,7 +31,10 @@ let namedAccounts = (
   out
 }
 
-let selectedLog = (log: SvmHyperSyncClient.EventItems.log, ~logFields: Utils.Set.t<string>): Envio.svmLog => {
+let selectedLog = (
+  log: SvmHyperSyncClient.EventItems.log,
+  ~logFields: Utils.Set.t<string>,
+): Envio.svmLog => {
   let out = Dict.make()
   if logFields->Utils.Set.has("kind") {
     switch log.kind->Null.toOption {
@@ -63,9 +65,11 @@ let toSvmInstruction = (
   ~fieldSelection: Internal.fieldSelection,
 ): Envio.svmInstruction => {
   let hasSelection = name => fieldSelection.instructionFields->Utils.Set.has(name)
+  // A program-wide registration has no configured discriminator, so the whole
+  // data stands in, hex-encoded like a configured one would be.
   let discriminator = switch eventConfig.discriminator {
   | Some(d) => d
-  | None => item.data
+  | None => "0x" ++ item.data->NodeJs.Buffer.fromUint8Array->NodeJs.Buffer.toHex
   }
   let out = Dict.make()
   out->setField("programName", programName)
@@ -83,8 +87,9 @@ let toSvmInstruction = (
   if hasSelection("isInner") {
     out->setField("isInner", item.isInner)
   }
-  if hasSelection("args") {
-    out->setField("args", item.argsJson->JSON.parseOrThrow)
+  switch item.args->Null.toOption {
+  | Some(args) => out->setField("args", args)
+  | None => ()
   }
   if hasSelection("accounts") {
     out->setField(
@@ -125,9 +130,7 @@ let make = (
     ~url=endpointUrl,
     ~apiToken?,
     ~httpReqTimeoutMillis=clientTimeoutMillis,
-    ~eventRegistrations=SvmHyperSyncClient.Registration.fromOnEventRegistrations(
-      onEventRegistrations,
-    ),
+    ~programs=SvmHyperSyncClient.Registration.fromOnEventRegistrations(onEventRegistrations),
     ~addressStore,
   )
 
@@ -198,7 +201,7 @@ let make = (
         ~fieldSelection=onEventRegistration.fieldSelection,
       )
       Internal.Event({
-        onEventRegistration,
+        onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
         chainId,
         blockNumber: item.slot,
         // A slot orders by `(transactionIndex, path)` — the
@@ -236,15 +239,15 @@ let make = (
 
   // 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),
+  let getBlockHashes = HyperSync.makeGetBlockHashes(~query=(~blockNumbers) =>
+    client.getBlockHashes(~blockNumbers)
   )
 
   {
     name,
     sourceFor: Sync,
     chainId,
-    pollingInterval: 1000,
+    pollingInterval: HyperSync.pollingInterval,
     poweredByHyperSync: true,
     getBlockHashes,
     getHeightOrThrow: async () => {

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -48,7 +48,7 @@ function setField(out, name, value) {
 
 function toSvmInstruction(item, programName, instructionName, eventConfig, fieldSelection) {
   let d = eventConfig.discriminator;
-  let discriminator = d !== undefined ? d : item.data;
+  let discriminator = d !== undefined ? d : "0x" + Buffer.from(item.data).toString("hex");
   let out = {};
   setField(out, "programName", programName);
   setField(out, "instructionName", instructionName);
@@ -65,8 +65,9 @@ function toSvmInstruction(item, programName, instructionName, eventConfig, field
   if (fieldSelection.instructionFields.has("isInner")) {
     setField(out, "isInner", item.isInner);
   }
-  if (fieldSelection.instructionFields.has("args")) {
-    setField(out, "args", JSON.parse(item.argsJson));
+  let args = item.args;
+  if (args !== null) {
+    setField(out, "args", args);
   }
   if (fieldSelection.instructionFields.has("accounts")) {
     setField(out, "accounts", namedAccounts(eventConfig.accounts, item.accounts));
@@ -163,7 +164,7 @@ function make(param) {
     sourceFor: "Sync",
     chainId: chainId,
     poweredByHyperSync: true,
-    pollingInterval: 1000,
+    pollingInterval: HyperSync.pollingInterval,
     getBlockHashes: getBlockHashes,
     getHeightOrThrow: async () => {
       let timer = Performance.now();

package/src/subgraph/blocks.ts

@@ -0,0 +1,176 @@
+/**
+ * A block handler's `block.timestamp`.
+ *
+ * envio hands a block handler only the block number, so the timestamp has to be
+ * fetched. Every handler invocation in a batch asks within the same microtask,
+ * so the requests are collected and answered by a single HyperSync range query
+ * rather than one round trip per block. An RPC endpoint, if one is configured,
+ * is the fallback for whatever HyperSync couldn't answer.
+ */
+
+import { createPublicClient, fallback, http } from "viem";
+
+const API_TOKEN_ENV_VAR = "ENVIO_API_TOKEN";
+
+const hypersyncUrl = (chainId: number) => `https://${chainId}.hypersync.xyz/query`;
+
+type Waiter = {
+  resolve: (timestamp: bigint) => void;
+  reject: (error: unknown) => void;
+};
+
+/** Blocks asked for since the last flush, by chain then block number. */
+let pending = new Map<number, Map<number, Waiter[]>>();
+let flushScheduled = false;
+
+let rpcUrls: string[] = [];
+let client: ReturnType<typeof createPublicClient> | null = null;
+
+export function configureBlockTimestamps(urls: string[]) {
+  rpcUrls = urls;
+  client = null;
+  pending = new Map();
+  flushScheduled = false;
+}
+
+export function requestBlockTimestamp(chainId: number, blockNumber: number): Promise<bigint> {
+  return new Promise((resolve, reject) => {
+    let blocks = pending.get(chainId);
+    if (!blocks) {
+      blocks = new Map();
+      pending.set(chainId, blocks);
+    }
+    const waiters = blocks.get(blockNumber);
+    if (waiters) {
+      waiters.push({ resolve, reject });
+    } else {
+      blocks.set(blockNumber, [{ resolve, reject }]);
+    }
+
+    if (!flushScheduled) {
+      flushScheduled = true;
+      queueMicrotask(() => {
+        flushScheduled = false;
+        const collected = pending;
+        pending = new Map();
+        for (const [chain, blocksForChain] of collected) {
+          void answer(chain, blocksForChain);
+        }
+      });
+    }
+  });
+}
+
+async function answer(chainId: number, blocks: Map<number, Waiter[]>) {
+  let timestamps = new Map<number, bigint>();
+
+  // A batch can hold thousands of blocks, and one argument per block would
+  // overflow the call stack inside the try, where it would read as a HyperSync
+  // failure and fall back to one round trip per block.
+  let lowest = Infinity;
+  let highest = -Infinity;
+  for (const blockNumber of blocks.keys()) {
+    if (blockNumber < lowest) lowest = blockNumber;
+    if (blockNumber > highest) highest = blockNumber;
+  }
+
+  try {
+    timestamps = await fromHyperSync(chainId, lowest, highest);
+  } catch (error) {
+    if (rpcUrls.length === 0) {
+      const message = error instanceof Error ? error.message : String(error);
+      for (const waiters of blocks.values()) {
+        for (const waiter of waiters) {
+          waiter.reject(
+            new Error(
+              `Envio Subgraph couldn't read a block timestamp from HyperSync: ${message}\n` +
+                `Set ${API_TOKEN_ENV_VAR} in .env or the environment — create one at\n` +
+                `https://envio.dev/app/api-tokens — or set ENVIO_SUBGRAPH_RPC to fall back to RPC.`,
+            ),
+          );
+        }
+      }
+      return;
+    }
+  }
+
+  for (const [blockNumber, waiters] of blocks) {
+    const known = timestamps.get(blockNumber);
+    if (known !== undefined) {
+      for (const waiter of waiters) waiter.resolve(known);
+      continue;
+    }
+    try {
+      const timestamp = await fromRpc(blockNumber);
+      for (const waiter of waiters) waiter.resolve(timestamp);
+    } catch (error) {
+      for (const waiter of waiters) waiter.reject(error);
+    }
+  }
+}
+
+type HyperSyncResponse = {
+  data: { blocks?: { number: number; timestamp: string }[] }[];
+  next_block: number;
+};
+
+async function fromHyperSync(
+  chainId: number,
+  fromBlock: number,
+  toBlock: number,
+): Promise<Map<number, bigint>> {
+  const token = process.env[API_TOKEN_ENV_VAR];
+  const timestamps = new Map<number, bigint>();
+
+  let cursor = fromBlock;
+  // HyperSync answers as much of the range as one response holds and points at
+  // where to resume, so a wide range takes more than one round trip.
+  while (cursor <= toBlock) {
+    const response = await fetch(hypersyncUrl(chainId), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(token ? { authorization: `Bearer ${token}` } : {}),
+      },
+      body: JSON.stringify({
+        from_block: cursor,
+        to_block: toBlock + 1,
+        include_all_blocks: true,
+        field_selection: { block: ["number", "timestamp"] },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HyperSync returned ${response.status} ${await response.text()}`);
+    }
+
+    const body = (await response.json()) as HyperSyncResponse;
+    for (const page of body.data ?? []) {
+      for (const block of page.blocks ?? []) {
+        timestamps.set(block.number, BigInt(block.timestamp));
+      }
+    }
+
+    if (!body.next_block || body.next_block <= cursor) {
+      break;
+    }
+    cursor = body.next_block;
+  }
+
+  return timestamps;
+}
+
+async function fromRpc(blockNumber: number): Promise<bigint> {
+  if (rpcUrls.length === 0) {
+    throw new Error(
+      `Envio Subgraph couldn't read the timestamp of block ${blockNumber}: HyperSync didn't\n` +
+        `return it, and no RPC fallback is configured. Set ENVIO_SUBGRAPH_RPC in .env or the\n` +
+        `environment.`,
+    );
+  }
+  client ??= createPublicClient({
+    transport: fallback(rpcUrls.map((url) => http(url, { retryCount: 0 }))),
+  });
+  const block = await client.getBlock({ blockNumber: BigInt(blockNumber) });
+  return block.timestamp;
+}