@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/src/msg_validators/tx_validator/data_validator.ts

@@ -1,106 +1,118 @@
-import { MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
-import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { computeCalldataHash } from '@aztec/stdlib/hash';
+import {
+  TX_ERROR_CALLDATA_COUNT_MISMATCH,
+  TX_ERROR_CALLDATA_COUNT_TOO_LARGE,
+  TX_ERROR_CONTRACT_CLASS_LOGS,
+  TX_ERROR_CONTRACT_CLASS_LOG_COUNT,
+  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,
+} from '@aztec/stdlib/tx';
 
 export class DataTxValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:tx_data');
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
-    const execRequestRes = this.#hasCorrectExecutionRequests(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 #hasCorrectExecutionRequests(tx: Tx): Promise<TxValidationResult> {
-    const callRequests = [
-      ...tx.data.getRevertiblePublicCallRequests(),
-      ...tx.data.getNonRevertiblePublicCallRequests(),
-    ];
-    if (callRequests.length !== tx.enqueuedPublicFunctionCalls.length) {
-      this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} because of mismatch number of execution requests for public calls. Expected ${
-          callRequests.length
-        }. Got ${tx.enqueuedPublicFunctionCalls.length}.`,
+  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 { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
+      return reason;
     }
+    return undefined;
+  }
 
-    if (tx.getTotalPublicArgsCount() > MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS) {
-      this.#log.warn(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because the total length of args to public enqueued calls is greater than ${MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS}`,
+  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 ${tx.getTxHash().toString()}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
+          tx.publicFunctionCalldata.length
+        }.`,
       );
-      return { result: 'invalid', reason: ['Too many args in total to enqueued public calls'] };
+      return reason;
     }
-    const invalidExecutionRequestIndex = (
-      await Promise.all(
-        tx.enqueuedPublicFunctionCalls.map(
-          async (execRequest, i) => !(await execRequest.isForCallRequest(callRequests[i])),
-        ),
-      )
-    ).findIndex(Boolean);
-    if (invalidExecutionRequestIndex !== -1) {
-      this.#log.warn(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`,
+
+    if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
+      const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
+      this.#log.verbose(
+        `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: ['Incorrect execution request for public call'] };
+      return reason;
     }
 
-    const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
-    const isInvalidTeardownExecutionRequest =
-      (!teardownCallRequest && !tx.publicTeardownFunctionCall.isEmpty()) ||
-      (teardownCallRequest && !(await tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest)));
-    if (isInvalidTeardownExecutionRequest) {
-      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect teardown execution requests.`);
-      return { result: 'invalid', reason: ['Incorrect teardown execution request'] };
+    const callRequests = tx.getPublicCallRequestsWithCalldata();
+    for (let i = 0; i < callRequests.length; i++) {
+      const { request, calldata } = callRequests[i];
+      const hash = await computeCalldataHash(calldata);
+      if (!hash.equals(request.calldataHash)) {
+        const reason = TX_ERROR_INCORRECT_CALLDATA;
+        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();
-    const hashedContractClasslogs = await Promise.all(tx.contractClassLogs.map(l => l.hash()));
-    if (contractClassLogsHashes.length !== hashedContractClasslogs.length) {
-      this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
+    if (contractClassLogsHashes.length !== tx.contractClassLogFields.length) {
+      this.#log.verbose(
+        `Rejecting tx ${tx.getTxHash().toString()} because of mismatched number of contract class logs. Expected ${
           contractClassLogsHashes.length
-        }. Got ${hashedContractClasslogs.length}.`,
+        }. Got ${tx.contractClassLogFields.length}.`,
       );
-      return { result: 'invalid', reason: ['Mismatched number of contract class logs'] };
+      return TX_ERROR_CONTRACT_CLASS_LOG_COUNT;
     }
+
+    const expectedHashes = await Promise.all(tx.contractClassLogFields.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(
-            `Rejecting tx ${Tx.getHash(
-              tx,
-            )} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
+      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 ${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: ['Incorrectly sorted contract class logs'] };
+          return TX_ERROR_CONTRACT_CLASS_LOG_SORTING;
         } else {
-          this.#log.warn(
-            `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
+          this.#log.verbose(
+            `Rejecting tx ${tx.getTxHash().toString()} 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: ['Mismatched contract class logs'] };
+          return TX_ERROR_CONTRACT_CLASS_LOGS;
         }
       }
-      if (logHash.logHash.length !== tx.contractClassLogs[i].getEmittedLength()) {
-        this.#log.warn(
-          `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs length. Expected ${
+
+      const expectedMinLength = 1 + tx.contractClassLogFields[i].fields.findLastIndex(f => !f.isZero());
+      if (logHash.logHash.length < expectedMinLength) {
+        this.#log.verbose(
+          `Rejecting tx ${tx.getTxHash().toString()} 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: ['Mismatched contract class logs length'] };
+        return TX_ERROR_CONTRACT_CLASS_LOG_LENGTH;
       }
     }
-    return { result: 'valid' };
+
+    return undefined;
   }
 }

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -1,5 +1,12 @@
 import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator, hasPublicCalls } from '@aztec/stdlib/tx';
+import {
+  type AnyTx,
+  TX_ERROR_DUPLICATE_NULLIFIER_IN_TX,
+  TX_ERROR_EXISTING_NULLIFIER,
+  Tx,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export interface NullifierSource {
   nullifiersExist: (nullifiers: Buffer[]) => Promise<boolean[]>;
@@ -14,25 +21,20 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    // Don't need to check for duplicate nullifiers if the tx has public calls
-    // because the AVM will perform merkle insertions as it goes and will fail on
-    // duplicate nullifier. In fact we CANNOT check here because the nullifiers
-    // have already been inserted, and so they will exist in nullifierSource.
-    if (!hasPublicCalls(tx)) {
-      const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
+    const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
 
-      // 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`);
-        return { result: 'invalid', reason: ['Duplicate nullifier in tx'] };
-      }
+    // Ditch this tx if it has repeated nullifiers
+    const uniqueNullifiers = new Set(nullifiers.map(n => n.toBigInt()));
+    if (uniqueNullifiers.size !== nullifiers.length) {
+      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.warn(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
-        return { result: 'invalid', reason: ['Existing nullifier'] };
-      }
+    if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
+      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for repeating a nullifier`);
+      return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
     }
+
     return { result: 'valid' };
   }
 }

package/src/msg_validators/tx_validator/factory.ts

@@ -0,0 +1,109 @@
+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 type { UInt64 } from '@aztec/stdlib/types';
+
+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 { TimestampTxValidator } from './timestamp_validator.js';
+import { TxPermittedValidator } from './tx_permitted_validator.js';
+import { TxProofValidator } from './tx_proof_validator.js';
+
+export interface MessageValidator {
+  validator: {
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+  };
+  severity: PeerErrorSeverity;
+}
+
+export function createTxMessageValidators(
+  timestamp: UInt64,
+  blockNumber: number,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  gasFees: GasFees,
+  l1ChainId: number,
+  rollupVersion: number,
+  protocolContractsHash: Fr,
+  contractDataSource: ContractDataSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  txsPermitted: boolean,
+  allowedInSetup: AllowedElement[] = [],
+): Record<string, MessageValidator>[] {
+  const merkleTree = worldStateSynchronizer.getCommitted();
+
+  return [
+    {
+      txsPermittedValidator: {
+        validator: new TxPermittedValidator(txsPermitted),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      dataValidator: {
+        validator: new DataTxValidator(),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      metadataValidator: {
+        validator: new MetadataTxValidator({
+          l1ChainId: new Fr(l1ChainId),
+          rollupVersion: new Fr(rollupVersion),
+          protocolContractsHash,
+          vkTreeRoot: getVKTreeRoot(),
+        }),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      timestampValidator: {
+        validator: new TimestampTxValidator<Tx>({
+          timestamp,
+          blockNumber,
+        }),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      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, timestamp),
+        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

@@ -0,0 +1,134 @@
+import { AVM_MAX_PROCESSABLE_L2_GAS, FIXED_DA_GAS, FIXED_L2_GAS } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Gas, GasFees } from '@aztec/stdlib/gas';
+import type { PublicStateSource } from '@aztec/stdlib/trees';
+import {
+  TX_ERROR_GAS_LIMIT_TOO_HIGH,
+  TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE,
+  TX_ERROR_INSUFFICIENT_FEE_PER_GAS,
+  TX_ERROR_INSUFFICIENT_GAS_LIMIT,
+  type Tx,
+  TxExecutionPhase,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
+
+export class GasTxValidator implements TxValidator<Tx> {
+  #log = createLogger('sequencer:tx_validator:tx_gas');
+  #publicDataSource: PublicStateSource;
+  #feeJuiceAddress: AztecAddress;
+  #gasFees: GasFees;
+
+  constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, gasFees: GasFees) {
+    this.#publicDataSource = publicDataSource;
+    this.#feeJuiceAddress = feeJuiceAddress;
+    this.#gasFees = gasFees;
+  }
+
+  async validateTx(tx: Tx): Promise<TxValidationResult> {
+    const gasLimitValidation = this.#validateGasLimit(tx);
+    if (gasLimitValidation.result === 'invalid') {
+      return Promise.resolve(gasLimitValidation);
+    }
+    if (this.#shouldSkip(tx)) {
+      return Promise.resolve({ result: 'skipped', reason: [TX_ERROR_INSUFFICIENT_FEE_PER_GAS] });
+    }
+    return await this.validateTxFee(tx);
+  }
+
+  /**
+   * Check whether the tx's max fees are valid for the current block, and skip if not.
+   * We skip instead of invalidating since the tx may become eligible later.
+   * 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.
+   */
+  #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.
+    const maxFeesPerGas = gasSettings.maxFeesPerGas;
+    const notEnoughMaxFees =
+      maxFeesPerGas.feePerDaGas < this.#gasFees.feePerDaGas || maxFeesPerGas.feePerL2Gas < this.#gasFees.feePerL2Gas;
+
+    if (notEnoughMaxFees) {
+      this.#log.verbose(`Skipping transaction ${tx.getTxHash().toString()} due to insufficient fee per gas`, {
+        txMaxFeesPerGas: maxFeesPerGas.toInspect(),
+        currentGasFees: this.#gasFees.toInspect(),
+      });
+    }
+    return notEnoughMaxFees;
+  }
+
+  /**
+   * Check whether the tx's gas limit is above the minimum amount.
+   */
+  #validateGasLimit(tx: Tx): TxValidationResult {
+    const gasLimits = tx.data.constants.txContext.gasSettings.gasLimits;
+    const minGasLimits = new Gas(FIXED_DA_GAS, FIXED_L2_GAS);
+
+    if (minGasLimits.gtAny(gasLimits)) {
+      this.#log.verbose(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
+        gasLimits,
+        minGasLimits,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_GAS_LIMIT] };
+    }
+
+    if (gasLimits.l2Gas > AVM_MAX_PROCESSABLE_L2_GAS) {
+      this.#log.verbose(`Rejecting transaction due to the gas limit(s) being higher than the maximum processable gas`, {
+        gasLimits,
+        minGasLimits,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_GAS_LIMIT_TOO_HIGH] };
+    }
+
+    return { result: 'valid' };
+  }
+
+  public async validateTxFee(tx: Tx): Promise<TxValidationResult> {
+    const feePayer = tx.data.feePayer;
+
+    // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
+    const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
+
+    // Read current balance of the feePayer
+    const initialBalance = await this.#publicDataSource.storageRead(
+      this.#feeJuiceAddress,
+      await computeFeePayerBalanceStorageSlot(feePayer),
+    );
+
+    // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
+    const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+    const increasePublicBalanceSelector = await FunctionSelector.fromSignature(
+      '_increase_public_balance((Field),u128)',
+    );
+
+    // Arguments of the claim function call:
+    // - args[0]: Amount recipient.
+    // - args[1]: Amount being claimed.
+    const claimFunctionCall = setupFns.find(
+      fn =>
+        fn.request.contractAddress.equals(this.#feeJuiceAddress) &&
+        fn.request.msgSender.equals(this.#feeJuiceAddress) &&
+        fn.calldata.length > 2 &&
+        fn.functionSelector.equals(increasePublicBalanceSelector) &&
+        fn.args[0].equals(feePayer.toField()) &&
+        !fn.request.isStaticCall,
+    );
+
+    const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[1]) : initialBalance;
+    if (balance.lt(feeLimit)) {
+      this.#log.verbose(`Rejecting transaction due to not enough fee payer balance`, {
+        feePayer,
+        balance: balance.toBigInt(),
+        feeLimit: feeLimit.toBigInt(),
+      });
+      return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE] };
+    }
+    return { result: 'valid' };
+  }
+}

package/src/msg_validators/tx_validator/index.ts

@@ -4,3 +4,10 @@ export * from './double_spend_validator.js';
 export * from './metadata_validator.js';
 export * from './tx_proof_validator.js';
 export * from './block_header_validator.js';
+export * from './gas_validator.js';
+export * from './phases_validator.js';
+export * from './test_utils.js';
+export * from './allowed_public_setup.js';
+export * from './archive_cache.js';
+export * from './tx_permitted_validator.js';
+export * from './timestamp_validator.js';

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,29 +1,49 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import {
+  type AnyTx,
+  TX_ERROR_INCORRECT_L1_CHAIN_ID,
+  TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH,
+  TX_ERROR_INCORRECT_ROLLUP_VERSION,
+  TX_ERROR_INCORRECT_VK_TREE_ROOT,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #log = createLogger('p2p:tx_validator:tx_metadata');
 
-  constructor(private chainId: Fr, private blockNumber: Fr) {}
+  constructor(
+    private values: {
+      l1ChainId: Fr;
+      rollupVersion: Fr;
+      vkTreeRoot: Fr;
+      protocolContractsHash: Fr;
+    },
+  ) {}
 
-  async validateTx(tx: T): Promise<TxValidationResult> {
+  validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
-    if (!(await this.#hasCorrectChainId(tx))) {
-      errors.push('Incorrect chain id');
+    if (!this.#hasCorrectL1ChainId(tx)) {
+      errors.push(TX_ERROR_INCORRECT_L1_CHAIN_ID);
     }
-    if (!(await this.#isValidForBlockNumber(tx))) {
-      errors.push('Invalid block number');
+    if (!this.#hasCorrectRollupVersion(tx)) {
+      errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
     }
-    return errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' };
+    if (!this.#hasCorrectVkTreeRoot(tx)) {
+      errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
+    }
+    if (!this.#hasCorrectprotocolContractsHash(tx)) {
+      errors.push(TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH);
+    }
+    return Promise.resolve(errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' });
   }
 
-  async #hasCorrectChainId(tx: T): Promise<boolean> {
-    if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
-      this.#log.warn(
-        `Rejecting tx ${await Tx.getHash(
-          tx,
-        )} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.chainId.toNumber()}`,
+  #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 ${'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 {
@@ -31,14 +51,31 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  async #isValidForBlockNumber(tx: T): Promise<boolean> {
-    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+  #hasCorrectprotocolContractsHash(tx: T): boolean {
+    if (!tx.data.constants.protocolContractsHash.equals(this.values.protocolContractsHash)) {
+      this.#log.verbose(
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`,
+      );
+      return false;
+    }
+    return true;
+  }
+
+  #hasCorrectL1ChainId(tx: T): boolean {
+    if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
+      this.#log.verbose(
+        `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 {
+      return true;
+    }
+  }
 
-    if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
-      this.#log.warn(
-        `Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${
-          maxBlockNumber.value
-        }, current block number: ${this.blockNumber}.`,
+  #hasCorrectRollupVersion(tx: T): boolean {
+    if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
+      this.#log.verbose(
+        `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 {