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

package/src/EventConfigBuilder.res.mjs

@@ -297,20 +297,22 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
     paramsRawEventSchema: buildParamsSchema(params),
     simulateParamsSchema: buildSimulateParamsSchema(params),
     startBlock: resolvedStartBlock,
+    selectedTransactionFields: match$1[1],
     getEventFiltersOrThrow: match.getEventFiltersOrThrow,
     selectedBlockFields: match$1[0],
-    selectedTransactionFields: match$1[1],
     sighash: sighash,
     topicCount: topicCount,
     paramsMetadata: params
   };
 }
 
-function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeTransaction, includeLogs, includeTokenBalances, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeLogs, transactionFieldsOpt, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+  let transactionFields = transactionFieldsOpt !== undefined ? transactionFieldsOpt : [];
   let accounts = accountsOpt !== undefined ? accountsOpt : [];
   let args = argsOpt !== undefined ? argsOpt : null;
   let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
   let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
+  let selectedTransactionFields = new Set(transactionFields);
   return {
     id: discriminator !== undefined ? discriminator : "none",
     name: instructionName,
@@ -323,12 +325,11 @@ function buildSvmInstructionEventConfig(contractName, instructionName, programId
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
     startBlock: startBlock,
+    selectedTransactionFields: selectedTransactionFields,
     programId: programId,
     discriminator: discriminator,
     discriminatorByteLen: discriminatorByteLen,
-    includeTransaction: includeTransaction,
     includeLogs: includeLogs,
-    includeTokenBalances: includeTokenBalances,
     accountFilters: accountFilters,
     isInner: isInner,
     accounts: accounts,
@@ -392,6 +393,7 @@ function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, is
     paramsRawEventSchema: paramsSchema,
     simulateParamsSchema: paramsSchema,
     startBlock: startBlock,
+    selectedTransactionFields: new Set(),
     kind: fuelKind
   };
 }

package/src/EventProcessing.res

@@ -281,6 +281,29 @@ type logPartitionInfo = {
   lastItemBlockNumber?: int,
 }
 
+// Off the hot path: bulk-materialise the selected transaction fields for the
+// batch's store-backed (HyperSync) items and write them onto the payloads, so
+// handlers read plain objects. A batch can span chains, each with its own store
+// and field mask, so group items by chain before materialising.
+let materializeBatchTransactions = async (batch: Batch.t, ~chainStates: dict<ChainState.t>) => {
+  let itemsByChain: dict<array<Internal.item>> = Dict.make()
+  batch.items->Array.forEach(item => {
+    let chainId = item->Internal.getItemChainId->Int.toString
+    switch itemsByChain->Utils.Dict.dangerouslyGetNonOption(chainId) {
+    | Some(items) => items->Array.push(item)
+    | None => itemsByChain->Dict.set(chainId, [item])
+    }
+  })
+
+  let _ = await itemsByChain
+  ->Dict.toArray
+  ->Array.map(async ((chainId, items)) => {
+    let cs = chainStates->Dict.getUnsafe(chainId)
+    await cs->ChainState.materializeBatchItems(~items)
+  })
+  ->Promise.all
+}
+
 let processEventBatch = async (
   ~batch: Batch.t,
   ~indexerState: IndexerState.t,
@@ -312,6 +335,9 @@ let processEventBatch = async (
     let timeRef = Hrtime.makeTimer()
 
     if batch.items->Utils.Array.notEmpty {
+      // Materialise store-backed transactions onto payloads before any handler
+      // (preload or execute) reads them.
+      await materializeBatchTransactions(batch, ~chainStates)
       await batch->preloadBatchOrThrow(~loadManager, ~persistence, ~indexerState, ~chains, ~config)
     }
 

package/src/EventProcessing.res.mjs

@@ -4,6 +4,7 @@ import * as Utils from "./Utils.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
@@ -180,6 +181,23 @@ function registerProcessEventBatchMetrics(logger, loadDuration, handlerDuration)
   Prometheus.ProcessingBatch.registerMetrics(loadDuration, handlerDuration);
 }
 
+async function materializeBatchTransactions(batch, chainStates) {
+  let itemsByChain = {};
+  batch.items.forEach(item => {
+    let chainId = Internal.getItemChainId(item).toString();
+    let items = itemsByChain[chainId];
+    if (items !== undefined) {
+      items.push(item);
+    } else {
+      itemsByChain[chainId] = [item];
+    }
+  });
+  await Promise.all(Object.entries(itemsByChain).map(async param => {
+    let cs = chainStates[param[0]];
+    return await ChainState.materializeBatchItems(cs, param[1]);
+  }));
+}
+
 async function processEventBatch(batch, indexerState, loadManager, persistence, config, chainStates) {
   let totalBatchSize = batch.totalBatchSize;
   let chains = computeChainsState(chainStates);
@@ -196,6 +214,7 @@ async function processEventBatch(batch, indexerState, loadManager, persistence,
     await Writing.awaitCapacity(indexerState);
     let timeRef = Hrtime.makeTimer();
     if (Utils.$$Array.notEmpty(batch.items)) {
+      await materializeBatchTransactions(batch, chainStates);
       await preloadBatchOrThrow(batch, loadManager, persistence, config, indexerState, chains);
     }
     let elapsedTimeAfterLoaders = Hrtime.toSecondsFloat(Hrtime.timeSince(timeRef));
@@ -240,6 +259,7 @@ export {
   preloadBatchOrThrow,
   runBatchHandlersOrThrow,
   registerProcessEventBatchMetrics,
+  materializeBatchTransactions,
   processEventBatch,
 }
 /* Utils Not a pure module */

package/src/Internal.res

@@ -136,6 +136,36 @@ let allEvmTransactionFields: array<evmTransactionField> = [
 ]
 let evmTransactionFieldSchema = S.enum(allEvmTransactionFields)
 
+// SVM transaction fields. Order mirrors the Rust `SvmTxField` ordinals (the bit
+// position in the selection mask) and `Svm.res` `transactionFields`.
+type svmTransactionField =
+  | @as("transactionIndex") TransactionIndex
+  | @as("signatures") Signatures
+  | @as("feePayer") FeePayer
+  | @as("success") Success
+  | @as("err") Err
+  | @as("fee") Fee
+  | @as("computeUnitsConsumed") ComputeUnitsConsumed
+  | @as("accountKeys") AccountKeys
+  | @as("recentBlockhash") RecentBlockhash
+  | @as("version") Version
+  | @as("tokenBalances") TokenBalances
+
+let allSvmTransactionFields: array<svmTransactionField> = [
+  TransactionIndex,
+  Signatures,
+  FeePayer,
+  Success,
+  Err,
+  Fee,
+  ComputeUnitsConsumed,
+  AccountKeys,
+  RecentBlockhash,
+  Version,
+  TokenBalances,
+]
+let svmTransactionFieldSchema = S.enum(allSvmTransactionFields)
+
 // Static sets of nullable field names — used by RpcSource and HyperSyncSource to wrap schemas with S.nullable
 let evmNullableBlockFields = Utils.Set.fromArray(
   (
@@ -277,7 +307,10 @@ type event
 // modules, not here, and are distinct per ecosystem.
 type eventPayload
 
-external payloadToEvent: eventPayload => event = "%identity"
+// Generic access to the payload's `transaction`, written at batch prep for
+// store-backed ecosystems (HyperSync) and present inline otherwise.
+@get external getPayloadTransaction: eventPayload => Nullable.t<eventTransaction> = "transaction"
+@set external setPayloadTransaction: (eventPayload, eventTransaction) => unit = "transaction"
 
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
@@ -382,6 +415,11 @@ type eventConfig = private {
   paramsRawEventSchema: S.schema<eventParams>,
   simulateParamsSchema: S.schema<eventParams>,
   startBlock: option<int>,
+  // Field names selected for the chain's transaction-store materialisation
+  // (camelCase, matching the ecosystem's `transactionFields`). Stored as a
+  // string set so the shared mask logic is ecosystem-agnostic; sources recover
+  // the typed view where they need it.
+  selectedTransactionFields: Utils.Set.t<string>,
 }
 
 type fuelEventKind =
@@ -419,7 +457,6 @@ type evmEventConfig = {
   ...eventConfig,
   getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
   selectedBlockFields: Utils.Set.t<evmBlockField>,
-  selectedTransactionFields: Utils.Set.t<evmTransactionField>,
   sighash: string,
   topicCount: int,
   paramsMetadata: array<paramMeta>,
@@ -456,9 +493,7 @@ type svmInstructionEventConfig = {
    `dN` selector at query time and the dispatch-key precomputation in the
    router. */
   discriminatorByteLen: int,
-  includeTransaction: bool,
   includeLogs: bool,
-  includeTokenBalances: bool,
   /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
    AND across positions. Empty outer array means "no account filter". */
   accountFilters: array<svmAccountFilterGroup>,
@@ -502,6 +537,9 @@ type eventItem = private {
   blockNumber: int,
   blockHash: string,
   logIndex: int,
+  // Within-block transaction index — the key into the per-chain transaction
+  // store. Unused (0) for ecosystems that carry the transaction inline (Fuel).
+  transactionIndex: int,
   payload: eventPayload,
 }
 
@@ -554,6 +592,7 @@ type item =
       blockNumber: int,
       blockHash: string,
       logIndex: int,
+      transactionIndex: int,
       payload: eventPayload,
     })
   | @as(1) Block({onBlockConfig: onBlockConfig, blockNumber: int, logIndex: int})

package/src/Internal.res.mjs

@@ -74,6 +74,22 @@ let allEvmTransactionFields = [
 
 let evmTransactionFieldSchema = S$RescriptSchema.$$enum(allEvmTransactionFields);
 
+let allSvmTransactionFields = [
+  "transactionIndex",
+  "signatures",
+  "feePayer",
+  "success",
+  "err",
+  "fee",
+  "computeUnitsConsumed",
+  "accountKeys",
+  "recentBlockhash",
+  "version",
+  "tokenBalances"
+];
+
+let svmTransactionFieldSchema = S$RescriptSchema.$$enum(allSvmTransactionFields);
+
 let evmNullableBlockFields = new Set([
   "nonce",
   "difficulty",
@@ -160,6 +176,8 @@ export {
   evmBlockFieldSchema,
   allEvmTransactionFields,
   evmTransactionFieldSchema,
+  allSvmTransactionFields,
+  svmTransactionFieldSchema,
   evmNullableBlockFields,
   evmNullableTransactionFields,
   dependsOnAddresses,

package/src/Main.res

@@ -1,19 +1,4 @@
-type chainData = {
-  chainId: float,
-  poweredByHyperSync: bool,
-  firstEventBlockNumber: option<int>,
-  latestProcessedBlock: option<int>,
-  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
-  numEventsProcessed: float,
-  latestFetchedBlockNumber: int,
-  // Need this for API backwards compatibility
-  @as("currentBlockHeight")
-  knownHeight: int,
-  numBatchesFetched: int,
-  startBlock: int,
-  endBlock: option<int>,
-  numAddresses: int,
-}
+type chainData = ChainState.chainData
 @tag("status")
 type state =
   | @as("disabled") Disabled({})
@@ -183,7 +168,7 @@ let buildChainsObject = (~config: Config.t) => {
             | Some(state) => {
                 let chain = ChainMap.Chain.makeUnsafe(~chainId=chainConfig.id)
                 let chainState = state->IndexerState.getChainState(~chain)
-                let indexingAddresses = (chainState->ChainState.fetchState).indexingAddresses
+                let indexingAddresses = chainState->ChainState.indexingAddresses
 
                 // Collect all addresses for this contract name from indexingAddresses
                 let addresses = []
@@ -780,39 +765,7 @@ let start = async (
       | None => Initializing({})
       | Some(state) => {
           let chains =
-            state
-            ->IndexerState.chainStates
-            ->Dict.valuesToArray
-            ->Array.map(cs => {
-              let fetchState = cs->ChainState.fetchState
-              let latestFetchedBlockNumber = Pervasives.max(
-                FetchState.bufferBlockNumber(fetchState),
-                0,
-              )
-              let knownHeight =
-                cs->ChainState.hasProcessedToEndblock
-                  ? fetchState.endBlock->Option.getOr(fetchState.knownHeight)
-                  : fetchState.knownHeight
-
-              {
-                chainId: (cs->ChainState.chainConfig).id->Int.toFloat,
-                poweredByHyperSync: (
-                  cs->ChainState.sourceManager->SourceManager.getActiveSource
-                ).poweredByHyperSync,
-                latestFetchedBlockNumber,
-                knownHeight,
-                numBatchesFetched: 0,
-                startBlock: fetchState.startBlock,
-                endBlock: fetchState.endBlock,
-                firstEventBlockNumber: fetchState.firstEventBlock,
-                latestProcessedBlock: cs->ChainState.committedProgressBlockNumber === -1
-                  ? None
-                  : Some(cs->ChainState.committedProgressBlockNumber),
-                timestampCaughtUpToHeadOrEndblock: cs->ChainState.timestampCaughtUpToHeadOrEndblock,
-                numEventsProcessed: cs->ChainState.numEventsProcessed,
-                numAddresses: fetchState->FetchState.numAddresses,
-              }
-            })
+            state->IndexerState.chainStates->Dict.valuesToArray->Array.map(ChainState.toChainData)
           Active({
             envioVersion,
             chains,

package/src/Main.res.mjs

@@ -11,7 +11,6 @@ import * as Process from "process";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.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 IndexerLoop from "./IndexerLoop.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
@@ -20,8 +19,6 @@ import Yargs from "yargs/yargs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as HandlerLoader from "./HandlerLoader.res.mjs";
-import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
-import * as SourceManager from "./sources/SourceManager.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Helpers from "yargs/helpers";
 import * as RollbackCommit from "./RollbackCommit.res.mjs";
@@ -168,7 +165,7 @@ function buildChainsObject(config) {
           if (state !== undefined) {
             let chain = ChainMap.Chain.makeUnsafe(chainConfig.id);
             let chainState = IndexerState.getChainState(Primitive_option.valFromOption(state), chain);
-            let indexingAddresses = ChainState.fetchState(chainState).indexingAddresses;
+            let indexingAddresses = ChainState.indexingAddresses(chainState);
             let addresses = [];
             let values = Object.values(indexingAddresses);
             for (let idx = 0, idx_finish = values.length; idx < idx_finish; ++idx) {
@@ -586,25 +583,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
         };
       }
       let state$1 = Primitive_option.valFromOption(state);
-      let chains = Object.values(IndexerState.chainStates(state$1)).map(cs => {
-        let fetchState = ChainState.fetchState(cs);
-        let latestFetchedBlockNumber = Primitive_int.max(FetchState.bufferBlockNumber(fetchState), 0);
-        let knownHeight = ChainState.hasProcessedToEndblock(cs) ? Stdlib_Option.getOr(fetchState.endBlock, fetchState.knownHeight) : fetchState.knownHeight;
-        return {
-          chainId: ChainState.chainConfig(cs).id,
-          poweredByHyperSync: SourceManager.getActiveSource(ChainState.sourceManager(cs)).poweredByHyperSync,
-          firstEventBlockNumber: fetchState.firstEventBlock,
-          latestProcessedBlock: ChainState.committedProgressBlockNumber(cs) === -1 ? undefined : ChainState.committedProgressBlockNumber(cs),
-          timestampCaughtUpToHeadOrEndblock: ChainState.timestampCaughtUpToHeadOrEndblock(cs),
-          numEventsProcessed: ChainState.numEventsProcessed(cs),
-          latestFetchedBlockNumber: latestFetchedBlockNumber,
-          currentBlockHeight: knownHeight,
-          numBatchesFetched: 0,
-          startBlock: fetchState.startBlock,
-          endBlock: fetchState.endBlock,
-          numAddresses: FetchState.numAddresses(fetchState)
-        };
-      });
+      let chains = Object.values(IndexerState.chainStates(state$1)).map(ChainState.toChainData);
       return {
         status: "active",
         envioVersion: envioVersion,

package/src/Rollback.res

@@ -18,7 +18,7 @@ let getLastKnownValidBlock = async (
     ->ChainState.reorgDetection
     ->ReorgDetection.getThresholdBlockNumbersBelowBlock(
       ~blockNumber=reorgBlockNumber,
-      ~knownHeight=(chainState->ChainState.fetchState).knownHeight,
+      ~knownHeight=chainState->ChainState.knownHeight,
     )
 
   switch scannedBlockNumbers {

package/src/Rollback.res.mjs

@@ -18,7 +18,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime) {
-  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.fetchState(chainState).knownHeight);
+  let scannedBlockNumbers = ReorgDetection.getThresholdBlockNumbersBelowBlock(ChainState.reorgDetection(chainState), reorgBlockNumber, ChainState.knownHeight(chainState));
   if (scannedBlockNumbers.length === 0) {
     return ChainState.getHighestBlockBelowThreshold(chainState);
   }

package/src/SimulateItems.res

@@ -288,6 +288,9 @@ let parse = (~simulateItems: array<JSON.t>, ~config: Config.t, ~chainConfig: Con
           blockNumber,
           blockHash,
           logIndex,
+          // Simulate keeps the transaction inline on the payload, so the store
+          // key is unused.
+          transactionIndex: 0,
           payload: (
             {
               contractName: eventConfig.contractName,

package/src/SimulateItems.res.mjs

@@ -241,6 +241,7 @@ function parse(simulateItems, config, chainConfig) {
       blockNumber: blockNumber,
       blockHash: match$3[3],
       logIndex: logIndex,
+      transactionIndex: 0,
       payload: {
         contractName: eventConfig.contractName,
         eventName: eventConfig.name,
@@ -248,7 +249,7 @@ function parse(simulateItems, config, chainConfig) {
         chainId: chainId,
         srcAddress: srcAddress,
         logIndex: logIndex,
-        transaction: transaction,
+        transaction: Primitive_option.some(transaction),
         block: match$3[0]
       }
     });

package/src/sources/Evm.res

@@ -1,5 +1,7 @@
 // EVM's concrete item payload. Erased to `Internal.eventPayload` on the item
-// and recovered here via `toPayload`.
+// and recovered here via `toPayload`. HyperSync omits `transaction` (it lives
+// raw in the per-chain store and is written onto the payload at batch prep);
+// RPC/simulate build it inline.
 type payload = {
   contractName: string,
   eventName: string,
@@ -7,12 +9,55 @@ type payload = {
   chainId: int,
   srcAddress: Address.t,
   logIndex: int,
-  transaction: Internal.eventTransaction,
+  transaction?: Internal.eventTransaction,
   block: Internal.eventBlock,
 }
 external fromPayload: payload => Internal.eventPayload = "%identity"
 external toPayload: Internal.eventPayload => payload = "%identity"
 
+// Ordered transaction field names. The index of each is the field code shared
+// with the Rust store (`EvmTxField`) — keep this order in sync.
+let transactionFields = [
+  "transactionIndex",
+  "hash",
+  "from",
+  "to",
+  "gas",
+  "gasPrice",
+  "maxPriorityFeePerGas",
+  "maxFeePerGas",
+  "cumulativeGasUsed",
+  "effectiveGasPrice",
+  "gasUsed",
+  "input",
+  "nonce",
+  "value",
+  "v",
+  "r",
+  "s",
+  "contractAddress",
+  "logsBloom",
+  "root",
+  "status",
+  "yParity",
+  "maxFeePerBlobGas",
+  "blobVersionedHashes",
+  "type",
+  "l1Fee",
+  "l1GasPrice",
+  "l1GasUsed",
+  "l1FeeScalar",
+  "gasUsedForL1",
+  "accessList",
+  "authorizationList",
+]
+
+// Field name → bit index (the code shared with the Rust store), built once.
+let transactionFieldCodes = TransactionStore.fieldCodes(transactionFields)
+
+let transactionFieldMask = (eventConfigs: array<Internal.eventConfig>): float =>
+  eventConfigs->TransactionStore.mask(~codes=transactionFieldCodes)
+
 let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.hash
     delete fields.number
@@ -50,41 +95,7 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     "sendRoot",
     "mixHash",
   ],
-  transactionFields: [
-    "transactionIndex",
-    "hash",
-    "from",
-    "to",
-    "gas",
-    "gasPrice",
-    "maxPriorityFeePerGas",
-    "maxFeePerGas",
-    "cumulativeGasUsed",
-    "effectiveGasPrice",
-    "gasUsed",
-    "input",
-    "nonce",
-    "value",
-    "v",
-    "r",
-    "s",
-    "contractAddress",
-    "logsBloom",
-    "root",
-    "status",
-    "yParity",
-    "chainId",
-    "maxFeePerBlobGas",
-    "blobVersionedHashes",
-    "type",
-    "l1Fee",
-    "l1GasPrice",
-    "l1GasUsed",
-    "l1FeeScalar",
-    "gasUsedForL1",
-    "accessList",
-    "authorizationList",
-  ],
+  transactionFields,
   blockNumberName: "number",
   blockTimestampName: "timestamp",
   blockHashName: "hash",
@@ -106,7 +117,10 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     s.field("block", S.option(S.object(s2 => s2.field("number", S.unknown))))
   ),
   logger,
-  toEvent: eventItem => eventItem.payload->Internal.payloadToEvent,
+  transactionFieldMask,
+  // The payload carries `transaction` by batch prep (HyperSync) or inline
+  // (RPC/simulate), so the event is the payload as-is.
+  toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem =>
     Logging.createChildFrom(
       ~logger,

package/src/sources/Evm.res.mjs

@@ -3,6 +3,48 @@
 import * as Logging from "../Logging.res.mjs";
 import * as RawEvent from "../RawEvent.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as TransactionStore from "./TransactionStore.res.mjs";
+
+let transactionFields = [
+  "transactionIndex",
+  "hash",
+  "from",
+  "to",
+  "gas",
+  "gasPrice",
+  "maxPriorityFeePerGas",
+  "maxFeePerGas",
+  "cumulativeGasUsed",
+  "effectiveGasPrice",
+  "gasUsed",
+  "input",
+  "nonce",
+  "value",
+  "v",
+  "r",
+  "s",
+  "contractAddress",
+  "logsBloom",
+  "root",
+  "status",
+  "yParity",
+  "maxFeePerBlobGas",
+  "blobVersionedHashes",
+  "type",
+  "l1Fee",
+  "l1GasPrice",
+  "l1GasUsed",
+  "l1FeeScalar",
+  "gasUsedForL1",
+  "accessList",
+  "authorizationList"
+];
+
+let transactionFieldCodes = TransactionStore.fieldCodes(transactionFields);
+
+function transactionFieldMask(eventConfigs) {
+  return TransactionStore.mask(eventConfigs, transactionFieldCodes);
+}
 
 let cleanUpRawEventFieldsInPlace = (fields => {
     delete fields.hash
@@ -42,41 +84,7 @@ function make(logger) {
       "sendRoot",
       "mixHash"
     ],
-    transactionFields: [
-      "transactionIndex",
-      "hash",
-      "from",
-      "to",
-      "gas",
-      "gasPrice",
-      "maxPriorityFeePerGas",
-      "maxFeePerGas",
-      "cumulativeGasUsed",
-      "effectiveGasPrice",
-      "gasUsed",
-      "input",
-      "nonce",
-      "value",
-      "v",
-      "r",
-      "s",
-      "contractAddress",
-      "logsBloom",
-      "root",
-      "status",
-      "yParity",
-      "chainId",
-      "maxFeePerBlobGas",
-      "blobVersionedHashes",
-      "type",
-      "l1Fee",
-      "l1GasPrice",
-      "l1GasUsed",
-      "l1FeeScalar",
-      "gasUsedForL1",
-      "accessList",
-      "authorizationList"
-    ],
+    transactionFields: transactionFields,
     blockNumberName: "number",
     blockTimestampName: "timestamp",
     blockHashName: "hash",
@@ -86,6 +94,7 @@ function make(logger) {
     onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
     logger: logger,
     toEvent: eventItem => eventItem.payload,
+    transactionFieldMask: transactionFieldMask,
     toEventLogger: eventItem => Logging.createChildFrom(logger, {
       contract: eventItem.eventConfig.contractName,
       event: eventItem.eventConfig.name,
@@ -102,7 +111,10 @@ function make(logger) {
 }
 
 export {
+  transactionFields,
+  transactionFieldCodes,
+  transactionFieldMask,
   cleanUpRawEventFieldsInPlace,
   make,
 }
-/* Logging Not a pure module */
+/* transactionFieldCodes Not a pure module */

package/src/sources/Fuel.res

@@ -41,7 +41,9 @@ let make = (~logger: Pino.t): Ecosystem.t => {
     s.field("block", S.option(S.object(s2 => s2.field("height", S.unknown))))
   ),
   logger,
-  toEvent: eventItem => eventItem.payload->Internal.payloadToEvent,
+  // Fuel carries the transaction inline on the payload.
+  transactionFieldMask: _ => 0.,
+  toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem =>
     Logging.createChildFrom(
       ~logger,