@aztec/p2p 0.85.0 → 0.86.0

package/src/config.ts

@@ -53,6 +53,11 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
    */
   p2pPort: number;
 
+  /**
+   * The port to broadcast the P2P service on (included in the node's ENR).
+   */
+  p2pBroadcastPort?: number;
+
   /**
    * The IP address for the P2P service.
    */
@@ -175,6 +180,11 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
    */
   trustedPeers: string[];
 
+  /**
+   * A list of private peers.
+   */
+  privatePeers: string[];
+
   /**
    * The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKB.
    */
@@ -189,6 +199,8 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
   maxTxPoolSize: number;
 }
 
+export const DEFAULT_P2P_PORT = 40400;
+
 export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   p2pEnabled: {
     env: 'P2P_ENABLED',
@@ -222,8 +234,12 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   },
   p2pPort: {
     env: 'P2P_PORT',
-    description: 'The port for the P2P service.',
-    ...numberConfigHelper(40400),
+    description: `The port for the P2P service. Defaults to ${DEFAULT_P2P_PORT}`,
+    ...numberConfigHelper(DEFAULT_P2P_PORT),
+  },
+  p2pBroadcastPort: {
+    env: 'P2P_BROADCAST_PORT',
+    description: `The port to broadcast the P2P service on (included in the node's ENR). Defaults to P2P_PORT.`,
   },
   p2pIp: {
     env: 'P2P_IP',
@@ -357,7 +373,14 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   trustedPeers: {
     env: 'P2P_TRUSTED_PEERS',
     parseEnv: (val: string) => val.split(','),
-    description: 'A list of trusted peers ENRs. Separated by commas.',
+    description: 'A list of trusted peer ENRs that will always be persisted. Separated by commas.',
+    defaultValue: [],
+  },
+  privatePeers: {
+    env: 'P2P_PRIVATE_PEERS',
+    parseEnv: (val: string) => val.split(','),
+    description:
+      'A list of private peer ENRs that will always be persisted and not be used for discovery. Separated by commas.',
     defaultValue: [],
   },
   p2pStoreMapSizeKb: {
@@ -398,7 +421,13 @@ export function getP2PDefaultConfig(): P2PConfig {
  */
 export type BootnodeConfig = Pick<
   P2PConfig,
-  'p2pIp' | 'p2pPort' | 'peerIdPrivateKey' | 'peerIdPrivateKeyPath' | 'bootstrapNodes' | 'listenAddress'
+  | 'p2pIp'
+  | 'p2pPort'
+  | 'p2pBroadcastPort'
+  | 'peerIdPrivateKey'
+  | 'peerIdPrivateKeyPath'
+  | 'bootstrapNodes'
+  | 'listenAddress'
 > &
   Required<Pick<P2PConfig, 'p2pIp' | 'p2pPort'>> &
   Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
@@ -407,6 +436,7 @@ export type BootnodeConfig = Pick<
 const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
   'p2pIp',
   'p2pPort',
+  'p2pBroadcastPort',
   'listenAddress',
   'peerIdPrivateKey',
   'peerIdPrivateKeyPath',

package/src/enr/generate-enr.ts

@@ -12,12 +12,12 @@ import { setAztecEnrKey } from '../versioning.js';
 export async function createBootnodeENRandPeerId(
   privateKey: string,
   p2pIp: string,
-  p2pPort: number,
+  p2pBroadcastPort: number,
   l1ChainId: number,
 ): Promise<{ enr: SignableENR; peerId: PeerId }> {
   const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
   const enr = SignableENR.createFromPeerId(peerId);
-  const publicAddr = multiaddr(convertToMultiaddr(p2pIp, p2pPort, 'udp'));
+  const publicAddr = multiaddr(convertToMultiaddr(p2pIp, p2pBroadcastPort, 'udp'));
   enr.setLocationMultiaddr(publicAddr);
 
   const config: ChainConfig = {

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -30,7 +30,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
   const createAttestationsForSlot = (slotNumber: number) => {
     const archive = Fr.random();
-    return Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    return signers.map(signer => mockAttestation(signer, slotNumber, archive));
   };
 
   // We compare buffers as the objects can have cached values attached to them which are not serialised
@@ -45,9 +45,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   it('should add attestations to pool', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(
-      signers.slice(0, -1).map(signer => mockAttestation(signer, slotNumber, archive)),
-    );
+    const attestations = signers.slice(0, -1).map(signer => mockAttestation(signer, slotNumber, archive));
 
     await ap.addAttestations(attestations);
 
@@ -63,7 +61,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     compareAttestations(retrievedAttestationsForSlot, attestations);
 
     // Add another one
-    const newAttestation = await mockAttestation(signers[NUMBER_OF_SIGNERS_PER_TEST - 1], slotNumber, archive);
+    const newAttestation = mockAttestation(signers[NUMBER_OF_SIGNERS_PER_TEST - 1], slotNumber, archive);
     await ap.addAttestations([newAttestation]);
     expect(metricsMock.recordAddedObjects).toHaveBeenCalledWith(1);
     const retrievedAttestationsAfterAdd = await ap.getAttestationsForSlotAndProposal(
@@ -96,7 +94,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     const attestations: BlockAttestation[] = [];
     const signer = signers[0];
     for (let i = 0; i < NUMBER_OF_SIGNERS_PER_TEST; i++) {
-      attestations.push(await mockAttestation(signer, slotNumber, archive, txs));
+      attestations.push(mockAttestation(signer, slotNumber, archive, txs));
     }
 
     // Add them to store and check we end up with only one
@@ -106,7 +104,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     expect(retreivedAttestations.length).toBe(1);
     expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
     expect(retreivedAttestations[0].payload.txHashes).toEqual(txs);
-    expect((await retreivedAttestations[0].getSender()).toString()).toEqual(signer.address.toString());
+    expect(retreivedAttestations[0].getSender().toString()).toEqual(signer.address.toString());
 
     // Try adding them on another operation and check they are still not duplicated
     await ap.addAttestations([attestations[0]]);
@@ -115,7 +113,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
   it('should store attestations by differing slot', async () => {
     const slotNumbers = [1, 2, 3, 4];
-    const attestations = await Promise.all(signers.map((signer, i) => mockAttestation(signer, slotNumbers[i])));
+    const attestations = signers.map((signer, i) => mockAttestation(signer, slotNumbers[i]));
 
     await ap.addAttestations(attestations);
 
@@ -133,9 +131,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   it('should store attestations by differing slot and archive', async () => {
     const slotNumbers = [1, 1, 2, 3];
     const archives = [Fr.random(), Fr.random(), Fr.random(), Fr.random()];
-    const attestations = await Promise.all(
-      signers.map((signer, i) => mockAttestation(signer, slotNumbers[i], archives[i])),
-    );
+    const attestations = signers.map((signer, i) => mockAttestation(signer, slotNumbers[i], archives[i]));
 
     await ap.addAttestations(attestations);
 
@@ -153,7 +149,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   it('should delete attestations', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    const attestations = signers.map(signer => mockAttestation(signer, slotNumber, archive));
     const proposalId = attestations[0].archive.toString();
 
     await ap.addAttestations(attestations);
@@ -175,7 +171,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   it('should blanket delete attestations per slot', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    const attestations = signers.map(signer => mockAttestation(signer, slotNumber, archive));
     const proposalId = attestations[0].archive.toString();
 
     await ap.addAttestations(attestations);
@@ -193,12 +189,12 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   it('should blanket delete attestations per slot and proposal', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const attestations = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive)));
+    const attestations = signers.map(signer => mockAttestation(signer, slotNumber, archive));
     const proposalId = attestations[0].archive.toString();
 
     // Add another set of attestations with a different proposalId, yet the same slot
     const archive2 = Fr.random();
-    const attestations2 = await Promise.all(signers.map(signer => mockAttestation(signer, slotNumber, archive2)));
+    const attestations2 = signers.map(signer => mockAttestation(signer, slotNumber, archive2));
     const proposalId2 = attestations2[0].archive.toString();
 
     await ap.addAttestations(attestations);

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -48,7 +48,7 @@ export class KvAttestationPool implements AttestationPool {
       for (const attestation of attestations) {
         const slotNumber = attestation.payload.header.globalVariables.slotNumber;
         const proposalId = attestation.archive;
-        const address = (await attestation.getSender()).toString();
+        const address = attestation.getSender().toString();
 
         await this.attestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
 
@@ -160,7 +160,7 @@ export class KvAttestationPool implements AttestationPool {
       for (const attestation of attestations) {
         const slotNumber = attestation.payload.header.globalVariables.slotNumber;
         const proposalId = attestation.archive;
-        const address = (await attestation.getSender()).toString();
+        const address = attestation.getSender().toString();
 
         await this.attestations.delete(this.getAttestationKey(slotNumber, proposalId, address));
         await this.attestationsForProposal.deleteValue(

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -34,13 +34,13 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve([]);
   }
 
-  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
+  public addAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       // Perf: order and group by slot before insertion
       const slotNumber = attestation.payload.header.globalVariables.slotNumber;
 
       const proposalId = attestation.archive.toString();
-      const address = await attestation.getSender();
+      const address = attestation.getSender();
 
       const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
       const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
@@ -118,7 +118,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+  public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       const slotNumber = attestation.payload.header.globalVariables.slotNumber;
       const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
@@ -126,7 +126,7 @@ export class InMemoryAttestationPool implements AttestationPool {
         const proposalId = attestation.archive.toString();
         const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
         if (proposalAttestationMap) {
-          const address = await attestation.getSender();
+          const address = attestation.getSender();
           proposalAttestationMap.delete(address.toString());
           this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
         }

package/src/mem_pools/attestation_pool/mocks.ts

@@ -27,17 +27,17 @@ export const generateAccount = (): LocalAccount => {
  * @param slot The slot number the attestation is for
  * @returns A Block Attestation
  */
-export const mockAttestation = async (
+export const mockAttestation = (
   signer: Secp256k1Signer,
   slot: number = 0,
   archive: Fr = Fr.random(),
   txs: TxHash[] = [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
-): Promise<BlockAttestation> => {
+): BlockAttestation => {
   // Use arbitrary numbers for all other than slot
   const header = makeHeader(1, 2, slot);
   const payload = new ConsensusPayload(header, archive, txs);
 
-  const hash = await getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
   const signature = signer.sign(hash);
 
   return new BlockAttestation(payload, signature);

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -218,6 +218,22 @@ export class AztecKVTxPool implements TxPool {
     return undefined;
   }
 
+  async getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    const txs = await Promise.all(txHashes.map(txHash => this.#txs.getAsync(txHash.toString())));
+    return txs.map((buffer, index) => {
+      if (buffer) {
+        const tx = Tx.fromBuffer(buffer);
+        tx.setTxHash(txHashes[index]);
+        return tx;
+      }
+      return undefined;
+    });
+  }
+
+  async hasTxs(txHashes: TxHash[]): Promise<boolean[]> {
+    return await Promise.all(txHashes.map(txHash => this.#txs.hasAsync(txHash.toString())));
+  }
+
   /**
    * Checks if an archived tx exists and returns it.
    * @param txHash - The tx hash.
@@ -341,6 +357,11 @@ export class AztecKVTxPool implements TxPool {
     return vals.map(x => TxHash.fromString(x));
   }
 
+  public setMaxTxPoolSize(maxSizeBytes: number | undefined): Promise<void> {
+    this.#maxTxPoolSize = maxSizeBytes;
+    return Promise.resolve();
+  }
+
   /**
    * Creates a GasTxValidator instance.
    * @param db - DB for the validator to use

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -103,6 +103,13 @@ export class InMemoryTxPool implements TxPool {
     return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
   }
 
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return Promise.all(txHashes.map(txHash => this.getTxByHash(txHash)));
+  }
+  hasTxs(txHashes: TxHash[]): Promise<boolean[]> {
+    return Promise.resolve(txHashes.map(txHash => this.txs.has(txHash.toBigInt())));
+  }
+
   public getArchivedTxByHash(): Promise<Tx | undefined> {
     return Promise.resolve(undefined);
   }
@@ -171,4 +178,8 @@ export class InMemoryTxPool implements TxPool {
   public getAllTxHashes(): Promise<TxHash[]> {
     return Promise.resolve(Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x)));
   }
+
+  setMaxTxPoolSize(_maxSizeBytes: number | undefined): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -17,6 +17,20 @@ export interface TxPool {
    */
   getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
 
+  /**
+   * Checks if transactions exist in the pool and returns them.
+   * @param txHashes - The hashes of the transactions
+   * @returns The transactions, if found, 'undefined' otherwise.
+   */
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+
+  /**
+   * Checks if transactions exist in the pool
+   * @param txHashes - The hashes of the transactions to check for
+   * @returns True or False for each tx hash
+   */
+  hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
+
   /**
    * Checks if an archived transaction exists in the pool and returns it.
    * @param txHash - The hash of the transaction, used as an ID.
@@ -73,4 +87,10 @@ export interface TxPool {
    * @returns Pending or mined depending on its status, or undefined if not found.
    */
   getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
+
+  /**
+   * Configure the maximum size of the tx pool
+   * @param maxSizeBytes - The maximum size in bytes of the mempool. Set to undefined to disable it
+   */
+  setMaxTxPoolSize(maxSizeBytes: number | undefined): Promise<void>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -110,6 +110,49 @@ export function describeTxPool(getTxPool: () => TxPool) {
     );
   });
 
+  it('Returns txs by their hash', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const requestedTxs = await pool.getTxsByHash([await tx1.getTxHash(), await tx3.getTxHash()]);
+    expect(requestedTxs).toHaveLength(2);
+    expect(requestedTxs).toEqual(expect.arrayContaining([tx1, tx3]));
+  });
+
+  it('Returns a large number of transactions by their hash', async () => {
+    const numTxs = 1000;
+    const txs = await Promise.all(Array.from({ length: numTxs }, (_, i) => mockTx(i)));
+    const hashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    await pool.addTxs(txs);
+    const requestedTxs = await pool.getTxsByHash(hashes);
+    expect(requestedTxs).toHaveLength(numTxs);
+    expect(requestedTxs).toEqual(expect.arrayContaining(txs));
+  });
+
+  it('Returns whether or not txs exist', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const tx4 = await mockTx(4);
+    const tx5 = await mockTx(5);
+
+    const availability = await pool.hasTxs([
+      await tx1.getTxHash(),
+      await tx2.getTxHash(),
+      await tx3.getTxHash(),
+      await tx4.getTxHash(),
+      await tx5.getTxHash(),
+    ]);
+    expect(availability).toHaveLength(5);
+    expect(availability).toEqual(expect.arrayContaining([true, true, true, false, false]));
+  });
+
   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);

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -16,7 +16,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
       return PeerErrorSeverity.HighToleranceError;
     }
 
-    const attester = await message.getSender();
+    const attester = message.getSender();
     if (!(await this.epochCache.isInCommittee(attester))) {
       return PeerErrorSeverity.HighToleranceError;
     }

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -1,11 +1,14 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
 export class BlockProposalValidator implements P2PValidator<BlockProposal> {
   private epochCache: EpochCacheInterface;
+  private logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
+    this.logger = createLogger('p2p:block_proposal_validator');
   }
 
   async validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined> {
@@ -15,12 +18,18 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
     // Check that the attestation is for the current or next slot
     const slotNumberBigInt = block.payload.header.globalVariables.slotNumber.toBigInt();
     if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
+      this.logger.debug(
+        `Penalizing peer for invalid slot number ${slotNumberBigInt}, current slot: ${currentSlot}, next slot: ${nextSlot}`,
+      );
       return PeerErrorSeverity.HighToleranceError;
     }
 
     // Check that the block proposal is from the current or next proposer
-    const proposer = await block.getSender();
+    const proposer = block.getSender();
     if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
+      this.logger.debug(
+        `Penalizing peer for invalid proposer ${proposer.toString()}, current proposer: ${currentProposer.toString()}, next proposer: ${nextProposer.toString()}`,
+      );
       return PeerErrorSeverity.HighToleranceError;
     }
 

package/src/services/discv5/discV5_service.ts

@@ -34,6 +34,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
 
   private bootstrapNodePeerIds: PeerId[] = [];
   public bootstrapNodeEnrs: ENR[] = [];
+  private trustedPeerEnrs: ENR[] = [];
 
   private startTime = 0;
 
@@ -51,21 +52,33 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     configOverrides: Partial<IDiscv5CreateOptions> = {},
   ) {
     super();
-    const { p2pIp, p2pPort, bootstrapNodes } = config;
+    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));
     // 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) {
+      this.logger.warn('No p2pBroadcastPort provided, using p2pPort as broadcast port');
+      config.p2pBroadcastPort = p2pPort;
+    }
+
     const bindAddrs: any = {
       ip4: multiaddr(convertToMultiaddr(config.listenAddress, p2pPort, 'udp')),
     };
 
     if (p2pIp) {
-      const multiAddrTcp = multiaddr(`${convertToMultiaddr(p2pIp!, p2pPort, 'tcp')}/p2p/${peerId.toString()}`);
-      // if no udp announce address is provided, use the tcp announce address
-      const multiAddrUdp = multiaddr(`${convertToMultiaddr(p2pIp!, p2pPort, 'udp')}/p2p/${peerId.toString()}`);
+      const multiAddrTcp = multiaddr(
+        `${convertToMultiaddr(p2pIp!, config.p2pBroadcastPort!, 'tcp')}/p2p/${peerId.toString()}`,
+      );
+      const multiAddrUdp = multiaddr(
+        `${convertToMultiaddr(p2pIp!, config.p2pBroadcastPort!, 'udp')}/p2p/${peerId.toString()}`,
+      );
 
       // set location multiaddr in ENR record
       this.enr.setLocationMultiaddr(multiAddrUdp);
@@ -113,7 +126,8 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
 
   private onMultiaddrUpdated(m: Multiaddr) {
     // We want to update our tcp port to match the udp port
-    const multiAddrTcp = multiaddr(convertToMultiaddr(m.nodeAddress().address, this.config.p2pPort, 'tcp'));
+    // 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() });
   }
@@ -159,6 +173,18 @@ 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> {
@@ -180,7 +206,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     }
   }
 
-  public getAllPeers(): ENR[] {
+  public getKadValues(): ENR[] {
     return this.discv5.kadValues();
   }
 

package/src/services/dummy_service.ts

@@ -111,9 +111,9 @@ export class DummyPeerDiscoveryService extends EventEmitter implements PeerDisco
   }
   /**
    * Called to discover peers in the network.
-   * @returns An array of discovered peer addresses.
+   * @returns An array of Enrs.
    */
-  public getAllPeers() {
+  public getKadValues() {
     return [];
   }