@aztec/p2p 0.86.0-starknet.1 → 0.87.0

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -44,9 +44,15 @@ export class AztecKVTxPool implements TxPool {
   /** The cumulative tx size in bytes that the pending txs in the pool take up. */
   #pendingTxSize: AztecAsyncSingleton<number>;
 
+  /** Count of total pending txs. */
+  #pendingTxCount: AztecAsyncSingleton<number>;
+
   /** In-memory mapping of pending tx hashes to the hydrated pending tx in the pool. */
   #pendingTxs: Map<string, Tx>;
 
+  /** In-memory set of txs that should not be evicted from the pool. */
+  #nonEvictableTxs: Set<string>;
+
   /** KV store for archived txs. */
   #archive: AztecAsyncKVStore;
 
@@ -91,8 +97,10 @@ export class AztecKVTxPool implements TxPool {
     this.#pendingTxHashToSize = store.openMap('pendingTxHashToSize');
     this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
     this.#pendingTxSize = store.openSingleton('pendingTxSize');
+    this.#pendingTxCount = store.openSingleton('pendingTxCount');
     this.#maxTxPoolSize = config.maxTxPoolSize;
     this.#pendingTxs = new Map<string, Tx>();
+    this.#nonEvictableTxs = new Set<string>();
 
     this.#archivedTxs = archive.openMap('archivedTxs');
     this.#archivedTxIndices = archive.openMap('archivedTxIndices');
@@ -112,7 +120,7 @@ export class AztecKVTxPool implements TxPool {
     return true;
   }
 
-  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
+  public async markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
@@ -120,7 +128,8 @@ export class AztecKVTxPool implements TxPool {
     let deletedPending = 0;
     const minedNullifiers = new Set<string>();
     const minedFeePayers = new Set<string>();
-    return this.#store.transactionAsync(async () => {
+
+    await this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
         const key = hash.toString();
@@ -139,6 +148,7 @@ export class AztecKVTxPool implements TxPool {
       }
       this.#metrics.recordAddedObjects(txHashes.length, 'mined');
       await this.#pendingTxSize.set(pendingTxSize);
+      await this.increasePendingTxCount(-deletedPending);
 
       const numTxsEvicted = await this.evictInvalidTxsAfterMining(
         txHashes,
@@ -148,43 +158,44 @@ export class AztecKVTxPool implements TxPool {
       );
       this.#metrics.recordRemovedObjects(deletedPending + numTxsEvicted, 'pending');
     });
+    // We update this after the transaction above. This ensures that the non-evictable transactions are not evicted
+    // until any that have been mined are marked as such.
+    // The non-evictable set is not considered when evicting transactions that are invalid after a block is mined.
+    this.#nonEvictableTxs.clear();
   }
 
-  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
+  public async markMinedAsPending(txHashes: TxHash[]): Promise<void> {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
 
     let markedAsPending = 0;
-    return this.#store
-      .transactionAsync(async () => {
-        let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
-        for (const hash of txHashes) {
-          const key = hash.toString();
-          await this.#minedTxHashToBlock.delete(key);
+    await this.#store.transactionAsync(async () => {
+      let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
+      for (const hash of txHashes) {
+        const key = hash.toString();
+        await this.#minedTxHashToBlock.delete(key);
 
-          // Rehydrate the tx in the in-memory pending txs mapping
-          const tx = await this.getPendingTxByHash(hash);
-          if (tx) {
-            await this.addPendingTxIndices(tx, key);
-            pendingTxSize += tx.getSize();
-            markedAsPending++;
-          }
+        // Rehydrate the tx in the in-memory pending txs mapping
+        const tx = await this.getPendingTxByHash(hash);
+        if (tx) {
+          await this.addPendingTxIndices(tx, key);
+          pendingTxSize += tx.getSize();
+          markedAsPending++;
         }
+      }
+
+      await this.#pendingTxSize.set(pendingTxSize);
+    });
 
-        await this.#pendingTxSize.set(pendingTxSize);
-      })
-      .then(async () => {
-        const numInvalidTxsEvicted = await this.evictInvalidTxsAfterReorg(txHashes);
-        const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(txHashes);
-
-        this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
-        this.#metrics.recordRemovedObjects(
-          numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted,
-          'pending',
-        );
-        this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
-      });
+    const numInvalidTxsEvicted = await this.evictInvalidTxsAfterReorg(txHashes);
+    const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(txHashes);
+
+    await this.increasePendingTxCount(markedAsPending);
+
+    this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
+    this.#metrics.recordRemovedObjects(numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
+    this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
   }
 
   public async getPendingTxHashes(): Promise<TxHash[]> {
@@ -197,6 +208,10 @@ export class AztecKVTxPool implements TxPool {
     return vals.map(([txHash, blockNumber]) => [TxHash.fromString(txHash), blockNumber]);
   }
 
+  public async getPendingTxCount(): Promise<number> {
+    return (await this.#pendingTxCount.getAsync()) ?? 0;
+  }
+
   public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
     const key = txHash.toString();
     const [isMined, isKnown] = await Promise.all([this.#minedTxHashToBlock.hasAsync(key), this.#txs.hasAsync(key)]);
@@ -266,21 +281,26 @@ export class AztecKVTxPool implements TxPool {
       txs.map(async tx => ({ txHash: await tx.getTxHash(), txStats: await tx.getStats() })),
     );
     await this.#store.transactionAsync(async () => {
-      let pendingCount = 0;
+      let addedCount = 0;
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       await Promise.all(
         txs.map(async (tx, i) => {
           const { txHash, txStats } = hashesAndStats[i];
+          const key = txHash.toString();
+          if (await this.#txs.hasAsync(key)) {
+            this.#log.debug(`Tx ${txHash.toString()} already exists in the pool`);
+            return;
+          }
+
           this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
             eventName: 'tx-added-to-pool',
             ...txStats,
           } satisfies TxAddedToPoolStats);
 
-          const key = txHash.toString();
           await this.#txs.set(key, tx.toBuffer());
 
           if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
-            pendingCount++;
+            addedCount++;
             pendingTxSize += tx.getSize();
             await this.addPendingTxIndices(tx, key);
             this.#metrics.recordSize(tx);
@@ -288,13 +308,13 @@ export class AztecKVTxPool implements TxPool {
         }),
       );
 
+      await this.increasePendingTxCount(addedCount);
       await this.#pendingTxSize.set(pendingTxSize);
-
       const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(
         hashesAndStats.map(({ txHash }) => txHash),
       );
 
-      this.#metrics.recordAddedObjects(pendingCount - numNewTxsEvicted, 'pending');
+      this.#metrics.recordAddedObjects(addedCount - numNewTxsEvicted, 'pending');
       this.#metrics.recordRemovedObjects(numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
     });
   }
@@ -335,6 +355,8 @@ export class AztecKVTxPool implements TxPool {
       }
 
       await this.#pendingTxSize.set(pendingTxSize);
+      await this.increasePendingTxCount(-pendingDeleted);
+
       this.#metrics.recordRemovedObjects(pendingDeleted, 'pending');
       this.#metrics.recordRemovedObjects(minedDeleted, 'mined');
     });
@@ -369,6 +391,11 @@ export class AztecKVTxPool implements TxPool {
     return Promise.resolve();
   }
 
+  public markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void> {
+    txHashes.forEach(txHash => this.#nonEvictableTxs.add(txHash.toString()));
+    return Promise.resolve();
+  }
+
   /**
    * Creates a GasTxValidator instance.
    * @param db - DB for the validator to use
@@ -466,6 +493,9 @@ export class AztecKVTxPool implements TxPool {
     let pendingTxsSize = (await this.#pendingTxSize.getAsync()) ?? 0;
     if (pendingTxsSize > this.#maxTxPoolSize) {
       for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()) {
+        if (this.#nonEvictableTxs.has(txHash.toString())) {
+          continue;
+        }
         this.#log.verbose(`Evicting tx ${txHash} from pool due to low priority to satisfy max tx size limit`);
         txsToEvict.push(TxHash.fromString(txHash));
 
@@ -613,4 +643,12 @@ export class AztecKVTxPool implements TxPool {
     await this.#pendingTxHashToHeaderHash.delete(txHash);
     this.#pendingTxs.delete(txHash);
   }
+
+  private async increasePendingTxCount(count: number): Promise<void> {
+    const pendingTxCount = (await this.#pendingTxCount.getAsync()) ?? 0;
+    this.#log.debug(
+      `Increasing pending tx count: current ${pendingTxCount} + count ${count} = ${pendingTxCount + count}`,
+    );
+    await this.#pendingTxCount.set(pendingTxCount + count);
+  }
 }

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -24,7 +24,10 @@ export class InMemoryTxPool implements TxPool {
    * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
    * @param log - A logger.
    */
-  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:tx_pool')) {
+  constructor(
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('p2p:tx_pool'),
+  ) {
     this.txs = new Map<bigint, Tx>();
     this.minedTxs = new Map();
     this.pendingTxs = new Set();
@@ -86,6 +89,10 @@ export class InMemoryTxPool implements TxPool {
     );
   }
 
+  public getPendingTxCount(): Promise<number> {
+    return Promise.resolve(this.pendingTxs.size);
+  }
+
   public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
     const key = txHash.toBigInt();
     if (this.pendingTxs.has(key)) {
@@ -186,4 +193,8 @@ export class InMemoryTxPool implements TxPool {
   setMaxTxPoolSize(_maxSizeBytes: number | undefined): Promise<void> {
     return Promise.resolve();
   }
+
+  markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -75,6 +75,9 @@ export interface TxPool {
    */
   getPendingTxHashes(): Promise<TxHash[]>;
 
+  /** Returns the number of pending txs in the pool. */
+  getPendingTxCount(): Promise<number>;
+
   /**
    * Gets the hashes of mined transactions currently in the tx pool.
    * @returns An array of mined transaction hashes found in the tx pool.
@@ -96,4 +99,10 @@ export interface TxPool {
 
   /** Returns whether the pool is empty. */
   isEmpty(): Promise<boolean>;
+
+  /**
+   * Marks transactions as non-evictible in the pool.
+   * @param txHashes - Hashes of the transactions to mark as non-evictible.
+   */
+  markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -24,6 +24,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     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()]);
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
   it('Removes txs from the pool', async () => {
@@ -34,6 +35,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
     await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+    await expect(pool.getPendingTxCount()).resolves.toEqual(0);
   });
 
   it('Marks txs as mined', async () => {
@@ -47,6 +49,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     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.getPendingTxCount()).resolves.toEqual(1);
   });
 
   it('Marks txs as pending after being mined', async () => {
@@ -61,6 +64,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
     expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(2);
   });
 
   it('Only marks txs as pending if they are known', async () => {
@@ -82,6 +86,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.markMinedAsPending([await 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.getPendingTxCount()).resolves.toEqual(1);
   });
 
   it('Returns all transactions in the pool', async () => {
@@ -94,6 +99,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const poolTxs = await pool.getAllTxs();
     expect(poolTxs).toHaveLength(3);
     expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
   it('Returns all txHashes in the pool', async () => {
@@ -104,10 +110,10 @@ 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()));
     expect(poolTxHashes).toHaveLength(3);
-    expect(poolTxHashes).toEqual(
-      expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash(), await tx3.getTxHash()]),
-    );
+    expect(poolTxHashes).toEqual(expect.arrayContaining(expectedHashes));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
   it('Returns txs by their hash', async () => {

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -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.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} 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

@@ -26,7 +26,7 @@ export class DataTxValidator implements TxValidator<Tx> {
   async #hasCorrectCalldata(tx: Tx): Promise<TxValidationResult> {
     if (tx.publicFunctionCalldata.length !== tx.numberOfPublicCalls()) {
       const reason = TX_ERROR_CALLDATA_COUNT_MISMATCH;
-      this.#log.warn(
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
           tx.publicFunctionCalldata.length
         }.`,
@@ -36,7 +36,7 @@ export class DataTxValidator implements TxValidator<Tx> {
 
     if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
       const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
-      this.#log.warn(
+      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()}.`,
@@ -50,7 +50,7 @@ export class DataTxValidator implements TxValidator<Tx> {
       const hash = await computeCalldataHash(calldata);
       if (!hash.equals(request.calldataHash)) {
         const reason = TX_ERROR_INCORRECT_CALLDATA;
-        this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Call request index: ${i}.`);
+        this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Call request index: ${i}.`);
         return { result: 'invalid', reason: [reason] };
       }
     }
@@ -60,44 +60,50 @@ export class DataTxValidator implements TxValidator<Tx> {
 
   async #hasCorrectContractClassLogs(tx: Tx): Promise<TxValidationResult> {
     const contractClassLogsHashes = tx.data.getNonEmptyContractClassLogsHashes();
-    const hashedContractClasslogs = await Promise.all(tx.contractClassLogs.map(l => l.hash()));
-    if (contractClassLogsHashes.length !== hashedContractClasslogs.length) {
-      this.#log.warn(
+    if (contractClassLogsHashes.length !== tx.contractClassLogs.length) {
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
           contractClassLogsHashes.length
-        }. Got ${hashedContractClasslogs.length}.`,
+        }. Got ${tx.contractClassLogs.length}.`,
       );
       return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_COUNT] };
     }
+
+    const expectedHashes = await Promise.all(tx.contractClassLogs.map(l => l.hash()));
     for (const [i, logHash] of contractClassLogsHashes.entries()) {
-      const hashedLog = hashedContractClasslogs[i];
-      if (!logHash.value.equals(hashedLog)) {
-        if (hashedContractClasslogs.some(l => logHash.value.equals(l))) {
-          const matchingLogIndex = hashedContractClasslogs.findIndex(l => logHash.value.equals(l));
-          this.#log.warn(
+      const hash = expectedHashes[i];
+      if (!logHash.value.equals(hash)) {
+        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.`,
           );
           return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_SORTING] };
         } else {
-          this.#log.warn(
+          this.#log.verbose(
             `Rejecting tx ${await Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
               logHash.value
-            } from the kernels. Got ${hashedLog} in the tx.`,
+            } from the kernels. Got ${hash} in the tx.`,
           );
           return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOGS] };
         }
       }
-      if (logHash.logHash.length !== tx.contractClassLogs[i].getEmittedLength()) {
-        this.#log.warn(
-          `Rejecting tx ${await Tx.getHash(tx)} because of mismatched contract class logs length. Expected ${
+
+      const expectedMinLength = 1 + tx.contractClassLogs[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 ${
             logHash.logHash.length
-          } from the kernel's log hashes. Got ${tx.contractClassLogs[i].getEmittedLength()} in the tx.`,
+          }.`,
         );
         return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_LENGTH] };
       }
     }
+
     return { result: 'valid' };
   }
 }

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.warn(`Rejecting tx ${await Tx.getHash(tx)} for emitting duplicate nullifiers`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} 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.warn(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
       return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
     }
 

package/src/msg_validators/tx_validator/factory.ts

@@ -0,0 +1,94 @@
+import { Fr } from '@aztec/foundation/fields';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { GasFees } from '@aztec/stdlib/gas';
+import type {
+  AllowedElement,
+  ClientProtocolCircuitVerifier,
+  WorldStateSynchronizer,
+} from '@aztec/stdlib/interfaces/server';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { DatabasePublicStateSource, MerkleTreeId } from '@aztec/stdlib/trees';
+import type { Tx, TxValidationResult } from '@aztec/stdlib/tx';
+
+import { ArchiveCache } from './archive_cache.js';
+import { BlockHeaderTxValidator } from './block_header_validator.js';
+import { DataTxValidator } from './data_validator.js';
+import { DoubleSpendTxValidator } from './double_spend_validator.js';
+import { GasTxValidator } from './gas_validator.js';
+import { MetadataTxValidator } from './metadata_validator.js';
+import { PhasesTxValidator } from './phases_validator.js';
+import { TxProofValidator } from './tx_proof_validator.js';
+
+export interface MessageValidator {
+  validator: {
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+  };
+  severity: PeerErrorSeverity;
+}
+
+export function createTxMessageValidators(
+  blockNumber: number,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  gasFees: GasFees,
+  l1ChainId: number,
+  rollupVersion: number,
+  protocolContractTreeRoot: Fr,
+  contractDataSource: ContractDataSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  allowedInSetup: AllowedElement[] = [],
+): Record<string, MessageValidator>[] {
+  const merkleTree = worldStateSynchronizer.getCommitted();
+
+  return [
+    {
+      dataValidator: {
+        validator: new DataTxValidator(),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      metadataValidator: {
+        validator: new MetadataTxValidator({
+          l1ChainId: new Fr(l1ChainId),
+          rollupVersion: new Fr(rollupVersion),
+          blockNumber: new Fr(blockNumber),
+          protocolContractTreeRoot,
+          vkTreeRoot: getVKTreeRoot(),
+        }),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      doubleSpendValidator: {
+        validator: new DoubleSpendTxValidator({
+          nullifiersExist: async (nullifiers: Buffer[]) => {
+            const merkleTree = worldStateSynchronizer.getCommitted();
+            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+            return indices.map(index => index !== undefined);
+          },
+        }),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      gasValidator: {
+        validator: new GasTxValidator(
+          new DatabasePublicStateSource(merkleTree),
+          ProtocolContractAddress.FeeJuice,
+          gasFees,
+        ),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      phasesValidator: {
+        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, blockNumber),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      blockHeaderValidator: {
+        validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree)),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+    },
+    {
+      proofValidator: {
+        validator: new TxProofValidator(proofVerifier),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+    },
+  ];
+}

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -55,7 +55,7 @@ export class GasTxValidator implements TxValidator<Tx> {
       maxFeesPerGas.feePerL2Gas.lt(this.#gasFees.feePerL2Gas);
 
     if (notEnoughMaxFees) {
-      this.#log.warn(`Skipping transaction ${await tx.getTxHash()} due to insufficient fee per gas`, {
+      this.#log.verbose(`Skipping transaction ${await tx.getTxHash()} due to insufficient fee per gas`, {
         txMaxFeesPerGas: maxFeesPerGas.toInspect(),
         currentGasFees: this.#gasFees.toInspect(),
       });
@@ -71,7 +71,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     const minGasLimits = new Gas(FIXED_DA_GAS, FIXED_L2_GAS);
 
     if (minGasLimits.gtAny(gasLimits)) {
-      this.#log.warn(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
+      this.#log.verbose(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
         gasLimits,
         minGasLimits,
       });
@@ -113,7 +113,7 @@ export class GasTxValidator implements TxValidator<Tx> {
 
     const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[1]) : initialBalance;
     if (balance.lt(feeLimit)) {
-      this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
+      this.#log.verbose(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,
         balance: balance.toBigInt(),
         feeLimit: feeLimit.toBigInt(),

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -42,7 +42,7 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   async #hasCorrectVkTreeRoot(tx: T): Promise<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.warn(
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(
           tx,
         )} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
@@ -55,7 +55,7 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
 
   async #hasCorrectProtocolContractTreeRoot(tx: T): Promise<boolean> {
     if (!tx.data.constants.protocolContractTreeRoot.equals(this.values.protocolContractTreeRoot)) {
-      this.#log.warn(
+      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()}`,
@@ -67,7 +67,7 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
 
   async #hasCorrectL1ChainId(tx: T): Promise<boolean> {
     if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
-      this.#log.warn(
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(
           tx,
         )} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
@@ -82,7 +82,7 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
 
     if (maxBlockNumber.isSome && maxBlockNumber.value < this.values.blockNumber) {
-      this.#log.warn(
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${
           maxBlockNumber.value
         }, current block number: ${this.values.blockNumber}.`,
@@ -95,7 +95,7 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
 
   async #hasCorrectRollupVersion(tx: T): Promise<boolean> {
     if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
-      this.#log.warn(
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(
           tx,
         )} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -16,7 +16,11 @@ export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_phases');
   private contractsDB: PublicContractsDB;
 
-  constructor(contracts: ContractDataSource, private setupAllowList: AllowedElement[], private blockNumber: number) {
+  constructor(
+    contracts: ContractDataSource,
+    private setupAllowList: AllowedElement[],
+    private blockNumber: number,
+  ) {
     this.contractsDB = new PublicContractsDB(contracts);
   }
 
@@ -37,7 +41,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
       const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
       for (const setupFn of setupFns) {
         if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
-          this.#log.warn(
+          this.#log.verbose(
             `Rejecting tx ${await Tx.getHash(tx)} because it calls setup function not on allow list: ${
               setupFn.request.contractAddress
             }:${setupFn.functionSelector}`,

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -9,7 +9,7 @@ export class TxProofValidator implements TxValidator<Tx> {
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!(await this.verifier.verifyProof(tx))) {
-      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for invalid proof`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for invalid proof`);
       return { result: 'invalid', reason: [TX_ERROR_INVALID_PROOF] };
     }
     this.#log.trace(`Accepted ${await Tx.getHash(tx)} with valid proof`);