@aztec/pxe 0.0.1-commit.321f6a9 → 0.0.1-commit.330febf

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -109,7 +109,6 @@ import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_t
 import type { SenderTaggingStore } from '../storage/tagging_store/sender_tagging_store.js';
 import type { TaggingSecretSourcesStore } from '../storage/tagging_store/tagging_secret_sources_store.js';
 import { AnchoredContractData } from './anchored_contract_data.js';
-import type { BenchmarkedNode } from './benchmarked_node.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
 import { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
 import { HashedValuesCache } from './hashed_values_cache.js';
@@ -444,22 +443,6 @@ export class ContractFunctionSimulator {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
   }
-
-  /**
-   * Returns the execution statistics collected during the simulator run.
-   * @returns The execution statistics.
-   */
-  getStats() {
-    const nodeRPCCalls =
-      typeof (this.aztecNode as BenchmarkedNode).getStats === 'function'
-        ? (this.aztecNode as BenchmarkedNode).getStats()
-        : {
-            perMethod: {},
-            roundTrips: { roundTrips: 0, totalBlockingTime: 0, roundTripDurations: [], roundTripMethods: [] },
-          };
-
-    return { nodeRPCCalls };
-  }
 }
 
 class OrderedSideEffect<T> {

package/src/contract_function_simulator/oracle/oracle_type_mappings.ts

@@ -712,8 +712,23 @@ export function BOUNDED_VEC<T>(inner: TypeMapping<T>): BoundedVecMapping<T> {
           fn: ([storageReader, lengthReader]) => {
             // slot 0 is the padded storage, slot 1 the actual length. Parse only the first `length` elements out of
             // storage, then drain the trailing zero-padding so the storage reader is fully consumed.
-            const maxLength = storageReader.remainingFields() / fieldWidth(inner.shape);
+            const elementWidth = fieldWidth(inner.shape);
+            const storageFields = storageReader.remainingFields();
+            if (storageFields % elementWidth !== 0) {
+              throw new Error(
+                `Malformed BoundedVec: storage array holds ${storageFields} field(s), which is not a whole number of ` +
+                  `${elementWidth}-field elements`,
+              );
+            }
+            // The BoundedVec's maximum length is determined by the size of the storage array, so its length is bounded
+            // by it.
+            const maxLength = storageFields / elementWidth;
             const length = lengthReader.readField().toNumber();
+            if (length > maxLength) {
+              throw new Error(
+                `Malformed BoundedVec: length ${length} exceeds the ${maxLength} element(s) its storage array holds`,
+              );
+            }
             const elements = unpackElements(inner, storageReader, length);
             storageReader.skip(storageReader.remainingFields());
             return BoundedVec.from<T>({ data: elements, maxLength });

package/src/contract_function_simulator/oracle/private_execution_oracle.ts

@@ -38,7 +38,7 @@ import {
 import { NoteService } from '../../notes/note_service.js';
 import { assertAllowedScope } from '../../storage/allowed_scopes.js';
 import type { SenderTaggingStore } from '../../storage/tagging_store/sender_tagging_store.js';
-import { syncSenderTaggingIndexes } from '../../tagging/index.js';
+import { logQueryAnchorOf, syncSenderTaggingIndexes } from '../../tagging/index.js';
 import type { ExecutionNoteCache } from '../execution_note_cache.js';
 import { ExecutionTaggingIndexCache } from '../execution_tagging_index_cache.js';
 import type { HashedValuesCache } from '../hashed_values_cache.js';
@@ -375,11 +375,16 @@ export class PrivateExecutionOracle extends UtilityExecutionOracle implements IP
       // This is a tagging secret we've not yet used in this tx, so first sync our store to make sure its indices
       // are up to date. We do this here because this store is not synced as part of the global sync because
       // that'd be wasteful as most tagging secrets are not used in each tx.
+      const [{ finalized }, anchor] = await Promise.all([
+        this.l2TipsStore.getL2Tips(),
+        logQueryAnchorOf(this.anchorBlockHeader),
+      ]);
       await syncSenderTaggingIndexes(
         secret,
         this.aztecNode,
         this.senderTaggingStore,
-        await this.anchorBlockHeader.hash(),
+        finalized.block.number,
+        anchor,
         this.jobId,
       );
 

package/src/contract_function_simulator/oracle/utility_execution_oracle.ts

@@ -1,4 +1,4 @@
-import { ARCHIVE_HEIGHT, type NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
+import { ARCHIVE_HEIGHT, type NOTE_HASH_TREE_HEIGHT, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { uniqueBy } from '@aztec/foundation/collection';
 import { Aes128 } from '@aztec/foundation/crypto/aes128';
@@ -33,20 +33,20 @@ import {
   type BlockHeader,
   CallContext,
   type Capsule,
-  type IndexedTxEffect,
   type OffchainEffect,
   type TxEffect,
   type TxHash,
+  type TxReceipt,
 } from '@aztec/stdlib/tx';
 
 import type { ContractSyncService } from '../../contract/contract_sync_service.js';
 import { createContractLogger, logContractMessage, stripAztecnrLogPrefix } from '../../contract_logging.js';
-import { EventService } from '../../events/event_service.js';
+import { EventService, type EventValidationTxData } from '../../events/event_service.js';
 import type { UtilityCallAuthorizationRequest } from '../../hooks/authorize_utility_call.js';
 import type { ExecutionHooks } from '../../hooks/index.js';
-import { LogService } from '../../logs/log_service.js';
-import { TxResolverService } from '../../messages/tx_resolver_service.js';
-import { NoteService } from '../../notes/note_service.js';
+import { LogService, type RetrievedTaggedLog } from '../../logs/log_service.js';
+import { type TxOnchainContext, TxResolverService } from '../../messages/tx_resolver_service.js';
+import { NoteService, type NoteValidationTxData } from '../../notes/note_service.js';
 import { ORACLE_VERSION_MAJOR } from '../../oracle_version.js';
 import type { AddressStore } from '../../storage/address_store/address_store.js';
 import { assertAllowedScope } from '../../storage/allowed_scopes.js';
@@ -58,7 +58,6 @@ import type { PrivateEventStore } from '../../storage/private_event_store/privat
 import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
 import type { TaggingSecretSourcesStore } from '../../storage/tagging_store/tagging_secret_sources_store.js';
 import type { AnchoredContractData } from '../anchored_contract_data.js';
-import { AztecNodeReadCache } from '../aztec_node_read_cache.js';
 import { EphemeralArrayService } from '../ephemeral_array_service.js';
 import { BoundedVec } from '../noir-structs/bounded_vec.js';
 import type { EmbeddedCurvePoint } from '../noir-structs/embedded_curve_point.js';
@@ -122,7 +121,15 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
   private offchainEffects: OffchainEffect[] = [];
   private readonly ephemeralArrayService = new EphemeralArrayService();
   protected readonly transientArrayService: TransientArrayService;
-  private readonly aztecNodeReadCache: AztecNodeReadCache;
+  /** Keyed by tx hash string. */
+  private readonly txReceiptsCache = new Map<string, Promise<TxReceipt<{ includeTxEffect: true }>>>();
+  /**
+   * Information that can be used to validate the existence of a note or an event, keyed by tx hash string. It is
+   * populated by the node queries that precede validation (tagged log retrieval, tx resolution), which already return
+   * everything validation needs, so validating a note or event created in one of those txs costs no node roundtrip.
+   * Notes and events reached through other paths (e.g. offchain inbox messages) still need a receipt.
+   */
+  private readonly validationTxDataCache = new Map<string, ValidationTxData>();
 
   // We store oracle version to be able to show a nice error message when an oracle handler is missing.
   private contractOracleVersion: { major: number; minor: number } | undefined;
@@ -176,7 +183,6 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     this.hooks = args.hooks;
     this.utilityExecutor = args.utilityExecutor;
     this.transientArrayService = args.transientArrayService;
-    this.aztecNodeReadCache = new AztecNodeReadCache(args.aztecNode);
   }
 
   public assertCompatibleOracleVersion(major: number, minor: number): void {
@@ -270,7 +276,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     // hash at all. If the block hash did not exist by the reference block hash, then the node will not return the
     // membership witness as there is none.
     const witness = await this.#queryWithBlockHashNotAfterAnchor(referenceBlockHash, () =>
-      this.aztecNodeReadCache.getBlockHashMembershipWitness(referenceBlockHash, blockHash),
+      this.aztecNode.getBlockHashMembershipWitness(referenceBlockHash, blockHash),
     );
     return witness ? Option.some(witness) : Option.none();
   }
@@ -284,7 +290,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     const memberships = await this.#queryWithBlockHashNotAfterAnchor(referenceBlockHash, () =>
       Promise.all(
         hashes.map(blockHash =>
-          this.aztecNodeReadCache.getBlockHashMembershipWitness(referenceBlockHash, blockHash).then(Boolean),
+          this.aztecNode.getBlockHashMembershipWitness(referenceBlockHash, blockHash).then(Boolean),
         ),
       ),
     );
@@ -339,7 +345,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
    */
   public async getPublicDataWitness(blockHash: BlockHash, leafSlot: Fr): Promise<PublicDataWitness> {
     const witness = await this.#queryWithBlockHashNotAfterAnchor(blockHash, () =>
-      this.aztecNodeReadCache.getPublicDataWitness(blockHash, leafSlot),
+      this.aztecNode.getPublicDataWitness(blockHash, leafSlot),
     );
     if (!witness) {
       throw new Error(`Public data witness not found for slot ${leafSlot} at block hash ${blockHash.toString()}.`);
@@ -530,11 +536,11 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     numberOfElements: number,
   ) {
     return this.#queryWithBlockHashNotAfterAnchor(blockHash, async () => {
-      const values = await this.aztecNodeReadCache.getPublicStorageRange(
-        blockHash,
-        contractAddress,
-        startStorageSlot,
-        numberOfElements,
+      const slots = Array(numberOfElements)
+        .fill(0)
+        .map((_, i) => new Fr(startStorageSlot.toBigInt() + BigInt(i)));
+      const values = await Promise.all(
+        slots.map(storageSlot => this.aztecNode.getPublicStorageAt(blockHash, contractAddress, storageSlot)),
       );
 
       this.logger.debug(
@@ -601,8 +607,11 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
       .map(ps => new AppTaggingSecret(ps.secret, this.contractAddress, ps.mode));
 
     const logService = this.#createLogService();
-    const logs = await logService.fetchTaggedLogs(this.contractAddress, scope, secrets);
-    return EphemeralArray.fromValues(this.ephemeralArrayService, logs);
+    const retrievedLogs = await logService.fetchTaggedLogs(this.contractAddress, scope, secrets);
+
+    this.#cacheValidationTxData(retrievedLogs);
+
+    return EphemeralArray.fromValues(this.ephemeralArrayService, retrievedLogs.map(toPendingTaggedLog));
   }
 
   #createLogService(): LogService {
@@ -637,7 +646,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     eventValidationRequests: EventValidationRequest[],
     scope: AztecAddress,
   ) {
-    const txEffects = await this.#fetchTxEffects([
+    const validationTxData = await this.#getValidationTxData([
       ...noteValidationRequests.map(r => r.txHash),
       ...eventValidationRequests.map(r => r.txHash),
     ]);
@@ -646,8 +655,8 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     const eventService = new EventService(this.anchorBlockHeader, this.aztecNode, this.privateEventStore, this.jobId);
 
     await Promise.all([
-      noteService.validateAndStoreNotes(noteValidationRequests, scope, txEffects),
-      eventService.validateAndStoreEvents(eventValidationRequests, scope, txEffects),
+      noteService.validateAndStoreNotes(noteValidationRequests, scope, validationTxData),
+      eventService.validateAndStoreEvents(eventValidationRequests, scope, validationTxData),
     ]);
   }
 
@@ -657,11 +666,13 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     const logRetrievalRequests = requests.readAll(this.ephemeralArrayService);
     const logService = this.#createLogService();
 
-    const logRetrievalResponses = await logService.fetchLogsByTag(this.contractAddress, logRetrievalRequests);
+    const retrievedLogsPerRequest = await logService.fetchLogsByTag(this.contractAddress, logRetrievalRequests);
+
+    this.#cacheValidationTxData(retrievedLogsPerRequest.flat());
 
     // Create an inner ephemeral array for each request's matching logs, then wrap all slots in an outer array.
-    const innerArrays = logRetrievalResponses.map(responses =>
-      EphemeralArray.fromValues(this.ephemeralArrayService, responses),
+    const innerArrays = retrievedLogsPerRequest.map(retrievedLogs =>
+      EphemeralArray.fromValues(this.ephemeralArrayService, retrievedLogs.map(toLogRetrievalResponse)),
     );
 
     return EphemeralArray.fromValues(this.ephemeralArrayService, innerArrays);
@@ -673,7 +684,9 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
 
     const resolved = await this.txResolver.resolveTxs(txHashes, this.anchorBlockHeader.getBlockNumber());
 
-    const options = resolved.map(r => (r ? Option.some(r) : Option.none<ResolvedTx>()));
+    this.#cacheValidationTxData(resolved.filter(tx => tx !== null));
+
+    const options = resolved.map(tx => (tx ? Option.some(toResolvedTx(tx)) : Option.none<ResolvedTx>()));
     return EphemeralArray.fromValues(this.ephemeralArrayService, options);
   }
 
@@ -1107,16 +1120,34 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     return this.offchainEffects;
   }
 
+  /** Stores the onchain context of the given txs, so that validating the notes and events they created is free. */
+  #cacheValidationTxData(txs: TxOnchainContext[]) {
+    txs.forEach(tx => this.validationTxDataCache.set(tx.txHash.toString(), toValidationTxData(tx)));
+  }
+
   /**
-   * Fetches tx effects for the given hashes in parallel, deduplicating repeated hashes so each tx is only requested
-   * once. Returns a map keyed by `TxHash.toString()`; hashes for which the node has no tx effect are omitted.
+   * Returns the information needed to validate the notes and events created in the given txs, keyed by
+   * `TxHash.toString()`. Txs already in {@link validationTxDataCache} cost no node request, and the rest are read from
+   * the node. Txs with no tx effect are absent from the returned map.
    */
-  async #fetchTxEffects(txHashes: TxHash[]): Promise<Map<string, IndexedTxEffect>> {
-    const uniqueTxHashes = uniqueBy(txHashes, h => h.toString());
-    const fetched = await Promise.all(uniqueTxHashes.map(h => this.aztecNodeReadCache.getTxReceiptWithEffect(h)));
-    return new Map(
-      uniqueTxHashes
-        .map((h, i): [string, IndexedTxEffect | undefined] => {
+  async #getValidationTxData(txHashes: TxHash[]): Promise<Map<string, ValidationTxData>> {
+    const known: [string, ValidationTxData][] = [];
+    const misses: TxHash[] = [];
+    for (const txHash of uniqueBy(txHashes, h => h.toString())) {
+      const key = txHash.toString();
+      const cached = this.validationTxDataCache.get(key);
+      if (cached) {
+        known.push([key, cached]);
+      } else {
+        misses.push(txHash);
+      }
+    }
+
+    const fetched = await Promise.all(misses.map(h => this.#getTxReceiptWithEffect(h)));
+    return new Map([
+      ...known,
+      ...misses
+        .map((h, i): [string, ValidationTxData | undefined] => {
           const receipt = fetched[i];
           if (!receipt.isMined() || !receipt.txEffect) {
             return [h.toString(), undefined];
@@ -1124,20 +1155,41 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
           return [
             h.toString(),
             {
-              data: receipt.txEffect,
+              noteHashes: receipt.txEffect.noteHashes,
+              nullifiers: receipt.txEffect.nullifiers,
               l2BlockNumber: receipt.blockNumber,
               l2BlockHash: receipt.blockHash,
               txIndexInBlock: receipt.txIndexInBlock,
-              slotNumber: receipt.slotNumber,
             },
           ];
         })
-        .filter((entry): entry is [string, IndexedTxEffect] => entry[1] !== undefined),
-    );
+        .filter((entry): entry is [string, ValidationTxData] => entry[1] !== undefined),
+    ]);
+  }
+
+  /**
+   * Reads a receipt with its effect, at most once per tx for the lifetime of this execution.
+   *
+   * A receipt is not cacheable in general, since pending, mined and dropped are all correct answers to the same call
+   * over time. Within one execution it is: the execution is anchored at a fixed block, and validation runs in several
+   * batches that name overlapping tx hashes, so re-reading would both cost extra requests and let one execution see a
+   * tx as included in one batch and absent in the next.
+   */
+  #getTxReceiptWithEffect(txHash: TxHash) {
+    const key = txHash.toString();
+    let receipt = this.txReceiptsCache.get(key);
+    if (!receipt) {
+      receipt = this.aztecNode.getTxReceipt(txHash, { includeTxEffect: true }).catch(err => {
+        this.txReceiptsCache.delete(key);
+        throw err;
+      });
+      this.txReceiptsCache.set(key, receipt);
+    }
+    return receipt;
   }
 
   async #getTxEffectOption(txHash: TxHash): Promise<Option<TxEffectData>> {
-    const receipt = await this.aztecNodeReadCache.getTxReceiptWithEffect(txHash);
+    const receipt = await this.#getTxReceiptWithEffect(txHash);
     if (!receipt.isMined() || !receipt.txEffect || receipt.blockNumber > this.anchorBlockHeader.getBlockNumber()) {
       return Option.none();
     }
@@ -1168,7 +1220,7 @@ export class UtilityExecutionOracle implements IMiscOracle, IUtilityExecutionOra
     const [response] = await Promise.all([
       query(),
       (async () => {
-        const block = await this.aztecNodeReadCache.getBlock(blockHash);
+        const block = await this.aztecNode.getBlock(blockHash);
         const header = block?.header;
         if (!header) {
           throw new Error(`Could not find block header for block hash ${blockHash}`);
@@ -1229,3 +1281,41 @@ async function isStandardHandshakeRegistryUtilityRead(
   );
   return matches.some(Boolean);
 }
+
+function toPendingTaggedLog(retrievedLog: RetrievedTaggedLog): PendingTaggedLog {
+  return { log: retrievedLog.logData, context: toResolvedTx(retrievedLog) };
+}
+
+function toResolvedTx(tx: TxOnchainContext): ResolvedTx {
+  const { txHash, blockNumber, blockHash, noteHashes, nullifiers } = tx;
+  return {
+    txHash,
+    uniqueNoteHashesInTx: noteHashes,
+    firstNullifierInTx: nullifiers[0],
+    blockNumber,
+    blockHash: blockHash.toFr(),
+  };
+}
+
+function toLogRetrievalResponse(retrievedLog: RetrievedTaggedLog): LogRetrievalResponse {
+  const { logData, txHash, blockNumber, blockHash, blockTimestamp, noteHashes, nullifiers } = retrievedLog;
+  return {
+    // Skip the tag, and clip to the wire cap: public logs can exceed PRIVATE_LOG_CIPHERTEXT_LEN, which is the fixed
+    // size of the oracle's BoundedVec slot. A no-op for private logs, which are already within the cap.
+    logPayload: logData.slice(1, 1 + PRIVATE_LOG_CIPHERTEXT_LEN),
+    txHash,
+    uniqueNoteHashesInTx: noteHashes,
+    firstNullifierInTx: nullifiers[0],
+    blockNumber,
+    blockTimestamp,
+    blockHash,
+  };
+}
+
+function toValidationTxData(tx: TxOnchainContext): ValidationTxData {
+  const { blockNumber, blockHash, txIndexInBlock, noteHashes, nullifiers } = tx;
+  return { noteHashes, nullifiers, l2BlockNumber: blockNumber, l2BlockHash: blockHash, txIndexInBlock };
+}
+
+/** The onchain context of a tx served to note and event validation: the union of what the two services read. */
+type ValidationTxData = NoteValidationTxData & EventValidationTxData;

package/src/events/event_service.ts

@@ -1,8 +1,10 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { InBlock } from '@aztec/stdlib/block';
 import { computePrivateEventCommitment, siloNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { BlockHeader, IndexedTxEffect } from '@aztec/stdlib/tx';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { EventValidationRequest } from '../contract_function_simulator/noir-structs/event_validation_request.js';
 import { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
@@ -17,17 +19,17 @@ export class EventService {
   ) {}
 
   /**
-   * Validates and stores a batch of private events against pre-fetched tx effects.
+   * Validates and stores a batch of private events against the pre-fetched onchain context of their txs.
    *
    * @param requests - The events to validate and store.
    * @param scope - The scope under which the events are being stored.
-   * @param txEffects - Pre-fetched tx effects keyed by `TxHash.toString()`. Must contain entries for every request's
-   *                   txHash; missing entries are treated as a node bug and cause an error.
+   * @param validationTxData - The onchain context of each request's tx, keyed by `TxHash.toString()`. Must contain
+   * entries for every request's txHash; missing entries are treated as a node bug and cause an error.
    */
   public async validateAndStoreEvents(
     requests: EventValidationRequest[],
     scope: AztecAddress,
-    txEffects: Map<string, IndexedTxEffect>,
+    validationTxData: ReadonlyMap<string, EventValidationTxData>,
   ): Promise<void> {
     if (requests.length === 0) {
       return;
@@ -35,13 +37,15 @@ export class EventService {
 
     const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
 
-    await Promise.all(requests.map(req => this.#validateAndStoreEvent(req, scope, txEffects, anchorBlockNumber)));
+    await Promise.all(
+      requests.map(req => this.#validateAndStoreEvent(req, scope, validationTxData, anchorBlockNumber)),
+    );
   }
 
   async #validateAndStoreEvent(
     request: EventValidationRequest,
     scope: AztecAddress,
-    txEffects: Map<string, IndexedTxEffect>,
+    validationTxData: ReadonlyMap<string, EventValidationTxData>,
     anchorBlockNumber: number,
   ): Promise<void> {
     const {
@@ -71,15 +75,15 @@ export class EventService {
     // since `fetchTaggedLogs` only processes logs up to the synced block.
     const siloedEventCommitment = await siloNullifier(contractAddress, eventCommitment);
 
-    const txEffect = txEffects.get(txHash.toString());
-    if (!txEffect) {
+    const txData = validationTxData.get(txHash.toString());
+    if (!txData) {
       // We error out instead of just logging a warning and skipping the event because this would indicate a bug. This
       // is because the node has already served info about this tx either when obtaining the log (LogResult carries
       // the tx info) or when getting metadata for the offchain message (before the message got passed to `process_log`).
       throw new Error(`Could not find tx effect for tx hash ${txHash} when processing an event.`);
     }
 
-    if (txEffect.l2BlockNumber > anchorBlockNumber) {
+    if (txData.l2BlockNumber > anchorBlockNumber) {
       // We should never process a message from a tx past the anchor block. If we got here, a preprocessing step made
       // a mistake.
       throw new Error(
@@ -88,7 +92,7 @@ export class EventService {
     }
 
     // Find the index of the event commitment in the nullifiers array to determine event ordering within the tx
-    const eventIndexInTx = txEffect.data.nullifiers.findIndex(n => n.equals(siloedEventCommitment));
+    const eventIndexInTx = txData.nullifiers.findIndex(n => n.equals(siloedEventCommitment));
     if (eventIndexInTx === -1) {
       // Unlike in NoteService, this might not be a bug since the commitment hasn't been verified yet in the message
       // processing pipeline. A malformed or malicious message could trigger this condition. Because of this we don't
@@ -108,12 +112,18 @@ export class EventService {
         contractAddress,
         scope,
         txHash,
-        l2BlockNumber: txEffect.l2BlockNumber,
-        l2BlockHash: txEffect.l2BlockHash,
-        txIndexInBlock: txEffect.txIndexInBlock,
+        l2BlockNumber: txData.l2BlockNumber,
+        l2BlockHash: txData.l2BlockHash,
+        txIndexInBlock: txData.txIndexInBlock,
         eventIndexInTx,
       },
       this.jobId,
     );
   }
 }
+
+/** The onchain context of the tx an event validation request points at: where it was mined and its nullifiers. */
+export type EventValidationTxData = InBlock & {
+  nullifiers: Fr[];
+  txIndexInBlock: number;
+};