@aztec/p2p 0.69.0 → 0.69.1-devnet

package/src/msg_validators/tx_validator/aggregate_tx_validator.ts

@@ -1,4 +1,4 @@
-import { type ProcessedTx, type Tx, type TxValidator } from '@aztec/circuit-types';
+import { type ProcessedTx, type Tx, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
 
 export class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValidator<T> {
   #validators: TxValidator<T>[];
@@ -10,27 +10,23 @@ export class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValid
     this.#validators = validators;
   }
 
-  async validateTxs(txs: T[]): Promise<[validTxs: T[], invalidTxs: T[], skippedTxs: T[]]> {
-    const invalidTxs: T[] = [];
-    const skippedTxs: T[] = [];
-    let txPool = txs;
+  async validateTx(tx: T): Promise<TxValidationResult> {
+    const aggregate: { result: string; reason?: string[] } = { result: 'valid', reason: [] };
     for (const validator of this.#validators) {
-      const [valid, invalid, skipped] = await validator.validateTxs(txPool);
-      invalidTxs.push(...invalid);
-      skippedTxs.push(...(skipped ?? []));
-      txPool = valid;
-    }
-
-    return [txPool, invalidTxs, skippedTxs];
-  }
-
-  async validateTx(tx: T): Promise<boolean> {
-    for (const validator of this.#validators) {
-      const valid = await validator.validateTx(tx);
-      if (!valid) {
-        return false;
+      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);
       }
     }
-    return true;
+    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 AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
+import { type Fr } from '@aztec/circuits.js';
+import { createLogger } from '@aztec/foundation/log';
+
+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([tx.data.constants.historicalHeader.hash()]);
+    if (index === undefined) {
+      this.#log.warn(`Rejecting tx ${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

@@ -1,29 +1,14 @@
-import { Tx, type TxValidator } from '@aztec/circuit-types';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 
 export class DataTxValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:tx_data');
 
-  validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
-    const validTxs: Tx[] = [];
-    const invalidTxs: Tx[] = [];
-    for (const tx of txs) {
-      if (!this.#hasCorrectExecutionRequests(tx)) {
-        invalidTxs.push(tx);
-        continue;
-      }
-
-      validTxs.push(tx);
-    }
-
-    return Promise.resolve([validTxs, invalidTxs]);
-  }
-
-  validateTx(tx: Tx): Promise<boolean> {
+  validateTx(tx: Tx): Promise<TxValidationResult> {
     return Promise.resolve(this.#hasCorrectExecutionRequests(tx));
   }
 
-  #hasCorrectExecutionRequests(tx: Tx): boolean {
+  #hasCorrectExecutionRequests(tx: Tx): TxValidationResult {
     const callRequests = [
       ...tx.data.getRevertiblePublicCallRequests(),
       ...tx.data.getNonRevertiblePublicCallRequests(),
@@ -34,7 +19,7 @@ export class DataTxValidator implements TxValidator<Tx> {
           callRequests.length
         }. Got ${tx.enqueuedPublicFunctionCalls.length}.`,
       );
-      return false;
+      return { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
     }
 
     const invalidExecutionRequestIndex = tx.enqueuedPublicFunctionCalls.findIndex(
@@ -46,7 +31,7 @@ export class DataTxValidator implements TxValidator<Tx> {
           tx,
         )} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`,
       );
-      return false;
+      return { result: 'invalid', reason: ['Incorrect execution request for public call'] };
     }
 
     const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
@@ -55,10 +40,10 @@ export class DataTxValidator implements TxValidator<Tx> {
       (teardownCallRequest && !tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest));
     if (isInvalidTeardownExecutionRequest) {
       this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of incorrect teardown execution requests.`);
-      return false;
+      return { result: 'invalid', reason: ['Incorrect teardown execution request'] };
     }
 
-    return true;
+    return { result: 'valid' };
   }
 
   // TODO: Check logs.

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -1,69 +1,33 @@
-import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 
 export interface NullifierSource {
-  getNullifierIndices: (nullifiers: Buffer[]) => Promise<(bigint | undefined)[]>;
+  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, private readonly isValidatingBlock: boolean = true) {
+  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];
-  }
-
-  validateTx(tx: T): Promise<boolean> {
-    return this.#uniqueNullifiers(tx, new Set<bigint>());
-  }
-
-  async #uniqueNullifiers(tx: AnyTx, thisBlockNullifiers: Set<bigint>): Promise<boolean> {
+  async validateTx(tx: T): Promise<TxValidationResult> {
     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 ${Tx.getHash(tx)} for emitting duplicate nullifiers`);
-      return false;
-    }
-
-    if (this.isValidatingBlock) {
-      for (const nullifier of nullifiers) {
-        const nullifierBigInt = nullifier.toBigInt();
-        if (thisBlockNullifiers.has(nullifierBigInt)) {
-          this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier in the same block`);
-          return false;
-        }
-
-        thisBlockNullifiers.add(nullifierBigInt);
-      }
+      return { result: 'invalid', reason: ['Duplicate nullifier in tx'] };
     }
 
-    const nullifierIndexes = await this.#nullifierSource.getNullifierIndices(nullifiers.map(n => n.toBuffer()));
-
-    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;
+    if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
+      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier`);
+      return { result: 'invalid', reason: ['Existing nullifier'] };
     }
 
-    return true;
+    return { result: 'valid' };
   }
 }

package/src/msg_validators/tx_validator/index.ts

@@ -3,3 +3,4 @@ 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

@@ -1,4 +1,4 @@
-import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
+import { type AnyTx, Tx, type TxValidationResult, type TxValidator } from '@aztec/circuit-types';
 import { type Fr } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
 
@@ -7,28 +7,15 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
 
   constructor(private chainId: Fr, private blockNumber: Fr) {}
 
-  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);
+  validateTx(tx: T): Promise<TxValidationResult> {
+    const errors = [];
+    if (!this.#hasCorrectChainId(tx)) {
+      errors.push('Incorrect chain id');
     }
-
-    return Promise.resolve([validTxs, invalidTxs]);
-  }
-
-  validateTx(tx: T): Promise<boolean> {
-    return Promise.resolve(this.#hasCorrectChainId(tx) && this.#isValidForBlockNumber(tx));
+    if (!this.#isValidForBlockNumber(tx)) {
+      errors.push('Invalid block number');
+    }
+    return Promise.resolve(errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' });
   }
 
   #hasCorrectChainId(tx: T): boolean {

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -1,4 +1,9 @@
-import { type ClientProtocolCircuitVerifier, Tx, type TxValidator } from '@aztec/circuit-types';
+import {
+  type ClientProtocolCircuitVerifier,
+  Tx,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
 
 export class TxProofValidator implements TxValidator<Tx> {
@@ -6,23 +11,12 @@ export class TxProofValidator implements TxValidator<Tx> {
 
   constructor(private verifier: ClientProtocolCircuitVerifier) {}
 
-  async validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
-    const validTxs: Tx[] = [];
-    const invalidTxs: Tx[] = [];
-
-    for (const tx of txs) {
-      if (await this.verifier.verifyProof(tx)) {
-        validTxs.push(tx);
-      } else {
-        this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for invalid proof`);
-        invalidTxs.push(tx);
-      }
+  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'] };
     }
-
-    return [validTxs, invalidTxs];
-  }
-
-  validateTx(tx: Tx): Promise<boolean> {
-    return this.verifier.verifyProof(tx);
+    this.#log.trace(`Accepted ${Tx.getHash(tx)} with valid proof`);
+    return { result: 'valid' };
   }
 }

package/src/services/libp2p/libp2p_service.ts

@@ -6,17 +6,18 @@ import {
   type Gossipable,
   type L2BlockSource,
   MerkleTreeId,
+  P2PClientType,
   PeerErrorSeverity,
   type PeerInfo,
   type RawGossipMessage,
   TopicTypeMap,
   Tx,
   TxHash,
+  type TxValidationResult,
   type WorldStateSynchronizer,
   getTopicTypeForClientType,
   metricsTopicStrToLabels,
 } from '@aztec/circuit-types';
-import { P2PClientType } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
 import { type EpochCache } from '@aztec/epoch-cache';
 import { createLogger } from '@aztec/foundation/log';
@@ -73,14 +74,14 @@ import { GossipSubEvent } from '../types.js';
 
 interface MessageValidator {
   validator: {
-    validateTx(tx: Tx): Promise<boolean>;
+    validateTx(tx: Tx): Promise<TxValidationResult>;
   };
   severity: PeerErrorSeverity;
 }
 
 interface ValidationResult {
   name: string;
-  isValid: boolean;
+  isValid: TxValidationResult;
   severity: PeerErrorSeverity;
 }
 
@@ -568,7 +569,7 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       return false;
     }
 
-    if (!validProof) {
+    if (validProof.result === 'invalid') {
       // If the proof is invalid, but the txHash is correct, then this is an active attack and we severly punish
       this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
       return false;
@@ -704,9 +705,10 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
       },
       doubleSpendValidator: {
         validator: new DoubleSpendTxValidator({
-          getNullifierIndices: (nullifiers: Buffer[]) => {
+          nullifiersExist: async (nullifiers: Buffer[]) => {
             const merkleTree = this.worldStateSynchronizer.getCommitted();
-            return merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+            return indices.map(index => index !== undefined);
           },
         }),
         severity: PeerErrorSeverity.HighToleranceError,
@@ -725,8 +727,8 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     messageValidators: Record<string, MessageValidator>,
   ): Promise<ValidationOutcome> {
     const validationPromises = Object.entries(messageValidators).map(async ([name, { validator, severity }]) => {
-      const isValid = await validator.validateTx(tx);
-      return { name, isValid, severity };
+      const { result } = await validator.validateTx(tx);
+      return { name, isValid: result === 'valid', severity };
     });
 
     // A promise that resolves when all validations have been run
@@ -767,16 +769,17 @@ export class LibP2PService<T extends P2PClientType> extends WithTracer implement
     }
 
     const snapshotValidator = new DoubleSpendTxValidator({
-      getNullifierIndices: (nullifiers: Buffer[]) => {
+      nullifiersExist: async (nullifiers: Buffer[]) => {
         const merkleTree = this.worldStateSynchronizer.getSnapshot(
           blockNumber - this.config.severePeerPenaltyBlockLength,
         );
-        return merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+        const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+        return indices.map(index => index !== undefined);
       },
     });
 
     const validSnapshot = await snapshotValidator.validateTx(tx);
-    if (!validSnapshot) {
+    if (validSnapshot.result !== 'valid') {
       this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
       return false;
     }