envio 3.3.0-alpha.1 → 3.3.0-alpha.3

package/src/sources/SourceManager.res

@@ -15,7 +15,7 @@ type sourceState = {
 // with a mutable state for easier reasoning and testing.
 type t = {
   sourcesState: array<sourceState>,
-  mutable statusStart: Hrtime.timeRef,
+  mutable statusStart: Performance.timeRef,
   mutable status: sourceManagerStatus,
   newBlockStallTimeout: int,
   newBlockStallTimeoutRealtime: int,
@@ -24,6 +24,10 @@ type t = {
   getHeightRetryInterval: (~retry: int) => int,
   mutable activeSource: Source.t,
   mutable waitingForNewBlockStateId: option<int>,
+  // Dedupes the "waiting for new blocks" trace so it fires once per contiguous
+  // wait period instead of on every epoch that re-enters the wait before any
+  // new block is found. Reset when blocks are found.
+  mutable waitingLogged: bool,
   // Should take into consideration partitions fetching for previous states (before rollback)
   mutable fetchingPartitionsCount: int,
   recoveryTimeout: float,
@@ -186,6 +190,7 @@ let make = (
     }),
     activeSource: initialActiveSource,
     waitingForNewBlockStateId: None,
+    waitingLogged: false,
     fetchingPartitionsCount: 0,
     newBlockStallTimeout,
     newBlockStallTimeoutRealtime,
@@ -193,7 +198,7 @@ let make = (
     reducedPollingInterval,
     getHeightRetryInterval,
     recoveryTimeout,
-    statusStart: Hrtime.makeTimer(),
+    statusStart: Performance.now(),
     status: Idle,
     hasRealtime,
     committedRateLimitTimeMs: 0.0,
@@ -211,9 +216,9 @@ let trackNewStatus = (sourceManager: t, ~newStatus) => {
   }
   promCounter->Prometheus.SafeCounter.handleFloat(
     ~labels=sourceManager.activeSource.chain->ChainMap.Chain.toChainId,
-    ~value=sourceManager.statusStart->Hrtime.timeSince->Hrtime.toSecondsFloat,
+    ~value=sourceManager.statusStart->Performance.secondsSince,
   )
-  sourceManager.statusStart = Hrtime.makeTimer()
+  sourceManager.statusStart = Performance.now()
   sourceManager.status = newStatus
 }
 
@@ -496,13 +501,14 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isRealtime, ~reduc
       "knownHeight": knownHeight,
     },
   )
-  if reducedPolling {
+  if !sourceManager.waitingLogged {
     logger->Logging.childTrace(
-      `Waiting for new blocks with reduced polling (${(sourceManager.reducedPollingInterval / 1000)
-          ->Int.toString}s). Chain is caught up, waiting for other chains to backfill.`,
+      reducedPolling
+        ? `Waiting for new blocks with reduced polling (${(sourceManager.reducedPollingInterval / 1000)
+              ->Int.toString}s). Chain is caught up, waiting for other chains to backfill.`
+        : "Initiating check for new blocks.",
     )
-  } else {
-    logger->Logging.childTrace("Initiating check for new blocks.")
+    sourceManager.waitingLogged = true
   }
 
   let mainSources = sourceManager->getNextSources(~isRealtime)
@@ -600,6 +606,7 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isRealtime, ~reduc
     "source": source.name,
     "newBlockHeight": newBlockHeight,
   })
+  sourceManager.waitingLogged = false
 
   status := Done
 
@@ -669,19 +676,13 @@ let executeQuery = async (
         ~fromBlock=query.fromBlock,
         ~toBlock,
         ~addressesByContractName=query.addressesByContractName,
-        ~indexingAddresses=query.indexingAddresses,
+        ~contractNameByAddress=query.contractNameByAddress,
         ~partitionId=query.partitionId,
         ~knownHeight,
         ~selection=query.selection,
         ~retry,
         ~logger,
       )
-      logger->Logging.childTrace({
-        "msg": "Fetched block range from server",
-        "toBlock": response.latestFetchedBlockNumber,
-        "numEvents": response.parsedQueueItems->Array.length,
-        "stats": response.stats,
-      })
       sourceState.lastFailedAt = None
       responseRef := Some(response)
     } catch {

package/src/sources/SourceManager.res.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 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 FetchState from "../FetchState.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -139,7 +139,7 @@ function make(sources, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeout
       disabled: false,
       lastFailedAt: undefined
     })),
-    statusStart: Hrtime.makeTimer(),
+    statusStart: Performance.now(),
     status: "Idle",
     newBlockStallTimeout: newBlockStallTimeout,
     newBlockStallTimeoutRealtime: newBlockStallTimeoutRealtime,
@@ -148,6 +148,7 @@ function make(sources, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeout
     getHeightRetryInterval: getHeightRetryInterval,
     activeSource: initialActiveSource,
     waitingForNewBlockStateId: undefined,
+    waitingLogged: false,
     fetchingPartitionsCount: 0,
     recoveryTimeout: recoveryTimeout,
     hasRealtime: hasRealtime,
@@ -172,8 +173,8 @@ function trackNewStatus(sourceManager, newStatus) {
       promCounter = Prometheus.IndexingQueryTime.counter;
       break;
   }
-  Prometheus.SafeCounter.handleFloat(promCounter, sourceManager.activeSource.chain, Hrtime.toSecondsFloat(Hrtime.timeSince(sourceManager.statusStart)));
-  sourceManager.statusStart = Hrtime.makeTimer();
+  Prometheus.SafeCounter.handleFloat(promCounter, sourceManager.activeSource.chain, Performance.secondsSince(sourceManager.statusStart));
+  sourceManager.statusStart = Performance.now();
   sourceManager.status = newStatus;
 }
 
@@ -408,10 +409,9 @@ async function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPo
     chainId: sourceManager.activeSource.chain,
     knownHeight: knownHeight
   });
-  if (reducedPolling) {
-    Logging.childTrace(logger, `Waiting for new blocks with reduced polling (` + (sourceManager.reducedPollingInterval / 1000 | 0).toString() + `s). Chain is caught up, waiting for other chains to backfill.`);
-  } else {
-    Logging.childTrace(logger, "Initiating check for new blocks.");
+  if (!sourceManager.waitingLogged) {
+    Logging.childTrace(logger, reducedPolling ? `Waiting for new blocks with reduced polling (` + (sourceManager.reducedPollingInterval / 1000 | 0).toString() + `s). Chain is caught up, waiting for other chains to backfill.` : "Initiating check for new blocks.");
+    sourceManager.waitingLogged = true;
   }
   let mainSources = getNextSources(sourceManager, isRealtime, undefined);
   let status = {
@@ -453,6 +453,7 @@ async function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPo
     source: source.name,
     newBlockHeight: newBlockHeight
   });
+  sourceManager.waitingLogged = false;
   status.contents = "Done";
   return newBlockHeight;
 }
@@ -499,13 +500,7 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
       retry: retry
     });
     try {
-      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingAddresses, knownHeight, query.partitionId, query.selection, retry, logger$2);
-      Logging.childTrace(logger$2, {
-        msg: "Fetched block range from server",
-        toBlock: response.latestFetchedBlockNumber,
-        numEvents: response.parsedQueueItems.length,
-        stats: response.stats
-      });
+      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.contractNameByAddress, knownHeight, query.partitionId, query.selection, retry, logger$2);
       sourceState.lastFailedAt = undefined;
       responseRef = response;
     } catch (raw_error) {

package/src/sources/Svm.res

@@ -4,10 +4,26 @@ let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.time
   }`)
 
+// Ordered transaction field names. The index of each is the field code shared
+// with the Rust store (`SvmTxField`) — keep this order in sync.
+let transactionFields = [
+  "transactionIndex",
+  "signatures",
+  "feePayer",
+  "success",
+  "err",
+  "fee",
+  "computeUnitsConsumed",
+  "accountKeys",
+  "recentBlockhash",
+  "version",
+  "tokenBalances",
+]
+
+let transactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
+
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Svm,
-  blockFields: ["slot"],
-  transactionFields: [],
   blockNumberName: "height",
   blockTimestampName: "time",
   blockHashName: "hash",
@@ -20,7 +36,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   // parse. The schema is a no-op object that always surfaces `None`.
   onEventBlockFilterSchema: S.object(_ => None),
   logger,
-  toEvent: eventItem => eventItem.payload->Internal.payloadToEvent,
+  transactionFieldMask,
+  toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem => {
     let instruction =
       eventItem.payload->(Utils.magic: Internal.eventPayload => Envio.svmInstruction)
@@ -71,9 +88,9 @@ let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): S
     getBlockHashes: (~blockNumbers as _, ~logger as _) =>
       JsError.throwWithMessage("Svm does not support getting block hashes"),
     getHeightOrThrow: async () => {
-      let timerRef = Hrtime.makeTimer()
+      let timerRef = Performance.now()
       let height = await GetFinalizedSlot.route->Rest.fetch((), ~client)
-      let seconds = timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+      let seconds = timerRef->Performance.secondsSince
       Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId, ~method="getSlot")
       Prometheus.SourceRequestCount.addSeconds(
         ~sourceName=name,
@@ -87,7 +104,7 @@ let makeRPCSource = (~chain, ~rpc: string, ~sourceFor: Source.sourceFor=Sync): S
       ~fromBlock as _,
       ~toBlock as _,
       ~addressesByContractName as _,
-      ~indexingAddresses as _,
+      ~contractNameByAddress as _,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,

package/src/sources/Svm.res.mjs

@@ -3,11 +3,12 @@
 import * as Rpc from "./Rpc.res.mjs";
 import * as Rest from "../vendored/Rest.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as TransactionStore from "./TransactionStore.res.mjs";
 
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.hash
@@ -15,11 +16,25 @@ let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.time
   });
 
+let transactionFields = [
+  "transactionIndex",
+  "signatures",
+  "feePayer",
+  "success",
+  "err",
+  "fee",
+  "computeUnitsConsumed",
+  "accountKeys",
+  "recentBlockhash",
+  "version",
+  "tokenBalances"
+];
+
+let transactionFieldMask = TransactionStore.makeMaskFn(transactionFields);
+
 function make(logger) {
   return {
     name: "svm",
-    blockFields: ["slot"],
-    transactionFields: [],
     blockNumberName: "height",
     blockTimestampName: "time",
     blockHashName: "hash",
@@ -29,6 +44,7 @@ function make(logger) {
     onEventBlockFilterSchema: S$RescriptSchema.object(param => {}),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
+    transactionFieldMask: transactionFieldMask,
     toEventLogger: eventItem => {
       let instruction = eventItem.payload;
       return Logging.createChildFrom(logger, {
@@ -67,9 +83,9 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
     pollingInterval: 10000,
     getBlockHashes: (param, param$1) => Stdlib_JsError.throwWithMessage("Svm does not support getting block hashes"),
     getHeightOrThrow: async () => {
-      let timerRef = Hrtime.makeTimer();
+      let timerRef = Performance.now();
       let height = await Rest.fetch(route, undefined, client);
-      let seconds = Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef));
+      let seconds = Performance.secondsSince(timerRef);
       Prometheus.SourceRequestCount.increment(name, chain, "getSlot");
       Prometheus.SourceRequestCount.addSeconds(name, chain, "getSlot", seconds);
       return height;
@@ -80,8 +96,10 @@ function makeRPCSource(chain, rpc, sourceForOpt) {
 
 export {
   cleanUpRawEventFieldsInPlace,
+  transactionFields,
+  transactionFieldMask,
   make,
   GetFinalizedSlot,
   makeRPCSource,
 }
-/* route Not a pure module */
+/* transactionFieldMask Not a pure module */

package/src/sources/SvmHyperSyncClient.res

@@ -147,22 +147,6 @@ module ResponseTypes = {
     blockHeight?: int,
   }
 
-  type transaction = {
-    slot: int,
-    transactionIndex: int,
-    signatures: array<string>,
-    feePayer?: string,
-    success?: bool,
-    err?: string,
-    fee?: int,
-    computeUnitsConsumed?: int,
-    accountKeys: array<string>,
-    recentBlockhash?: string,
-    version?: string,
-    loadedAddressesWritable: array<string>,
-    loadedAddressesReadonly: array<string>,
-  }
-
   /// Borsh-decoded view attached by the Rust client. `argsJson`/`accountsJson`
   /// are stringified to side-step napi-rs's lack of native JSON passthrough.
   /** Solana instruction record.
@@ -204,22 +188,10 @@ module ResponseTypes = {
     message?: string,
   }
 
-  type tokenBalance = {
-    slot: int,
-    transactionIndex?: int,
-    account?: string,
-    mint?: string,
-    owner?: string,
-    preAmount?: string,
-    postAmount?: string,
-  }
-
   type queryResponseData = {
     blocks: array<block>,
-    transactions: array<transaction>,
     instructions: array<instruction>,
     logs: array<log>,
-    tokenBalances: array<tokenBalance>,
   }
 
   type queryResponse = {
@@ -234,7 +206,9 @@ type queryResponse = ResponseTypes.queryResponse
 
 type t = {
   getHeight: unit => promise<int>,
-  get: (~query: query) => promise<queryResponse>,
+  // Returns the response plus a page of raw transactions (kept in Rust),
+  // keyed by (slot, transactionIndex), materialised at batch prep.
+  get: (~query: query) => promise<(queryResponse, TransactionStore.t)>,
 }
 
 @send

package/src/sources/SvmHyperSyncSource.res

@@ -188,7 +188,6 @@ let toSvmInstruction = (
   instr: SvmHyperSyncClient.ResponseTypes.instruction,
   ~programName,
   ~instructionName,
-  ~transaction,
   ~logs,
   ~block,
 ): Envio.svmInstruction => {
@@ -204,35 +203,10 @@ let toSvmInstruction = (
   d4: ?instr.d4,
   d8: ?instr.d8,
   params: ?(instr.decoded->Option.map(parseDecoded)),
-  ?transaction,
   ?logs,
   block,
 }
 
-let toSvmTransaction = (tx: SvmHyperSyncClient.ResponseTypes.transaction): Envio.svmTransaction => {
-  signatures: tx.signatures,
-  accountKeys: tx.accountKeys->SvmTypes.Pubkey.fromStringsUnsafe,
-  feePayer: ?(tx.feePayer->Option.map(SvmTypes.Pubkey.fromStringUnsafe)),
-  success: ?tx.success,
-  err: ?tx.err,
-  // u64 lamports / compute units arrive as `int` over napi. Convert to
-  // `bigint` so the public type stays defensible even for pathological values.
-  fee: ?(tx.fee->Option.map(BigInt.fromInt)),
-  computeUnitsConsumed: ?(tx.computeUnitsConsumed->Option.map(BigInt.fromInt)),
-  recentBlockhash: ?tx.recentBlockhash,
-  version: ?tx.version,
-}
-
-let toSvmTokenBalance = (
-  tb: SvmHyperSyncClient.ResponseTypes.tokenBalance,
-): Envio.svmTokenBalance => {
-  account: ?(tb.account->Option.map(SvmTypes.Pubkey.fromStringUnsafe)),
-  mint: ?(tb.mint->Option.map(SvmTypes.Pubkey.fromStringUnsafe)),
-  owner: ?(tb.owner->Option.map(SvmTypes.Pubkey.fromStringUnsafe)),
-  preAmount: ?tb.preAmount,
-  postAmount: ?tb.postAmount,
-}
-
 // Probe the discriminator byte-length ordering longest-first. Stops at the
 // first router hit. Falls back to the `_none` key (program-wide handler) when
 // no discriminator-keyed handler matches.
@@ -242,11 +216,11 @@ let probeRouter = (
   instr: SvmHyperSyncClient.ResponseTypes.instruction,
   byteLengthsDesc: array<int>,
   ~contractAddress,
-  ~indexingAddresses,
+  ~contractNameByAddress,
 ) => {
   let probe = (dN: option<string>) => {
     let tag = EventRouter.getSvmEventId(~programId, ~discriminator=dN)
-    router->EventRouter.get(~tag, ~contractAddress, ~blockNumber=instr.slot, ~indexingAddresses)
+    router->EventRouter.get(~tag, ~contractAddress, ~contractNameByAddress)
   }
 
   let result = byteLengthsDesc->Array.reduce(None, (acc, len) =>
@@ -273,6 +247,27 @@ let probeRouter = (
   }
 }
 
+// Map a selected transaction field to the extra query-side column it needs.
+// `transactionIndex` is always fetched as the store key, and `tokenBalances`
+// lives in a separate table (requested via `needsTokenBalances`), so neither
+// adds a transaction column here.
+let toQueryTxField = (field: Internal.svmTransactionField): option<
+  SvmHyperSyncClient.QueryTypes.transactionField,
+> =>
+  switch field {
+  | TransactionIndex => None
+  | Signatures => Some(Signatures)
+  | FeePayer => Some(FeePayer)
+  | Success => Some(Success)
+  | Err => Some(Err)
+  | Fee => Some(Fee)
+  | ComputeUnitsConsumed => Some(ComputeUnitsConsumed)
+  | AccountKeys => Some(AccountKeys)
+  | RecentBlockhash => Some(RecentBlockhash)
+  | Version => Some(Version)
+  | TokenBalances => None
+  }
+
 let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: options): t => {
   let name = "SvmHyperSync"
   let chainId = chain->ChainMap.Chain.toChainId
@@ -298,23 +293,58 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
     orderingByProgram->Dict.set(o.programId->SvmTypes.Pubkey.toString, o.byteLengthsDesc)
   )
 
-  let needsTransactions = eventConfigs->Array.some(cfg => cfg.includeTransaction)
   let needsLogs = eventConfigs->Array.some(cfg => cfg.includeLogs)
-  let needsTokenBalances = eventConfigs->Array.some(cfg => cfg.includeTokenBalances)
+
+  // Union of selected transaction fields across the chain's events. Drives both
+  // the query column selection (fetch only what's used) and the materialisation
+  // mask. `slot`/`transactionIndex` are always fetched as the store key.
+  let selectedTxFields = Utils.Set.make()
+  eventConfigs->Array.forEach(cfg =>
+    cfg.selectedTransactionFields
+    ->(Utils.magic: Utils.Set.t<string> => Utils.Set.t<Internal.svmTransactionField>)
+    ->Utils.Set.forEach(field => selectedTxFields->Utils.Set.add(field)->ignore)
+  )
+  let needsTokenBalances = selectedTxFields->Utils.Set.has(Internal.TokenBalances)
+  let txQueryFields = {
+    // Slot + TransactionIndex are always fetched so the store can be keyed by
+    // (slot, transactionIndex).
+    let fields: array<SvmHyperSyncClient.QueryTypes.transactionField> = [Slot, TransactionIndex]
+    selectedTxFields
+    ->Utils.Set.toArray
+    ->Array.forEach(field =>
+      switch toQueryTxField(field) {
+      | Some(queryField) => fields->Array.push(queryField)
+      | None => ()
+      }
+    )
+    fields
+  }
+  // The transaction table is fetched only when a selected field is actually read
+  // off a stored transaction record. `transactionIndex` materialises from the
+  // store key and `tokenBalances` lives in its own table, so neither requires it.
+  let needsTransactions =
+    selectedTxFields
+    ->Utils.Set.toArray
+    ->Array.some(field =>
+      switch field {
+      | Internal.TransactionIndex | Internal.TokenBalances => false
+      | _ => true
+      }
+    )
 
   let getItemsOrThrow = async (
     ~fromBlock,
     ~toBlock,
     ~addressesByContractName as _,
-    ~indexingAddresses,
+    ~contractNameByAddress,
     ~knownHeight,
     ~partitionId as _,
     ~selection as _,
     ~retry,
     ~logger,
   ) => {
-    let totalTimeRef = Hrtime.makeTimer()
-    let pageFetchRef = Hrtime.makeTimer()
+    let totalTimeRef = Performance.now()
+    let pageFetchRef = Performance.now()
 
     let instructionSelections = buildInstructionSelections(eventConfigs)
     // Under the server's default merge mode, requesting a table's columns is
@@ -323,23 +353,7 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
     // opted-into table needs its columns spelled out here.
     let fields: SvmHyperSyncClient.QueryTypes.fieldSelection = {
       block: [Slot, Blockhash, BlockTime],
-      transaction: ?(
-        needsTransactions
-          ? Some([
-              Slot,
-              TransactionIndex,
-              Signatures,
-              FeePayer,
-              Success,
-              Err,
-              Fee,
-              ComputeUnitsConsumed,
-              AccountKeys,
-              RecentBlockhash,
-              Version,
-            ])
-          : None
-      ),
+      transaction: ?(needsTransactions ? Some(txQueryFields) : None),
       log: ?(needsLogs ? Some([Slot, TransactionIndex, InstructionAddress, Kind, Message]) : None),
       tokenBalance: ?(
         needsTokenBalances
@@ -358,7 +372,7 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
 
     Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId, ~method="getInstructions")
 
-    let resp = try await client.get(~query) catch {
+    let (resp, transactionStore) = try await client.get(~query) catch {
     | exn =>
       throw(
         Source.GetItemsError(
@@ -376,9 +390,9 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
         ),
       )
     }
-    let pageFetchTime = pageFetchRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let pageFetchTime = pageFetchRef->Performance.secondsSince
 
-    let parsingRef = Hrtime.makeTimer()
+    let parsingRef = Performance.now()
 
     // Per-slot unix timestamp lookup from the response's `blocks` table. Slots
     // without a block row (rare; usually skipped slots) fall back to `None`.
@@ -390,13 +404,6 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
       }
     })
 
-    // Per (slot, transaction_index) lookup for parent transactions.
-    let txByKey = Dict.make()
-    resp.data.transactions->Array.forEach(tx => {
-      let key = tx.slot->Int.toString ++ ":" ++ tx.transactionIndex->Int.toString
-      txByKey->Dict.set(key, tx)
-    })
-
     // Per (slot, transaction_index, instruction_address) lookup for logs
     // scoped to a single instruction. `instructionAddress: None` logs are
     // attached to no instruction (rare; usually only system messages).
@@ -418,21 +425,6 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
       }
     })
 
-    let tokenBalancesByTx = Dict.make()
-    if needsTokenBalances {
-      resp.data.tokenBalances->Array.forEach(tb => {
-        switch tb.transactionIndex {
-        | Some(txIdx) =>
-          let key = tb.slot->Int.toString ++ ":" ++ txIdx->Int.toString
-          switch tokenBalancesByTx->Dict.get(key) {
-          | Some(existing) => existing->Array.push(tb)
-          | None => tokenBalancesByTx->Dict.set(key, [tb])
-          }
-        | None => ()
-        }
-      })
-    }
-
     let parsedQueueItems = []
     resp.data.instructions->Array.forEach(instr => {
       let programId = instr.programId->SvmTypes.Pubkey.fromStringUnsafe
@@ -448,26 +440,12 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
         instr,
         byteLengths,
         ~contractAddress,
-        ~indexingAddresses,
+        ~contractNameByAddress,
       )
 
       switch maybeConfig {
       | None => ()
       | Some(eventConfig) =>
-        let txKey = instr.slot->Int.toString ++ ":" ++ instr.transactionIndex->Int.toString
-        let maybeTx =
-          txByKey->Utils.Dict.dangerouslyGetNonOption(txKey)->Option.map(toSvmTransaction)
-        let maybeTx = if eventConfig.includeTokenBalances {
-          maybeTx->Option.map(tx => {
-            let maybeBalances =
-              tokenBalancesByTx
-              ->Utils.Dict.dangerouslyGetNonOption(txKey)
-              ->Option.map(bals => bals->Array.map(toSvmTokenBalance))
-            {...tx, tokenBalances: ?maybeBalances}
-          })
-        } else {
-          maybeTx
-        }
         let logKey =
           instr.slot->Int.toString ++
           ":" ++
@@ -492,7 +470,6 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
           instr,
           ~programName=eventConfig.contractName,
           ~instructionName=eventConfig.name,
-          ~transaction=eventConfig.includeTransaction ? maybeTx : None,
           ~logs=eventConfig.includeLogs ? maybeLogs : None,
           ~block={
             slot: instr.slot,
@@ -510,6 +487,8 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
             blockNumber: instr.slot,
             blockHash: "",
             logIndex: synthLogIndex(instr),
+            // The parent transaction is materialised from the store at batch prep.
+            transactionIndex: instr.transactionIndex,
             payload: payload->(Utils.magic: Envio.svmInstruction => Internal.eventPayload),
           }),
         )
@@ -519,7 +498,7 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
       let _ = logger
     })
 
-    let parsingTimeElapsed = parsingRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let parsingTimeElapsed = parsingRef->Performance.secondsSince
     let highestSlot = resp.nextSlot - 1
     let latestBlockTime =
       blockTimeBySlot
@@ -534,11 +513,13 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
       blockHash: b.blockhash,
     })
 
-    let totalTimeElapsed = totalTimeRef->Hrtime.timeSince->Hrtime.toSecondsFloat
+    let totalTimeElapsed = totalTimeRef->Performance.secondsSince
 
     {
       latestFetchedBlockTimestamp: latestBlockTime,
       parsedQueueItems,
+      // Raw transactions kept in Rust; materialised (selected fields) at batch prep.
+      transactionStore: Some(transactionStore),
       latestFetchedBlockNumber: highestSlot,
       stats: {totalTimeElapsed, parsingTimeElapsed, pageFetchTime},
       knownHeight,
@@ -563,7 +544,8 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
         maxNumBlocks: 1000,
       }
       Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId, ~method="getBlockHashes")
-      let resp = await client.get(~query)
+      // Block-only query; the store page is empty.
+      let (resp, _) = await client.get(~query)
       resp.data.blocks->Array.forEach(b =>
         blockDatas
         ->Array.push({
@@ -621,9 +603,9 @@ let make = ({chain, endpointUrl, apiToken, eventConfigs, clientTimeoutMillis}: o
     poweredByHyperSync: true,
     getBlockHashes,
     getHeightOrThrow: async () => {
-      let timer = Hrtime.makeTimer()
+      let timer = Performance.now()
       let h = await client.getHeight()
-      let seconds = timer->Hrtime.timeSince->Hrtime.toSecondsFloat
+      let seconds = timer->Performance.secondsSince
       Prometheus.SourceRequestCount.increment(~sourceName=name, ~chainId, ~method="getHeight")
       Prometheus.SourceRequestCount.addSeconds(
         ~sourceName=name,