@aztec/p2p 0.65.2 → 0.67.0

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,5 +1,5 @@
 import { type BlockAttestation } from '@aztec/circuit-types';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
@@ -10,7 +10,7 @@ export class InMemoryAttestationPool implements AttestationPool {
 
   private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
 
-  constructor(telemetry: TelemetryClient, private log = createDebugLogger('aztec:attestation_pool')) {
+  constructor(telemetry: TelemetryClient, private log = createLogger('p2p:attestation_pool')) {
     this.attestations = new Map();
     this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
   }
@@ -58,6 +58,27 @@ export class InMemoryAttestationPool implements AttestationPool {
     return total;
   }
 
+  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+    const olderThan = [];
+
+    // Entries are iterated in insertion order, so we can break as soon as we find a slot that is older than the oldestSlot.
+    // Note: this will only prune correctly if attestations are added in order of rising slot, it is important that we do not allow
+    // insertion of attestations that are old. #(https://github.com/AztecProtocol/aztec-packages/issues/10322)
+    const slots = this.attestations.keys();
+    for (const slot of slots) {
+      if (slot < oldestSlot) {
+        olderThan.push(slot);
+      } else {
+        break;
+      }
+    }
+
+    for (const oldSlot of olderThan) {
+      await this.deleteAttestationsForSlot(oldSlot);
+    }
+    return Promise.resolve();
+  }
+
   public deleteAttestationsForSlot(slot: bigint): Promise<void> {
     // We count the number of attestations we are removing
     const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);

package/src/mem_pools/instrumentation.ts

@@ -3,6 +3,7 @@ import {
   Attributes,
   type Histogram,
   LmdbMetrics,
+  type LmdbStatsCallback,
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
@@ -58,7 +59,7 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
 
   private defaultAttributes;
 
-  constructor(telemetry: TelemetryClient, name: PoolName) {
+  constructor(telemetry: TelemetryClient, name: PoolName, dbStats?: LmdbStatsCallback) {
     const meter = telemetry.getMeter(name);
     this.defaultAttributes = { [Attributes.POOL_NAME]: name };
 
@@ -71,40 +72,17 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
     this.objectSize = meter.createHistogram(metricsLabels.objectSize, {
       unit: 'By',
       description: 'The size of transactions in the mempool',
-      advice: {
-        explicitBucketBoundaries: [
-          5_000, // 5KB
-          10_000,
-          20_000,
-          50_000,
-          75_000,
-          100_000, // 100KB
-          200_000,
-        ],
-      },
     });
 
     this.dbMetrics = new LmdbMetrics(
       meter,
       {
-        name: Metrics.MEMPOOL_DB_MAP_SIZE,
-        description: 'Database map size for the Tx mempool',
-      },
-      {
-        name: Metrics.MEMPOOL_DB_USED_SIZE,
-        description: 'Database used size for the Tx mempool',
-      },
-      {
-        name: Metrics.MEMPOOL_DB_NUM_ITEMS,
-        description: 'Num items in database for the Tx mempool',
+        [Attributes.DB_DATA_TYPE]: 'tx-pool',
       },
+      dbStats,
     );
   }
 
-  public recordDBMetrics(metrics: { mappingSize: number; numItems: number; actualSize: number }) {
-    this.dbMetrics.recordDBMetrics(metrics);
-  }
-
   public recordSize(poolObject: PoolObject) {
     this.objectSize.record(poolObject.getSize());
   }

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,6 +1,6 @@
 import { Tx, TxHash } from '@aztec/circuit-types';
 import { type TxAddedToPoolStats } from '@aztec/circuit-types/stats';
-import { type Logger, createDebugLogger } from '@aztec/foundation/log';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type AztecKVStore, type AztecMap, type AztecSet } from '@aztec/kv-store';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
@@ -30,14 +30,14 @@ export class AztecKVTxPool implements TxPool {
    * @param store - A KV store.
    * @param log - A logger.
    */
-  constructor(store: AztecKVStore, telemetry: TelemetryClient, log = createDebugLogger('aztec:tx_pool')) {
+  constructor(store: AztecKVStore, telemetry: TelemetryClient, log = createLogger('p2p:tx_pool')) {
     this.#txs = store.openMap('txs');
     this.#minedTxs = store.openMap('minedTxs');
     this.#pendingTxs = store.openSet('pendingTxs');
 
     this.#store = store;
     this.#log = log;
-    this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL);
+    this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, () => store.estimateSize());
   }
 
   public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
@@ -53,8 +53,6 @@ export class AztecKVTxPool implements TxPool {
       }
       this.#metrics.recordRemovedObjects(deleted, 'pending');
       this.#metrics.recordAddedObjects(txHashes.length, 'mined');
-      const storeSizes = this.#store.estimateSize();
-      this.#metrics.recordDBMetrics(storeSizes);
     });
   }
 
@@ -127,7 +125,7 @@ export class AztecKVTxPool implements TxPool {
       let pendingCount = 0;
       for (const [i, tx] of txs.entries()) {
         const txHash = txHashes[i];
-        this.#log.info(`Adding tx with id ${txHash.toString()}`, {
+        this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
           eventName: 'tx-added-to-pool',
           ...tx.getStats(),
         } satisfies TxAddedToPoolStats);

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -1,6 +1,6 @@
 import { Tx, TxHash } from '@aztec/circuit-types';
 import { type TxAddedToPoolStats } from '@aztec/circuit-types/stats';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName } from '../instrumentation.js';
@@ -23,7 +23,7 @@ export class InMemoryTxPool implements TxPool {
    * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
    * @param log - A logger.
    */
-  constructor(telemetry: TelemetryClient, private log = createDebugLogger('aztec:tx_pool')) {
+  constructor(telemetry: TelemetryClient, private log = createLogger('p2p:tx_pool')) {
     this.txs = new Map<bigint, Tx>();
     this.minedTxs = new Map();
     this.pendingTxs = new Set();
@@ -105,7 +105,7 @@ export class InMemoryTxPool implements TxPool {
     let pending = 0;
     for (const tx of txs) {
       const txHash = tx.getTxHash();
-      this.log.debug(`Adding tx with id ${txHash.toString()}`, {
+      this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
         eventName: 'tx-added-to-pool',
         ...tx.getStats(),
       } satisfies TxAddedToPoolStats);

package/src/mocks/index.ts

@@ -5,6 +5,7 @@ import {
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
+import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
@@ -14,6 +15,7 @@ import { yamux } from '@chainsafe/libp2p-yamux';
 import { bootstrap } from '@libp2p/bootstrap';
 import { identify } from '@libp2p/identify';
 import { type PeerId } from '@libp2p/interface';
+import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import getPort from 'get-port';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
@@ -22,7 +24,7 @@ import { BootstrapNode } from '../bootstrap/bootstrap.js';
 import { type BootnodeConfig, type P2PConfig } from '../config.js';
 import { type MemPools } from '../mem_pools/interface.js';
 import { DiscV5Service } from '../service/discV5_service.js';
-import { LibP2PService, createLibP2PPeerId } from '../service/libp2p_service.js';
+import { LibP2PService } from '../service/libp2p_service.js';
 import { type PeerManager } from '../service/peer_manager.js';
 import { type P2PReqRespConfig } from '../service/reqresp/config.js';
 import { pingHandler, statusHandler } from '../service/reqresp/handlers.js';
@@ -102,7 +104,7 @@ export async function createTestLibP2PService(
   port: number = 0,
   peerId?: PeerId,
 ) {
-  peerId = peerId ?? (await createLibP2PPeerId());
+  peerId = peerId ?? (await createSecp256k1PeerId());
   const config = {
     tcpAnnounceAddress: `127.0.0.1:${port}`,
     udpAnnounceAddress: `127.0.0.1:${port}`,
@@ -146,7 +148,7 @@ export type ReqRespNode = {
 export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [PING_PROTOCOL]: pingHandler,
   [STATUS_PROTOCOL]: statusHandler,
-  [TX_REQ_PROTOCOL]: (_msg: any) => Promise.resolve(Uint8Array.from(Buffer.from('tx'))),
+  [TX_REQ_PROTOCOL]: (_msg: any) => Promise.resolve(Buffer.from('tx')),
 };
 
 // By default, all requests are valid
@@ -231,6 +233,8 @@ export function createBootstrapNodeConfig(privateKey: string, port: number): Boo
     peerIdPrivateKey: privateKey,
     minPeerCount: 10,
     maxPeerCount: 100,
+    dataDirectory: undefined,
+    dataStoreMapSizeKB: 0,
   };
 }
 
@@ -247,14 +251,16 @@ export async function createBootstrapNode(
   port: number,
   telemetry: TelemetryClient = new NoopTelemetryClient(),
 ): Promise<BootstrapNode> {
-  const peerId = await createLibP2PPeerId();
+  const peerId = await createSecp256k1PeerId();
   const config = createBootstrapNodeConfig(Buffer.from(peerId.privateKey!).toString('hex'), port);
 
   return startBootstrapNode(config, telemetry);
 }
 
 async function startBootstrapNode(config: BootnodeConfig, telemetry: TelemetryClient) {
-  const bootstrapNode = new BootstrapNode(telemetry);
+  // Open an ephemeral store that will only exist in memory
+  const store = openTmpStore(true);
+  const bootstrapNode = new BootstrapNode(store, telemetry);
   await bootstrapNode.start(config);
   return bootstrapNode;
 }

package/src/service/discV5_service.ts

@@ -1,11 +1,11 @@
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { OtelMetricsAdapter, type TelemetryClient } from '@aztec/telemetry-client';
 
 import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
 import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
-import { multiaddr } from '@multiformats/multiaddr';
+import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
 import EventEmitter from 'events';
 
 import type { P2PConfig } from '../config.js';
@@ -35,6 +35,9 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   /** This instance's ENR */
   private enr: SignableENR;
 
+  /** UDP listen addr */
+  private listenMultiAddrUdp: Multiaddr;
+
   private currentState = PeerDiscoveryState.STOPPED;
 
   private bootstrapNodes: string[];
@@ -46,7 +49,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     private peerId: PeerId,
     config: P2PConfig,
     telemetry: TelemetryClient,
-    private logger = createDebugLogger('aztec:discv5_service'),
+    private logger = createLogger('p2p:discv5_service'),
   ) {
     super();
     const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
@@ -66,7 +69,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       `${convertToMultiaddr(udpAnnounceAddress || tcpAnnounceAddress, 'udp')}/p2p/${peerId.toString()}`,
     );
 
-    const listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
+    this.listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
 
     // set location multiaddr in ENR record
     this.enr.setLocationMultiaddr(multiAddrUdp);
@@ -76,7 +79,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     this.discv5 = Discv5.create({
       enr: this.enr,
       peerId,
-      bindAddrs: { ip4: listenMultiAddrUdp },
+      bindAddrs: { ip4: this.listenMultiAddrUdp },
       config: {
         lookupTimeout: 2000,
         requestTimeout: 2000,
@@ -85,14 +88,11 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       metricsRegistry,
     });
 
-    this.logger.info(`ENR NodeId: ${this.enr.nodeId}`);
-    this.logger.info(`ENR UDP: ${multiAddrUdp.toString()}`);
-
     (this.discv5 as Discv5EventEmitter).on('discovered', (enr: ENR) => this.onDiscovered(enr));
     (this.discv5 as Discv5EventEmitter).on('enrAdded', async (enr: ENR) => {
       const multiAddrTcp = await enr.getFullMultiaddr('tcp');
       const multiAddrUdp = await enr.getFullMultiaddr('udp');
-      this.logger.debug(`ENR multiaddr: ${multiAddrTcp?.toString()}, ${multiAddrUdp?.toString()}`);
+      this.logger.debug(`Added ENR ${enr.encodeTxt()}`, { multiAddrTcp, multiAddrUdp, nodeId: enr.nodeId });
       this.onDiscovered(enr);
     });
   }
@@ -101,18 +101,23 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     if (this.currentState === PeerDiscoveryState.RUNNING) {
       throw new Error('DiscV5Service already started');
     }
-    this.logger.info('Starting DiscV5');
+    this.logger.debug('Starting DiscV5');
     await this.discv5.start();
     this.startTime = Date.now();
 
-    this.logger.info('DiscV5 started');
+    this.logger.info(`DiscV5 service started`, {
+      nodeId: this.enr.nodeId,
+      peerId: this.peerId,
+      enrUdp: await this.enr.getFullMultiaddr('udp'),
+      enrTcp: await this.enr.getFullMultiaddr('tcp'),
+    });
     this.currentState = PeerDiscoveryState.RUNNING;
 
     // Add bootnode ENR if provided
     if (this.bootstrapNodes?.length) {
       // Do this conversion once since it involves an async function call
       this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodes.map(enr => ENR.decodeTxt(enr).peerId()));
-      this.logger.info(`Adding bootstrap ENRs: ${this.bootstrapNodes.join(', ')}`);
+      this.logger.info(`Adding bootstrap nodes ENRs: ${this.bootstrapNodes.join(', ')}`);
       try {
         this.bootstrapNodes.forEach(enr => {
           this.discv5.addEnr(enr);

package/src/service/dummy_service.ts

@@ -1,4 +1,4 @@
-import type { BlockAttestation, BlockProposal, Gossipable, TxHash } from '@aztec/circuit-types';
+import type { BlockAttestation, BlockProposal, Gossipable, PeerInfo, TxHash } from '@aztec/circuit-types';
 
 import type { PeerId } from '@libp2p/interface';
 import EventEmitter from 'events';
@@ -10,6 +10,11 @@ import { type P2PService, type PeerDiscoveryService, PeerDiscoveryState } from '
  * A dummy implementation of the P2P Service.
  */
 export class DummyP2PService implements P2PService {
+  /** Returns an empty array for peers. */
+  getPeers(): PeerInfo[] {
+    return [];
+  }
+
   /**
    * Starts the dummy implementation.
    * @returns A resolved promise.

package/src/service/encoding.ts

@@ -0,0 +1,61 @@
+// Taken from lodestar: https://github.com/ChainSafe/lodestar
+import { sha256 } from '@aztec/foundation/crypto';
+
+import { type RPC } from '@chainsafe/libp2p-gossipsub/message';
+import { type DataTransform } from '@chainsafe/libp2p-gossipsub/types';
+import { type Message } from '@libp2p/interface';
+import { compressSync, uncompressSync } from 'snappy';
+import xxhashFactory from 'xxhash-wasm';
+
+// Load WASM
+const xxhash = await xxhashFactory();
+
+// Use salt to prevent msgId from being mined for collisions
+const h64Seed = BigInt(Math.floor(Math.random() * 1e9));
+
+// Shared buffer to convert msgId to string
+const sharedMsgIdBuf = Buffer.alloc(20);
+
+/**
+ * The function used to generate a gossipsub message id
+ * We use the first 8 bytes of SHA256(data) for content addressing
+ */
+export function fastMsgIdFn(rpcMsg: RPC.Message): string {
+  if (rpcMsg.data) {
+    return xxhash.h64Raw(rpcMsg.data, h64Seed).toString(16);
+  }
+  return '0000000000000000';
+}
+
+export function msgIdToStrFn(msgId: Uint8Array): string {
+  // This happens serially, no need to reallocate the buffer
+  sharedMsgIdBuf.set(msgId);
+  return `0x${sharedMsgIdBuf.toString('hex')}`;
+}
+
+/**
+ * Get the message identifier from a libp2p message
+ *
+ * Follows similarly to:
+ * https://github.com/ethereum/consensus-specs/blob/v1.1.0-alpha.7/specs/altair/p2p-interface.md#topics-and-messages
+ *
+ * @param message - The libp2p message
+ * @returns The message identifier
+ */
+export function getMsgIdFn(message: Message) {
+  const { topic } = message;
+
+  const vec = [Buffer.from(topic), message.data];
+  return sha256(Buffer.concat(vec)).subarray(0, 20);
+}
+
+export class SnappyTransform implements DataTransform {
+  inboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
+    const uncompressed = Buffer.from(uncompressSync(Buffer.from(data), { asBuffer: true }));
+    return new Uint8Array(uncompressed);
+  }
+
+  outboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
+    return new Uint8Array(compressSync(Buffer.from(data)));
+  }
+}

package/src/service/libp2p_service.ts

@@ -6,6 +6,7 @@ import {
   type Gossipable,
   type L2BlockSource,
   MerkleTreeId,
+  type PeerInfo,
   type RawGossipMessage,
   TopicType,
   TopicTypeMap,
@@ -15,7 +16,7 @@ import {
   metricsTopicStrToLabels,
 } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import type { AztecKVStore } from '@aztec/kv-store';
@@ -30,7 +31,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 +44,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 +61,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.
  */
@@ -104,7 +89,7 @@ export class LibP2PService extends WithTracer implements P2PService {
     private worldStateSynchronizer: WorldStateSynchronizer,
     private telemetry: TelemetryClient,
     private requestResponseHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS,
-    private logger = createDebugLogger('aztec:libp2p_service'),
+    private logger = createLogger('p2p:libp2p_service'),
   ) {
     super(telemetry, 'LibP2PService');
 
@@ -133,20 +118,17 @@ export class LibP2PService extends WithTracer implements P2PService {
       throw new Error('P2P service already started');
     }
 
-    // Log listen & announce addresses
+    // Get listen & announce addresses for logging
     const { tcpListenAddress, tcpAnnounceAddress } = this.config;
-    this.logger.info(`Starting P2P node on ${tcpListenAddress}`);
     if (!tcpAnnounceAddress) {
       throw new Error('Announce address not provided.');
     }
     const announceTcpMultiaddr = convertToMultiaddr(tcpAnnounceAddress, 'tcp');
-    this.logger.info(`Announcing at ${announceTcpMultiaddr}`);
 
     // Start job queue, peer discovery service and libp2p node
     this.jobQueue.start();
     await this.peerDiscoveryService.start();
     await this.node.start();
-    this.logger.info(`Started P2P client with Peer ID ${this.node.peerId.toString()}`);
 
     // Subscribe to standard GossipSub topics by default
     for (const topic in TopicType) {
@@ -156,7 +138,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));
     });
@@ -173,6 +155,11 @@ export class LibP2PService extends WithTracer implements P2PService {
       [TX_REQ_PROTOCOL]: this.validateRequestedTx.bind(this),
     };
     await this.reqresp.start(this.requestResponseHandlers, reqrespSubProtocolValidators);
+    this.logger.info(`Started P2P service`, {
+      listen: tcpListenAddress,
+      announce: announceTcpMultiaddr,
+      peerId: this.node.peerId.toString(),
+    });
   }
 
   /**
@@ -191,7 +178,6 @@ export class LibP2PService extends WithTracer implements P2PService {
     this.logger.debug('Stopping LibP2P...');
     await this.stopLibP2P();
     this.logger.info('LibP2P service stopped');
-    this.logger.debug('Stopping request response service...');
   }
 
   /**
@@ -259,6 +245,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 +285,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 = {
@@ -321,6 +311,10 @@ export class LibP2PService extends WithTracer implements P2PService {
     );
   }
 
+  public getPeers(includePending?: boolean): PeerInfo[] {
+    return this.peerManager.getPeers(includePending);
+  }
+
   /**
    * Send Request via the ReqResp service
    * The subprotocol defined will determine the request and response types
@@ -468,7 +462,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);
     });
@@ -595,10 +589,10 @@ export class LibP2PService extends WithTracer implements P2PService {
     const parent = message.constructor as typeof Gossipable;
 
     const identifier = message.p2pMessageIdentifier().toString();
-    this.logger.verbose(`[${identifier}] sending`);
+    this.logger.trace(`Sending message ${identifier}`);
 
     const recipientsNum = await this.publishToTopic(parent.p2pTopic, message.toBuffer());
-    this.logger.verbose(`[${identifier}] sent to ${recipientsNum} peers`);
+    this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`);
   }
 
   // Libp2p seems to hang sometimes if new peers are initiating connections.
@@ -609,7 +603,7 @@ export class LibP2PService extends WithTracer implements P2PService {
     });
     try {
       await Promise.race([this.node.stop(), timeout]);
-      this.logger.debug('Libp2p stopped');
+      this.logger.debug('LibP2P stopped');
     } catch (error) {
       this.logger.error('Error during stop or timeout:', error);
     }