@aztec/p2p 0.0.0-test.0

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -0,0 +1,76 @@
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
+ */
+export interface TxPool {
+  /**
+   * Adds a list of transactions to the pool. Duplicates are ignored.
+   * @param txs - An array of txs to be added to the pool.
+   */
+  addTxs(txs: Tx[]): Promise<void>;
+
+  /**
+   * Checks if a transaction exists in the pool and returns it.
+   * @param txHash - The hash of the transaction, used as an ID.
+   * @returns The transaction, if found, 'undefined' otherwise.
+   */
+  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+
+  /**
+   * Checks if an archived transaction exists in the pool and returns it.
+   * @param txHash - The hash of the transaction, used as an ID.
+   * @returns The transaction, if found, 'undefined' otherwise.
+   */
+  getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+
+  /**
+   * Marks the set of txs as mined, as opposed to pending.
+   * @param txHashes - Hashes of the txs to flag as mined.
+   */
+  markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
+
+  /**
+   * Moves mined txs back to the pending set in the case of a reorg.
+   * Note: txs not known by this peer will be ignored.
+   * @param txHashes - Hashes of the txs to flag as pending.
+   */
+  markMinedAsPending(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
+   * @param txHashes - An array of tx hashes to be removed from the tx pool.
+   */
+  deleteTxs(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Gets all transactions currently in the tx pool.
+   * @returns An array of transaction objects found in the tx pool.
+   */
+  getAllTxs(): Promise<Tx[]>;
+
+  /**
+   * Gets the hashes of all transactions currently in the tx pool.
+   * @returns An array of transaction hashes found in the tx pool.
+   */
+  getAllTxHashes(): Promise<TxHash[]>;
+
+  /**
+   * Gets the hashes of pending transactions currently in the tx pool sorted by priority (see getPendingTxPriority).
+   * @returns An array of pending transaction hashes found in the tx pool.
+   */
+  getPendingTxHashes(): Promise<TxHash[]>;
+
+  /**
+   * Gets the hashes of mined transactions currently in the tx pool.
+   * @returns An array of mined transaction hashes found in the tx pool.
+   */
+  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
+
+  /**
+   * Returns whether the given tx hash is flagged as pending or mined.
+   * @param txHash - Hash of the tx to query.
+   * @returns Pending or mined depending on its status, or undefined if not found.
+   */
+  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
+}

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -0,0 +1,130 @@
+import { unfreeze } from '@aztec/foundation/types';
+import { GasFees } from '@aztec/stdlib/gas';
+import { mockTx } from '@aztec/stdlib/testing';
+import type { Tx } from '@aztec/stdlib/tx';
+
+import type { TxPool } from './tx_pool.js';
+
+/**
+ * Tests a TxPool implementation.
+ * @param getTxPool - Gets a fresh TxPool
+ */
+export function describeTxPool(getTxPool: () => TxPool) {
+  let pool: TxPool;
+
+  beforeEach(() => {
+    pool = getTxPool();
+  });
+
+  it('Adds txs to the pool as pending', async () => {
+    const tx1 = await mockTx();
+
+    await pool.addTxs([tx1]);
+    const poolTx = await pool.getTxByHash(await tx1.getTxHash());
+    expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
+    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]);
+  });
+
+  it('Removes txs from the pool', async () => {
+    const tx1 = await mockTx();
+
+    await pool.addTxs([tx1]);
+    await pool.deleteTxs([await tx1.getTxHash()]);
+
+    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
+    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+  });
+
+  it('Marks txs as mined', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+
+    await pool.addTxs([tx1, tx2]);
+    await pool.markAsMined([await tx1.getTxHash()], 1);
+
+    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
+    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([[await tx1.getTxHash(), 1]]);
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx2.getTxHash()]);
+  });
+
+  it('Marks txs as pending after being mined', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+
+    await pool.addTxs([tx1, tx2]);
+    await pool.markAsMined([await tx1.getTxHash()], 1);
+
+    await pool.markMinedAsPending([await tx1.getTxHash()]);
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+    const pending = await pool.getPendingTxHashes();
+    expect(pending).toHaveLength(2);
+    expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
+  });
+
+  it('Only marks txs as pending if they are known', async () => {
+    const tx1 = await mockTx(1);
+    // simulate a situation where not all peers have all the txs
+    const tx2 = await mockTx(2);
+    const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
+    await pool.addTxs([tx1]);
+    // this peer knows that tx2 was mined, but it does not have the tx object
+    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
+    expect(await pool.getMinedTxHashes()).toEqual(
+      expect.arrayContaining([
+        [await tx1.getTxHash(), 1],
+        [someTxHashThatThisPeerDidNotSee, 1],
+      ]),
+    );
+
+    // reorg: both txs should now become available again
+    await pool.markMinedAsPending([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]); // tx2 is not in the pool
+  });
+
+  it('Returns all transactions in the pool', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const poolTxs = await pool.getAllTxs();
+    expect(poolTxs).toHaveLength(3);
+    expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
+  });
+
+  it('Returns all txHashes in the pool', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const poolTxHashes = await pool.getAllTxHashes();
+    expect(poolTxHashes).toHaveLength(3);
+    expect(poolTxHashes).toEqual(
+      expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash(), await tx3.getTxHash()]),
+    );
+  });
+
+  it('Returns pending tx hashes sorted by priority', async () => {
+    const withPriorityFee = (tx: Tx, fee: number) => {
+      unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
+      return tx;
+    };
+
+    const tx1 = withPriorityFee(await mockTx(0), 1000);
+    const tx2 = withPriorityFee(await mockTx(1), 100);
+    const tx3 = withPriorityFee(await mockTx(2), 200);
+    const tx4 = withPriorityFee(await mockTx(3), 3000);
+
+    await pool.addTxs([tx1, tx2, tx3, tx4]);
+
+    const poolTxHashes = await pool.getPendingTxHashes();
+    expect(poolTxHashes).toHaveLength(4);
+    expect(poolTxHashes).toEqual(await Promise.all([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash())));
+  });
+}

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -0,0 +1,26 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+
+export class AttestationValidator implements P2PValidator<BlockAttestation> {
+  private epochCache: EpochCacheInterface;
+
+  constructor(epochCache: EpochCacheInterface) {
+    this.epochCache = epochCache;
+  }
+
+  async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+    const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
+
+    const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
+    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    const attester = await message.getSender();
+    if (!(await this.epochCache.isInCommittee(attester))) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    return undefined;
+  }
+}

package/src/msg_validators/attestation_validator/index.ts

@@ -0,0 +1 @@
+export * from './attestation_validator.js';

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -0,0 +1,29 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+
+export class BlockProposalValidator implements P2PValidator<BlockProposal> {
+  private epochCache: EpochCacheInterface;
+
+  constructor(epochCache: EpochCacheInterface) {
+    this.epochCache = epochCache;
+  }
+
+  async validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined> {
+    const { currentProposer, nextProposer, currentSlot, nextSlot } =
+      await this.epochCache.getProposerInCurrentOrNextSlot();
+
+    // Check that the attestation is for the current or next slot
+    const slotNumberBigInt = block.payload.header.globalVariables.slotNumber.toBigInt();
+    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    // Check that the block proposal is from the current or next proposer
+    const proposer = await block.getSender();
+    if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
+      return PeerErrorSeverity.HighToleranceError;
+    }
+
+    return undefined;
+  }
+}

package/src/msg_validators/block_proposal_validator/index.ts

@@ -0,0 +1 @@
+export * from './block_proposal_validator.js';

package/src/msg_validators/index.ts

@@ -0,0 +1,3 @@
+export * from './tx_validator/index.js';
+export * from './block_proposal_validator/index.js';
+export * from './attestation_validator/index.js';

package/src/msg_validators/tx_validator/aggregate_tx_validator.ts

@@ -0,0 +1,32 @@
+import type { ProcessedTx, Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
+
+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 validateTx(tx: T): Promise<TxValidationResult> {
+    const aggregate: { result: string; reason?: string[] } = { result: 'valid', reason: [] };
+    for (const validator of this.#validators) {
+      const result = await validator.validateTx(tx);
+      if (result.result === 'invalid') {
+        aggregate.result = 'invalid';
+        aggregate.reason!.push(...result.reason);
+      } else if (result.result === 'skipped') {
+        if (aggregate.result === 'valid') {
+          aggregate.result = 'skipped';
+        }
+        aggregate.reason!.push(...result.reason);
+      }
+    }
+    if (aggregate.result === 'valid') {
+      delete aggregate.reason;
+    }
+    return aggregate as TxValidationResult;
+  }
+}

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -0,0 +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';
+
+export interface ArchiveSource {
+  getArchiveIndices: (archives: Fr[]) => Promise<(bigint | undefined)[]>;
+}
+
+export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createLogger('p2p:tx_validator:tx_block_header');
+  #archiveSource: ArchiveSource;
+
+  constructor(archiveSource: ArchiveSource) {
+    this.#archiveSource = archiveSource;
+  }
+
+  async validateTx(tx: T): Promise<TxValidationResult> {
+    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.historicalHeader.hash()]);
+    if (index === undefined) {
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
+      return { result: 'invalid', reason: ['Block header not found'] };
+    }
+    return { result: 'valid' };
+  }
+}

package/src/msg_validators/tx_validator/data_validator.ts

@@ -0,0 +1,106 @@
+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';
+
+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);
+  }
+
+  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}.`,
+      );
+      return { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
+    }
+
+    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}`,
+      );
+      return { result: 'invalid', reason: ['Too many args in total to enqueued public calls'] };
+    }
+    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}.`,
+      );
+      return { result: 'invalid', reason: ['Incorrect execution request for public call'] };
+    }
+
+    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'] };
+    }
+
+    return { result: 'valid' };
+  }
+
+  async #hasCorrectContractClassLogs(tx: Tx): Promise<TxValidationResult> {
+    const contractClassLogsHashes = tx.data.getNonEmptyContractClassLogsHashes();
+    const hashedContractClasslogs = await Promise.all(tx.contractClassLogs.map(l => l.hash()));
+    if (contractClassLogsHashes.length !== hashedContractClasslogs.length) {
+      this.#log.warn(
+        `Rejecting tx ${Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
+          contractClassLogsHashes.length
+        }. Got ${hashedContractClasslogs.length}.`,
+      );
+      return { result: 'invalid', reason: ['Mismatched number of contract class logs'] };
+    }
+    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.`,
+          );
+          return { result: 'invalid', reason: ['Incorrectly sorted contract class logs'] };
+        } else {
+          this.#log.warn(
+            `Rejecting tx ${Tx.getHash(tx)} because of mismatched contract class logs. Expected hash ${
+              logHash.value
+            } from the kernels. Got ${hashedLog} in the tx.`,
+          );
+          return { result: 'invalid', reason: ['Mismatched 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 ${
+            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 { result: 'valid' };
+  }
+}

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -0,0 +1,38 @@
+import { createLogger } from '@aztec/foundation/log';
+import { type AnyTx, Tx, type TxValidationResult, type TxValidator, hasPublicCalls } 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');
+  #nullifierSource: NullifierSource;
+
+  constructor(nullifierSource: NullifierSource) {
+    this.#nullifierSource = nullifierSource;
+  }
+
+  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;
+
+      // 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'] };
+      }
+
+      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'] };
+      }
+    }
+    return { result: 'valid' };
+  }
+}

package/src/msg_validators/tx_validator/index.ts

@@ -0,0 +1,6 @@
+export * from './aggregate_tx_validator.js';
+export * from './data_validator.js';
+export * from './double_spend_validator.js';
+export * from './metadata_validator.js';
+export * from './tx_proof_validator.js';
+export * from './block_header_validator.js';

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -0,0 +1,48 @@
+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';
+
+export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createLogger('p2p:tx_validator:tx_metadata');
+
+  constructor(private chainId: Fr, private blockNumber: Fr) {}
+
+  async validateTx(tx: T): Promise<TxValidationResult> {
+    const errors = [];
+    if (!(await this.#hasCorrectChainId(tx))) {
+      errors.push('Incorrect chain id');
+    }
+    if (!(await this.#isValidForBlockNumber(tx))) {
+      errors.push('Invalid block number');
+    }
+    return 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()}`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  async #isValidForBlockNumber(tx: T): Promise<boolean> {
+    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+
+    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}.`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
+}

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -0,0 +1,18 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+
+export class TxProofValidator implements TxValidator<Tx> {
+  #log = createLogger('p2p:tx_validator:private_proof');
+
+  constructor(private verifier: ClientProtocolCircuitVerifier) {}
+
+  async validateTx(tx: Tx): Promise<TxValidationResult> {
+    if (!(await this.verifier.verifyProof(tx))) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for invalid proof`);
+      return { result: 'invalid', reason: ['Invalid proof'] };
+    }
+    this.#log.trace(`Accepted ${Tx.getHash(tx)} with valid proof`);
+    return { result: 'valid' };
+  }
+}