@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/msg_validators/tx_validator/allowed_public_setup.ts

@@ -0,0 +1,35 @@
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+
+let defaultAllowedSetupFunctions: AllowedElement[] | undefined = undefined;
+export async function getDefaultAllowedSetupFunctions(): Promise<AllowedElement[]> {
+  if (defaultAllowedSetupFunctions === undefined) {
+    defaultAllowedSetupFunctions = [
+      // needed for authwit support
+      {
+        address: ProtocolContractAddress.AuthRegistry,
+      },
+      // needed for claiming on the same tx as a spend
+      {
+        address: ProtocolContractAddress.FeeJuice,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),u128)'),
+      },
+      // needed for private transfers via FPC
+      {
+        classId: (await getContractClassFromArtifact(TokenContractArtifact)).id,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('_increase_public_balance((Field),u128)'),
+      },
+      {
+        classId: (await getContractClassFromArtifact(FPCContract.artifact)).id,
+        // We can't restrict the selector because public functions get routed via dispatch.
+        // selector: FunctionSelector.fromSignature('prepare_fee((Field),Field,(Field),Field)'),
+      },
+    ];
+  }
+  return defaultAllowedSetupFunctions;
+}

package/src/msg_validators/tx_validator/archive_cache.ts

@@ -0,0 +1,28 @@
+import type { ArchiveSource } from '@aztec/p2p';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export class ArchiveCache implements ArchiveSource {
+  archives: Map<string, bigint>;
+
+  constructor(private db: MerkleTreeReadOperations) {
+    this.archives = new Map<string, bigint>();
+  }
+
+  public async getArchiveIndices(archives: BlockHash[]): Promise<(bigint | undefined)[]> {
+    const toCheckDb = archives.filter(n => !this.archives.has(n.toString())).map(n => n.toFr());
+    const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
+    dbHits.forEach((x, index) => {
+      if (x !== undefined) {
+        this.archives.set(toCheckDb[index].toString(), x);
+      }
+    });
+
+    return archives.map(n => this.archives.get(n.toString()));
+  }
+}

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,24 +1,25 @@
-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 Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import type { BlockHash } from '@aztec/stdlib/block';
+import { type AnyTx, TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export interface ArchiveSource {
-  getArchiveIndices: (archives: Fr[]) => Promise<(bigint | undefined)[]>;
+  getArchiveIndices: (archives: BlockHash[]) => Promise<(bigint | undefined)[]>;
 }
 
 export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_block_header');
+  #log: Logger;
   #archiveSource: ArchiveSource;
 
-  constructor(archiveSource: ArchiveSource) {
+  constructor(archiveSource: ArchiveSource, bindings?: LoggerBindings) {
     this.#archiveSource = archiveSource;
+    this.#log = createLogger('p2p:tx_validator:tx_block_header', bindings);
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.historicalHeader.hash()]);
+    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.anchorBlockHeader.hash()]);
     if (index === undefined) {
-      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
-      return { result: 'invalid', reason: ['Block header not found'] };
+      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for referencing an unknown block header`);
+      return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };
     }
     return { result: 'valid' };
   }

package/src/msg_validators/tx_validator/data_validator.ts

@@ -1,106 +1,130 @@
-import { MAX_FR_ARGS_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
-import { createLogger } from '@aztec/foundation/log';
-import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS } from '@aztec/constants';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+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');
+  #log: Logger;
+
+  constructor(bindings?: LoggerBindings) {
+    this.#log = createLogger('p2p:tx_validator:tx_data', bindings);
+  }
 
   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,38 +1,41 @@
-import { createLogger } from '@aztec/foundation/log';
-import { type AnyTx, Tx, type TxValidationResult, type TxValidator, hasPublicCalls } from '@aztec/stdlib/tx';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+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[]>;
 }
 
 export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:tx_double_spend');
+  #log: Logger;
   #nullifierSource: NullifierSource;
 
-  constructor(nullifierSource: NullifierSource) {
+  constructor(nullifierSource: NullifierSource, bindings?: LoggerBindings) {
     this.#nullifierSource = nullifierSource;
+    this.#log = createLogger('p2p:tx_validator:tx_double_spend', bindings);
   }
 
   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,151 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec/foundation/log';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractAddress, protocolContractsHash } 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, TxValidator } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+import { AggregateTxValidator } from './aggregate_tx_validator.js';
+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 { SizeTxValidator } from './size_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: BlockNumber,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  gasFees: GasFees,
+  l1ChainId: number,
+  rollupVersion: number,
+  protocolContractsHash: Fr,
+  contractDataSource: ContractDataSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  txsPermitted: boolean,
+  allowedInSetup: AllowedElement[] = [],
+  bindings?: LoggerBindings,
+): Record<string, MessageValidator>[] {
+  const merkleTree = worldStateSynchronizer.getCommitted();
+
+  return [
+    {
+      txsPermittedValidator: {
+        validator: new TxPermittedValidator(txsPermitted, bindings),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      dataValidator: {
+        validator: new DataTxValidator(bindings),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      metadataValidator: {
+        validator: new MetadataTxValidator(
+          {
+            l1ChainId: new Fr(l1ChainId),
+            rollupVersion: new Fr(rollupVersion),
+            protocolContractsHash,
+            vkTreeRoot: getVKTreeRoot(),
+          },
+          bindings,
+        ),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      timestampValidator: {
+        validator: new TimestampTxValidator<Tx>(
+          {
+            timestamp,
+            blockNumber,
+          },
+          bindings,
+        ),
+        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);
+            },
+          },
+          bindings,
+        ),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      gasValidator: {
+        validator: new GasTxValidator(
+          new DatabasePublicStateSource(merkleTree),
+          ProtocolContractAddress.FeeJuice,
+          gasFees,
+          bindings,
+        ),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      phasesValidator: {
+        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, timestamp, bindings),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      blockHeaderValidator: {
+        validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree), bindings),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+    },
+    {
+      proofValidator: {
+        validator: new TxProofValidator(proofVerifier, bindings),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+    },
+  ];
+}
+
+export function createTxReqRespValidator(
+  verifier: ClientProtocolCircuitVerifier,
+  {
+    l1ChainId,
+    rollupVersion,
+  }: {
+    l1ChainId: number;
+    rollupVersion: number;
+  },
+  bindings?: LoggerBindings,
+): TxValidator {
+  return new AggregateTxValidator(
+    new MetadataTxValidator(
+      {
+        l1ChainId: new Fr(l1ChainId),
+        rollupVersion: new Fr(rollupVersion),
+        protocolContractsHash,
+        vkTreeRoot: getVKTreeRoot(),
+      },
+      bindings,
+    ),
+    new SizeTxValidator(bindings),
+    new DataTxValidator(bindings),
+    new TxProofValidator(verifier, bindings),
+  );
+}

package/src/msg_validators/tx_validator/fee_payer_balance.ts

@@ -0,0 +1,40 @@
+import { getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
+
+export type FeePayerBalanceDelta = {
+  feeLimit: bigint;
+  claimAmount: bigint;
+};
+
+const increasePublicBalanceSelectorPromise = FunctionSelector.fromSignature('_increase_public_balance((Field),u128)');
+
+export function getTxFeeLimit(tx: Tx): bigint {
+  return tx.data.constants.txContext.gasSettings.getFeeLimit().toBigInt();
+}
+
+export async function getFeePayerClaimAmount(tx: Tx, feeJuiceAddress: AztecAddress): Promise<bigint> {
+  const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+  const increasePublicBalanceSelector = await increasePublicBalanceSelectorPromise;
+  const feePayer = tx.data.feePayer;
+
+  const claimFunctionCall = setupFns.find(
+    fn =>
+      fn.request.contractAddress.equals(feeJuiceAddress) &&
+      fn.request.msgSender.equals(feeJuiceAddress) &&
+      fn.calldata.length > 2 &&
+      fn.functionSelector.equals(increasePublicBalanceSelector) &&
+      fn.args[0].equals(feePayer.toField()) &&
+      !fn.request.isStaticCall,
+  );
+
+  return claimFunctionCall ? claimFunctionCall.args[1].toBigInt() : 0n;
+}
+
+export async function getFeePayerBalanceDelta(tx: Tx, feeJuiceAddress: AztecAddress): Promise<FeePayerBalanceDelta> {
+  return {
+    feeLimit: getTxFeeLimit(tx),
+    claimAmount: await getFeePayerClaimAmount(tx, feeJuiceAddress),
+  };
+}