@aztec/p2p 0.65.2 → 0.66.0

package/src/service/libp2p_service.ts

@@ -30,7 +30,6 @@ import { identify } from '@libp2p/identify';
 import type { PeerId } from '@libp2p/interface';
 import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
-import { createFromJSON, createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { createLibp2p } from 'libp2p';
 
@@ -44,6 +43,7 @@ import {
 } from '../tx_validator/index.js';
 import { type PubSubLibp2p, convertToMultiaddr } from '../util.js';
 import { AztecDatastore } from './data_store.js';
+import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from './encoding.js';
 import { PeerManager } from './peer_manager.js';
 import { PeerErrorSeverity } from './peer_scoring.js';
 import { pingHandler, statusHandler } from './reqresp/handlers.js';
@@ -60,22 +60,6 @@ import {
 import { ReqResp } from './reqresp/reqresp.js';
 import type { P2PService, PeerDiscoveryService } from './service.js';
 
-/**
- * Create a libp2p peer ID from the private key if provided, otherwise creates a new random ID.
- * @param privateKey - Optional peer ID private key as hex string
- * @returns The peer ID.
- */
-export async function createLibP2PPeerId(privateKey?: string): Promise<PeerId> {
-  if (!privateKey?.length) {
-    return await createSecp256k1PeerId();
-  }
-  const base64 = Buffer.from(privateKey, 'hex').toString('base64');
-  return await createFromJSON({
-    id: '',
-    privKey: base64,
-  });
-}
-
 /**
  * Lib P2P implementation of the P2PService interface.
  */
@@ -156,7 +140,7 @@ export class LibP2PService extends WithTracer implements P2PService {
     // add GossipSub listener
     this.node.services.pubsub.addEventListener('gossipsub:message', async e => {
       const { msg, propagationSource: peerId } = e.detail;
-      this.logger.debug(`Received PUBSUB message.`);
+      this.logger.trace(`Received PUBSUB message.`);
 
       await this.jobQueue.put(() => this.handleNewGossipMessage(msg, peerId));
     });
@@ -259,6 +243,10 @@ export class LibP2PService extends WithTracer implements P2PService {
           heartbeatInterval: config.gossipsubInterval,
           mcacheLength: config.gossipsubMcacheLength,
           mcacheGossip: config.gossipsubMcacheGossip,
+          msgIdFn: getMsgIdFn,
+          msgIdToStrFn: msgIdToStrFn,
+          fastMsgIdFn: fastMsgIdFn,
+          dataTransform: new SnappyTransform(),
           metricsRegister: otelMetricsAdapter,
           metricsTopicStrToLabel: metricsTopicStrToLabels(),
           scoreParams: createPeerScoreParams({
@@ -295,11 +283,11 @@ export class LibP2PService extends WithTracer implements P2PService {
      * @param msg - the tx request message
      * @returns the tx response message
      */
-    const txHandler = (msg: Buffer): Promise<Uint8Array> => {
+    const txHandler = (msg: Buffer): Promise<Buffer> => {
       const txHash = TxHash.fromBuffer(msg);
       const foundTx = mempools.txPool.getTxByHash(txHash);
-      const asUint8Array = Uint8Array.from(foundTx ? foundTx.toBuffer() : Buffer.alloc(0));
-      return Promise.resolve(asUint8Array);
+      const buf = foundTx ? foundTx.toBuffer() : Buffer.alloc(0);
+      return Promise.resolve(buf);
     };
 
     const requestResponseHandlers = {
@@ -468,7 +456,7 @@ export class LibP2PService extends WithTracer implements P2PService {
    * @param message - The message to propagate.
    */
   public propagate<T extends Gossipable>(message: T): void {
-    this.logger.debug(`[${message.p2pMessageIdentifier()}] queued`);
+    this.logger.trace(`[${message.p2pMessageIdentifier()}] queued`);
     void this.jobQueue.put(async () => {
       await this.sendToPeers(message);
     });

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

@@ -5,6 +5,7 @@ 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 {
@@ -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/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);
+}