@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.21caa21

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,29 +1,49 @@
 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 AnyTx,
+  TX_ERROR_INCORRECT_L1_CHAIN_ID,
+  TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH,
+  TX_ERROR_INCORRECT_ROLLUP_VERSION,
+  TX_ERROR_INCORRECT_VK_TREE_ROOT,
+  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) {}
+  constructor(
+    private values: {
+      l1ChainId: Fr;
+      rollupVersion: Fr;
+      vkTreeRoot: Fr;
+      protocolContractsHash: Fr;
+    },
+  ) {}
 
-  async validateTx(tx: T): Promise<TxValidationResult> {
+  validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
-    if (!(await this.#hasCorrectChainId(tx))) {
-      errors.push('Incorrect chain id');
+    if (!this.#hasCorrectL1ChainId(tx)) {
+      errors.push(TX_ERROR_INCORRECT_L1_CHAIN_ID);
     }
-    if (!(await this.#isValidForBlockNumber(tx))) {
-      errors.push('Invalid block number');
+    if (!this.#hasCorrectRollupVersion(tx)) {
+      errors.push(TX_ERROR_INCORRECT_ROLLUP_VERSION);
     }
-    return errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' };
+    if (!this.#hasCorrectVkTreeRoot(tx)) {
+      errors.push(TX_ERROR_INCORRECT_VK_TREE_ROOT);
+    }
+    if (!this.#hasCorrectprotocolContractsHash(tx)) {
+      errors.push(TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH);
+    }
+    return Promise.resolve(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()}`,
+  #hasCorrectVkTreeRoot(tx: T): 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 ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
       );
       return false;
     } else {
@@ -31,14 +51,31 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  async #isValidForBlockNumber(tx: T): Promise<boolean> {
-    const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
+  #hasCorrectprotocolContractsHash(tx: T): boolean {
+    if (!tx.data.constants.protocolContractsHash.equals(this.values.protocolContractsHash)) {
+      this.#log.verbose(
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`,
+      );
+      return false;
+    }
+    return true;
+  }
+
+  #hasCorrectL1ChainId(tx: T): boolean {
+    if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
+      this.#log.verbose(
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
+      );
+      return false;
+    } else {
+      return true;
+    }
+  }
 
-    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}.`,
+  #hasCorrectRollupVersion(tx: T): boolean {
+    if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
+      this.#log.verbose(
+        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} 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

@@ -0,0 +1,116 @@
+import { createLogger } from '@aztec/foundation/log';
+import { PublicContractsDB, getCallRequestsWithCalldataByPhase } from '@aztec/simulator/server';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { AllowedElement } from '@aztec/stdlib/interfaces/server';
+import {
+  type PublicCallRequestWithCalldata,
+  TX_ERROR_DURING_VALIDATION,
+  TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED,
+  Tx,
+  TxExecutionPhase,
+  type TxValidationResult,
+  type TxValidator,
+} from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+export class PhasesTxValidator implements TxValidator<Tx> {
+  #log = createLogger('sequencer:tx_validator:tx_phases');
+  private contractsDB: PublicContractsDB;
+
+  constructor(
+    contracts: ContractDataSource,
+    private setupAllowList: AllowedElement[],
+    private timestamp: UInt64,
+  ) {
+    this.contractsDB = new PublicContractsDB(contracts);
+  }
+
+  async validateTx(tx: Tx): Promise<TxValidationResult> {
+    this.contractsDB.createCheckpoint();
+    try {
+      // TODO(@spalladino): We add this just to handle public authwit-check calls during setup
+      // which are needed for public FPC flows, but fail if the account contract hasnt been deployed yet,
+      // which is what we're trying to do as part of the current txs.
+      // We only need to create/revert checkpoint here because of this addNewContracts call.
+      await this.contractsDB.addNewContracts(tx);
+
+      if (!tx.data.forPublic) {
+        this.#log.debug(
+          `Tx ${tx.getTxHash().toString()} does not contain enqueued public functions. Skipping phases validation.`,
+        );
+        return { result: 'valid' };
+      }
+
+      const setupFns = getCallRequestsWithCalldataByPhase(tx, TxExecutionPhase.SETUP);
+      for (const setupFn of setupFns) {
+        if (!(await this.isOnAllowList(setupFn, this.setupAllowList))) {
+          this.#log.verbose(
+            `Rejecting tx ${tx.getTxHash().toString()} because it calls setup function not on allow list: ${
+              setupFn.request.contractAddress
+            }:${setupFn.functionSelector}`,
+            { allowList: this.setupAllowList },
+          );
+
+          return { result: 'invalid', reason: [TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED] };
+        }
+      }
+
+      return { result: 'valid' };
+    } catch (err) {
+      this.#log.error(`Error validating phases for tx`, err);
+      return { result: 'invalid', reason: [TX_ERROR_DURING_VALIDATION] };
+    } finally {
+      this.contractsDB.revertCheckpoint();
+    }
+  }
+
+  private async isOnAllowList(
+    publicCall: PublicCallRequestWithCalldata,
+    allowList: AllowedElement[],
+  ): Promise<boolean> {
+    if (publicCall.isEmpty()) {
+      return true;
+    }
+
+    const contractAddress = publicCall.request.contractAddress;
+    const functionSelector = publicCall.functionSelector;
+
+    // do these checks first since they don't require the contract class
+    for (const entry of allowList) {
+      if ('address' in entry && !('selector' in entry)) {
+        if (contractAddress.equals(entry.address)) {
+          return true;
+        }
+      }
+
+      if ('address' in entry && 'selector' in entry) {
+        if (contractAddress.equals(entry.address) && entry.selector.equals(functionSelector)) {
+          return true;
+        }
+      }
+
+      const contractClass = await this.contractsDB.getContractInstance(contractAddress, this.timestamp);
+
+      if (!contractClass) {
+        throw new Error(`Contract not found: ${contractAddress}`);
+      }
+
+      if ('classId' in entry && !('selector' in entry)) {
+        if (contractClass.currentContractClassId.equals(entry.classId)) {
+          return true;
+        }
+      }
+
+      if ('classId' in entry && 'selector' in entry) {
+        if (
+          contractClass.currentContractClassId.equals(entry.classId) &&
+          (entry.selector === undefined || entry.selector.equals(functionSelector))
+        ) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+}

package/src/msg_validators/tx_validator/test_utils.ts

@@ -0,0 +1,43 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { HashedValues, type Tx } from '@aztec/stdlib/tx';
+
+export function patchNonRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  return patchFn('nonRevertibleAccumulatedData', tx, index, overrides);
+}
+
+export function patchRevertibleFn(
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  return patchFn('revertibleAccumulatedData', tx, index, overrides);
+}
+
+async function patchFn(
+  where: 'revertibleAccumulatedData' | 'nonRevertibleAccumulatedData',
+  tx: Tx,
+  index: number,
+  overrides: { address?: AztecAddress; selector: FunctionSelector; args?: Fr[]; msgSender?: AztecAddress },
+): Promise<AztecAddress> {
+  const calldataIndex =
+    where === 'nonRevertibleAccumulatedData'
+      ? index
+      : index + tx.data.forPublic!.nonRevertibleAccumulatedData.publicCallRequests.length;
+  const calldata = [overrides.selector.toField(), ...(overrides.args ?? [])];
+  const hashedCalldata = await HashedValues.fromCalldata(calldata);
+  tx.publicFunctionCalldata[calldataIndex] = hashedCalldata;
+
+  const request = tx.data.forPublic![where].publicCallRequests[index];
+  request.contractAddress = overrides.address ?? request.contractAddress;
+  request.msgSender = overrides.msgSender ?? request.msgSender;
+  request.calldataHash = hashedCalldata.hash;
+  tx.data.forPublic![where].publicCallRequests[index] = request;
+
+  return request.contractAddress;
+}

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -0,0 +1,46 @@
+import { createLogger } from '@aztec/foundation/log';
+import {
+  type AnyTx,
+  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
+  type TxValidationResult,
+  type TxValidator,
+  getTxHash,
+} from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
+  #log = createLogger('p2p:tx_validator:timestamp');
+
+  constructor(
+    private values: {
+      // Timestamp at which we will validate that the tx is not expired. This is typically the timestamp of the block
+      // being built.
+      timestamp: UInt64;
+      // Block number in which the tx is considered to be included.
+      blockNumber: number;
+    },
+  ) {}
+
+  validateTx(tx: T): Promise<TxValidationResult> {
+    const includeByTimestamp = tx.data.includeByTimestamp;
+    // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
+    // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
+    const buildingBlock1 = this.values.blockNumber === 1;
+
+    if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
+      if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber === 0) {
+        this.#log.warn(
+          `A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`,
+        );
+      }
+      this.#log.verbose(
+        `Rejecting tx ${getTxHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
+          this.values.timestamp
+        }.`,
+      );
+      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP] });
+    } else {
+      return Promise.resolve({ result: 'valid' });
+    }
+  }
+}

package/src/msg_validators/tx_validator/tx_permitted_validator.ts

@@ -0,0 +1,17 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
+
+export class TxPermittedValidator implements TxValidator<Tx> {
+  #log = createLogger('p2p:tx_validator:tx_permitted');
+
+  constructor(private permitted: boolean) {}
+
+  validateTx(tx: Tx): Promise<TxValidationResult> {
+    if (!this.permitted) {
+      const txHash = tx.getTxHash();
+      this.#log.verbose(`Rejecting tx ${txHash.toString()}. Reason: Transactions are not permitted`);
+      return Promise.resolve({ result: 'invalid', reason: ['Transactions are not permitted'] });
+    }
+    return Promise.resolve({ result: 'valid' });
+  }
+}

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
-import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { TX_ERROR_INVALID_PROOF, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export class TxProofValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:private_proof');
@@ -8,11 +8,12 @@ export class TxProofValidator implements TxValidator<Tx> {
   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'] };
+    const result = await this.verifier.verifyProof(tx);
+    if (!result.valid) {
+      this.#log.verbose(`Rejecting tx ${tx.getTxHash().toString()} for invalid proof`);
+      return { result: 'invalid', reason: [TX_ERROR_INVALID_PROOF] };
     }
-    this.#log.trace(`Accepted ${Tx.getHash(tx)} with valid proof`);
+    this.#log.trace(`Accepted ${tx.getTxHash().toString()} with valid proof`);
     return { result: 'valid' };
   }
 }

package/src/services/discv5/discV5_service.ts

@@ -3,16 +3,16 @@ import { sleep } from '@aztec/foundation/sleep';
 import { type ComponentsVersions, checkCompressedComponentVersion } from '@aztec/stdlib/versioning';
 import { OtelMetricsAdapter, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
-import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import { Discv5, type Discv5EventEmitter, type IDiscv5CreateOptions } from '@nethermindeth/discv5';
+import { ENR, SignableENR } from '@nethermindeth/enr';
 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;
@@ -30,57 +30,74 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   /** Version identifiers. */
   private versions: ComponentsVersions;
 
-  /** UDP listen addr */
-  private listenMultiAddrUdp: Multiaddr;
-
   private currentState = PeerDiscoveryState.STOPPED;
 
-  public readonly bootstrapNodes: string[] = [];
   private bootstrapNodePeerIds: PeerId[] = [];
-  private bootstrapNodeEnrs: ENR[] = [];
+  public bootstrapNodeEnrs: ENR[] = [];
+  private trustedPeerEnrs: ENR[] = [];
 
   private startTime = 0;
 
+  private handlers = {
+    onMultiaddrUpdated: this.onMultiaddrUpdated.bind(this),
+    onDiscovered: this.onDiscovered.bind(this),
+    onEnrAdded: this.onEnrAdded.bind(this),
+  };
+
   constructor(
     private peerId: PeerId,
     private config: P2PConfig,
+    private readonly packageVersion: string,
     telemetry: TelemetryClient = getTelemetryClient(),
     private logger = createLogger('p2p:discv5_service'),
+    configOverrides: Partial<IDiscv5CreateOptions> = {},
   ) {
     super();
-    const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
-    this.bootstrapNodes = bootstrapNodes ?? [];
-    this.bootstrapNodeEnrs = this.bootstrapNodes.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 (!tcpAnnounceAddress) {
-      throw new Error('You need to provide at least a TCP announce address.');
+    const { p2pIp, p2pPort, p2pBroadcastPort, bootstrapNodes, trustedPeers, privatePeers } = config;
+
+    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));
+
+    // If no overridden broadcast port is provided, use the p2p port as the broadcast port
+    if (!p2pBroadcastPort) {
+      this.logger.warn('No p2pBroadcastPort provided, using p2pPort as broadcast port');
+      config.p2pBroadcastPort = p2pPort;
     }
 
-    const multiAddrTcp = multiaddr(`${convertToMultiaddr(tcpAnnounceAddress, 'tcp')}/p2p/${peerId.toString()}`);
-    // if no udp announce address is provided, use the tcp announce address
-    const multiAddrUdp = multiaddr(
-      `${convertToMultiaddr(udpAnnounceAddress || tcpAnnounceAddress, 'udp')}/p2p/${peerId.toString()}`,
-    );
+    const bindAddrs: any = {
+      ip4: multiaddr(convertToMultiaddr(config.listenAddress, p2pPort, 'udp')),
+    };
 
-    this.listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
+    let multiAddrUdp, multiAddrTcp;
+    if (p2pIp) {
+      multiAddrTcp = multiaddr(
+        `${convertToMultiaddr(p2pIp!, config.p2pBroadcastPort!, 'tcp')}/p2p/${peerId.toString()}`,
+      );
+      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,
       peerId,
-      bindAddrs: { ip4: this.listenMultiAddrUdp },
+      bindAddrs,
       config: {
         lookupTimeout: 2000,
         requestTimeout: 2000,
         allowUnverifiedSessions: true,
+        enrUpdate: !p2pIp ? true : false, // If no p2p IP is set, enrUpdate can automatically resolve it
+        ...configOverrides.config,
       },
       metricsRegistry,
     });
@@ -104,8 +121,17 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       }
     };
 
-    this.discv5.on(Discv5Event.DISCOVERED, this.onDiscovered.bind(this));
-    this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
+    this.discv5.on(Discv5Event.DISCOVERED, this.handlers.onDiscovered);
+    this.discv5.on(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+    this.discv5.on(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
+  }
+
+  private onMultiaddrUpdated(m: Multiaddr) {
+    // We want to update our tcp port to match the udp port
+    // p2pBroadcastPort is optional on config, however it is set to default within the p2p client factory
+    const multiAddrTcp = multiaddr(convertToMultiaddr(m.nodeAddress().address, this.config.p2pBroadcastPort!, 'tcp'));
+    this.enr.setLocationMultiaddr(multiAddrTcp);
+    this.logger.info('Multiaddr updated', { multiaddr: multiAddrTcp.toString() });
   }
 
   public async start(): Promise<void> {
@@ -126,10 +152,14 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     this.currentState = PeerDiscoveryState.RUNNING;
 
     // Add bootnode ENR if provided
-    if (this.bootstrapNodes?.length) {
+    if (this.bootstrapNodeEnrs?.length) {
       // Do this conversion once since it involves an async function call
       this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodeEnrs.map(enr => enr.peerId()));
-      this.logger.info(`Adding ${this.bootstrapNodes} bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
+      this.logger.info(
+        `Adding ${this.bootstrapNodeEnrs.length} bootstrap nodes ENRs: ${this.bootstrapNodeEnrs
+          .map(enr => enr.encodeTxt())
+          .join(', ')}`,
+      );
       for (const enr of this.bootstrapNodeEnrs) {
         try {
           if (this.config.bootstrapNodeEnrVersionCheck) {
@@ -145,11 +175,23 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
         }
       }
     }
+
+    // Add trusted peer ENRs if provided
+    if (this.trustedPeerEnrs?.length) {
+      this.logger.info(
+        `Adding ${this.trustedPeerEnrs.length} trusted peer ENRs: ${this.trustedPeerEnrs
+          .map(enr => enr.encodeTxt())
+          .join(', ')}`,
+      );
+      for (const enr of this.trustedPeerEnrs) {
+        this.discv5.addEnr(enr);
+      }
+    }
   }
 
   public async runRandomNodesQuery(): Promise<void> {
     if (this.currentState !== PeerDiscoveryState.RUNNING) {
-      throw new Error('DiscV5Service not running');
+      return;
     }
 
     // First, wait some time before starting the peer discovery
@@ -166,7 +208,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     }
   }
 
-  public getAllPeers(): ENR[] {
+  public getKadValues(): ENR[] {
     return this.discv5.kadValues();
   }
 
@@ -187,8 +229,12 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   }
 
   public async stop(): Promise<void> {
-    await this.discv5.off(Discv5Event.DISCOVERED, this.onDiscovered);
-    await this.discv5.off(Discv5Event.ENR_ADDED, this.onEnrAdded);
+    if (this.currentState !== PeerDiscoveryState.RUNNING) {
+      return;
+    }
+    await this.discv5.off(Discv5Event.DISCOVERED, this.handlers.onDiscovered);
+    await this.discv5.off(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+    await this.discv5.off(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
 
     await this.discv5.stop();
 
@@ -231,7 +277,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     // Check the peer is an aztec peer
     const value = enr.kvs.get(AZTEC_ENR_KEY);
     if (!value) {
-      this.logger.warn(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
+      this.logger.debug(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
       return false;
     }