@aztec/p2p 0.43.0 → 0.44.0

package/src/service/libp2p_service.ts

@@ -1,17 +1,16 @@
-import { type Tx, type TxHash } from '@aztec/circuit-types';
+import { type Tx } from '@aztec/circuit-types';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import type { AztecKVStore } from '@aztec/kv-store';
 
-import { ENR } from '@chainsafe/enr';
 import { type GossipsubEvents, gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { identify } from '@libp2p/identify';
-import type { PeerId, PubSub, Stream } from '@libp2p/interface';
+import type { PeerId, PubSub } from '@libp2p/interface';
 import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
-import { peerIdFromString } from '@libp2p/peer-id';
 import { createFromJSON, createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { type Libp2p, createLibp2p } from 'libp2p';
@@ -20,7 +19,6 @@ import { type P2PConfig } from '../config.js';
 import { type TxPool } from '../tx_pool/index.js';
 import { convertToMultiaddr } from '../util.js';
 import { AztecDatastore } from './data_store.js';
-import { KnownTxLookup } from './known_txs.js';
 import { PeerManager } from './peer_manager.js';
 import type { P2PService, PeerDiscoveryService } from './service.js';
 import { AztecTxMessageCreator, fromTxMessage } from './tx_messages.js';
@@ -30,7 +28,6 @@ export interface PubSubLibp2p extends Libp2p {
     pubsub: PubSub<GossipsubEvents>;
   };
 }
-
 /**
  * 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
@@ -52,16 +49,14 @@ export async function createLibP2PPeerId(privateKey?: string): Promise<PeerId> {
  */
 export class LibP2PService implements P2PService {
   private jobQueue: SerialQueue = new SerialQueue();
-  private knownTxLookup: KnownTxLookup = new KnownTxLookup();
   private messageCreator: AztecTxMessageCreator;
   private peerManager: PeerManager;
+  private discoveryRunningPromise?: RunningPromise;
   constructor(
     private config: P2PConfig,
     private node: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
-    private protocolId: string,
     private txPool: TxPool,
-    private bootstrapPeerIds: PeerId[] = [],
     private logger = createDebugLogger('aztec:libp2p_service'),
   ) {
     this.messageCreator = new AztecTxMessageCreator(config.txGossipVersion);
@@ -73,54 +68,42 @@ export class LibP2PService implements P2PService {
    * @returns An empty promise.
    */
   public async start() {
+    // Check if service is already started
     if (this.node.status === 'started') {
       throw new Error('P2P service already started');
     }
+
+    // Log listen & announce addresses
     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}`);
-    // handle discovered peers from external discovery service
-    this.peerDiscoveryService.on('peer:discovered', async (enr: ENR) => {
-      await this.addPeer(enr);
-    });
-
-    this.node.addEventListener('peer:connect', async evt => {
-      const peerId = evt.detail;
-      await this.handleNewConnection(peerId as PeerId);
-    });
-
-    this.node.addEventListener('peer:disconnect', async evt => {
-      const peerId = evt.detail;
-      if (this.isBootstrapPeer(peerId)) {
-        this.logger.info(`Disconnect from bootstrap peer ${peerId.toString()}`);
-      } else {
-        this.logger.info(`Disconnected from transaction peer ${peerId.toString()}`);
-        await this.peerManager.updateDiscoveryService();
-      }
-    });
 
+    // 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 topics by default
+    // Subscribe to standard GossipSub topics by default
     this.subscribeToTopic(this.messageCreator.getTopic());
 
-    // add gossipsub listener
+    // add GossipSub listener
     this.node.services.pubsub.addEventListener('gossipsub:message', async e => {
       const { msg } = e.detail;
       this.logger.debug(`Received PUBSUB message.`);
 
       await this.jobQueue.put(() => this.handleNewGossipMessage(msg.topic, msg.data));
     });
+
+    // Start running promise for peer discovery
+    this.discoveryRunningPromise = new RunningPromise(() => {
+      this.peerManager.discover();
+    }, this.config.p2pPeerCheckIntervalMS);
+    this.discoveryRunningPromise.start();
   }
 
   /**
@@ -130,8 +113,12 @@ export class LibP2PService implements P2PService {
   public async stop() {
     this.logger.debug('Stopping job queue...');
     await this.jobQueue.end();
+    this.logger.debug('Stopping running promise...');
+    await this.discoveryRunningPromise?.stop();
+    this.logger.debug('Stopping peer discovery service...');
+    await this.peerDiscoveryService.stop();
     this.logger.debug('Stopping LibP2P...');
-    await this.node.stop();
+    await this.stopLibP2P();
     this.logger.info('LibP2P service stopped');
   }
 
@@ -146,11 +133,14 @@ export class LibP2PService implements P2PService {
     peerDiscoveryService: PeerDiscoveryService,
     peerId: PeerId,
     txPool: TxPool,
+    store: AztecKVStore,
   ) {
-    const { tcpListenAddress, minPeerCount, maxPeerCount, transactionProtocol: protocolId } = config;
+    const { tcpListenAddress, tcpAnnounceAddress, minPeerCount, maxPeerCount } = config;
     const bindAddrTcp = convertToMultiaddr(tcpListenAddress, 'tcp');
+    // We know tcpAnnounceAddress cannot be null here because we set it or throw when setting up the service.
+    const announceAddrTcp = convertToMultiaddr(tcpAnnounceAddress!, 'tcp');
 
-    const datastore = new AztecDatastore(AztecLmdbStore.open());
+    const datastore = new AztecDatastore(store);
 
     // The autonat service seems quite problematic in that using it seems to cause a lot of attempts
     // to dial ephemeral ports. I suspect that it works better if you can get the uPNPnat service to
@@ -171,10 +161,19 @@ export class LibP2PService implements P2PService {
       peerId,
       addresses: {
         listen: [bindAddrTcp],
+        announce: [announceAddrTcp],
       },
       transports: [
         tcp({
           maxConnections: config.maxPeerCount,
+          // socket option: the maximum length of the queue of pending connections
+          // https://nodejs.org/dist/latest-v18.x/docs/api/net.html#serverlisten
+          // it's not safe if we increase this number
+          backlog: 5,
+          closeServerOnMaxConnections: {
+            closeAbove: maxPeerCount ?? Infinity,
+            listenBelow: maxPeerCount ?? Infinity,
+          },
         }),
       ],
       datastore,
@@ -200,15 +199,7 @@ export class LibP2PService implements P2PService {
       },
     });
 
-    // extract bootstrap node peer IDs
-    let bootstrapPeerIds: PeerId[] = [];
-    if (config.bootstrapNodes.length) {
-      bootstrapPeerIds = await Promise.all(
-        config.bootstrapNodes.map(bootnodeEnr => ENR.decodeTxt(bootnodeEnr).peerId()),
-      );
-    }
-
-    return new LibP2PService(config, node, peerDiscoveryService, protocolId, txPool, bootstrapPeerIds);
+    return new LibP2PService(config, node, peerDiscoveryService, txPool);
   }
 
   /**
@@ -260,71 +251,31 @@ export class LibP2PService implements P2PService {
     void this.jobQueue.put(() => Promise.resolve(this.sendTxToPeers(tx)));
   }
 
-  /**
-   * Handles the settling of a new batch of transactions.
-   * @param txHashes - The hashes of the newly settled transactions.
-   */
-  public settledTxs(txHashes: TxHash[]): void {
-    this.knownTxLookup.handleSettledTxs(txHashes.map(x => x.toString()));
-  }
-
-  private async addPeer(enr: ENR) {
-    const peerMultiAddr = await enr.getFullMultiaddr('tcp');
-    if (!peerMultiAddr) {
-      // No TCP address, can't connect
-      return;
-    }
-    const peerIdStr = peerMultiAddr.getPeerId();
-
-    if (!peerIdStr) {
-      this.logger.debug(`Peer ID not found in discovered node's multiaddr: ${peerMultiAddr}`);
-      return;
-    }
-
-    // check if peer is already known
-    const peerId = peerIdFromString(peerIdStr);
-    const hasPeer = await this.node.peerStore.has(peerId);
-
-    // add to peer store if not already known
-    if (!hasPeer) {
-      this.logger.info(`Discovered peer ${peerIdStr}. Adding to libp2p peer list`);
-      let stream: Stream | undefined;
-      try {
-        stream = await this.node.dialProtocol(peerMultiAddr, this.protocolId);
-      } catch (err) {
-        this.logger.debug(`Failed to dial peer ${peerIdStr}: ${err}`);
-      } finally {
-        if (stream) {
-          await stream.close();
-        }
-      }
-    }
-  }
-
-  private async handleNewConnection(peerId: PeerId) {
-    if (this.isBootstrapPeer(peerId)) {
-      this.logger.info(`Connected to bootstrap peer ${peerId.toString()}`);
-    } else {
-      this.logger.info(`Connected to transaction peer ${peerId.toString()}`);
-      await this.peerManager.updateDiscoveryService();
-    }
-  }
-
   private async processTxFromPeer(tx: Tx): Promise<void> {
     const txHash = tx.getTxHash();
     const txHashString = txHash.toString();
-    this.logger.debug(`Received tx ${txHashString} from external peer.`);
+    this.logger.verbose(`Received tx ${txHashString} from external peer.`);
     await this.txPool.addTxs([tx]);
   }
 
   private async sendTxToPeers(tx: Tx) {
     const { data: txData } = this.messageCreator.createTxMessage(tx);
-    this.logger.debug(`Sending tx ${tx.getTxHash().toString()} to peers`);
+    this.logger.verbose(`Sending tx ${tx.getTxHash().toString()} to peers`);
     const recipientsNum = await this.publishToTopic(this.messageCreator.getTopic(), txData);
-    this.logger.debug(`Sent tx ${tx.getTxHash().toString()} to ${recipientsNum} peers`);
+    this.logger.verbose(`Sent tx ${tx.getTxHash().toString()} to ${recipientsNum} peers`);
   }
 
-  private isBootstrapPeer(peer: PeerId) {
-    return this.bootstrapPeerIds.some(bootstrapPeer => bootstrapPeer.equals(peer));
+  // Libp2p seems to hang sometimes if new peers are initiating connections.
+  private async stopLibP2P() {
+    const TIMEOUT_MS = 5000; // 5 seconds timeout
+    const timeout = new Promise((resolve, reject) => {
+      setTimeout(() => reject(new Error('Timeout during libp2p.stop()')), TIMEOUT_MS);
+    });
+    try {
+      await Promise.race([this.node.stop(), timeout]);
+      this.logger.debug('Libp2p stopped');
+    } catch (error) {
+      this.logger.error('Error during stop or timeout:', error);
+    }
   }
 }

package/src/service/peer_manager.ts

@@ -1,26 +1,201 @@
 import { createDebugLogger } from '@aztec/foundation/log';
 
+import { type ENR } from '@chainsafe/enr';
+import { type PeerId } from '@libp2p/interface';
+import { type Multiaddr } from '@multiformats/multiaddr';
 import { type Libp2p } from 'libp2p';
 
 import { type P2PConfig } from '../config.js';
-import { type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
+import { type PeerDiscoveryService } from './service.js';
+
+const MAX_DIAL_ATTEMPTS = 3;
+const MAX_CACHED_PEERS = 100;
+
+type CachedPeer = {
+  peerId: PeerId;
+  enr: ENR;
+  multiaddrTcp: Multiaddr;
+  dialAttempts: number;
+};
 
 export class PeerManager {
+  private cachedPeers: Map<string, CachedPeer> = new Map();
   constructor(
     private libP2PNode: Libp2p,
-    private discV5Node: PeerDiscoveryService,
+    private peerDiscoveryService: PeerDiscoveryService,
     private config: P2PConfig,
     private logger = createDebugLogger('aztec:p2p:peer_manager'),
-  ) {}
-
-  async updateDiscoveryService() {
-    const peerCount = this.libP2PNode.getPeers().length;
-    if (peerCount >= this.config.maxPeerCount && this.discV5Node.getStatus() === PeerDiscoveryState.RUNNING) {
-      this.logger.debug('Max peer count reached, stopping discovery service');
-      await this.discV5Node.stop();
-    } else if (peerCount <= this.config.minPeerCount && this.discV5Node.getStatus() === PeerDiscoveryState.STOPPED) {
-      this.logger.debug('Min peer count reached, starting discovery service');
-      await this.discV5Node.start();
+  ) {
+    // 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()}`);
+      } else {
+        this.logger.debug(`Connected to transaction peer ${peerId.toString()}`);
+      }
+    });
+
+    // Handle lost connections
+    this.libP2PNode.addEventListener('peer:disconnect', evt => {
+      const peerId = evt.detail;
+      if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
+        this.logger.debug(`Disconnected from bootstrap peer ${peerId.toString()}`);
+      } else {
+        this.logger.debug(`Disconnected from transaction peer ${peerId.toString()}`);
+      }
+    });
+
+    // Handle Discovered peers
+    this.peerDiscoveryService.on('peer:discovered', async (enr: ENR) => {
+      await this.handleDiscoveredPeer(enr);
+    });
+  }
+
+  /**
+   * Discovers peers.
+   */
+  public discover() {
+    // Get current connections
+    const connections = this.libP2PNode.getConnections();
+
+    // 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}`,
+    );
+
+    // Exit if no peers to connect
+    if (peersToConnect <= 0) {
+      return;
+    }
+
+    const cachedPeersToDial: CachedPeer[] = [];
+
+    const pendingDials = new Set(
+      this.libP2PNode
+        .getDialQueue()
+        .map(pendingDial => pendingDial.peerId?.toString())
+        .filter(Boolean) as string[],
+    );
+
+    for (const [id, peerData] of this.cachedPeers.entries()) {
+      // if already dialling or connected to, remove from cache
+      if (pendingDials.has(id) || connections.some(conn => conn.remotePeer.equals(peerData.peerId))) {
+        this.cachedPeers.delete(id);
+      } else {
+        // cachedPeersToDial.set(id, enr);
+        cachedPeersToDial.push(peerData);
+      }
+    }
+
+    // reverse to dial older entries first
+    cachedPeersToDial.reverse();
+
+    for (const peer of cachedPeersToDial) {
+      this.cachedPeers.delete(peer.peerId.toString());
+      void this.dialPeer(peer);
+    }
+
+    // if we need more peers, start randomNodesQuery
+    if (peersToConnect > 0) {
+      this.logger.debug('Running random nodes query');
+      void this.peerDiscoveryService.runRandomNodesQuery();
+    }
+  }
+
+  /**
+   *  Handles a discovered peer.
+   * @param enr - The discovered peer's ENR.
+   */
+  private async handleDiscoveredPeer(enr: ENR) {
+    // TODO: Will be handling peer scoring here
+
+    // 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()}`);
+
+    // throw if no tcp addr in multiaddr
+    if (!multiaddrTcp) {
+      this.logger.debug(`No TCP address in discovered node's multiaddr: ${enr.toString()}`);
+      return;
+    }
+    const connections = this.libP2PNode.getConnections();
+    if (connections.some(conn => conn.remotePeer.equals(peerId))) {
+      this.logger.debug(`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}`);
+      return;
+    }
+
+    // create cached peer object
+    const cachedPeer: CachedPeer = {
+      peerId,
+      enr,
+      multiaddrTcp,
+      dialAttempts: 0,
+    };
+
+    // 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.cachedPeers.set(id, cachedPeer);
+      // Prune set of cached peers
+      this.pruneCachedPeers();
+    }
+  }
+
+  async dialPeer(peer: CachedPeer) {
+    const id = peer.peerId.toString();
+    await this.libP2PNode.peerStore.merge(peer.peerId, { multiaddrs: [peer.multiaddrTcp] });
+
+    this.logger.debug(`Dialing peer ${id}`);
+    try {
+      await this.libP2PNode.dial(peer.multiaddrTcp);
+    } catch {
+      this.logger.debug(`Failed to dial peer ${id}`);
+      peer.dialAttempts++;
+      if (peer.dialAttempts < MAX_DIAL_ATTEMPTS) {
+        this.cachedPeers.set(id, peer);
+      } else {
+        this.cachedPeers.delete(id);
+      }
+    }
+  }
+
+  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');
+      return false;
+    }
+    return true;
+  }
+
+  private pruneCachedPeers() {
+    let peersToDelete = this.cachedPeers.size - MAX_CACHED_PEERS;
+    if (peersToDelete <= 0) {
+      return;
+    }
+
+    // Remove the oldest peers
+    for (const key of this.cachedPeers.keys()) {
+      this.cachedPeers.delete(key);
+      peersToDelete--;
+      if (peersToDelete <= 0) {
+        break;
+      }
     }
   }
 }

package/src/service/service.ts

@@ -1,6 +1,7 @@
-import type { Tx, TxHash } from '@aztec/circuit-types';
+import type { Tx } from '@aztec/circuit-types';
 
 import type { ENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
 import type EventEmitter from 'events';
 
 export enum PeerDiscoveryState {
@@ -29,12 +30,6 @@ export interface P2PService {
    * @param tx - The transaction to be propagated.
    */
   propagateTx(tx: Tx): void;
-
-  /**
-   * Called upon receipt of settled transactions.
-   * @param txHashes - The hashes of the settled transactions.
-   */
-  settledTxs(txHashes: TxHash[]): void;
 }
 
 /**
@@ -57,6 +52,18 @@ export interface PeerDiscoveryService extends EventEmitter {
    */
   getAllPeers(): ENR[];
 
+  /**
+   * Runs findRandomNode query.
+   */
+  runRandomNodesQuery(): Promise<void>;
+
+  /**
+   * Checks if the given peer is a bootstrap peer.
+   * @param peerId - The peer ID to check.
+   * @returns True if the peer is a bootstrap peer.
+   */
+  isBootstrapPeer(peerId: PeerId): boolean;
+
   /**
    * Event emitted when a new peer is discovered.
    */

package/src/tx_pool/aztec_kv_tx_pool.ts

@@ -2,7 +2,9 @@ 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 AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import { type TelemetryClient } from '@aztec/telemetry-client';
 
+import { TxPoolInstrumentation } from './instrumentation.js';
 import { type TxPool } from './tx_pool.js';
 
 /**
@@ -18,15 +20,18 @@ export class AztecKVTxPool implements TxPool {
 
   #log: Logger;
 
+  #metrics: TxPoolInstrumentation;
+
   /**
    * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
    * @param store - A KV store.
    * @param log - A logger.
    */
-  constructor(store: AztecKVStore, log = createDebugLogger('aztec:tx_pool')) {
+  constructor(store: AztecKVStore, telemetry: TelemetryClient, log = createDebugLogger('aztec:tx_pool')) {
     this.#txs = store.openMap('txs');
     this.#store = store;
     this.#log = log;
+    this.#metrics = new TxPoolInstrumentation(telemetry, 'AztecKVTxPool');
   }
 
   /**
@@ -44,8 +49,8 @@ export class AztecKVTxPool implements TxPool {
    * @param txs - An array of txs to be added to the pool.
    * @returns Empty promise.
    */
-  public async addTxs(txs: Tx[]): Promise<void> {
-    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+  public addTxs(txs: Tx[]): Promise<void> {
+    const txHashes = txs.map(tx => tx.getTxHash());
     return this.#store.transaction(() => {
       for (const [i, tx] of txs.entries()) {
         const txHash = txHashes[i];
@@ -56,6 +61,8 @@ export class AztecKVTxPool implements TxPool {
 
         void this.#txs.set(txHash.toString(), tx.toBuffer());
       }
+
+      this.#metrics.recordTxs(txs);
     });
   }
 
@@ -69,6 +76,8 @@ export class AztecKVTxPool implements TxPool {
       for (const hash of txHashes) {
         void this.#txs.delete(hash.toString());
       }
+
+      this.#metrics.removeTxs(txHashes.length);
     });
   }
 

package/src/tx_pool/instrumentation.ts

@@ -0,0 +1,58 @@
+import { type Tx } from '@aztec/circuit-types';
+import { type Histogram, Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
+
+/**
+ * Instrumentation class for the TxPool.
+ */
+export class TxPoolInstrumentation {
+  /** The number of txs in the mempool */
+  private txInMempool: UpDownCounter;
+  /** Tracks tx size */
+  private txSize: Histogram;
+
+  constructor(telemetry: TelemetryClient, name: string) {
+    const meter = telemetry.getMeter(name);
+    this.txInMempool = meter.createUpDownCounter(Metrics.MEMPOOL_TX_COUNT, {
+      description: 'The current number of transactions in the mempool',
+    });
+
+    this.txSize = meter.createHistogram(Metrics.MEMPOOL_TX_SIZE, {
+      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,
+        ],
+      },
+    });
+  }
+
+  /**
+   * Updates the metrics with the new transactions.
+   * @param txs - The transactions to record
+   */
+  public recordTxs(txs: Tx[]) {
+    for (const tx of txs) {
+      this.txSize.record(tx.getSize());
+    }
+
+    this.txInMempool.add(txs.length);
+  }
+
+  /**
+   * Updates the metrics by removing transactions from the mempool.
+   * @param count - The number of transactions to remove from the mempool
+   */
+  public removeTxs(count = 1) {
+    if (count < 0) {
+      throw new Error('Count must be positive');
+    }
+    this.txInMempool.add(-1 * count);
+  }
+}

package/src/tx_pool/memory_tx_pool.ts

@@ -1,7 +1,9 @@
 import { Tx, TxHash } from '@aztec/circuit-types';
 import { type TxAddedToPoolStats } from '@aztec/circuit-types/stats';
 import { createDebugLogger } from '@aztec/foundation/log';
+import { type TelemetryClient } from '@aztec/telemetry-client';
 
+import { TxPoolInstrumentation } from './instrumentation.js';
 import { type TxPool } from './tx_pool.js';
 
 /**
@@ -13,12 +15,15 @@ export class InMemoryTxPool implements TxPool {
    */
   private txs: Map<bigint, Tx>;
 
+  private metrics: TxPoolInstrumentation;
+
   /**
    * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
    * @param log - A logger.
    */
-  constructor(private log = createDebugLogger('aztec:tx_pool')) {
+  constructor(telemetry: TelemetryClient, private log = createDebugLogger('aztec:tx_pool')) {
     this.txs = new Map<bigint, Tx>();
+    this.metrics = new TxPoolInstrumentation(telemetry, 'InMemoryTxPool');
   }
 
   /**
@@ -37,6 +42,7 @@ export class InMemoryTxPool implements TxPool {
    * @returns Empty promise.
    */
   public addTxs(txs: Tx[]): Promise<void> {
+    this.metrics.recordTxs(txs);
     for (const tx of txs) {
       const txHash = tx.getTxHash();
       this.log.debug(`Adding tx with id ${txHash.toString()}`, {
@@ -54,6 +60,7 @@ export class InMemoryTxPool implements TxPool {
    * @returns The number of transactions that was deleted from the pool.
    */
   public deleteTxs(txHashes: TxHash[]): Promise<void> {
+    this.metrics.removeTxs(txHashes.length);
     for (const txHash of txHashes) {
       this.txs.delete(txHash.toBigInt());
     }