envio 3.3.0-alpha.1 → 3.3.0-alpha.2

package/src/ChainState.res.mjs

@@ -10,6 +10,7 @@ import * as EvmChain from "./sources/EvmChain.res.mjs";
 import * as FetchState from "./FetchState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as EventRouter from "./sources/EventRouter.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SourceManager from "./sources/SourceManager.res.mjs";
@@ -19,6 +20,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HyperFuelSource from "./sources/HyperFuelSource.res.mjs";
 import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as TransactionStore from "./sources/TransactionStore.res.mjs";
 import * as SvmHyperSyncSource from "./sources/SvmHyperSyncSource.res.mjs";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 
@@ -36,11 +38,12 @@ function configAddresses(chainConfig) {
   return addresses;
 }
 
-function make(chainConfig, fetchState, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, logger) {
+function make(chainConfig, fetchState, sourceManager, reorgDetection, committedProgressBlockNumber, safeCheckpointTrackingOpt, numEventsProcessedOpt, timestampCaughtUpToHeadOrEndblockOpt, isProgressAtHeadOpt, transactionFieldMaskOpt, logger) {
   let safeCheckpointTracking = safeCheckpointTrackingOpt !== undefined ? Primitive_option.valFromOption(safeCheckpointTrackingOpt) : undefined;
   let numEventsProcessed = numEventsProcessedOpt !== undefined ? numEventsProcessedOpt : 0;
   let timestampCaughtUpToHeadOrEndblock = timestampCaughtUpToHeadOrEndblockOpt !== undefined ? Primitive_option.valFromOption(timestampCaughtUpToHeadOrEndblockOpt) : undefined;
   let isProgressAtHead = isProgressAtHeadOpt !== undefined ? isProgressAtHeadOpt : false;
+  let transactionFieldMask = transactionFieldMaskOpt !== undefined ? transactionFieldMaskOpt : 0;
   return {
     logger: logger,
     fetchState: fetchState,
@@ -52,7 +55,9 @@ function make(chainConfig, fetchState, sourceManager, reorgDetection, committedP
     numEventsProcessed: numEventsProcessed,
     pendingBudget: 0,
     reorgDetection: reorgDetection,
-    safeCheckpointTracking: safeCheckpointTracking
+    safeCheckpointTracking: safeCheckpointTracking,
+    transactionStore: TransactionStore.make(),
+    transactionFieldMask: transactionFieldMask
   };
 }
 
@@ -171,7 +176,7 @@ function makeInternal(chainConfig, indexingAddresses, startBlock, endBlock, firs
       sources$1 = sources._0;
       break;
   }
-  return make(chainConfig, fetchState, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, logger);
+  return make(chainConfig, fetchState, SourceManager.make(sources$1, isRealtime, undefined, undefined, undefined, reducedPollingInterval, undefined, undefined), ReorgDetection.make(chainReorgCheckpoints, maxReorgDepth, config.shouldRollbackOnReorg), progressBlockNumber, Primitive_option.some(SafeCheckpointTracking.make(maxReorgDepth, config.shouldRollbackOnReorg, chainReorgCheckpoints)), numEventsProcessed, Primitive_option.some(timestampCaughtUpToHeadOrEndblock), undefined, config.ecosystem.transactionFieldMask(eventConfigs), logger);
 }
 
 function makeFromConfig(chainConfig, config, registrations, knownHeight) {
@@ -195,10 +200,6 @@ function logger(cs) {
   return cs.logger;
 }
 
-function fetchState(cs) {
-  return cs.fetchState;
-}
-
 function sourceManager(cs) {
   return cs.sourceManager;
 }
@@ -235,11 +236,55 @@ function timestampCaughtUpToHeadOrEndblock(cs) {
   return cs.timestampCaughtUpToHeadOrEndblock;
 }
 
+function knownHeight(cs) {
+  return cs.fetchState.knownHeight;
+}
+
+function indexingAddresses(cs) {
+  return cs.fetchState.indexingAddresses;
+}
+
+function bufferSize(cs) {
+  return FetchState.bufferSize(cs.fetchState);
+}
+
+function bufferReadyCount(cs) {
+  return FetchState.bufferReadyCount(cs.fetchState);
+}
+
+function getProgressPercentage(cs) {
+  return FetchState.getProgressPercentage(cs.fetchState);
+}
+
+function getProgressPercentageAt(cs, blockNumber) {
+  return FetchState.getProgressPercentageAt(cs.fetchState, blockNumber);
+}
+
+function hasReadyItem(cs) {
+  if (FetchState.isActivelyIndexing(cs.fetchState)) {
+    return FetchState.hasReadyItem(cs.fetchState);
+  } else {
+    return false;
+  }
+}
+
+function isReadyToEnterReorgThreshold(cs) {
+  return FetchState.isReadyToEnterReorgThreshold(cs.fetchState);
+}
+
 function startFetchingQueries(cs, queries) {
   FetchState.startFetchingQueries(cs.fetchState, queries);
   cs.pendingBudget = cs.pendingBudget + Stdlib_Array.reduce(queries, 0, (acc, query) => acc + query.estResponseSize);
 }
 
+function getNextQuery(cs, budget) {
+  return FetchState.getNextQuery(cs.fetchState, budget, cs.pendingBudget);
+}
+
+function dispatch(cs, executeQuery, waitForNewBlock, onNewBlock, action, stateId) {
+  return SourceManager.dispatch(cs.sourceManager, cs.fetchState, executeQuery, waitForNewBlock, onNewBlock, action, stateId);
+}
+
 function hasProcessedToEndblock(cs) {
   let fetchState = cs.fetchState;
   let committedProgressBlockNumber = cs.committedProgressBlockNumber;
@@ -272,7 +317,30 @@ function isFetchingAtHead(cs) {
   return FetchState.isFetchingAtHead(cs.fetchState);
 }
 
-function handleQueryResult(cs, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight) {
+function isAtHeadWithoutEndBlock(cs) {
+  if (cs.isProgressAtHead) {
+    return Stdlib_Option.isNone(cs.fetchState.endBlock);
+  } else {
+    return false;
+  }
+}
+
+function materializeBatchItems(cs, items) {
+  return TransactionStore.materializeItems(cs.transactionStore, items, cs.transactionFieldMask);
+}
+
+function materializePageItems(cs, items, page) {
+  if (page !== undefined) {
+    return TransactionStore.materializeItems(Primitive_option.valFromOption(page), items, cs.transactionFieldMask);
+  } else {
+    return Promise.resolve();
+  }
+}
+
+function handleQueryResult(cs, query, newItems, newItemsWithDcs, latestFetchedBlock, knownHeight, page) {
+  if (page !== undefined) {
+    cs.transactionStore.merge(Primitive_option.valFromOption(page));
+  }
   let fs = newItemsWithDcs.length !== 0 ? FetchState.registerDynamicContracts(cs.fetchState, newItemsWithDcs) : cs.fetchState;
   cs.fetchState = FetchState.updateKnownHeight(FetchState.handleQueryResult(fs, query, latestFetchedBlock, newItems), knownHeight);
   cs.pendingBudget = Primitive_float.max(0, cs.pendingBudget - query.estResponseSize);
@@ -344,6 +412,48 @@ function enterReorgThreshold(cs) {
   cs.fetchState = FetchState.updateInternal(cs.fetchState, undefined, undefined, undefined, cs.chainConfig.blockLag, undefined);
 }
 
+function toChainMetadata(cs) {
+  return {
+    first_event_block: Stdlib_Null.fromOption(cs.fetchState.firstEventBlock),
+    buffer_block: FetchState.bufferBlockNumber(cs.fetchState),
+    ready_at: Stdlib_Null.fromOption(cs.timestampCaughtUpToHeadOrEndblock),
+    _is_hyper_sync: SourceManager.getActiveSource(cs.sourceManager).poweredByHyperSync
+  };
+}
+
+function toChainData(cs) {
+  return {
+    chainId: cs.chainConfig.id,
+    poweredByHyperSync: SourceManager.getActiveSource(cs.sourceManager).poweredByHyperSync,
+    firstEventBlockNumber: cs.fetchState.firstEventBlock,
+    latestProcessedBlock: cs.committedProgressBlockNumber === -1 ? undefined : cs.committedProgressBlockNumber,
+    timestampCaughtUpToHeadOrEndblock: cs.timestampCaughtUpToHeadOrEndblock,
+    numEventsProcessed: cs.numEventsProcessed,
+    latestFetchedBlockNumber: Primitive_int.max(FetchState.bufferBlockNumber(cs.fetchState), 0),
+    currentBlockHeight: hasProcessedToEndblock(cs) ? Stdlib_Option.getOr(cs.fetchState.endBlock, cs.fetchState.knownHeight) : cs.fetchState.knownHeight,
+    numBatchesFetched: 0,
+    startBlock: cs.fetchState.startBlock,
+    endBlock: cs.fetchState.endBlock,
+    numAddresses: FetchState.numAddresses(cs.fetchState)
+  };
+}
+
+function toChainBeforeBatch(cs) {
+  return {
+    fetchState: cs.fetchState,
+    reorgDetection: cs.reorgDetection,
+    progressBlockNumber: cs.committedProgressBlockNumber,
+    sourceBlockNumber: cs.fetchState.knownHeight,
+    totalEventsProcessed: cs.numEventsProcessed,
+    chainConfig: cs.chainConfig
+  };
+}
+
+function isReadyToEnterReorgThresholdAfterBatch(cs, batch) {
+  let chainAfterBatch = batch.progressedChainsById[cs.fetchState.chainId];
+  return FetchState.isReadyToEnterReorgThreshold(chainAfterBatch !== undefined ? chainAfterBatch.fetchState : cs.fetchState);
+}
+
 function advanceAfterBatch(cs, batch, enteringReorgThreshold) {
   let chainAfterBatch = batch.progressedChainsById[cs.fetchState.chainId];
   if (chainAfterBatch !== undefined) {
@@ -394,6 +504,7 @@ function applyBatchProgress(cs, batch) {
   }
   cs.committedProgressBlockNumber = chainAfterBatch.progressBlockNumber;
   cs.numEventsProcessed = chainAfterBatch.totalEventsProcessed;
+  cs.transactionStore.prune(chainAfterBatch.progressBlockNumber);
   cs.isProgressAtHead = cs.isProgressAtHead || chainAfterBatch.isProgressAtHeadWhenBatchCreated;
   let safeCheckpointTracking = cs.safeCheckpointTracking;
   if (safeCheckpointTracking !== undefined) {
@@ -415,6 +526,7 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
     if (isReorgChain) {
       cs.reorgDetection = ReorgDetection.rollbackToValidBlockNumber(cs.reorgDetection, rollbackTargetBlockNumber);
       cs.fetchState = FetchState.rollback(cs.fetchState, rollbackTargetBlockNumber);
+      cs.transactionStore.rollback(rollbackTargetBlockNumber);
       cs.committedProgressBlockNumber = Primitive_int.min(cs.committedProgressBlockNumber, rollbackTargetBlockNumber);
       return;
     } else {
@@ -436,6 +548,7 @@ function rollback(cs, newProgressBlockNumber, eventsProcessedDiff, rollbackTarge
     cs.safeCheckpointTracking = SafeCheckpointTracking.rollback(safeCheckpointTracking, newProgressBlockNumber);
   }
   cs.fetchState = FetchState.rollback(cs.fetchState, newProgressBlockNumber);
+  cs.transactionStore.rollback(newProgressBlockNumber);
   cs.committedProgressBlockNumber = newProgressBlockNumber;
   cs.numEventsProcessed = newTotalEventsProcessed;
 }
@@ -446,7 +559,6 @@ export {
   makeFromConfig,
   makeFromDbState,
   logger,
-  fetchState,
   sourceManager,
   chainConfig,
   reorgDetection,
@@ -457,12 +569,29 @@ export {
   pendingBudget,
   startFetchingQueries,
   timestampCaughtUpToHeadOrEndblock,
+  knownHeight,
+  indexingAddresses,
+  bufferSize,
+  bufferReadyCount,
+  getProgressPercentage,
+  getProgressPercentageAt,
+  hasReadyItem,
+  isReadyToEnterReorgThreshold,
+  getNextQuery,
+  dispatch,
+  toChainData,
+  toChainMetadata,
+  toChainBeforeBatch,
+  isReadyToEnterReorgThresholdAfterBatch,
   hasProcessedToEndblock,
   getHighestBlockBelowThreshold,
   isActivelyIndexing,
   isReady,
   isFetchingAtHead,
+  isAtHeadWithoutEndBlock,
   handleQueryResult,
+  materializeBatchItems,
+  materializePageItems,
   registerReorgGuard,
   prepareReorg,
   updateKnownHeight,

package/src/ChainState.resi

@@ -15,6 +15,7 @@ let make: (
   ~numEventsProcessed: float=?,
   ~timestampCaughtUpToHeadOrEndblock: option<Date.t>=?,
   ~isProgressAtHead: bool=?,
+  ~transactionFieldMask: float=?,
   ~logger: Pino.t,
 ) => t
 
@@ -38,7 +39,6 @@ let makeFromDbState: (
 
 // Accessors.
 let logger: t => Pino.t
-let fetchState: t => FetchState.t
 let sourceManager: t => SourceManager.t
 let chainConfig: t => Config.chain
 let reorgDetection: t => ReorgDetection.t
@@ -50,12 +50,55 @@ let pendingBudget: t => float
 let startFetchingQueries: (t, ~queries: array<FetchState.query>) => unit
 let timestampCaughtUpToHeadOrEndblock: t => option<Date.t>
 
+// Fetch-frontier reads.
+let knownHeight: t => int
+let indexingAddresses: t => dict<FetchState.indexingAddress>
+let bufferSize: t => int
+let bufferReadyCount: t => int
+let getProgressPercentage: t => float
+let getProgressPercentageAt: (t, ~blockNumber: int) => float
+let hasReadyItem: t => bool
+let isReadyToEnterReorgThreshold: t => bool
+
+// Fetch control.
+let getNextQuery: (t, ~budget: int) => FetchState.nextQuery
+let dispatch: (
+  t,
+  ~executeQuery: FetchState.query => promise<unit>,
+  ~waitForNewBlock: (~knownHeight: int) => promise<int>,
+  ~onNewBlock: (~knownHeight: int) => unit,
+  ~action: FetchState.nextQuery,
+  ~stateId: int,
+) => promise<unit>
+
+// Views.
+type chainData = {
+  chainId: float,
+  poweredByHyperSync: bool,
+  firstEventBlockNumber: option<int>,
+  latestProcessedBlock: option<int>,
+  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
+  numEventsProcessed: float,
+  latestFetchedBlockNumber: int,
+  @as("currentBlockHeight")
+  knownHeight: int,
+  numBatchesFetched: int,
+  startBlock: int,
+  endBlock: option<int>,
+  numAddresses: int,
+}
+let toChainData: t => chainData
+let toChainMetadata: t => InternalTable.Chains.metaFields
+let toChainBeforeBatch: t => Batch.chainBeforeBatch
+let isReadyToEnterReorgThresholdAfterBatch: (t, ~batch: Batch.t) => bool
+
 // Derived (pure).
 let hasProcessedToEndblock: t => bool
 let getHighestBlockBelowThreshold: t => int
 let isActivelyIndexing: t => bool
 let isReady: t => bool
 let isFetchingAtHead: t => bool
+let isAtHeadWithoutEndBlock: t => bool
 
 // State transitions. The chain state is mutated only through these.
 let handleQueryResult: (
@@ -65,7 +108,14 @@ let handleQueryResult: (
   ~newItemsWithDcs: array<Internal.item>,
   ~latestFetchedBlock: FetchState.blockNumberAndTimestamp,
   ~knownHeight: int,
+  ~transactionStore: option<TransactionStore.t>,
 ) => unit
+let materializeBatchItems: (t, ~items: array<Internal.item>) => promise<unit>
+let materializePageItems: (
+  t,
+  ~items: array<Internal.item>,
+  ~page: option<TransactionStore.t>,
+) => promise<unit>
 let registerReorgGuard: (
   t,
   ~blockHashes: array<ReorgDetection.blockData>,

package/src/Config.res

@@ -195,9 +195,8 @@ let svmEventDescriptorSchema = S.schema(s =>
   {
     "discriminator": s.matches(S.option(S.string)),
     "discriminatorByteLen": s.matches(S.int),
-    "includeTransaction": s.matches(S.bool),
+    "transactionFields": s.matches(S.array(Internal.svmTransactionFieldSchema)),
     "includeLogs": s.matches(S.bool),
-    "includeTokenBalances": s.matches(S.bool),
     "accountFilters": s.matches(
       S.option(
         S.array(
@@ -704,9 +703,8 @@ let fromPublic = (publicConfigJson: JSON.t) => {
                 "svm": option<{
                   "discriminator": option<string>,
                   "discriminatorByteLen": int,
-                  "includeTransaction": bool,
+                  "transactionFields": array<Internal.svmTransactionField>,
                   "includeLogs": bool,
-                  "includeTokenBalances": bool,
                   "accountFilters": option<
                     array<array<{"position": int, "values": array<string>}>>,
                   >,
@@ -740,9 +738,8 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~programId,
             ~discriminator=svm["discriminator"],
             ~discriminatorByteLen=svm["discriminatorByteLen"],
-            ~includeTransaction=svm["includeTransaction"],
+            ~transactionFields=svm["transactionFields"],
             ~includeLogs=svm["includeLogs"],
-            ~includeTokenBalances=svm["includeTokenBalances"],
             ~accountFilters,
             ~isInner=svm["isInner"],
             ~isWildcard=false,

package/src/Config.res.mjs

@@ -111,9 +111,8 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
 let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
   discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   discriminatorByteLen: s.m(S$RescriptSchema.int),
-  includeTransaction: s.m(S$RescriptSchema.bool),
+  transactionFields: s.m(S$RescriptSchema.array(Internal.svmTransactionFieldSchema)),
   includeLogs: s.m(S$RescriptSchema.bool),
-  includeTokenBalances: s.m(S$RescriptSchema.bool),
   accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
     position: s.m(S$RescriptSchema.int),
     values: s.m(S$RescriptSchema.array(S$RescriptSchema.string))
@@ -518,7 +517,7 @@ function fromPublic(publicConfigJson) {
               position: af.position,
               values: af.values
             })));
-            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeTransaction, svm.includeLogs, svm.includeTokenBalances, accountFilters, svm.isInner, false, undefined, undefined, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes, startBlock);
+            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeLogs, svm.transactionFields, accountFilters, svm.isInner, false, undefined, undefined, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes, startBlock);
         }
       });
     } else {

package/src/Core.res

@@ -9,6 +9,7 @@ type evmRpcClientCtor
 type evmDecoderCtor
 type svmHypersyncClientCtor
 type hyperfuelClientCtor
+type transactionStoreCtor
 
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
@@ -23,6 +24,12 @@ type addon = {
   svmHypersyncClient: svmHypersyncClientCtor,
   @as("HyperfuelClient")
   hyperfuelClient: hyperfuelClientCtor,
+  @as("TransactionStore")
+  transactionStore: transactionStoreCtor,
+  // Ordered transaction-field names exposed for the field-code contract test
+  // (the ReScript `transactionFields` arrays must match the Rust ordinals).
+  evmTransactionFieldNames: unit => array<string>,
+  svmTransactionFieldNames: unit => array<string>,
 }
 
 @module("node:module") external createRequire: string => {..} = "createRequire"

package/src/CrossChainState.res

@@ -57,7 +57,7 @@ let totalReadyCount = (crossChainState: t) => {
   let total = ref(0)
   for i in 0 to crossChainState.chainIds->Array.length - 1 {
     let cs = crossChainState->getChainState(crossChainState.chainIds->Array.getUnsafe(i))
-    total := total.contents + cs->ChainState.fetchState->FetchState.bufferReadyCount
+    total := total.contents + cs->ChainState.bufferReadyCount
   }
   total.contents
 }
@@ -65,9 +65,7 @@ let totalReadyCount = (crossChainState: t) => {
 // --- Derived (pure). ---
 
 let nextItemIsNone = (crossChainState: t): bool =>
-  !Batch.hasReadyItem(
-    crossChainState.chainStates->Dict.valuesToArray->Array.map(ChainState.fetchState),
-  )
+  !(crossChainState.chainStates->Dict.valuesToArray->Array.some(ChainState.hasReadyItem))
 
 let getSafeCheckpointId = (crossChainState: t) => {
   let result: ref<option<bigint>> = ref(None)
@@ -79,7 +77,7 @@ let getSafeCheckpointId = (crossChainState: t) => {
     | Some(safeCheckpointTracking) =>
       let safeCheckpointId =
         safeCheckpointTracking->SafeCheckpointTracking.getSafeCheckpointId(
-          ~sourceBlockNumber=(cs->ChainState.fetchState).knownHeight,
+          ~sourceBlockNumber=cs->ChainState.knownHeight,
         )
       switch result.contents {
       | None => result := Some(safeCheckpointId)
@@ -111,16 +109,9 @@ let createBatch = (
       // in an append-only ClickHouse insert.
       isRollback ? 1n : 0n,
     ),
-    ~chainsBeforeBatch=crossChainState.chainStates->Utils.Dict.mapValues((
-      cs
-    ): Batch.chainBeforeBatch => {
-      fetchState: cs->ChainState.fetchState,
-      progressBlockNumber: cs->ChainState.committedProgressBlockNumber,
-      totalEventsProcessed: cs->ChainState.numEventsProcessed,
-      sourceBlockNumber: (cs->ChainState.fetchState).knownHeight,
-      reorgDetection: cs->ChainState.reorgDetection,
-      chainConfig: cs->ChainState.chainConfig,
-    }),
+    ~chainsBeforeBatch=crossChainState.chainStates->Utils.Dict.mapValues(
+      ChainState.toChainBeforeBatch,
+    ),
     ~batchSizeTarget,
   )
 }
@@ -184,10 +175,7 @@ let priorityOrder = (crossChainState: t) =>
   crossChainState.chainStates
   ->Dict.valuesToArray
   ->Array.toSorted((a, b) =>
-    Float.compare(
-      a->ChainState.fetchState->FetchState.getProgressPercentage,
-      b->ChainState.fetchState->FetchState.getProgressPercentage,
-    )
+    Float.compare(a->ChainState.getProgressPercentage, b->ChainState.getProgressPercentage)
   )
 
 // In-flight estimated items across every chain — the live draw against
@@ -235,11 +223,7 @@ let checkAndFetch = async (
   for i in 0 to chainIds->Array.length - 1 {
     let chainId = chainIds->Array.getUnsafe(i)
     let cs = crossChainState->getChainState(chainId)
-    let fetchState = cs->ChainState.fetchState
-    switch fetchState->FetchState.getNextQuery(
-      ~budget=remaining,
-      ~chainPendingBudget=cs->ChainState.pendingBudget,
-    ) {
+    switch cs->ChainState.getNextQuery(~budget=remaining) {
     | (WaitingForNewBlock | NothingToQuery) as action =>
       actionByChain->Utils.Dict.setByInt(chainId, action)
     | Ready(queries) =>
@@ -247,8 +231,7 @@ let checkAndFetch = async (
       actionByChain->Utils.Dict.setByInt(chainId, FetchState.NothingToQuery)
       queries->Array.forEach(query => {
         query.chainId = chainId
-        query.progress =
-          fetchState->FetchState.getProgressPercentageAt(~blockNumber=query.fromBlock)
+        query.progress = cs->ChainState.getProgressPercentageAt(~blockNumber=query.fromBlock)
         candidates->Array.push(query)
       })
     }

package/src/CrossChainState.res.mjs

@@ -6,7 +6,6 @@ import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as FetchState from "./FetchState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
@@ -53,13 +52,13 @@ function totalReadyCount(crossChainState) {
   let total = 0;
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
-    total = total + FetchState.bufferReadyCount(ChainState.fetchState(cs)) | 0;
+    total = total + ChainState.bufferReadyCount(cs) | 0;
   }
   return total;
 }
 
 function nextItemIsNone(crossChainState) {
-  return !Batch.hasReadyItem(Object.values(crossChainState.chainStates).map(ChainState.fetchState));
+  return !Object.values(crossChainState.chainStates).some(ChainState.hasReadyItem);
 }
 
 function getSafeCheckpointId(crossChainState) {
@@ -68,7 +67,7 @@ function getSafeCheckpointId(crossChainState) {
     let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
     let safeCheckpointTracking = ChainState.safeCheckpointTracking(cs);
     if (safeCheckpointTracking !== undefined) {
-      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, ChainState.fetchState(cs).knownHeight);
+      let safeCheckpointId = SafeCheckpointTracking.getSafeCheckpointId(safeCheckpointTracking, ChainState.knownHeight(cs));
       let current = result;
       if (!(current !== undefined && safeCheckpointId >= current)) {
         result = safeCheckpointId;
@@ -84,14 +83,7 @@ function getSafeCheckpointId(crossChainState) {
 function createBatch(crossChainState, processedCheckpointId, batchSizeTarget, isRollback) {
   return Batch.make(processedCheckpointId + (
     isRollback ? 1n : 0n
-  ), Utils.Dict.mapValues(crossChainState.chainStates, cs => ({
-    fetchState: ChainState.fetchState(cs),
-    reorgDetection: ChainState.reorgDetection(cs),
-    progressBlockNumber: ChainState.committedProgressBlockNumber(cs),
-    sourceBlockNumber: ChainState.fetchState(cs).knownHeight,
-    totalEventsProcessed: ChainState.numEventsProcessed(cs),
-    chainConfig: ChainState.chainConfig(cs)
-  })), batchSizeTarget, crossChainState.isInReorgThreshold);
+  ), Utils.Dict.mapValues(crossChainState.chainStates, ChainState.toChainBeforeBatch), batchSizeTarget, crossChainState.isInReorgThreshold);
 }
 
 function enterReorgThreshold(crossChainState) {
@@ -131,7 +123,7 @@ function applyBatchProgress(crossChainState, batch) {
 }
 
 function priorityOrder(crossChainState) {
-  return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(FetchState.getProgressPercentage(ChainState.fetchState(a)), FetchState.getProgressPercentage(ChainState.fetchState(b))));
+  return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(ChainState.getProgressPercentage(a), ChainState.getProgressPercentage(b)));
 }
 
 function totalReservedSize(crossChainState) {
@@ -155,15 +147,14 @@ async function checkAndFetch(crossChainState, dispatchChain) {
   for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
     let chainId = chainIds[i];
     let cs = crossChainState.chainStates[chainId];
-    let fetchState = ChainState.fetchState(cs);
-    let action = FetchState.getNextQuery(fetchState, remaining, ChainState.pendingBudget(cs));
+    let action = ChainState.getNextQuery(cs, remaining);
     if (typeof action !== "object") {
       actionByChain[chainId] = action;
     } else {
       actionByChain[chainId] = "NothingToQuery";
       action._0.forEach(query => {
         query.chainId = chainId;
-        query.progress = FetchState.getProgressPercentageAt(fetchState, query.fromBlock);
+        query.progress = ChainState.getProgressPercentageAt(cs, query.fromBlock);
         candidates.push(query);
       });
     }

package/src/Ecosystem.res

@@ -33,8 +33,13 @@ type t = {
       loggers (see `getItemLogger`). */
   logger: Pino.t,
   /** Materialise the user-facing event handed to handlers and contract
-      registration from an item's opaque payload. */
+      registration from an item's opaque payload. `event.transaction` is written
+      onto the payload at batch prep (HyperSync) or inline (RPC/simulate). */
   toEvent: Internal.eventItem => Internal.event,
+  /** Bitmask (as a float) of the transaction fields selected across the chain's
+      events — the set the store materialises at batch prep. `0.` when the
+      ecosystem carries transactions inline. */
+  transactionFieldMask: array<Internal.eventConfig> => float,
   /** Build the per-item child logger for an event item, with
       ecosystem-specific log fields (EVM/Fuel: contract/event/address; SVM:
       program/instruction/programId). Closes over the injected logger. */

package/src/Envio.res

@@ -48,6 +48,7 @@ type svmTokenBalance = {
 }
 
 type svmTransaction = {
+  transactionIndex?: int,
   signatures: array<string>,
   feePayer?: SvmTypes.Pubkey.t,
   success?: bool,
@@ -104,8 +105,8 @@ type svmInstruction = {
   d8?: string,
   /** Borsh-decoded params view. See [[svmInstructionParams]]. */
   params?: svmInstructionParams,
-  /** Parent transaction. Absent when the per-instruction
-   `include_transaction` flag is `false`. */
+  /** Parent transaction. Carries only the fields selected via
+   `field_selection.transaction_fields`; absent when none are selected. */
   transaction?: svmTransaction,
   /** Program log entries scoped to this instruction. Absent when the
    per-instruction `include_logs` flag is `false`. */

package/src/EventConfigBuilder.res

@@ -306,7 +306,14 @@ let resolveFieldSelection = (
   | Some(fields) => Utils.Set.fromArray(fields)
   | None => globalTransactionFieldsSet
   }
-  (selectedBlockFields, selectedTransactionFields)
+  // The base eventConfig stores these as a string set (field names match the
+  // typed variants at runtime).
+  (
+    selectedBlockFields,
+    selectedTransactionFields->(
+      Utils.magic: Utils.Set.t<Internal.evmTransactionField> => Utils.Set.t<string>
+    ),
+  )
 }
 
 // ============== Client-side address filter ==============
@@ -427,9 +434,8 @@ let buildSvmInstructionEventConfig = (
   ~programId: SvmTypes.Pubkey.t,
   ~discriminator: option<string>,
   ~discriminatorByteLen: int,
-  ~includeTransaction: bool,
   ~includeLogs: bool,
-  ~includeTokenBalances: bool,
+  ~transactionFields: array<Internal.svmTransactionField>=[],
   ~accountFilters: array<Internal.svmAccountFilterGroup>,
   ~isInner: option<bool>,
   ~isWildcard: bool,
@@ -444,6 +450,13 @@ let buildSvmInstructionEventConfig = (
     S.json(~validate=false)
     ->Utils.Schema.coerceToJsonPgType
     ->(Utils.magic: S.t<JSON.t> => S.t<Internal.eventParams>)
+
+  // The base eventConfig stores these as a string set (field names match the
+  // typed variants at runtime).
+  let selectedTransactionFields =
+    Utils.Set.fromArray(transactionFields)->(
+      Utils.magic: Utils.Set.t<Internal.svmTransactionField> => Utils.Set.t<string>
+    )
   {
     id: switch discriminator {
     | Some(d) => d
@@ -462,9 +475,8 @@ let buildSvmInstructionEventConfig = (
     programId,
     discriminator,
     discriminatorByteLen,
-    includeTransaction,
     includeLogs,
-    includeTokenBalances,
+    selectedTransactionFields,
     accountFilters,
     isInner,
     accounts,
@@ -530,6 +542,8 @@ let buildFuelEventConfig = (
     filterByAddresses: false,
     dependsOnAddresses: !isWildcard,
     startBlock,
+    // Fuel keeps the transaction inline on the payload; nothing to materialise.
+    selectedTransactionFields: Utils.Set.make(),
     kind: fuelKind,
   }
 }