envio 3.3.0-alpha.0 → 3.3.0-alpha.2

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,
@@ -615,7 +594,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
       };
     }, persistence$1, isDevelopmentMode);
   }
-  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrations, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, undefined, undefined, onError);
+  let state = IndexerState.makeFromDbState(config$2, persistence$1, Persistence.getInitializedState(persistence$1), registrations, isDevelopmentMode, shouldUseTui, exitAfterFirstEventBlock, undefined, undefined, onError);
   if (shouldUseTui) {
     Tui.start(() => state);
   }

package/src/Prometheus.res

@@ -351,17 +351,6 @@ module IndexingAddresses = {
   }
 }
 
-module IndexingMaxConcurrency = {
-  let gauge = PromClient.Gauge.makeGauge({
-    "name": "envio_indexing_max_concurrency",
-    "help": "The maximum number of concurrent data-source queries across the whole indexer.",
-  })
-
-  let set = (~maxConcurrency) => {
-    gauge->PromClient.Gauge.set(maxConcurrency)
-  }
-}
-
 module IndexingConcurrency = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_indexing_concurrency",

package/src/Prometheus.res.mjs

@@ -400,42 +400,28 @@ let IndexingAddresses = {
   set: set$4
 };
 
-let gauge$5 = PromClient.Gauge.makeGauge({
-  name: "envio_indexing_max_concurrency",
-  help: "The maximum number of concurrent data-source queries across the whole indexer."
-});
+let gauge$5 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
 
-function set$5(maxConcurrency) {
-  gauge$5.set(maxConcurrency);
+function set$5(concurrency, chainId) {
+  handleInt$1(gauge$5, chainId, concurrency);
 }
 
-let IndexingMaxConcurrency = {
+let IndexingConcurrency = {
   gauge: gauge$5,
   set: set$5
 };
 
-let gauge$6 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
+let gauge$6 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
 
-function set$6(concurrency, chainId) {
-  handleInt$1(gauge$6, chainId, concurrency);
+function set$6(partitionsCount, chainId) {
+  handleInt$1(gauge$6, chainId, partitionsCount);
 }
 
-let IndexingConcurrency = {
+let IndexingPartitions = {
   gauge: gauge$6,
   set: set$6
 };
 
-let gauge$7 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
-
-function set$7(partitionsCount, chainId) {
-  handleInt$1(gauge$7, chainId, partitionsCount);
-}
-
-let IndexingPartitions = {
-  gauge: gauge$7,
-  set: set$7
-};
-
 let counter = makeOrThrow("envio_indexing_idle_seconds", "The time the indexer source syncing has been idle. A high value may indicate the source sync is a bottleneck.", chainIdLabelsSchema);
 
 let IndexingIdleTime = {
@@ -454,51 +440,51 @@ let IndexingQueryTime = {
   counter: counter$2
 };
 
-let gauge$8 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
+let gauge$7 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
 
-function set$8(bufferSize, chainId) {
-  handleInt$1(gauge$8, chainId, bufferSize);
+function set$7(bufferSize, chainId) {
+  handleInt$1(gauge$7, chainId, bufferSize);
 }
 
 let IndexingBufferSize = {
-  gauge: gauge$8,
-  set: set$8
+  gauge: gauge$7,
+  set: set$7
 };
 
-let gauge$9 = PromClient.Gauge.makeGauge({
+let gauge$8 = PromClient.Gauge.makeGauge({
   name: "envio_indexing_target_buffer_size",
   help: "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target."
 });
 
-function set$9(targetBufferSize) {
-  gauge$9.set(targetBufferSize);
+function set$8(targetBufferSize) {
+  gauge$8.set(targetBufferSize);
 }
 
 let IndexingTargetBufferSize = {
-  gauge: gauge$9,
-  set: set$9
+  gauge: gauge$8,
+  set: set$8
 };
 
-let gauge$10 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
+let gauge$9 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
 
-function set$10(blockNumber, chainId) {
-  handleInt$1(gauge$10, chainId, blockNumber);
+function set$9(blockNumber, chainId) {
+  handleInt$1(gauge$9, chainId, blockNumber);
 }
 
 let IndexingBufferBlockNumber = {
-  gauge: gauge$10,
-  set: set$10
+  gauge: gauge$9,
+  set: set$9
 };
 
-let gauge$11 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
+let gauge$10 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
 
-function set$11(endBlock, chainId) {
-  handleInt$1(gauge$11, chainId, endBlock);
+function set$10(endBlock, chainId) {
+  handleInt$1(gauge$10, chainId, endBlock);
 }
 
 let IndexingEndBlock = {
-  gauge: gauge$11,
-  set: set$11
+  gauge: gauge$10,
+  set: set$10
 };
 
 let sourceLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -539,18 +525,18 @@ let SourceRequestCount = {
   addSeconds: addSeconds
 };
 
-let gauge$12 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
+let gauge$11 = makeOrThrow$1("envio_source_known_height", "The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.", sourceLabelsSchema);
 
-function set$12(sourceName, chainId, blockNumber) {
-  handleInt$1(gauge$12, {
+function set$11(sourceName, chainId, blockNumber) {
+  handleInt$1(gauge$11, {
     source: sourceName,
     chainId: chainId
   }, blockNumber);
 }
 
 let SourceHeight = {
-  gauge: gauge$12,
-  set: set$12
+  gauge: gauge$11,
+  set: set$11
 };
 
 let counter$4 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
@@ -564,43 +550,43 @@ let ReorgCount = {
   increment: increment$5
 };
 
-let gauge$13 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
+let gauge$12 = makeOrThrow$1("envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", chainIdLabelsSchema);
 
-function set$13(blockNumber, chain) {
-  handleInt$1(gauge$13, chain, blockNumber);
+function set$12(blockNumber, chain) {
+  handleInt$1(gauge$12, chain, blockNumber);
 }
 
 let ReorgDetectionBlockNumber = {
-  gauge: gauge$13,
-  set: set$13
+  gauge: gauge$12,
+  set: set$12
 };
 
-let gauge$14 = PromClient.Gauge.makeGauge({
+let gauge$13 = PromClient.Gauge.makeGauge({
   name: "envio_reorg_threshold",
   help: "Whether indexing is currently within the reorg threshold"
 });
 
-function set$14(isInReorgThreshold) {
-  gauge$14.set(isInReorgThreshold ? 1 : 0);
+function set$13(isInReorgThreshold) {
+  gauge$13.set(isInReorgThreshold ? 1 : 0);
 }
 
 let ReorgThreshold = {
-  gauge: gauge$14,
-  set: set$14
+  gauge: gauge$13,
+  set: set$13
 };
 
-let gauge$15 = PromClient.Gauge.makeGauge({
+let gauge$14 = PromClient.Gauge.makeGauge({
   name: "envio_rollback_enabled",
   help: "Whether rollback on reorg is enabled"
 });
 
-function set$15(enabled) {
-  gauge$15.set(enabled ? 1 : 0);
+function set$14(enabled) {
+  gauge$14.set(enabled ? 1 : 0);
 }
 
 let RollbackEnabled = {
-  gauge: gauge$15,
-  set: set$15
+  gauge: gauge$14,
+  set: set$14
 };
 
 let timeCounter$3 = PromClient.Counter.makeCounter({
@@ -649,62 +635,62 @@ let RollbackHistoryPrune = {
   increment: increment$7
 };
 
-let gauge$16 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
+let gauge$15 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
 
-function set$16(blockNumber, chain) {
-  handleInt$1(gauge$16, chain, blockNumber);
+function set$15(blockNumber, chain) {
+  handleInt$1(gauge$15, chain, blockNumber);
 }
 
 let RollbackTargetBlockNumber = {
-  gauge: gauge$16,
-  set: set$16
+  gauge: gauge$15,
+  set: set$15
 };
 
-let gauge$17 = PromClient.Gauge.makeGauge({
+let gauge$16 = PromClient.Gauge.makeGauge({
   name: "envio_processing_max_batch_size",
   help: "The maximum number of items to process in a single batch."
 });
 
-function set$17(maxBatchSize) {
-  gauge$17.set(maxBatchSize);
+function set$16(maxBatchSize) {
+  gauge$16.set(maxBatchSize);
 }
 
 let ProcessingMaxBatchSize = {
-  gauge: gauge$17,
-  set: set$17
+  gauge: gauge$16,
+  set: set$16
 };
 
-let gauge$18 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+let gauge$17 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$18(blockNumber, chainId) {
-  handleInt$1(gauge$18, chainId, blockNumber);
+function set$17(blockNumber, chainId) {
+  handleInt$1(gauge$17, chainId, blockNumber);
 }
 
 let ProgressBlockNumber = {
-  gauge: gauge$18,
-  set: set$18
+  gauge: gauge$17,
+  set: set$17
 };
 
-let gauge$19 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+let gauge$18 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$19(processedCount, chainId) {
-  handleFloat$1(gauge$19, chainId, processedCount);
+function set$18(processedCount, chainId) {
+  handleFloat$1(gauge$18, chainId, processedCount);
 }
 
 let ProgressEventsCount = {
-  gauge: gauge$19,
-  set: set$19
+  gauge: gauge$18,
+  set: set$18
 };
 
-let gauge$20 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
+let gauge$19 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
 
-function set$20(latencyMs, chainId) {
-  handleInt$1(gauge$20, chainId, latencyMs);
+function set$19(latencyMs, chainId) {
+  handleInt$1(gauge$19, chainId, latencyMs);
 }
 
 let ProgressLatency = {
-  gauge: gauge$20,
-  set: set$20
+  gauge: gauge$19,
+  set: set$19
 };
 
 let effectLabelsSchema = S$RescriptSchema.object(s => s.f("effect", S$RescriptSchema.string));
@@ -724,15 +710,15 @@ let EffectCalls = {
   activeCallsCount: activeCallsCount
 };
 
-let gauge$21 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
+let gauge$20 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$21(count, effectName) {
-  handleInt$1(gauge$21, effectName, count);
+function set$20(count, effectName) {
+  handleInt$1(gauge$20, effectName, count);
 }
 
 let EffectCacheCount = {
-  gauge: gauge$21,
-  set: set$21
+  gauge: gauge$20,
+  set: set$20
 };
 
 let counter$7 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
@@ -746,18 +732,18 @@ let EffectCacheInvalidationsCount = {
   increment: increment$8
 };
 
-let gauge$22 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
+let gauge$21 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
 
 let timeCounter$6 = makeOrThrow("envio_effect_queue_wait_seconds", "The time spent waiting in the rate limit queue.", effectLabelsSchema);
 
-function set$22(count, effectName) {
-  handleInt$1(gauge$22, effectName, count);
+function set$21(count, effectName) {
+  handleInt$1(gauge$21, effectName, count);
 }
 
 let EffectQueueCount = {
-  gauge: gauge$22,
+  gauge: gauge$21,
   timeCounter: timeCounter$6,
-  set: set$22
+  set: set$21
 };
 
 let loadLabelsSchema = S$RescriptSchema.schema(s => ({
@@ -861,7 +847,6 @@ export {
   Info,
   ProcessStartTimeSeconds,
   IndexingAddresses,
-  IndexingMaxConcurrency,
   IndexingConcurrency,
   IndexingPartitions,
   IndexingIdleTime,

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,