@aztec/p2p 0.65.2 → 0.67.0

package/src/service/peer_manager.ts

@@ -1,8 +1,10 @@
-import { createDebugLogger } from '@aztec/foundation/log';
+import { type PeerInfo } from '@aztec/circuit-types';
+import { createLogger } from '@aztec/foundation/log';
 
 import { type ENR } from '@chainsafe/enr';
 import { type PeerId } from '@libp2p/interface';
 import { type Multiaddr } from '@multiformats/multiaddr';
+import { inspect } from 'util';
 
 import { type P2PConfig } from '../config.js';
 import { type PubSubLibp2p } from '../util.js';
@@ -22,21 +24,22 @@ type CachedPeer = {
 export class PeerManager {
   private cachedPeers: Map<string, CachedPeer> = new Map();
   private peerScoring: PeerScoring;
+  private heartbeatCounter: number = 0;
 
   constructor(
     private libP2PNode: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
     private config: P2PConfig,
-    private logger = createDebugLogger('aztec:p2p:peer_manager'),
+    private logger = createLogger('p2p:peer-manager'),
   ) {
     this.peerScoring = new PeerScoring(config);
     // Handle new established connections
     this.libP2PNode.addEventListener('peer:connect', evt => {
       const peerId = evt.detail;
       if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
-        this.logger.debug(`Connected to bootstrap peer ${peerId.toString()}`);
+        this.logger.verbose(`Connected to bootstrap peer ${peerId.toString()}`);
       } else {
-        this.logger.debug(`Connected to transaction peer ${peerId.toString()}`);
+        this.logger.verbose(`Connected to transaction peer ${peerId.toString()}`);
       }
     });
 
@@ -44,9 +47,9 @@ export class PeerManager {
     this.libP2PNode.addEventListener('peer:disconnect', evt => {
       const peerId = evt.detail;
       if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
-        this.logger.debug(`Disconnected from bootstrap peer ${peerId.toString()}`);
+        this.logger.verbose(`Disconnected from bootstrap peer ${peerId.toString()}`);
       } else {
-        this.logger.debug(`Disconnected from transaction peer ${peerId.toString()}`);
+        this.logger.verbose(`Disconnected from transaction peer ${peerId.toString()}`);
       }
     });
 
@@ -57,6 +60,7 @@ export class PeerManager {
   }
 
   public heartbeat() {
+    this.heartbeatCounter++;
     this.discover();
     this.peerScoring.decayAllScores();
   }
@@ -64,13 +68,47 @@ export class PeerManager {
   public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {
     const id = peerId.toString();
     const penaltyValue = this.peerScoring.peerPenalties[penalty];
-    this.peerScoring.updateScore(id, -penaltyValue);
+    const newScore = this.peerScoring.updateScore(id, -penaltyValue);
+    this.logger.verbose(`Penalizing peer ${id} with ${penalty} (new score is ${newScore})`);
   }
 
   public getPeerScore(peerId: string): number {
     return this.peerScoring.getScore(peerId);
   }
 
+  public getPeers(includePending = false): PeerInfo[] {
+    const connected = this.libP2PNode
+      .getPeers()
+      .map(peer => ({ id: peer.toString(), score: this.getPeerScore(peer.toString()), status: 'connected' as const }));
+
+    if (!includePending) {
+      return connected;
+    }
+
+    const dialQueue = this.libP2PNode
+      .getDialQueue()
+      .filter(peer => !!peer.peerId)
+      .map(peer => ({
+        id: peer.peerId!.toString(),
+        status: 'dialing' as const,
+        dialStatus: peer.status,
+        addresses: peer.multiaddrs.map(m => m.toString()),
+      }));
+
+    const cachedPeers = Array.from(this.cachedPeers.values())
+      .filter(peer => !dialQueue.some(dialPeer => dialPeer.id && peer.peerId.toString() === dialPeer.id.toString()))
+      .filter(peer => !connected.some(connPeer => connPeer.id.toString() === peer.peerId.toString()))
+      .map(peer => ({
+        status: 'cached' as const,
+        id: peer.peerId.toString(),
+        addresses: [peer.multiaddrTcp.toString()],
+        dialAttempts: peer.dialAttempts,
+        enr: peer.enr.encodeTxt(),
+      }));
+
+    return [...connected, ...dialQueue, ...cachedPeers];
+  }
+
   /**
    * Discovers peers.
    */
@@ -81,9 +119,13 @@ export class PeerManager {
     // Calculate how many connections we're looking to make
     const peersToConnect = this.config.maxPeerCount - connections.length;
 
-    this.logger.debug(
-      `Connections: ${connections.length}, Peers to connect: ${peersToConnect}, maxPeerCount: ${this.config.maxPeerCount}, cachedPeers: ${this.cachedPeers.size}`,
-    );
+    const logLevel = this.heartbeatCounter % 60 === 0 ? 'info' : 'debug';
+    this.logger[logLevel](`Connected to ${connections.length} peers`, {
+      connections: connections.length,
+      maxPeerCount: this.config.maxPeerCount,
+      cachedPeers: this.cachedPeers.size,
+      ...this.peerScoring.getStats(),
+    });
 
     // Exit if no peers to connect
     if (peersToConnect <= 0) {
@@ -119,7 +161,7 @@ export class PeerManager {
 
     // if we need more peers, start randomNodesQuery
     if (peersToConnect > 0) {
-      this.logger.debug('Running random nodes query');
+      this.logger.trace(`Running random nodes query to connect to ${peersToConnect} peers`);
       void this.peerDiscoveryService.runRandomNodesQuery();
     }
   }
@@ -134,23 +176,25 @@ export class PeerManager {
     // check if peer is already connected
     const [peerId, multiaddrTcp] = await Promise.all([enr.peerId(), enr.getFullMultiaddr('tcp')]);
 
-    this.logger.debug(`Handling discovered peer ${peerId.toString()}, ${multiaddrTcp?.toString()}`);
+    this.logger.trace(
+      `Handling discovered peer ${peerId.toString()} at ${multiaddrTcp?.toString() ?? 'undefined address'}`,
+    );
 
     // throw if no tcp addr in multiaddr
     if (!multiaddrTcp) {
-      this.logger.debug(`No TCP address in discovered node's multiaddr: ${enr.toString()}`);
+      this.logger.debug(`No TCP address in discovered node's multiaddr ${enr.encodeTxt()}`);
       return;
     }
     const connections = this.libP2PNode.getConnections();
     if (connections.some(conn => conn.remotePeer.equals(peerId))) {
-      this.logger.debug(`Already connected to peer ${peerId.toString()}`);
+      this.logger.trace(`Already connected to peer ${peerId.toString()}`);
       return;
     }
 
     // check if peer is already in cache
     const id = peerId.toString();
     if (this.cachedPeers.has(id)) {
-      this.logger.debug(`Already in cache ${id}`);
+      this.logger.trace(`Peer already in cache ${id}`);
       return;
     }
 
@@ -164,10 +208,9 @@ export class PeerManager {
 
     // Determine if we should dial immediately or not
     if (this.shouldDialPeer()) {
-      this.logger.debug(`Dialing peer ${id}`);
       void this.dialPeer(cachedPeer);
     } else {
-      this.logger.debug(`Caching peer ${id}`);
+      this.logger.trace(`Caching peer ${id}`);
       this.cachedPeers.set(id, cachedPeer);
       // Prune set of cached peers
       this.pruneCachedPeers();
@@ -178,15 +221,16 @@ export class PeerManager {
     const id = peer.peerId.toString();
     await this.libP2PNode.peerStore.merge(peer.peerId, { multiaddrs: [peer.multiaddrTcp] });
 
-    this.logger.debug(`Dialing peer ${id}`);
+    this.logger.trace(`Dialing peer ${id}`);
     try {
       await this.libP2PNode.dial(peer.multiaddrTcp);
-    } catch {
-      this.logger.debug(`Failed to dial peer ${id}`);
+    } catch (error) {
       peer.dialAttempts++;
       if (peer.dialAttempts < MAX_DIAL_ATTEMPTS) {
+        this.logger.trace(`Failed to dial peer ${id} (attempt ${peer.dialAttempts})`, { error: inspect(error) });
         this.cachedPeers.set(id, peer);
       } else {
+        this.logger.debug(`Failed to dial peer ${id} (dropping)`, { error: inspect(error) });
         this.cachedPeers.delete(id);
       }
     }
@@ -194,9 +238,10 @@ export class PeerManager {
 
   private shouldDialPeer(): boolean {
     const connections = this.libP2PNode.getConnections().length;
-    this.logger.debug(`Connections: ${connections}, maxPeerCount: ${this.config.maxPeerCount}`);
     if (connections >= this.config.maxPeerCount) {
-      this.logger.debug('Not dialing peer, maxPeerCount reached');
+      this.logger.trace(
+        `Not dialing peer due to max peer count of ${this.config.maxPeerCount} reached (${connections} current connections)`,
+      );
       return false;
     }
     return true;
@@ -211,6 +256,7 @@ export class PeerManager {
     // Remove the oldest peers
     for (const key of this.cachedPeers.keys()) {
       this.cachedPeers.delete(key);
+      this.logger.trace(`Pruning peer ${key} from cache`);
       peersToDelete--;
       if (peersToDelete <= 0) {
         break;

package/src/service/peer_scoring.ts

@@ -1,3 +1,5 @@
+import { median } from '@aztec/foundation/collection';
+
 import { type P2PConfig } from '../config.js';
 
 export enum PeerErrorSeverity {
@@ -43,7 +45,7 @@ export class PeerScoring {
     };
   }
 
-  updateScore(peerId: string, scoreDelta: number): void {
+  updateScore(peerId: string, scoreDelta: number): number {
     const currentTime = Date.now();
     const lastUpdate = this.lastUpdateTime.get(peerId) || currentTime;
     const timePassed = currentTime - lastUpdate;
@@ -59,6 +61,7 @@ export class PeerScoring {
 
     this.scores.set(peerId, currentScore);
     this.lastUpdateTime.set(peerId, currentTime);
+    return currentScore;
   }
 
   decayAllScores(): void {
@@ -78,4 +81,8 @@ export class PeerScoring {
   getScore(peerId: string): number {
     return this.scores.get(peerId) || 0;
   }
+
+  getStats(): { medianScore: number } {
+    return { medianScore: median(Array.from(this.scores.values())) ?? 0 };
+  }
 }

package/src/service/reqresp/handlers.ts

@@ -3,8 +3,8 @@
  * @param _msg - The ping request message.
  * @returns A resolved promise with the pong response.
  */
-export function pingHandler(_msg: any): Promise<Uint8Array> {
-  return Promise.resolve(Uint8Array.from(Buffer.from('pong')));
+export function pingHandler(_msg: any): Promise<Buffer> {
+  return Promise.resolve(Buffer.from('pong'));
 }
 
 /**
@@ -12,6 +12,6 @@ export function pingHandler(_msg: any): Promise<Uint8Array> {
  * @param _msg - The status request message.
  * @returns A resolved promise with the ok response.
  */
-export function statusHandler(_msg: any): Promise<Uint8Array> {
-  return Promise.resolve(Uint8Array.from(Buffer.from('ok')));
+export function statusHandler(_msg: any): Promise<Buffer> {
+  return Promise.resolve(Buffer.from('ok'));
 }

package/src/service/reqresp/interface.ts

@@ -16,7 +16,7 @@ export type ReqRespSubProtocol = typeof PING_PROTOCOL | typeof STATUS_PROTOCOL |
  * A handler for a sub protocol
  * The message will arrive as a buffer, and the handler must return a buffer
  */
-export type ReqRespSubProtocolHandler = (msg: Buffer) => Promise<Uint8Array>;
+export type ReqRespSubProtocolHandler = (msg: Buffer) => Promise<Buffer>;
 
 /**
  * A type mapping from supprotocol to it's rate limits
@@ -83,8 +83,8 @@ export type SubProtocolMap = {
  * Default handler for unimplemented sub protocols, this SHOULD be overwritten
  * by the service, but is provided as a fallback
  */
-const defaultHandler = (_msg: any): Promise<Uint8Array> => {
-  return Promise.resolve(Uint8Array.from(Buffer.from('unimplemented')));
+const defaultHandler = (_msg: any): Promise<Buffer> => {
+  return Promise.resolve(Buffer.from('unimplemented'));
 };
 
 /**

package/src/service/reqresp/reqresp.ts

@@ -1,10 +1,11 @@
 // @attribution: lodestar impl for inspiration
-import { type Logger, createDebugLogger } from '@aztec/foundation/log';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { executeTimeoutWithCustomError } from '@aztec/foundation/timer';
 
 import { type IncomingStreamData, type PeerId, type Stream } from '@libp2p/interface';
 import { pipe } from 'it-pipe';
 import { type Libp2p } from 'libp2p';
+import { compressSync, uncompressSync } from 'snappy';
 import { type Uint8ArrayList } from 'uint8arraylist';
 
 import { CollectiveReqRespTimeoutError, IndiviualReqRespTimeoutError } from '../../errors/reqresp.error.js';
@@ -31,6 +32,9 @@ import { RequestResponseRateLimiter } from './rate_limiter/rate_limiter.js';
  * This service implements the request response sub protocol, it is heavily inspired from
  * ethereum implementations of the same name.
  *
+ * Note, responses get compressed in streamHandler
+ *       so they get decompressed in readMessage
+ *
  * see: https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/p2p-interface.md#the-reqresp-domain
  */
 export class ReqResp {
@@ -46,7 +50,7 @@ export class ReqResp {
   private rateLimiter: RequestResponseRateLimiter;
 
   constructor(config: P2PReqRespConfig, protected readonly libp2p: Libp2p, private peerManager: PeerManager) {
-    this.logger = createDebugLogger('aztec:p2p:reqresp');
+    this.logger = createLogger('p2p:reqresp');
 
     this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
     this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
@@ -192,7 +196,7 @@ export class ReqResp {
     let stream: Stream | undefined;
     try {
       stream = await this.libp2p.dialProtocol(peerId, subProtocol);
-      this.logger.debug(`Stream opened with ${peerId.toString()} for ${subProtocol}`);
+      this.logger.trace(`Stream opened with ${peerId.toString()} for ${subProtocol}`);
 
       // Open the stream with a timeout
       const result = await executeTimeoutWithCustomError<Buffer>(
@@ -202,17 +206,17 @@ export class ReqResp {
       );
 
       await stream.close();
-      this.logger.debug(`Stream closed with ${peerId.toString()} for ${subProtocol}`);
+      this.logger.trace(`Stream closed with ${peerId.toString()} for ${subProtocol}`);
 
       return result;
     } catch (e: any) {
-      this.logger.error(`${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`);
+      this.logger.error(`Error sending request to peer`, e, { peerId: peerId.toString(), subProtocol });
       this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
     } finally {
       if (stream) {
         try {
           await stream.close();
-          this.logger.debug(`Stream closed with ${peerId.toString()} for ${subProtocol}`);
+          this.logger.trace(`Stream closed with ${peerId.toString()} for ${subProtocol}`);
         } catch (closeError) {
           this.logger.error(
             `Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`,
@@ -232,7 +236,7 @@ export class ReqResp {
       chunks.push(chunk.subarray());
     }
     const messageData = chunks.concat();
-    return Buffer.concat(messageData);
+    return uncompressSync(Buffer.concat(messageData), { asBuffer: true }) as Buffer;
   }
 
   /**
@@ -269,7 +273,8 @@ export class ReqResp {
         async function* (source: any) {
           for await (const chunkList of source) {
             const msg = Buffer.from(chunkList.subarray());
-            yield handler(msg);
+            const response = await handler(msg);
+            yield new Uint8Array(compressSync(response));
           }
         },
         stream,

package/src/service/service.ts

@@ -1,4 +1,4 @@
-import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/circuit-types';
+import type { BlockAttestation, BlockProposal, Gossipable, PeerInfo } from '@aztec/circuit-types';
 
 import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
@@ -49,6 +49,8 @@ export interface P2PService {
   registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
 
   getEnr(): ENR | undefined;
+
+  getPeers(includePending?: boolean): PeerInfo[];
 }
 
 /**

package/src/tx_validator/data_validator.ts

@@ -1,8 +1,8 @@
 import { Tx, type TxValidator } from '@aztec/circuit-types';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 
 export class DataTxValidator implements TxValidator<Tx> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_data');
+  #log = createLogger('p2p:tx_validator:tx_data');
 
   validateTxs(txs: Tx[]): Promise<[validTxs: Tx[], invalidTxs: Tx[]]> {
     const validTxs: Tx[] = [];

package/src/tx_validator/double_spend_validator.ts

@@ -1,13 +1,13 @@
 import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 
 export interface NullifierSource {
   getNullifierIndex: (nullifier: Fr) => Promise<bigint | undefined>;
 }
 
 export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_double_spend');
+  #log = createLogger('p2p:tx_validator:tx_double_spend');
   #nullifierSource: NullifierSource;
 
   constructor(nullifierSource: NullifierSource, private readonly isValidatingBlock: boolean = true) {

package/src/tx_validator/metadata_validator.ts

@@ -1,9 +1,9 @@
 import { type AnyTx, Tx, type TxValidator } from '@aztec/circuit-types';
 import { type Fr } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 
 export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:tx_metadata');
+  #log = createLogger('p2p:tx_validator:tx_metadata');
 
   constructor(private chainId: Fr, private blockNumber: Fr) {}
 

package/src/tx_validator/tx_proof_validator.ts

@@ -1,8 +1,8 @@
 import { type ClientProtocolCircuitVerifier, Tx, type TxValidator } from '@aztec/circuit-types';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 
 export class TxProofValidator implements TxValidator<Tx> {
-  #log = createDebugLogger('aztec:sequencer:tx_validator:private_proof');
+  #log = createLogger('p2p:tx_validator:private_proof');
 
   constructor(private verifier: ClientProtocolCircuitVerifier) {}
 

package/src/util.ts

@@ -1,6 +1,10 @@
+import { type AztecKVStore, type AztecSingleton } from '@aztec/kv-store';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 
 import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
+import { generateKeyPair, marshalPrivateKey, unmarshalPrivateKey } from '@libp2p/crypto/keys';
+import { type PeerId, type PrivateKey } from '@libp2p/interface';
+import { createFromPrivKey } from '@libp2p/peer-id-factory';
 import { resolve } from 'dns/promises';
 import type { Libp2p } from 'libp2p';
 
@@ -19,8 +23,7 @@ export interface PubSubLibp2p extends Libp2p {
  * const udpAddr = '[2001:db8::1]:8080' -> /ip6/2001:db8::1/udp/8080
  * @param address - The address string to convert. Has to be in the format <addr>:<port>.
  * @param protocol - The protocol to use in the multiaddr string.
- * @returns A multiaddr compliant string.
- */
+ * @returns A multiaddr compliant string.  */
 export function convertToMultiaddr(address: string, protocol: 'tcp' | 'udp'): string {
   const [addr, port] = splitAddressPort(address, false);
 
@@ -141,3 +144,46 @@ export async function configureP2PClientAddresses(
 
   return config;
 }
+
+/**
+ * Get the peer id private key
+ *
+ * 1. Check if we have a peer id private key in the config
+ * 2. If not, check we have a peer id private key persisted in the node
+ * 3. If not, create a new one, then persist it in the node
+ *
+ */
+export async function getPeerIdPrivateKey(config: { peerIdPrivateKey?: string }, store: AztecKVStore): Promise<string> {
+  const peerIdPrivateKeySingleton: AztecSingleton<string> = store.openSingleton('peerIdPrivateKey');
+  if (config.peerIdPrivateKey) {
+    await peerIdPrivateKeySingleton.set(config.peerIdPrivateKey);
+    return config.peerIdPrivateKey;
+  }
+
+  const storedPeerIdPrivateKey = peerIdPrivateKeySingleton.get();
+  if (storedPeerIdPrivateKey) {
+    return storedPeerIdPrivateKey;
+  }
+
+  const newPeerIdPrivateKey = await generateKeyPair('secp256k1');
+  const privateKeyString = Buffer.from(marshalPrivateKey(newPeerIdPrivateKey)).toString('hex');
+
+  await peerIdPrivateKeySingleton.set(privateKeyString);
+  return privateKeyString;
+}
+
+/**
+ * Create a libp2p peer ID from the private key.
+ * @param privateKey - peer ID private key as hex string
+ * @returns The peer ID.
+ */
+export async function createLibP2PPeerIdFromPrivateKey(privateKey: string): Promise<PeerId> {
+  if (!privateKey?.length) {
+    throw new Error('No peer private key provided');
+  }
+
+  const asLibp2pPrivateKey: PrivateKey<'secp256k1'> = await unmarshalPrivateKey(
+    new Uint8Array(Buffer.from(privateKey, 'hex')),
+  );
+  return await createFromPrivKey(asLibp2pPrivateKey);
+}