@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -0,0 +1,219 @@
+import {
+  MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT,
+  MAX_PROCESSABLE_L2_GAS,
+  PRIVATE_TX_L2_GAS_OVERHEAD,
+  PUBLIC_TX_L2_GAS_OVERHEAD,
+  TX_DA_GAS_OVERHEAD,
+} from '@aztec/constants';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+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,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
+
+import { getFeePayerClaimAmount, getTxFeeLimit } from './fee_payer_balance.js';
+
+/** Structural interface for types that carry gas limit data, used by {@link GasLimitsValidator}. */
+export interface HasGasLimitData {
+  txHash: { toString(): string };
+  data: {
+    // We just need to know whether there is something here or not
+    forPublic?: unknown;
+    constants: {
+      txContext: {
+        gasSettings: { gasLimits: Gas };
+      };
+    };
+  };
+}
+
+/**
+ * Validates that a transaction's gas limits are within acceptable bounds.
+ *
+ * Rejects transactions whose gas limits fall below the fixed minimums (FIXED_DA_GAS,
+ * FIXED_L2_GAS) or exceed the AVM's maximum processable L2 gas. This is a cheap,
+ * stateless check that operates on gas settings alone.
+ *
+ * Generic over T so it can validate both full {@link Tx} objects and {@link TxMetaData}
+ * (used during pending pool migration).
+ *
+ * Used by: pending pool migration (via factory), and indirectly by {@link GasTxValidator}.
+ */
+export class GasLimitsValidator<T extends HasGasLimitData> implements TxValidator<T> {
+  #log: Logger;
+  #effectiveMaxL2Gas: number;
+  #effectiveMaxDAGas: number;
+  #rollupManaLimit: number;
+  #maxBlockL2Gas: number;
+  #maxBlockDAGas: number;
+
+  constructor(opts?: {
+    rollupManaLimit?: number;
+    maxBlockL2Gas?: number;
+    maxBlockDAGas?: number;
+    bindings?: LoggerBindings;
+  }) {
+    this.#log = createLogger('sequencer:tx_validator:tx_gas', opts?.bindings);
+    this.#rollupManaLimit = opts?.rollupManaLimit ?? Infinity;
+    this.#maxBlockL2Gas = opts?.maxBlockL2Gas ?? Infinity;
+    this.#maxBlockDAGas = opts?.maxBlockDAGas ?? Infinity;
+    this.#effectiveMaxL2Gas = Math.min(MAX_PROCESSABLE_L2_GAS, this.#rollupManaLimit, this.#maxBlockL2Gas);
+    this.#effectiveMaxDAGas = Math.min(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, this.#maxBlockDAGas);
+  }
+
+  validateTx(tx: T): Promise<TxValidationResult> {
+    return Promise.resolve(this.validateGasLimit(tx));
+  }
+
+  /** Checks gas limits are >= fixed minimums and <= effective max gas (L2 and DA). */
+  validateGasLimit(tx: T): TxValidationResult {
+    const gasLimits = tx.data.constants.txContext.gasSettings.gasLimits;
+    const minGasLimits = new Gas(
+      TX_DA_GAS_OVERHEAD,
+      tx.data.forPublic ? PUBLIC_TX_L2_GAS_OVERHEAD : PRIVATE_TX_L2_GAS_OVERHEAD,
+    );
+
+    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 > this.#effectiveMaxL2Gas) {
+      this.#log.verbose(`Rejecting transaction due to the L2 gas limit being higher than the effective maximum`, {
+        gasLimits,
+        effectiveMaxL2Gas: this.#effectiveMaxL2Gas,
+        rollupManaLimit: this.#rollupManaLimit,
+        maxBlockL2Gas: this.#maxBlockL2Gas,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_GAS_LIMIT_TOO_HIGH] };
+    }
+
+    if (gasLimits.daGas > this.#effectiveMaxDAGas) {
+      this.#log.verbose(`Rejecting transaction due to the DA gas limit being higher than the effective maximum`, {
+        gasLimits,
+        effectiveMaxDAGas: this.#effectiveMaxDAGas,
+        maxBlockDAGas: this.#maxBlockDAGas,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_GAS_LIMIT_TOO_HIGH] };
+    }
+
+    return { result: 'valid' };
+  }
+}
+
+/**
+ * Validates that a transaction can pay its gas fees.
+ *
+ * Runs three checks in order:
+ * 1. **Gas limits** (delegates to {@link GasLimitsValidator}) — rejects if limits are
+ *    out of bounds.
+ * 2. **Max fee per gas** — skips (not rejects) the tx if its maxFeesPerGas is below
+ *    the current block's gas fees. We skip rather than reject because the tx may
+ *    become eligible in a later block with lower fees.
+ * 3. **Fee payer balance** — reads the fee payer's FeeJuice balance from public state,
+ *    adds any pending claim from a setup-phase `_increase_public_balance` call, and
+ *    rejects if the total is less than the tx's fee limit (gasLimits * maxFeePerGas).
+ *
+ * Used by: gossip (stage 1), RPC, and block building validators.
+ */
+export class GasTxValidator implements TxValidator<Tx> {
+  #log: Logger;
+  #publicDataSource: PublicStateSource;
+  #feeJuiceAddress: AztecAddress;
+  #gasFees: GasFees;
+  #gasLimitOpts?: { rollupManaLimit?: number; maxBlockL2Gas?: number; maxBlockDAGas?: number };
+
+  constructor(
+    publicDataSource: PublicStateSource,
+    feeJuiceAddress: AztecAddress,
+    gasFees: GasFees,
+    private bindings?: LoggerBindings,
+    opts?: { rollupManaLimit?: number; maxBlockL2Gas?: number; maxBlockDAGas?: number },
+  ) {
+    this.#log = createLogger('sequencer:tx_validator:tx_gas', bindings);
+    this.#publicDataSource = publicDataSource;
+    this.#feeJuiceAddress = feeJuiceAddress;
+    this.#gasFees = gasFees;
+    this.#gasLimitOpts = opts;
+  }
+
+  async validateTx(tx: Tx): Promise<TxValidationResult> {
+    const gasLimitValidation = new GasLimitsValidator({
+      ...this.#gasLimitOpts,
+      bindings: this.bindings,
+    }).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;
+  }
+
+  /**
+   * Checks the fee payer has enough FeeJuice balance to cover the tx's fee limit.
+   * Accounts for any pending claim from a setup-phase `_increase_public_balance` call.
+   */
+  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 = getTxFeeLimit(tx);
+
+    // 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 claimAmount = await getFeePayerClaimAmount(tx, this.#feeJuiceAddress);
+    const balance = initialBalance.toBigInt() + claimAmount;
+
+    if (balance < feeLimit) {
+      this.#log.verbose(`Rejecting transaction due to not enough fee payer balance`, {
+        feePayer,
+        balance,
+        feeLimit,
+      });
+      return { result: 'invalid', reason: [TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE] };
+    }
+    return { result: 'valid' };
+  }
+}

package/src/msg_validators/tx_validator/index.ts

@@ -4,3 +4,13 @@ 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 './allowed_setup_helpers.js';
+export * from './archive_cache.js';
+export * from './tx_permitted_validator.js';
+export * from './timestamp_validator.js';
+export * from './size_validator.js';
+export * from './factory.js';

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,29 +1,62 @@
-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 { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+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');
+  #log: Logger;
 
-  constructor(private chainId: Fr, private blockNumber: Fr) {}
+  constructor(
+    private values: {
+      l1ChainId: Fr;
+      rollupVersion: Fr;
+      vkTreeRoot: Fr;
+      protocolContractsHash: Fr;
+    },
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_metadata', bindings);
+  }
 
-  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} (tx: ${tx.data.constants.txContext.chainId.toNumber()}, expected: ${this.values.l1ChainId.toNumber()})`,
+      );
     }
-    if (!(await this.#isValidForBlockNumber(tx))) {
-      errors.push('Invalid block number');
+    if (!this.#hasCorrectRollupVersion(tx)) {
+      errors.push(
+        `${TX_ERROR_INCORRECT_ROLLUP_VERSION} (tx: ${tx.data.constants.txContext.version.toNumber()}, expected: ${this.values.rollupVersion.toNumber()})`,
+      );
+    }
+    if (!this.#hasCorrectVkTreeRoot(tx)) {
+      errors.push(
+        `${TX_ERROR_INCORRECT_VK_TREE_ROOT} (tx: ${tx.data.constants.vkTreeRoot.toString()}, expected: ${this.values.vkTreeRoot.toString()})`,
+      );
     }
-    return errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' };
+    if (!this.#hasCorrectprotocolContractsHash(tx)) {
+      errors.push(
+        `${TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH} (tx: ${tx.data.constants.protocolContractsHash.toString()}, expected: ${this.values.protocolContractsHash.toString()})`,
+      );
+    }
+    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 +64,37 @@ 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 {

package/src/msg_validators/tx_validator/nullifier_cache.ts

@@ -0,0 +1,30 @@
+import type { NullifierSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+
+/**
+ * Implements a nullifier source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class NullifierCache implements NullifierSource {
+  nullifiers: Set<string>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.nullifiers = new Set();
+  }
+
+  public async nullifiersExist(nullifiers: Buffer[]): Promise<boolean[]> {
+    const cacheResults = nullifiers.map(n => this.nullifiers.has(n.toString()));
+    const toCheckDb = nullifiers.filter((_n, index) => !cacheResults[index]);
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, toCheckDb);
+
+    let dbIndex = 0;
+    return nullifiers.map((_n, index) => cacheResults[index] || dbHits[dbIndex++] !== undefined);
+  }
+
+  public addNullifiers(nullifiers: Buffer[]) {
+    for (const nullifier of nullifiers) {
+      this.nullifiers.add(nullifier.toString());
+    }
+  }
+}

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -0,0 +1,173 @@
+import { NULL_MSG_SENDER_CONTRACT_ADDRESS } from '@aztec/constants';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+import {
+  type PublicCallRequestWithCalldata,
+  TX_ERROR_DURING_VALIDATION,
+  TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED,
+  TX_ERROR_SETUP_FUNCTION_UNKNOWN_CONTRACT,
+  TX_ERROR_SETUP_NULL_MSG_SENDER,
+  TX_ERROR_SETUP_ONLY_SELF_WRONG_SENDER,
+  TX_ERROR_SETUP_WRONG_CALLDATA_LENGTH,
+  Tx,
+  TxExecutionPhase,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+export class PhasesTxValidator implements TxValidator<Tx> {
+  #log: Logger;
+  private contractsDB: PublicContractsDB;
+
+  constructor(
+    contracts: ContractDataSource,
+    private setupAllowList: AllowedElement[],
+    private timestamp: UInt64,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('sequencer:tx_validator:tx_phases', bindings);
+    this.contractsDB = new PublicContractsDB(contracts, bindings);
+  }
+
+  async validateTx(tx: Tx): Promise<TxValidationResult> {
+    this.contractsDB.createCheckpoint();
+    try {
+      // TODO(@spalladino): We add this just to handle public authwit-check calls during setup
+      // which are needed for public FPC flows, but fail if the account contract hasnt been deployed yet,
+      // which is what we're trying to do as part of the current txs.
+      // We only need to create/revert checkpoint here because of this addNewContracts call.
+      await this.contractsDB.addNewContracts(tx);
+
+      if (!tx.data.forPublic) {
+        this.#log.debug(
+          `Tx ${tx.getTxHash().toString()} does not contain enqueued public functions. Skipping phases validation.`,
+        );
+        return { result: 'valid' };
+      }
+
+      const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+      for (const setupFn of setupFns) {
+        const rejectionReason = await this.checkAllowList(setupFn, this.setupAllowList);
+        if (rejectionReason) {
+          this.#log.verbose(
+            `Rejecting tx ${tx.getTxHash().toString()} because it calls setup function not on allow list: ${
+              setupFn.request.contractAddress
+            }:${setupFn.functionSelector}`,
+            { allowList: this.setupAllowList },
+          );
+
+          return { result: 'invalid', reason: [rejectionReason] };
+        }
+      }
+
+      return { result: 'valid' };
+    } catch (err) {
+      this.#log.error(`Error validating phases for tx`, err);
+      return { result: 'invalid', reason: [TX_ERROR_DURING_VALIDATION] };
+    } finally {
+      this.contractsDB.revertCheckpoint();
+    }
+  }
+
+  /** Returns a rejection reason if the call is not on the allow list, or undefined if it is allowed. */
+  private async checkAllowList(
+    publicCall: PublicCallRequestWithCalldata,
+    allowList: AllowedElement[],
+  ): Promise<string | undefined> {
+    if (publicCall.isEmpty()) {
+      return undefined;
+    }
+
+    const contractAddress = publicCall.request.contractAddress;
+    const functionSelector = publicCall.functionSelector;
+
+    // Check address-based entries first since they don't require the contract class.
+    for (const entry of allowList) {
+      if ('address' in entry) {
+        if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
+          if (entry.calldataLength !== undefined && publicCall.calldata.length !== entry.calldataLength) {
+            return TX_ERROR_SETUP_WRONG_CALLDATA_LENGTH;
+          }
+          if (entry.onlySelf && !publicCall.request.msgSender.equals(contractAddress)) {
+            return TX_ERROR_SETUP_ONLY_SELF_WRONG_SENDER;
+          }
+          if (
+            entry.rejectNullMsgSender &&
+            publicCall.request.msgSender.equals(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS))
+          ) {
+            return TX_ERROR_SETUP_NULL_MSG_SENDER;
+          }
+          return undefined;
+        }
+      }
+    }
+
+    // Check class-based entries. Fetch the contract instance lazily (only once).
+    let contractClassId: undefined | { value: string | undefined };
+    for (const entry of allowList) {
+      if (!('classId' in entry)) {
+        continue;
+      }
+
+      if (contractClassId === undefined) {
+        const instance = await this.contractsDB.getContractInstance(contractAddress, this.timestamp);
+        contractClassId = { value: instance?.currentContractClassId.toString() };
+        if (!contractClassId.value) {
+          return TX_ERROR_SETUP_FUNCTION_UNKNOWN_CONTRACT;
+        }
+      }
+
+      if (contractClassId.value === entry.classId.toString() && entry.selector.equals(functionSelector)) {
+        if (entry.calldataLength !== undefined && publicCall.calldata.length !== entry.calldataLength) {
+          return TX_ERROR_SETUP_WRONG_CALLDATA_LENGTH;
+        }
+        if (entry.onlySelf && !publicCall.request.msgSender.equals(contractAddress)) {
+          return TX_ERROR_SETUP_ONLY_SELF_WRONG_SENDER;
+        }
+        if (
+          entry.rejectNullMsgSender &&
+          publicCall.request.msgSender.equals(AztecAddress.fromBigInt(NULL_MSG_SENDER_CONTRACT_ADDRESS))
+        ) {
+          return TX_ERROR_SETUP_NULL_MSG_SENDER;
+        }
+        return undefined;
+      }
+    }
+
+    return TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED;
+  }
+}
+
+/** Structural interface for the allowed-setup-calls flag check. */
+export interface HasAllowedSetupCallsData {
+  txHash: { toString(): string };
+  allowedSetupCalls: boolean;
+}
+
+/**
+ * Validates that a transaction's setup-phase calls were allowed at receipt time.
+ *
+ * Checks the precomputed `allowedSetupCalls` flag on TxMetaData. The flag is
+ * computed by running the PhasesTxValidator on the full Tx when it first enters
+ * the pool. This lightweight validator is used during pending pool migration to
+ * reject txs whose setup calls are not on the allow list.
+ */
+export class AllowedSetupCallsMetaValidator<T extends HasAllowedSetupCallsData> implements TxValidator<T> {
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('sequencer:tx_validator:tx_phases_meta', bindings);
+  }
+
+  validateTx(tx: T): Promise<TxValidationResult> {
+    if (!tx.allowedSetupCalls) {
+      this.#log.verbose(`Rejecting tx ${tx.txHash} because its setup calls are not on the allow list`);
+      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED] });
+    }
+    return Promise.resolve({ result: 'valid' });
+  }
+}

package/src/msg_validators/tx_validator/size_validator.ts

@@ -0,0 +1,22 @@
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { MAX_TX_SIZE_KB } from '@aztec/stdlib/p2p';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+
+export class SizeTxValidator implements TxValidator<Tx> {
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_size', bindings);
+  }
+
+  validateTx(tx: Tx): Promise<TxValidationResult> {
+    const txSize = tx.getSize();
+    if (txSize > MAX_TX_SIZE_KB * 1024) {
+      this.#log.verbose(
+        `Rejecting transaction ${tx.getTxHash().toString()}. Reason: size above size limit. ${txSize}bytes > ${MAX_TX_SIZE_KB}Kb`,
+      );
+      return Promise.resolve({ result: 'invalid', reason: ['Transaction size above size limit'] });
+    }
+    return Promise.resolve({ result: 'valid' });
+  }
+}

package/src/msg_validators/tx_validator/test_utils.ts

@@ -0,0 +1,43 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { HashedValues, type Tx } from '@aztec/stdlib/tx';
+
+export function patchNonRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
+}
+
+export function patchRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  return patchFn('revertibleAccumulatedData', tx, index, overrides);
+}
+
+async function patchFn(
+  where: 'revertibleAccumulatedData' | 'nonRevertibleAccumulatedData',
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  const calldataIndex =
+    where === 'nonRevertibleAccumulatedData'
+      ? index
+      : index + tx.data.forPublic!.nonRevertibleAccumulatedData.publicCallRequests.length;
+  const calldata = [overrides.selector.toField(), ...(overrides.args ?? [])];
+  const hashedCalldata = await HashedValues.fromCalldata(calldata);
+  tx.publicFunctionCalldata[calldataIndex] = hashedCalldata;
+
+  const request = tx.data.forPublic![where].publicCallRequests[index];
+  request.contractAddress = overrides.address ?? request.contractAddress;
+  request.msgSender = overrides.msgSender ?? request.msgSender;
+  request.calldataHash = hashedCalldata.hash;
+  tx.data.forPublic![where].publicCallRequests[index] = request;
+
+  return request.contractAddress;
+}