@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -1,16 +1,19 @@
 import { createLogger } from '@aztec/foundation/log';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
+import EventEmitter from 'node:events';
+
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
-import type { TxPool, TxPoolOptions } from './tx_pool.js';
+import type { TxPool, TxPoolEvents, TxPoolOptions } from './tx_pool.js';
 
 /**
  * In-memory implementation of the Transaction Pool.
  */
-export class InMemoryTxPool implements TxPool {
+export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter<TxPoolEvents>) implements TxPool {
   /**
    * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
    */
@@ -28,6 +31,7 @@ export class InMemoryTxPool implements TxPool {
     telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('p2p:tx_pool'),
   ) {
+    super();
     this.txs = new Map<bigint, Tx>();
     this.minedTxs = new Map();
     this.pendingTxs = new Set();
@@ -129,24 +133,30 @@ export class InMemoryTxPool implements TxPool {
    * @param txs - An array of txs to be added to the pool.
    * @returns Empty promise.
    */
-  public async addTxs(txs: Tx[]): Promise<number> {
-    let pending = 0;
+  public addTxs(txs: Tx[], opts: { source?: string } = {}): Promise<number> {
+    const added: Tx[] = [];
     for (const tx of txs) {
-      const txHash = await tx.getTxHash();
+      const txHash = tx.getTxHash();
       this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
         eventName: 'tx-added-to-pool',
-        ...(await tx.getStats()),
+        ...tx.getStats(),
       } satisfies TxAddedToPoolStats);
 
       const key = txHash.toBigInt();
-      this.txs.set(key, tx);
+      if (!this.txs.has(key)) {
+        added.push(tx as Tx);
+        this.txs.set(key, tx);
+      }
+
       if (!this.minedTxs.has(key)) {
-        pending++;
         this.metrics.recordSize(tx);
         this.pendingTxs.add(key);
       }
     }
-    return pending;
+    if (added.length > 0) {
+      this.emit('txs-added', { ...opts, txs: added });
+    }
+    return Promise.resolve(added.length);
   }
 
   /**

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,3 +1,4 @@
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 export type TxPoolOptions = {
@@ -6,16 +7,20 @@ export type TxPoolOptions = {
   archivedTxLimit?: number;
 };
 
+export type TxPoolEvents = {
+  ['txs-added']: (args: { txs: Tx[]; source?: string }) => void | Promise<void>;
+};
+
 /**
  * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
  */
-export interface TxPool {
+export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
   /**
    * Adds a list of transactions to the pool. Duplicates are ignored.
    * @param txs - An array of txs to be added to the pool.
    * @returns The number of txs added to the pool. Note if the transaction already exists, it will not be added again.
    */
-  addTxs(txs: Tx[]): Promise<number>;
+  addTxs(txs: Tx[], opts?: { source?: string }): Promise<number>;
 
   /**
    * Checks if a transaction exists in the pool and returns it.

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -20,80 +20,103 @@ export function describeTxPool(getTxPool: () => TxPool) {
     pool = getTxPool();
   });
 
-  it('Adds txs to the pool as pending', async () => {
+  afterEach(() => {
+    pool.removeAllListeners('txs-added');
+  });
+
+  it('adds txs to the pool as pending', async () => {
     const tx1 = await mockTx();
 
     await pool.addTxs([tx1]);
-    const poolTx = await pool.getTxByHash(await tx1.getTxHash());
-    expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]);
+    const poolTx = await pool.getTxByHash(tx1.getTxHash());
+    expect(poolTx!.getTxHash()).toEqual(tx1.getTxHash());
+    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('pending');
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]);
     await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Removes txs from the pool', async () => {
+  it('emits txs-added event with new txs', async () => {
+    const tx1 = await mockTx(); // existing and pending
+    const tx2 = await mockTx(); // mined but not known
+    const tx3 = await mockTx(); // brand new
+
+    await pool.addTxs([tx1]);
+    await pool.markAsMined([tx2.getTxHash()], minedBlockHeader);
+
+    let txsFromEvent: Tx[] | undefined = undefined;
+    pool.once('txs-added', ({ txs }) => {
+      txsFromEvent = txs;
+    });
+
+    await pool.addTxs([tx1, tx2, tx3]);
+    expect(txsFromEvent).toBeDefined();
+    expect(txsFromEvent).toHaveLength(2);
+    expect(txsFromEvent).toEqual(expect.arrayContaining([tx2, tx3]));
+  });
+
+  it('removes txs from the pool', async () => {
     const tx1 = await mockTx();
 
     await pool.addTxs([tx1]);
-    await pool.deleteTxs([await tx1.getTxHash()]);
+    await pool.deleteTxs([tx1.getTxHash()]);
 
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+    await expect(pool.getTxByHash(tx1.getTxHash())).resolves.toBeFalsy();
+    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toBeUndefined();
     await expect(pool.getPendingTxCount()).resolves.toEqual(0);
   });
 
-  it('Marks txs as mined', async () => {
+  it('marks txs as mined', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], minedBlockHeader);
+    await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
-    await expect(pool.getMinedTxHashes()).resolves.toEqual([[await tx1.getTxHash(), 1]]);
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx2.getTxHash()]);
+    await expect(pool.getTxByHash(tx1.getTxHash())).resolves.toEqual(tx1);
+    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('mined');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([[tx1.getTxHash(), 1]]);
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx2.getTxHash()]);
     await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Marks txs as pending after being mined', async () => {
+  it('marks txs as pending after being mined', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], minedBlockHeader);
+    await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await pool.markMinedAsPending([await tx1.getTxHash()]);
+    await pool.markMinedAsPending([tx1.getTxHash()]);
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
-    expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
+    expect(pending).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash()]));
     await expect(pool.getPendingTxCount()).resolves.toEqual(2);
   });
 
-  it('Only marks txs as pending if they are known', async () => {
+  it('only marks txs as pending if they are known', async () => {
     const tx1 = await mockTx(1);
     // simulate a situation where not all peers have all the txs
     const tx2 = await mockTx(2);
-    const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
+    const someTxHashThatThisPeerDidNotSee = tx2.getTxHash();
     await pool.addTxs([tx1]);
     // this peer knows that tx2 was mined, but it does not have the tx object
-    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], minedBlockHeader);
+    await pool.markAsMined([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], minedBlockHeader);
     expect(await pool.getMinedTxHashes()).toEqual(
       expect.arrayContaining([
-        [await tx1.getTxHash(), 1],
+        [tx1.getTxHash(), 1],
         [someTxHashThatThisPeerDidNotSee, 1],
       ]),
     );
 
     // reorg: both txs should now become available again
-    await pool.markMinedAsPending([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]); // tx2 is not in the pool
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]); // tx2 is not in the pool
     await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Returns all transactions in the pool', async () => {
+  it('returns all transactions in the pool', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
@@ -106,7 +129,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
-  it('Returns all txHashes in the pool', async () => {
+  it('returns all txHashes in the pool', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
@@ -114,35 +137,35 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2, tx3]);
 
     const poolTxHashes = await pool.getAllTxHashes();
-    const expectedHashes = await Promise.all([tx1, tx2, tx3].map(tx => tx.getTxHash()));
+    const expectedHashes = [tx1, tx2, tx3].map(tx => tx.getTxHash());
     expect(poolTxHashes).toHaveLength(3);
     expect(poolTxHashes).toEqual(expect.arrayContaining(expectedHashes));
     await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
-  it('Returns txs by their hash', async () => {
+  it('returns txs by their hash', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
 
     await pool.addTxs([tx1, tx2, tx3]);
 
-    const requestedTxs = await pool.getTxsByHash([await tx1.getTxHash(), await tx3.getTxHash()]);
+    const requestedTxs = await pool.getTxsByHash([tx1.getTxHash(), tx3.getTxHash()]);
     expect(requestedTxs).toHaveLength(2);
     expect(requestedTxs).toEqual(expect.arrayContaining([tx1, tx3]));
   });
 
-  it('Returns a large number of transactions by their hash', async () => {
+  it('returns a large number of transactions by their hash', async () => {
     const numTxs = 1000;
     const txs = await Promise.all(Array.from({ length: numTxs }, (_, i) => mockTx(i)));
-    const hashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    const hashes = txs.map(tx => tx.getTxHash());
     await pool.addTxs(txs);
     const requestedTxs = await pool.getTxsByHash(hashes);
     expect(requestedTxs).toHaveLength(numTxs);
     expect(requestedTxs).toEqual(expect.arrayContaining(txs));
   });
 
-  it('Returns whether or not txs exist', async () => {
+  it('returns whether or not txs exist', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
@@ -153,17 +176,17 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const tx5 = await mockTx(5);
 
     const availability = await pool.hasTxs([
-      await tx1.getTxHash(),
-      await tx2.getTxHash(),
-      await tx3.getTxHash(),
-      await tx4.getTxHash(),
-      await tx5.getTxHash(),
+      tx1.getTxHash(),
+      tx2.getTxHash(),
+      tx3.getTxHash(),
+      tx4.getTxHash(),
+      tx5.getTxHash(),
     ]);
     expect(availability).toHaveLength(5);
     expect(availability).toEqual(expect.arrayContaining([true, true, true, false, false]));
   });
 
-  it('Returns pending tx hashes sorted by priority', async () => {
+  it('returns pending tx hashes sorted by priority', async () => {
     const withPriorityFee = (tx: Tx, fee: number) => {
       unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
       return tx;
@@ -178,6 +201,6 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const poolTxHashes = await pool.getPendingTxHashes();
     expect(poolTxHashes).toHaveLength(4);
-    expect(poolTxHashes).toEqual(await Promise.all([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash())));
+    expect(poolTxHashes).toEqual([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash()));
   });
 }

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -19,7 +19,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
       }
 
       const attester = message.getSender();
-      if (!(await this.epochCache.isInCommittee(attester))) {
+      if (!(await this.epochCache.isInCommittee(slotNumberBigInt, attester))) {
         return PeerErrorSeverity.HighToleranceError;
       }
       return undefined;

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,6 +1,6 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, TX_ERROR_BLOCK_HEADER, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { type AnyTx, TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export interface ArchiveSource {
   getArchiveIndices: (archives: Fr[]) => Promise<(bigint | undefined)[]>;
@@ -17,7 +17,7 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
   async validateTx(tx: T): Promise<TxValidationResult> {
     const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.historicalHeader.hash()]);
     if (index === undefined) {
-      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
+      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for referencing an unknown block header`);
       return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };
     }
     return { result: 'valid' };

package/src/msg_validators/tx_validator/data_validator.ts

@@ -9,6 +9,7 @@ import {
   TX_ERROR_CONTRACT_CLASS_LOG_LENGTH,
   TX_ERROR_CONTRACT_CLASS_LOG_SORTING,
   TX_ERROR_INCORRECT_CALLDATA,
+  TX_ERROR_INCORRECT_HASH,
   Tx,
   type TxValidationResult,
   type TxValidator,
@@ -18,30 +19,42 @@ export class DataTxValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:tx_data');
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
-    const execRequestRes = this.#hasCorrectCalldata(tx);
-    // Note: If we ever skip txs here, must change this return statement to account for them.
-    return (await execRequestRes).result === 'invalid' ? execRequestRes : this.#hasCorrectContractClassLogs(tx);
+    const reason =
+      (await this.#hasCorrectHash(tx)) ??
+      (await this.#hasCorrectCalldata(tx)) ??
+      (await this.#hasCorrectContractClassLogs(tx));
+    return reason ? { result: 'invalid', reason: [reason] } : { result: 'valid' };
   }
 
-  async #hasCorrectCalldata(tx: Tx): Promise<TxValidationResult> {
+  async #hasCorrectHash(tx: Tx): Promise<string | undefined> {
+    const expected = await Tx.computeTxHash(tx);
+    if (!tx.getTxHash().equals(expected)) {
+      const reason = TX_ERROR_INCORRECT_HASH;
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected hash ${expected.toString()}. Got ${tx.getTxHash().toString()}.`,
+      );
+      return reason;
+    }
+    return undefined;
+  }
+
+  async #hasCorrectCalldata(tx: Tx): Promise<string | undefined> {
     if (tx.publicFunctionCalldata.length !== tx.numberOfPublicCalls()) {
       const reason = TX_ERROR_CALLDATA_COUNT_MISMATCH;
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
           tx.publicFunctionCalldata.length
         }.`,
       );
-      return { result: 'invalid', reason: [reason] };
+      return reason;
     }
 
     if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
       const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
       );
-      return { result: 'invalid', reason: [reason] };
+      return reason;
     }
 
     const callRequests = tx.getPublicCallRequestsWithCalldata();
@@ -50,23 +63,23 @@ export class DataTxValidator implements TxValidator<Tx> {
       const hash = await computeCalldataHash(calldata);
       if (!hash.equals(request.calldataHash)) {
         const reason = TX_ERROR_INCORRECT_CALLDATA;
-        this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Call request index: ${i}.`);
-        return { result: 'invalid', reason: [reason] };
+        this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Call request index: ${i}.`);
+        return reason;
       }
     }
 
-    return { result: 'valid' };
+    return undefined;
   }
 
-  async #hasCorrectContractClassLogs(tx: Tx): Promise<TxValidationResult> {
+  async #hasCorrectContractClassLogs(tx: Tx): Promise<string | undefined> {
     const contractClassLogsHashes = tx.data.getNonEmptyContractClassLogsHashes();
     if (contractClassLogsHashes.length !== tx.contractClassLogFields.length) {
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
+        `Rejecting tx ${tx.getTxHash().toString()} because of mismatched number of contract class logs. Expected ${
           contractClassLogsHashes.length
         }. Got ${tx.contractClassLogFields.length}.`,
       );
-      return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_COUNT] };
+      return TX_ERROR_CONTRACT_CLASS_LOG_COUNT;
     }
 
     const expectedHashes = await Promise.all(tx.contractClassLogFields.map(l => l.hash()));
@@ -76,34 +89,30 @@ export class DataTxValidator implements TxValidator<Tx> {
         if (expectedHashes.some(h => logHash.value.equals(h))) {
           const matchingLogIndex = expectedHashes.findIndex(l => logHash.value.equals(l));
           this.#log.verbose(
-            `Rejecting tx ${await Tx.getHash(
-              tx,
-            )} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
+            `Rejecting tx ${tx.getTxHash().toString()} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
           );
-          return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_SORTING] };
+          return TX_ERROR_CONTRACT_CLASS_LOG_SORTING;
         } else {
           this.#log.verbose(
-            `Rejecting tx ${await Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
+            `Rejecting tx ${tx.getTxHash().toString()} because of mismatched contract class logs. Expected hash ${
               logHash.value
             } from the kernels. Got ${hash} in the tx.`,
           );
-          return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOGS] };
+          return TX_ERROR_CONTRACT_CLASS_LOGS;
         }
       }
 
       const expectedMinLength = 1 + tx.contractClassLogFields[i].fields.findLastIndex(f => !f.isZero());
       if (logHash.logHash.length < expectedMinLength) {
         this.#log.verbose(
-          `Rejecting tx ${await Tx.getHash(
-            tx,
-          )} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
+          `Rejecting tx ${tx.getTxHash().toString()} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
             logHash.logHash.length
           }.`,
         );
-        return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_LENGTH] };
+        return TX_ERROR_CONTRACT_CLASS_LOG_LENGTH;
       }
     }
 
-    return { result: 'valid' };
+    return undefined;
   }
 }

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -26,12 +26,12 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(nullifiers);
     if (uniqueNullifiers.size !== nullifiers.length) {
-      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for emitting duplicate nullifiers`);
+      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for emitting duplicate nullifiers`);
       return { result: 'invalid', reason: [TX_ERROR_DUPLICATE_NULLIFIER_IN_TX] };
     }
 
     if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
-      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
+      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for repeating a nullifier`);
       return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
     }
 

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -33,10 +33,10 @@ export class GasTxValidator implements TxValidator<Tx> {
     if (gasLimitValidation.result === 'invalid') {
       return Promise.resolve(gasLimitValidation);
     }
-    if (await this.#shouldSkip(tx)) {
+    if (this.#shouldSkip(tx)) {
       return Promise.resolve({ result: 'skipped', reason: [TX_ERROR_INSUFFICIENT_FEE_PER_GAS] });
     }
-    return this.validateTxFee(tx);
+    return await this.validateTxFee(tx);
   }
 
   /**
@@ -45,7 +45,7 @@ export class GasTxValidator implements TxValidator<Tx> {
    * Note that circuits check max fees even if fee payer is unset, so we
    * keep this validation even if the tx does not pay fees.
    */
-  async #shouldSkip(tx: Tx): Promise<boolean> {
+  #shouldSkip(tx: Tx): boolean {
     const gasSettings = tx.data.constants.txContext.gasSettings;
 
     // Skip the tx if its max fees are not enough for the current block's gas fees.
@@ -54,7 +54,7 @@ export class GasTxValidator implements TxValidator<Tx> {
       maxFeesPerGas.feePerDaGas < this.#gasFees.feePerDaGas || maxFeesPerGas.feePerL2Gas < this.#gasFees.feePerL2Gas;
 
     if (notEnoughMaxFees) {
-      this.#log.verbose(`Skipping transaction ${await tx.getTxHash()} due to insufficient fee per gas`, {
+      this.#log.verbose(`Skipping transaction ${tx.getTxHash().toString()} due to insufficient fee per gas`, {
         txMaxFeesPerGas: maxFeesPerGas.toInspect(),
         currentGasFees: this.#gasFees.toInspect(),
       });

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -7,9 +7,9 @@ import {
   TX_ERROR_INCORRECT_ROLLUP_VERSION,
   TX_ERROR_INCORRECT_VK_TREE_ROOT,
   TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
-  Tx,
   type TxValidationResult,
   type TxValidator,
+  getTxHash,
 } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
@@ -30,33 +30,31 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     },
   ) {}
 
-  async validateTx(tx: T): Promise<TxValidationResult> {
+  validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
-    if (!(await this.#hasCorrectL1ChainId(tx))) {
+    if (!this.#hasCorrectL1ChainId(tx)) {
       errors.push(TX_ERROR_INCORRECT_L1_CHAIN_ID);
     }
-    if (!(await this.#hasCorrectRollupVersion(tx))) {
+    if (!this.#hasCorrectRollupVersion(tx)) {
       errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
     }
-    if (!(await this.#isValidForTimestamp(tx))) {
+    if (!this.#isValidForTimestamp(tx)) {
       errors.push(TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP);
     }
-    if (!(await this.#hasCorrectVkTreeRoot(tx))) {
+    if (!this.#hasCorrectVkTreeRoot(tx)) {
       errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
     }
-    if (!(await this.#hasCorrectProtocolContractTreeRoot(tx))) {
+    if (!this.#hasCorrectProtocolContractTreeRoot(tx)) {
       errors.push(TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT);
     }
-    return errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' };
+    return Promise.resolve(errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' });
   }
 
-  async #hasCorrectVkTreeRoot(tx: T): Promise<boolean> {
+  #hasCorrectVkTreeRoot(tx: T): boolean {
     // This gets implicitly tested in the proof validator, but we can get a much cheaper check here by looking early at the vk.
     if (!tx.data.constants.vkTreeRoot.equals(this.values.vkTreeRoot)) {
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
       );
       return false;
     } else {
@@ -64,24 +62,20 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  async #hasCorrectProtocolContractTreeRoot(tx: T): Promise<boolean> {
+  #hasCorrectProtocolContractTreeRoot(tx: T): boolean {
     if (!tx.data.constants.protocolContractTreeRoot.equals(this.values.protocolContractTreeRoot)) {
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because of incorrect protocol contract tree root ${tx.data.constants.protocolContractTreeRoot.toString()} != ${this.values.protocolContractTreeRoot.toString()}`,
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect protocol contract tree root ${tx.data.constants.protocolContractTreeRoot.toString()} != ${this.values.protocolContractTreeRoot.toString()}`,
       );
       return false;
     }
     return true;
   }
 
-  async #hasCorrectL1ChainId(tx: T): Promise<boolean> {
+  #hasCorrectL1ChainId(tx: T): boolean {
     if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
       );
       return false;
     } else {
@@ -89,20 +83,22 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  async #isValidForTimestamp(tx: T): Promise<boolean> {
-    const includeByTimestamp = tx.data.rollupValidationRequests.includeByTimestamp;
+  #isValidForTimestamp(tx: T): boolean {
+    const includeByTimestamp = tx.data.includeByTimestamp;
     // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
     // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
     const buildingBlock1 = this.values.blockNumber === 1;
 
-    if (!buildingBlock1 && includeByTimestamp.isSome && includeByTimestamp.value < this.values.timestamp) {
+    if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
       if (tx.data.constants.historicalHeader.globalVariables.blockNumber === 0) {
         this.#log.warn(
           `A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`,
         );
       }
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp.value}, timestamp: ${this.values.timestamp}.`,
+        `Rejecting tx ${getTxHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
+          this.values.timestamp
+        }.`,
       );
       return false;
     } else {
@@ -110,12 +106,10 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  async #hasCorrectRollupVersion(tx: T): Promise<boolean> {
+  #hasCorrectRollupVersion(tx: T): boolean {
     if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
       this.#log.verbose(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,
       );
       return false;
     } else {