@aztec/sequencer-client 0.33.0 → 0.35.0

package/src/publisher/l1-publisher.ts

@@ -122,7 +122,7 @@ export class L1Publisher implements L2BlockReceiver {
     // TODO(#4148) Remove this block number check, it's here because we don't currently have proper genesis state on the contract
     const lastArchive = block.header.lastArchive.root.toBuffer();
     if (block.number != 1 && !(await this.checkLastArchiveHash(lastArchive))) {
-      this.log(`Detected different last archive prior to publishing a block, aborting publish...`);
+      this.log.info(`Detected different last archive prior to publishing a block, aborting publish...`);
       return false;
     }
 
@@ -131,7 +131,7 @@ export class L1Publisher implements L2BlockReceiver {
     // Publish block transaction effects
     while (!this.interrupted) {
       if (await this.txSender.checkIfTxsAreAvailable(block)) {
-        this.log(`Transaction effects of a block ${block.number} already published.`);
+        this.log.verbose(`Transaction effects of a block ${block.number} already published.`);
         break;
       }
 
@@ -151,14 +151,14 @@ export class L1Publisher implements L2BlockReceiver {
           // txsEffectsHash from IAvailabilityOracle.TxsPublished event
           txsEffectsHash = receipt.logs[0].data;
         } else {
-          this.log(`Expected 1 log, got ${receipt.logs.length}`);
+          this.log.warn(`Expected 1 log, got ${receipt.logs.length}`);
         }
 
         this.log.info(`Block txs effects published, txsEffectsHash: ${txsEffectsHash}`);
         break;
       }
 
-      this.log(`AvailabilityOracle.publish tx status failed: ${receipt.transactionHash}`);
+      this.log.error(`AvailabilityOracle.publish tx status failed: ${receipt.transactionHash}`);
       await this.sleepOrInterrupted();
     }
 
@@ -196,15 +196,15 @@ export class L1Publisher implements L2BlockReceiver {
 
       // Check if someone else incremented the block number
       if (!(await this.checkLastArchiveHash(lastArchive))) {
-        this.log('Publish failed. Detected different last archive hash.');
+        this.log.warn('Publish failed. Detected different last archive hash.');
         break;
       }
 
-      this.log(`Rollup.process tx status failed: ${receipt.transactionHash}`);
+      this.log.error(`Rollup.process tx status failed: ${receipt.transactionHash}`);
       await this.sleepOrInterrupted();
     }
 
-    this.log('L2 block data syncing interrupted while processing blocks.');
+    this.log.verbose('L2 block data syncing interrupted while processing blocks.');
     return false;
   }
 
@@ -233,8 +233,8 @@ export class L1Publisher implements L2BlockReceiver {
     const fromChain = await this.txSender.getCurrentArchive();
     const areSame = lastArchive.equals(fromChain);
     if (!areSame) {
-      this.log(`CONTRACT ARCHIVE: ${fromChain.toString('hex')}`);
-      this.log(`NEW BLOCK LAST ARCHIVE: ${lastArchive.toString('hex')}`);
+      this.log.debug(`Contract archive: ${fromChain.toString('hex')}`);
+      this.log.debug(`New block last archive: ${lastArchive.toString('hex')}`);
     }
     return areSame;
   }

package/src/publisher/viem-tx-sender.ts

@@ -114,7 +114,7 @@ export class ViemTxSender implements L1PublisherTxSender {
       };
     }
 
-    this.log(`Receipt not found for tx hash ${txHash}`);
+    this.log.debug(`Receipt not found for tx hash ${txHash}`);
     return undefined;
   }
 

package/src/sequencer/sequencer.ts

@@ -1,5 +1,12 @@
-import { type L1ToL2MessageSource, type L2Block, type L2BlockSource, type ProcessedTx, Tx } from '@aztec/circuit-types';
-import { type BlockProver, PROVING_STATUS } from '@aztec/circuit-types/interfaces';
+import {
+  type L1ToL2MessageSource,
+  type L2Block,
+  type L2BlockSource,
+  type ProcessedTx,
+  Tx,
+  type TxValidator,
+} from '@aztec/circuit-types';
+import { type AllowedFunction, type BlockProver, PROVING_STATUS } from '@aztec/circuit-types/interfaces';
 import { type L2BlockBuiltStats } from '@aztec/circuit-types/stats';
 import { AztecAddress, EthAddress } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
@@ -7,14 +14,13 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { Timer, elapsed } from '@aztec/foundation/timer';
 import { type P2P } from '@aztec/p2p';
+import { type PublicProcessorFactory } from '@aztec/simulator';
 import { type WorldStateStatus, type WorldStateSynchronizer } from '@aztec/world-state';
 
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
 import { type L1Publisher } from '../publisher/l1-publisher.js';
+import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
 import { type SequencerConfig } from './config.js';
-import { type PublicProcessorFactory } from './public_processor.js';
-import { type TxValidator } from './tx_validator.js';
-import { type TxValidatorFactory } from './tx_validator_factory.js';
 
 /**
  * Sequencer client
@@ -35,8 +41,8 @@ export class Sequencer {
   private _feeRecipient = AztecAddress.ZERO;
   private lastPublishedBlock = 0;
   private state = SequencerState.STOPPED;
-  private allowedFeePaymentContractClasses: Fr[] = [];
-  private allowedFeePaymentContractInstances: AztecAddress[] = [];
+  private allowedFunctionsInSetup: AllowedFunction[] = [];
+  private allowedFunctionsInTeardown: AllowedFunction[] = [];
 
   constructor(
     private publisher: L1Publisher,
@@ -52,7 +58,7 @@ export class Sequencer {
     private log = createDebugLogger('aztec:sequencer'),
   ) {
     this.updateConfig(config);
-    this.log(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
+    this.log.verbose(`Initialized sequencer with ${this.minTxsPerBLock}-${this.maxTxsPerBlock} txs per block.`);
   }
 
   /**
@@ -75,11 +81,11 @@ export class Sequencer {
     if (config.feeRecipient) {
       this._feeRecipient = config.feeRecipient;
     }
-    if (config.allowedFeePaymentContractClasses) {
-      this.allowedFeePaymentContractClasses = config.allowedFeePaymentContractClasses;
+    if (config.allowedFunctionsInSetup) {
+      this.allowedFunctionsInSetup = config.allowedFunctionsInSetup;
     }
-    if (config.allowedFeePaymentContractInstances) {
-      this.allowedFeePaymentContractInstances = config.allowedFeePaymentContractInstances;
+    if (config.allowedFunctionsInTeardown) {
+      this.allowedFunctionsInTeardown = config.allowedFunctionsInTeardown;
     }
   }
 
@@ -92,25 +98,25 @@ export class Sequencer {
     this.runningPromise = new RunningPromise(this.work.bind(this), this.pollingIntervalMs);
     this.runningPromise.start();
     this.state = SequencerState.IDLE;
-    this.log('Sequencer started');
+    this.log.info('Sequencer started');
   }
 
   /**
    * Stops the sequencer from processing txs and moves to STOPPED state.
    */
   public async stop(): Promise<void> {
-    this.log(`Stopping sequencer`);
+    this.log.debug(`Stopping sequencer`);
     await this.runningPromise?.stop();
     this.publisher.interrupt();
     this.state = SequencerState.STOPPED;
-    this.log('Stopped sequencer');
+    this.log.info('Stopped sequencer');
   }
 
   /**
    * Starts a previously stopped sequencer.
    */
   public restart() {
-    this.log('Restarting sequencer');
+    this.log.info('Restarting sequencer');
     this.publisher.restart();
     this.runningPromise!.start();
     this.state = SequencerState.IDLE;
@@ -137,7 +143,7 @@ export class Sequencer {
       // Update state when the previous block has been synced
       const prevBlockSynced = await this.isBlockSynced();
       if (prevBlockSynced && this.state === SequencerState.PUBLISHING_BLOCK) {
-        this.log(`Block has been synced`);
+        this.log.debug(`Block has been synced`);
         this.state = SequencerState.IDLE;
       }
 
@@ -178,14 +184,15 @@ export class Sequencer {
         this._feeRecipient,
       );
 
-      const txValidator = this.txValidatorFactory.buildTxValidator(
-        newGlobalVariables,
-        this.allowedFeePaymentContractClasses,
-        this.allowedFeePaymentContractInstances,
-      );
-
       // TODO: It should be responsibility of the P2P layer to validate txs before passing them on here
-      const validTxs = await this.takeValidTxs(pendingTxs, txValidator);
+      const validTxs = await this.takeValidTxs(
+        pendingTxs,
+        this.txValidatorFactory.validatorForNewTxs(
+          newGlobalVariables,
+          this.allowedFunctionsInSetup,
+          this.allowedFunctionsInTeardown,
+        ),
+      );
       if (validTxs.length < this.minTxsPerBLock) {
         return;
       }
@@ -194,9 +201,9 @@ export class Sequencer {
       this.state = SequencerState.CREATING_BLOCK;
 
       // Get l1 to l2 messages from the contract
-      this.log('Requesting L1 to L2 messages from contract');
+      this.log.debug('Requesting L1 to L2 messages from contract');
       const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(newBlockNumber));
-      this.log(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
+      this.log.verbose(`Retrieved ${l1ToL2Messages.length} L1 to L2 messages for block ${newBlockNumber}`);
 
       // We create a fresh processor each time to reset any cached state (eg storage writes)
       const processor = await this.publicProcessorFactory.create(historicalHeader, newGlobalVariables);
@@ -213,16 +220,16 @@ export class Sequencer {
       const blockTicket = await this.prover.startNewBlock(blockSize, newGlobalVariables, l1ToL2Messages, emptyTx);
 
       const [publicProcessorDuration, [processedTxs, failedTxs]] = await elapsed(() =>
-        processor.process(validTxs, blockSize, this.prover, txValidator),
+        processor.process(validTxs, blockSize, this.prover, this.txValidatorFactory.validatorForProcessedTxs()),
       );
       if (failedTxs.length > 0) {
         const failedTxData = failedTxs.map(fail => fail.tx);
-        this.log(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
+        this.log.debug(`Dropping failed txs ${Tx.getHashes(failedTxData).join(', ')}`);
         await this.p2pClient.deleteTxs(Tx.getHashes(failedTxData));
       }
 
       if (processedTxs.length === 0) {
-        this.log('No txs processed correctly to build block. Exiting');
+        this.log.verbose('No txs processed correctly to build block. Exiting');
         this.prover.cancelBlock();
         return;
       }
@@ -248,7 +255,7 @@ export class Sequencer {
 
       await assertBlockHeight();
 
-      this.log(`Assembled block ${block.number}`, {
+      this.log.verbose(`Assembled block ${block.number}`, {
         eventName: 'l2-block-built',
         duration: workTimer.ms(),
         publicProcessDuration: publicProcessorDuration,
@@ -275,17 +282,16 @@ export class Sequencer {
     this.state = SequencerState.PUBLISHING_BLOCK;
     const publishedL2Block = await this.publisher.processL2Block(block);
     if (publishedL2Block) {
-      this.log(`Successfully published block ${block.number}`);
       this.lastPublishedBlock = block.number;
     } else {
       throw new Error(`Failed to publish block`);
     }
   }
 
-  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], validator: TxValidator): Promise<T[]> {
+  protected async takeValidTxs<T extends Tx | ProcessedTx>(txs: T[], validator: TxValidator<T>): Promise<T[]> {
     const [valid, invalid] = await validator.validateTxs(txs);
     if (invalid.length > 0) {
-      this.log(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
+      this.log.debug(`Dropping invalid txs from the p2p pool ${Tx.getHashes(invalid).join(', ')}`);
       await this.p2pClient.deleteTxs(Tx.getHashes(invalid));
     }
 

package/src/tx_validator/aggregate_tx_validator.ts

@@ -0,0 +1,24 @@
+import { type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
+
+export class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValidator<T> {
+  #validators: TxValidator<T>[];
+  constructor(...validators: TxValidator<T>[]) {
+    if (validators.length === 0) {
+      throw new Error('At least one validator must be provided');
+    }
+
+    this.#validators = validators;
+  }
+
+  async validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const invalidTxs: T[] = [];
+    let txPool = txs;
+    for (const validator of this.#validators) {
+      const [valid, invalid] = await validator.validateTxs(txPool);
+      invalidTxs.push(...invalid);
+      txPool = valid;
+    }
+
+    return [txPool, invalidTxs];
+  }
+}

package/src/tx_validator/double_spend_validator.ts

@@ -0,0 +1,65 @@
+import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
+import { Fr } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export interface NullifierSource {
+  getNullifierIndex: (nullifier: Fr) => Promise<bigint | undefined>;
+}
+
+export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_double_spend');
+  #nullifierSource: NullifierSource;
+
+  constructor(nullifierSource: NullifierSource) {
+    this.#nullifierSource = nullifierSource;
+  }
+
+  async validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const validTxs: T[] = [];
+    const invalidTxs: T[] = [];
+    const thisBlockNullifiers = new Set<bigint>();
+
+    for (const tx of txs) {
+      if (!(await this.#uniqueNullifiers(tx, thisBlockNullifiers))) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return [validTxs, invalidTxs];
+  }
+
+  async #uniqueNullifiers(tx: AnyTx, thisBlockNullifiers: Set<bigint>): Promise<boolean> {
+    const newNullifiers = tx.data.getNonEmptyNullifiers().map(x => x.toBigInt());
+
+    // Ditch this tx if it has repeated nullifiers
+    const uniqueNullifiers = new Set(newNullifiers);
+    if (uniqueNullifiers.size !== newNullifiers.length) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for emitting duplicate nullifiers`);
+      return false;
+    }
+
+    for (const nullifier of newNullifiers) {
+      if (thisBlockNullifiers.has(nullifier)) {
+        this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier in the same block`);
+        return false;
+      }
+
+      thisBlockNullifiers.add(nullifier);
+    }
+
+    const nullifierIndexes = await Promise.all(
+      newNullifiers.map(n => this.#nullifierSource.getNullifierIndex(new Fr(n))),
+    );
+
+    const hasDuplicates = nullifierIndexes.some(index => index !== undefined);
+    if (hasDuplicates) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating nullifiers present in state trees`);
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/tx_validator/gas_validator.ts

@@ -0,0 +1,81 @@
+import { Tx, type TxValidator } from '@aztec/circuit-types';
+import { type AztecAddress, Fr } from '@aztec/circuits.js';
+import { pedersenHash } from '@aztec/foundation/crypto';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { GasTokenContract } from '@aztec/noir-contracts.js';
+import { AbstractPhaseManager, PublicKernelPhase } from '@aztec/simulator';
+
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+  storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}
+
+export class GasTxValidator implements TxValidator<Tx> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_gas');
+  #publicDataSource: PublicStateSource;
+  #gasTokenAddress: AztecAddress;
+  #requireFees: boolean;
+
+  constructor(publicDataSource: PublicStateSource, gasTokenAddress: AztecAddress, requireFees = false) {
+    this.#publicDataSource = publicDataSource;
+    this.#gasTokenAddress = gasTokenAddress;
+    this.#requireFees = requireFees;
+  }
+
+  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+    const validTxs: Tx[] = [];
+    const invalidTxs: Tx[] = [];
+
+    for (const tx of txs) {
+      if (await this.#validateTxFee(tx)) {
+        validTxs.push(tx);
+      } else {
+        invalidTxs.push(tx);
+      }
+    }
+
+    return [validTxs, invalidTxs];
+  }
+
+  async #validateTxFee(tx: Tx): Promise<boolean> {
+    const { [PublicKernelPhase.TEARDOWN]: teardownFns } = AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(
+      tx.data,
+      tx.enqueuedPublicFunctionCalls,
+    );
+
+    if (teardownFns.length === 0) {
+      if (this.#requireFees) {
+        this.#log.warn(
+          `Rejecting tx ${Tx.getHash(tx)} because it should pay for gas but has no enqueued teardown functions`,
+        );
+        return false;
+      } else {
+        this.#log.debug(`Tx ${Tx.getHash(tx)} does not pay fees. Skipping balance check.`);
+        return true;
+      }
+    }
+
+    if (teardownFns.length > 1) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because it has multiple teardown functions`);
+      return false;
+    }
+
+    // check that the caller of the teardown function has enough balance to pay for tx costs
+    const teardownFn = teardownFns[0];
+    const slot = pedersenHash([GasTokenContract.storage.balances.slot, teardownFn.callContext.msgSender]);
+    const gasBalance = await this.#publicDataSource.storageRead(this.#gasTokenAddress, slot);
+
+    // TODO(#5004) calculate fee needed based on tx limits and gas prices
+    const gasAmountNeeded = new Fr(1);
+    if (gasBalance.lt(gasAmountNeeded)) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because it should pay for gas but has insufficient balance ${gasBalance.toShortString()} < ${gasAmountNeeded.toShortString()}`,
+      );
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/tx_validator/metadata_validator.ts

@@ -0,0 +1,60 @@
+import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type GlobalVariables } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_metadata');
+  #globalVariables: GlobalVariables;
+
+  constructor(globalVariables: GlobalVariables) {
+    this.#globalVariables = globalVariables;
+  }
+
+  validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[]]> {
+    const validTxs: T[] = [];
+    const invalidTxs: T[] = [];
+    for (const tx of txs) {
+      if (!this.#hasCorrectChainId(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      if (!this.#isValidForBlockNumber(tx)) {
+        invalidTxs.push(tx);
+        continue;
+      }
+
+      validTxs.push(tx);
+    }
+
+    return Promise.resolve([validTxs, invalidTxs]);
+  }
+
+  #hasCorrectChainId(tx: T): boolean {
+    if (!tx.data.constants.txContext.chainId.equals(this.#globalVariables.chainId)) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(
+          tx,
+        )} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.#globalVariables.chainId.toNumber()}`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  #isValidForBlockNumber(tx: T): boolean {
+    const target =
+      tx instanceof Tx
+        ? tx.data.forRollup?.rollupValidationRequests || tx.data.forPublic!.validationRequests.forRollup
+        : tx.data.rollupValidationRequests;
+    const maxBlockNumber = target.maxBlockNumber;
+
+    if (maxBlockNumber.isSome && maxBlockNumber.value < this.#globalVariables.blockNumber) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for low max block number`);
+      return false;
+    } else {
+      return true;
+    }
+  }
+}

package/src/tx_validator/phases_validator.ts

@@ -0,0 +1,101 @@
+import { type AllowedFunction, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type PublicCallRequest } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AbstractPhaseManager, PublicKernelPhase } from '@aztec/simulator';
+import { type ContractDataSource } from '@aztec/types/contracts';
+
+export class PhasesTxValidator implements TxValidator<Tx> {
+  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_phases');
+
+  constructor(
+    private contractDataSource: ContractDataSource,
+    private setupAllowList: AllowedFunction[],
+    private teardownAllowList: AllowedFunction[],
+  ) {}
+
+  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
+    const validTxs: Tx[] = [];
+    const invalidTxs: Tx[] = [];
+
+    for (const tx of txs) {
+      if (await this.#validateTx(tx)) {
+        validTxs.push(tx);
+      } else {
+        invalidTxs.push(tx);
+      }
+    }
+
+    return Promise.resolve([validTxs, invalidTxs]);
+  }
+
+  async #validateTx(tx: Tx): Promise<boolean> {
+    if (!tx.data.forPublic) {
+      this.#log.debug(`Tx ${Tx.getHash(tx)} does not contain enqueued public functions. Skipping phases validation.`);
+      return true;
+    }
+
+    const { [PublicKernelPhase.SETUP]: setupFns, [PublicKernelPhase.TEARDOWN]: teardownFns } =
+      AbstractPhaseManager.extractEnqueuedPublicCallsByPhase(tx.data, tx.enqueuedPublicFunctionCalls);
+
+    for (const setupFn of setupFns) {
+      if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
+        this.#log.warn(
+          `Rejecting tx ${Tx.getHash(tx)} because it calls setup function not on allow list: ${
+            setupFn.contractAddress
+          }:${setupFn.functionData.selector}`,
+        );
+
+        return false;
+      }
+    }
+
+    for (const teardownFn of teardownFns) {
+      if (!(await this.isOnAllowList(teardownFn, this.teardownAllowList))) {
+        this.#log.warn(
+          `Rejecting tx ${Tx.getHash(tx)} because it calls teardown function not on allowlist: ${
+            teardownFn.contractAddress
+          }:${teardownFn.functionData.selector}`,
+        );
+
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  async isOnAllowList(publicCall: PublicCallRequest, allowList: AllowedFunction[]): Promise<boolean> {
+    const {
+      contractAddress,
+      functionData: { selector },
+    } = publicCall;
+
+    // do these checks first since they don't require the contract class
+    for (const entry of allowList) {
+      if (!('address' in entry)) {
+        continue;
+      }
+
+      if (contractAddress.equals(entry.address) && entry.selector.equals(selector)) {
+        return true;
+      }
+    }
+
+    const contractClass = await this.contractDataSource.getContract(contractAddress);
+    if (!contractClass) {
+      throw new Error(`Contract not found: ${publicCall.contractAddress.toString()}`);
+    }
+
+    for (const entry of allowList) {
+      if (!('classId' in entry)) {
+        continue;
+      }
+
+      if (contractClass.contractClassId.equals(entry.classId) && entry.selector.equals(selector)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

package/src/tx_validator/tx_validator_factory.ts

@@ -0,0 +1,37 @@
+import { type AllowedFunction, type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
+import { type EthAddress, type GlobalVariables } from '@aztec/circuits.js';
+import { getCanonicalGasTokenAddress } from '@aztec/protocol-contracts/gas-token';
+import { WorldStateDB, WorldStatePublicDB } from '@aztec/simulator';
+import { type ContractDataSource } from '@aztec/types/contracts';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { AggregateTxValidator } from './aggregate_tx_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';
+
+export class TxValidatorFactory {
+  constructor(
+    private merkleTreeDb: MerkleTreeOperations,
+    private contractDataSource: ContractDataSource,
+    private gasPortalAddress: EthAddress,
+  ) {}
+
+  validatorForNewTxs(
+    globalVariables: GlobalVariables,
+    setupAllowList: AllowedFunction[],
+    teardownAllowList: AllowedFunction[],
+  ): TxValidator<Tx> {
+    return new AggregateTxValidator(
+      new MetadataTxValidator(globalVariables),
+      new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb)),
+      new PhasesTxValidator(this.contractDataSource, setupAllowList, teardownAllowList),
+      new GasTxValidator(new WorldStatePublicDB(this.merkleTreeDb), getCanonicalGasTokenAddress(this.gasPortalAddress)),
+    );
+  }
+
+  validatorForProcessedTxs(): TxValidator<ProcessedTx> {
+    return new DoubleSpendTxValidator(new WorldStateDB(this.merkleTreeDb));
+  }
+}