@aztec/p2p 0.86.0 → 0.87.0

package/src/msg_validators/tx_validator/data_validator.ts

@@ -26,7 +26,7 @@ export class DataTxValidator implements TxValidator<Tx> {
   async #hasCorrectCalldata(tx: Tx): Promise<TxValidationResult> {
     if (tx.publicFunctionCalldata.length !== tx.numberOfPublicCalls()) {
       const reason = TX_ERROR_CALLDATA_COUNT_MISMATCH;
-      this.#log.warn(
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Expected ${tx.numberOfPublicCalls()}. Got ${
           tx.publicFunctionCalldata.length
         }.`,
@@ -36,7 +36,7 @@ export class DataTxValidator implements TxValidator<Tx> {
 
     if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
       const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
-      this.#log.warn(
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(
           tx,
         )}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
@@ -50,7 +50,7 @@ export class DataTxValidator implements TxValidator<Tx> {
       const hash = await computeCalldataHash(calldata);
       if (!hash.equals(request.calldataHash)) {
         const reason = TX_ERROR_INCORRECT_CALLDATA;
-        this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Call request index: ${i}.`);
+        this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)}. Reason: ${reason}. Call request index: ${i}.`);
         return { result: 'invalid', reason: [reason] };
       }
     }
@@ -60,44 +60,50 @@ export class DataTxValidator implements TxValidator<Tx> {
 
   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(
+    if (contractClassLogsHashes.length !== tx.contractClassLogs.length) {
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(tx)} because of mismatched number of contract class logs. Expected ${
           contractClassLogsHashes.length
-        }. Got ${hashedContractClasslogs.length}.`,
+        }. Got ${tx.contractClassLogs.length}.`,
       );
       return { result: 'invalid', reason: [TX_ERROR_CONTRACT_CLASS_LOG_COUNT] };
     }
+
+    const expectedHashes = await Promise.all(tx.contractClassLogs.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(
+      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 ${await 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: [TX_ERROR_CONTRACT_CLASS_LOG_SORTING] };
         } else {
-          this.#log.warn(
+          this.#log.verbose(
             `Rejecting tx ${await Tx.getHash(tx)} 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: [TX_ERROR_CONTRACT_CLASS_LOGS] };
         }
       }
-      if (logHash.logHash.length !== tx.contractClassLogs[i].getEmittedLength()) {
-        this.#log.warn(
-          `Rejecting tx ${await Tx.getHash(tx)} because of mismatched contract class logs length. Expected ${
+
+      const expectedMinLength = 1 + tx.contractClassLogs[i].fields.findLastIndex(f => !f.isZero());
+      if (logHash.logHash.length < expectedMinLength) {
+        this.#log.verbose(
+          `Rejecting tx ${await Tx.getHash(
+            tx,
+          )} 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: [TX_ERROR_CONTRACT_CLASS_LOG_LENGTH] };
       }
     }
+
     return { result: 'valid' };
   }
 }

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -26,12 +26,12 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
     // 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`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} 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`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
       return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
     }
 

package/src/msg_validators/tx_validator/factory.ts

@@ -0,0 +1,94 @@
+import { Fr } from '@aztec/foundation/fields';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractAddress } 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 } from '@aztec/stdlib/tx';
+
+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 { TxProofValidator } from './tx_proof_validator.js';
+
+export interface MessageValidator {
+  validator: {
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+  };
+  severity: PeerErrorSeverity;
+}
+
+export function createTxMessageValidators(
+  blockNumber: number,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  gasFees: GasFees,
+  l1ChainId: number,
+  rollupVersion: number,
+  protocolContractTreeRoot: Fr,
+  contractDataSource: ContractDataSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  allowedInSetup: AllowedElement[] = [],
+): Record<string, MessageValidator>[] {
+  const merkleTree = worldStateSynchronizer.getCommitted();
+
+  return [
+    {
+      dataValidator: {
+        validator: new DataTxValidator(),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      metadataValidator: {
+        validator: new MetadataTxValidator({
+          l1ChainId: new Fr(l1ChainId),
+          rollupVersion: new Fr(rollupVersion),
+          blockNumber: new Fr(blockNumber),
+          protocolContractTreeRoot,
+          vkTreeRoot: getVKTreeRoot(),
+        }),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      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);
+          },
+        }),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      gasValidator: {
+        validator: new GasTxValidator(
+          new DatabasePublicStateSource(merkleTree),
+          ProtocolContractAddress.FeeJuice,
+          gasFees,
+        ),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      phasesValidator: {
+        validator: new PhasesTxValidator(contractDataSource, allowedInSetup, blockNumber),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      blockHeaderValidator: {
+        validator: new BlockHeaderTxValidator(new ArchiveCache(merkleTree)),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+    },
+    {
+      proofValidator: {
+        validator: new TxProofValidator(proofVerifier),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+    },
+  ];
+}

package/src/msg_validators/tx_validator/gas_validator.ts

@@ -55,7 +55,7 @@ export class GasTxValidator implements TxValidator<Tx> {
       maxFeesPerGas.feePerL2Gas.lt(this.#gasFees.feePerL2Gas);
 
     if (notEnoughMaxFees) {
-      this.#log.warn(`Skipping transaction ${await tx.getTxHash()} due to insufficient fee per gas`, {
+      this.#log.verbose(`Skipping transaction ${await tx.getTxHash()} due to insufficient fee per gas`, {
         txMaxFeesPerGas: maxFeesPerGas.toInspect(),
         currentGasFees: this.#gasFees.toInspect(),
       });
@@ -71,7 +71,7 @@ export class GasTxValidator implements TxValidator<Tx> {
     const minGasLimits = new Gas(FIXED_DA_GAS, FIXED_L2_GAS);
 
     if (minGasLimits.gtAny(gasLimits)) {
-      this.#log.warn(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
+      this.#log.verbose(`Rejecting transaction due to the gas limit(s) not being above the minimum gas limit`, {
         gasLimits,
         minGasLimits,
       });
@@ -113,7 +113,7 @@ export class GasTxValidator implements TxValidator<Tx> {
 
     const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[1]) : initialBalance;
     if (balance.lt(feeLimit)) {
-      this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
+      this.#log.verbose(`Rejecting transaction due to not enough fee payer balance`, {
         feePayer,
         balance: balance.toBigInt(),
         feeLimit: feeLimit.toBigInt(),

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -2,8 +2,10 @@ import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
-  TX_ERROR_INCORRECT_CHAIN_ID,
+  TX_ERROR_INCORRECT_L1_CHAIN_ID,
+  TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT,
   TX_ERROR_INCORRECT_ROLLUP_VERSION,
+  TX_ERROR_INCORRECT_VK_TREE_ROOT,
   TX_ERROR_INVALID_BLOCK_NUMBER,
   Tx,
   type TxValidationResult,
@@ -13,12 +15,14 @@ import {
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #log = createLogger('p2p:tx_validator:tx_metadata');
 
-  constructor(private chainId: Fr, private rollupVersion: Fr, private blockNumber: Fr) {}
+  constructor(
+    private values: { l1ChainId: Fr; rollupVersion: Fr; blockNumber: Fr; vkTreeRoot: Fr; protocolContractTreeRoot: Fr },
+  ) {}
 
   async validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
-    if (!(await this.#hasCorrectChainId(tx))) {
-      errors.push(TX_ERROR_INCORRECT_CHAIN_ID);
+    if (!(await this.#hasCorrectL1ChainId(tx))) {
+      errors.push(TX_ERROR_INCORRECT_L1_CHAIN_ID);
     }
     if (!(await this.#hasCorrectRollupVersion(tx))) {
       errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
@@ -26,15 +30,47 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     if (!(await this.#isValidForBlockNumber(tx))) {
       errors.push(TX_ERROR_INVALID_BLOCK_NUMBER);
     }
+    if (!(await this.#hasCorrectVkTreeRoot(tx))) {
+      errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
+    }
+    if (!(await this.#hasCorrectProtocolContractTreeRoot(tx))) {
+      errors.push(TX_ERROR_INCORRECT_PROTOCOL_CONTRACT_TREE_ROOT);
+    }
     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(
+  async #hasCorrectVkTreeRoot(tx: T): Promise<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 ${await Tx.getHash(
+          tx,
+        )} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  async #hasCorrectProtocolContractTreeRoot(tx: T): Promise<boolean> {
+    if (!tx.data.constants.protocolContractTreeRoot.equals(this.values.protocolContractTreeRoot)) {
+      this.#log.verbose(
+        `Rejecting tx ${await Tx.getHash(
+          tx,
+        )} because of incorrect protocol contract tree root ${tx.data.constants.protocolContractTreeRoot.toString()} != ${this.values.protocolContractTreeRoot.toString()}`,
+      );
+      return false;
+    }
+    return true;
+  }
+
+  async #hasCorrectL1ChainId(tx: T): Promise<boolean> {
+    if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(
           tx,
-        )} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.chainId.toNumber()}`,
+        )} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
       );
       return false;
     } else {
@@ -45,11 +81,11 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   async #isValidForBlockNumber(tx: T): Promise<boolean> {
     const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
 
-    if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
-      this.#log.warn(
+    if (maxBlockNumber.isSome && maxBlockNumber.value < this.values.blockNumber) {
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${
           maxBlockNumber.value
-        }, current block number: ${this.blockNumber}.`,
+        }, current block number: ${this.values.blockNumber}.`,
       );
       return false;
     } else {
@@ -58,11 +94,11 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async #hasCorrectRollupVersion(tx: T): Promise<boolean> {
-    if (!tx.data.constants.txContext.version.equals(this.rollupVersion)) {
-      this.#log.warn(
+    if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
+      this.#log.verbose(
         `Rejecting tx ${await Tx.getHash(
           tx,
-        )} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.rollupVersion.toNumber()}`,
+        )} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,
       );
       return false;
     } else {

package/src/msg_validators/tx_validator/phases_validator.ts

@@ -16,7 +16,11 @@ export class PhasesTxValidator implements TxValidator<Tx> {
   #log = createLogger('sequencer:tx_validator:tx_phases');
   private contractsDB: PublicContractsDB;
 
-  constructor(contracts: ContractDataSource, private setupAllowList: AllowedElement[], private blockNumber: number) {
+  constructor(
+    contracts: ContractDataSource,
+    private setupAllowList: AllowedElement[],
+    private blockNumber: number,
+  ) {
     this.contractsDB = new PublicContractsDB(contracts);
   }
 
@@ -37,7 +41,7 @@ export class PhasesTxValidator implements TxValidator<Tx> {
       const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
       for (const setupFn of setupFns) {
         if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
-          this.#log.warn(
+          this.#log.verbose(
             `Rejecting tx ${await Tx.getHash(tx)} because it calls setup function not on allow list: ${
               setupFn.request.contractAddress
             }:${setupFn.functionSelector}`,

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -9,7 +9,7 @@ export class TxProofValidator implements TxValidator<Tx> {
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!(await this.verifier.verifyProof(tx))) {
-      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for invalid proof`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for invalid proof`);
       return { result: 'invalid', reason: [TX_ERROR_INVALID_PROOF] };
     }
     this.#log.trace(`Accepted ${await Tx.getHash(tx)} with valid proof`);

package/src/services/discv5/discV5_service.ts

@@ -10,9 +10,9 @@ import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
 import EventEmitter from 'events';
 
 import type { P2PConfig } from '../../config.js';
+import { createNodeENR } from '../../enr/generate-enr.js';
 import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../../types/index.js';
 import { convertToMultiaddr } from '../../util.js';
-import { setAztecEnrKey } from '../../versioning.js';
 import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
 
 const delayBeforeStart = 2000; // 2sec
@@ -22,7 +22,7 @@ const delayBeforeStart = 2000; // 2sec
  */
 export class DiscV5Service extends EventEmitter implements PeerDiscoveryService {
   /** The Discv5 instance */
-  private discv5: Discv5 & Discv5EventEmitter;
+  private discv5: Discv5EventEmitter;
 
   /** This instance's ENR */
   private enr: SignableENR;
@@ -47,6 +47,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   constructor(
     private peerId: PeerId,
     private config: P2PConfig,
+    private readonly packageVersion: string,
     telemetry: TelemetryClient = getTelemetryClient(),
     private logger = createLogger('p2p:discv5_service'),
     configOverrides: Partial<IDiscv5CreateOptions> = {},
@@ -57,10 +58,6 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     this.bootstrapNodeEnrs = bootstrapNodes.map(x => ENR.decodeTxt(x));
     const privatePeerEnrs = new Set(privatePeers);
     this.trustedPeerEnrs = trustedPeers.filter(x => !privatePeerEnrs.has(x)).map(x => ENR.decodeTxt(x));
-    // create ENR from PeerId
-    this.enr = SignableENR.createFromPeerId(peerId);
-    // Add aztec identification to ENR
-    this.versions = setAztecEnrKey(this.enr, config);
 
     // If no overridden broadcast port is provided, use the p2p port as the broadcast port
     if (!p2pBroadcastPort) {
@@ -72,19 +69,24 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       ip4: multiaddr(convertToMultiaddr(config.listenAddress, p2pPort, 'udp')),
     };
 
+    let multiAddrUdp, multiAddrTcp;
     if (p2pIp) {
-      const multiAddrTcp = multiaddr(
+      multiAddrTcp = multiaddr(
         `${convertToMultiaddr(p2pIp!, config.p2pBroadcastPort!, 'tcp')}/p2p/${peerId.toString()}`,
       );
-      const multiAddrUdp = multiaddr(
+      multiAddrUdp = multiaddr(
         `${convertToMultiaddr(p2pIp!, config.p2pBroadcastPort!, 'udp')}/p2p/${peerId.toString()}`,
       );
-
-      // set location multiaddr in ENR record
-      this.enr.setLocationMultiaddr(multiAddrUdp);
-      this.enr.setLocationMultiaddr(multiAddrTcp);
     }
 
+    ({ enr: this.enr, versions: this.versions } = createNodeENR(
+      peerId,
+      multiAddrUdp,
+      multiAddrTcp,
+      config,
+      this.packageVersion,
+    ));
+
     const metricsRegistry = new OtelMetricsAdapter(telemetry);
     this.discv5 = Discv5.create({
       enr: this.enr,

package/src/services/dummy_service.ts

@@ -1,6 +1,6 @@
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
-import { TxHash } from '@aztec/stdlib/tx';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
@@ -38,7 +38,9 @@ export class DummyP2PService implements P2PService {
    * Called to have the given message propagated through the P2P network.
    * @param _ - The message to be propagated.
    */
-  public propagate<T extends Gossipable>(_: T) {}
+  public propagate<T extends Gossipable>(_: T) {
+    return Promise.resolve();
+  }
 
   /**
    * Called upon receipt of settled transactions.
@@ -84,6 +86,10 @@ export class DummyP2PService implements P2PService {
   public getEnr(): undefined {
     return undefined;
   }
+
+  validate(_txs: Tx[]): Promise<void> {
+    return Promise.resolve();
+  }
 }
 
 /**