@aztec/p2p 2.0.3 → 2.1.0-rc.2

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -68,7 +68,7 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    * Deletes transactions from the pool. Tx hashes that are not present are ignored.
    * @param txHashes - An array of tx hashes to be removed from the tx pool.
    */
-  deleteTxs(txHashes: TxHash[]): Promise<void>;
+  deleteTxs(txHashes: TxHash[], opts?: { permanently?: boolean }): Promise<void>;
 
   /**
    * Gets all transactions currently in the tx pool.
@@ -98,11 +98,11 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
   getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
 
   /**
-   * Returns whether the given tx hash is flagged as pending or mined.
+   * Returns whether the given tx hash is flagged as pending, mined, or deleted.
    * @param txHash - Hash of the tx to query.
-   * @returns Pending or mined depending on its status, or undefined if not found.
+   * @returns Pending, mined, or deleted depending on its status, or undefined if not found.
    */
-  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined>;
+  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
 
   /**
    * Configure the maximum size of the tx pool
@@ -118,4 +118,11 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    * @param txHashes - Hashes of the transactions to mark as non-evictible.
    */
   markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
+   * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
+   * @returns The number of transactions permanently deleted.
+   */
+  cleanupDeletedMinedTxs(blockNumber: number): Promise<number>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -54,14 +54,24 @@ export function describeTxPool(getTxPool: () => TxPool) {
     expect(txsFromEvent).toEqual(expect.arrayContaining([tx2, tx3]));
   });
 
-  it('removes txs from the pool', async () => {
-    const tx1 = await mockTx();
-
-    await pool.addTxs([tx1]);
-    await pool.deleteTxs([tx1.getTxHash()]);
+  it('permanently deletes pending txs and soft-deletes mined txs', async () => {
+    const pendingTx = await mockTx(1);
+    const minedTx = await mockTx(2);
+
+    await pool.addTxs([pendingTx, minedTx]);
+    await pool.markAsMined([minedTx.getTxHash()], minedBlockHeader);
+
+    // Delete a pending tx - should be permanently deleted
+    await pool.deleteTxs([pendingTx.getTxHash()]);
+    await expect(pool.getTxByHash(pendingTx.getTxHash())).resolves.toBeUndefined();
+    await expect(pool.getTxStatus(pendingTx.getTxHash())).resolves.toBeUndefined();
+
+    // Delete a mined tx - should be soft-deleted (still in storage)
+    await pool.deleteTxs([minedTx.getTxHash()]);
+    await expect(pool.getTxByHash(minedTx.getTxHash())).resolves.toBeDefined();
+    await expect(pool.getTxStatus(minedTx.getTxHash())).resolves.toEqual('deleted');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
 
-    await expect(pool.getTxByHash(tx1.getTxHash())).resolves.toBeFalsy();
-    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toBeUndefined();
     await expect(pool.getPendingTxCount()).resolves.toEqual(0);
   });
 
@@ -203,4 +213,101 @@ export function describeTxPool(getTxPool: () => TxPool) {
     expect(poolTxHashes).toHaveLength(4);
     expect(poolTxHashes).toEqual([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash()));
   });
+
+  describe('soft-delete', () => {
+    it('soft-deletes mined txs and keeps them in storage', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
+      await pool.addTxs(txs);
+
+      // Mark first tx as mined
+      await pool.markAsMined([txs[0].getTxHash()], minedBlockHeader);
+
+      // Verify initial state
+      await expect(pool.getPendingTxCount()).resolves.toBe(2);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeDefined();
+
+      // Delete mined tx - should be soft-deleted
+      await pool.deleteTxs([txs[0].getTxHash()]);
+
+      // Delete pending tx - should be permanently deleted
+      await pool.deleteTxs([txs[1].getTxHash()]);
+
+      // Verify mined tx still exists in storage but has 'deleted' status
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+      await expect(pool.getTxStatus(txs[0].getTxHash())).resolves.toEqual('deleted');
+
+      // Verify pending tx is permanently deleted
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxStatus(txs[1].getTxHash())).resolves.toBeUndefined();
+
+      // Verify remaining pending count
+      await expect(pool.getPendingTxCount()).resolves.toBe(1);
+
+      // Verify pending hashes don't include deleted txs
+      const pendingHashes = await pool.getPendingTxHashes();
+      expect(pendingHashes).toHaveLength(1);
+      expect(pendingHashes.map(h => h.toString())).toContain(txs[2].getTxHash().toString());
+    });
+
+    it('cleans up old deleted mined transactions', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
+      await pool.addTxs(txs);
+
+      // Mark first two as mined in block 1
+      await pool.markAsMined([txs[0].getTxHash(), txs[1].getTxHash()], minedBlockHeader);
+
+      // Soft-delete mined transactions
+      await pool.deleteTxs([txs[0].getTxHash(), txs[1].getTxHash()]);
+
+      // Clean up deleted mined txs from block 1 and earlier
+      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+
+      // Verify old transactions are permanently deleted
+      expect(deletedCount).toBe(2);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxByHash(txs[2].getTxHash())).resolves.toBeDefined();
+    });
+
+    it('does not clean up recent deleted mined transactions', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2)]);
+      await pool.addTxs(txs);
+
+      // Mark as mined in block 2
+      const laterBlockHeader = BlockHeader.empty({
+        globalVariables: GlobalVariables.empty({ blockNumber: 2, timestamp: 0n }),
+      });
+      await pool.markAsMined([txs[0].getTxHash()], laterBlockHeader);
+
+      // Soft-delete a mined transaction
+      await pool.deleteTxs([txs[0].getTxHash()]);
+
+      // Try to clean up with block 1 (before the mined block)
+      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+
+      // Verify no transactions were cleaned up
+      expect(deletedCount).toBe(0);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+    });
+
+    it('restores deleted mined tx when it is mined again', async () => {
+      const tx = await mockTx(1);
+      await pool.addTxs([tx]);
+
+      // Mark as mined
+      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
+
+      // Soft-delete it
+      await pool.deleteTxs([tx.getTxHash()]);
+      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('deleted');
+
+      // Mark as mined again (e.g., after a reorg)
+      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
+
+      // Should be back to mined status
+      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('mined');
+      await expect(pool.getTxByHash(tx.getTxHash())).resolves.toBeDefined();
+    });
+  });
 }

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -24,7 +24,7 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
     const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
 
     // Ditch this tx if it has repeated nullifiers
-    const uniqueNullifiers = new Set(nullifiers);
+    const uniqueNullifiers = new Set(nullifiers.map(n => n.toBigInt()));
     if (uniqueNullifiers.size !== nullifiers.length) {
       this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for emitting duplicate nullifiers`);
       return { result: 'invalid', reason: [TX_ERROR_DUPLICATE_NULLIFIER_IN_TX] };

package/src/services/libp2p/libp2p_service.ts

@@ -43,7 +43,6 @@ import { bootstrap } from '@libp2p/bootstrap';
 import { identify } from '@libp2p/identify';
 import { type Message, type MultiaddrConnection, type PeerId, TopicValidatorResult } from '@libp2p/interface';
 import type { ConnectionManager } from '@libp2p/interface-internal';
-import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
 import { tcp } from '@libp2p/tcp';
 import { createLibp2p } from 'libp2p';
@@ -273,7 +272,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
           // The connection attempts to the node on TCP layer are not necessarily valid Aztec peers so we want to have a bit of leeway here
           // If we hit the limit, the connection will be temporarily accepted and immediately dropped.
           // Docs: https://nodejs.org/api/net.html#servermaxconnections
-          maxConnections: Math.ceil(maxPeerCount * 1.5),
+          maxConnections: maxPeerCount * 2,
           // socket option: the maximum length of the queue of pending connections
           // https://nodejs.org/dist/latest-v22.x/docs/api/net.html#serverlisten
           // it's not safe if we increase this number
@@ -284,7 +283,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
             // In case closeAbove is reached, the server stops listening altogether
             // It's important that there is enough difference between closeAbove and listenAbove,
             // otherwise the server.listener will flap between being closed and open potentially degrading perf even more
-            closeAbove: maxPeerCount * 2,
+            closeAbove: maxPeerCount * 3,
             listenBelow: Math.floor(maxPeerCount * 0.9),
           },
         }),
@@ -294,8 +293,10 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       streamMuxers: [yamux(), mplex()],
       connectionEncryption: [noise()],
       connectionManager: {
-        minConnections: 0,
-        maxConnections: maxPeerCount,
+        minConnections: 0, // Disable libp2p peer dialing, we do it manually
+        // We set maxConnections above maxPeerCount because if we hit limit of maxPeerCount
+        // libp2p will start aggressively rejecting all new connections, preventing network discovery and crawling.
+        maxConnections: maxPeerCount * 2,
         maxParallelDials: 100,
         dialTimeout: 30_000,
         maxPeerAddrsToDial: 5,
@@ -453,10 +454,6 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     const goodbyeHandler = reqGoodbyeHandler(this.peerManager);
     const blockHandler = reqRespBlockHandler(this.archiver);
     const statusHandler = reqRespStatusHandler(this.protocolVersion, this.worldStateSynchronizer, this.logger);
-    // In case P2P client doesnt'have attestation pool,
-    // const blockTxsHandler = this.mempools.attestationPool
-    //   ? reqRespBlockTxsHandler(this.mempools.attestationPool, this.mempools.txPool)
-    //   : def;
 
     const requestResponseHandlers: Partial<ReqRespSubProtocolHandlers> = {
       [ReqRespSubProtocol.PING]: pingHandler,
@@ -811,9 +808,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private async processValidBlockProposal(block: BlockProposal, sender: PeerId) {
     const slot = block.slotNumber.toBigInt();
     const previousSlot = slot - 1n;
-    const epoch = slot / 32n;
     this.logger.verbose(
-      `Received block ${block.blockNumber} for slot ${slot} epoch ${epoch} from external peer ${sender.toString()}.`,
+      `Received block ${block.blockNumber} for slot ${slot} from external peer ${sender.toString()}.`,
       {
         p2pMessageIdentifier: await block.p2pMessageIdentifier(),
         slot: block.slotNumber.toNumber(),

package/src/services/peer-manager/peer_manager.ts

@@ -883,7 +883,7 @@ export class PeerManager implements PeerManagerInterface {
       const response = await this.reqresp.sendRequestToPeer(peerId, ReqRespSubProtocol.AUTH, authRequest.toBuffer());
       const { status } = response;
       if (status !== ReqRespStatus.SUCCESS) {
-        this.logger.debug(`Disconnecting peer ${peerId} who failed to respond auth handshake`, {
+        this.logger.verbose(`Disconnecting peer ${peerId} who failed to respond auth handshake`, {
           peerId,
           status: ReqRespStatus[status],
         });
@@ -899,7 +899,7 @@ export class PeerManager implements PeerManagerInterface {
 
       const peerStatusMessage = peerAuthResponse.status;
       if (!ourStatus.validate(peerStatusMessage)) {
-        this.logger.debug(`Disconnecting peer ${peerId} due to failed status handshake as part of auth.`, logData);
+        this.logger.verbose(`Disconnecting peer ${peerId} due to failed status handshake as part of auth.`, logData);
         this.markAuthHandshakeFailed(peerId);
         this.markPeerForDisconnect(peerId);
         return;
@@ -911,12 +911,9 @@ export class PeerManager implements PeerManagerInterface {
       const registeredValidators = await this.epochCache.getRegisteredValidators();
       const found = registeredValidators.find(v => v.toString() === sender.toString()) !== undefined;
       if (!found) {
-        this.logger.debug(
+        this.logger.verbose(
           `Disconnecting peer ${peerId} due to failed auth handshake, peer is not a registered validator.`,
-          {
-            peerId,
-            address: sender.toString(),
-          },
+          { ...logData, address: sender.toString() },
         );
         this.markAuthHandshakeFailed(peerId);
         this.markPeerForDisconnect(peerId);
@@ -926,8 +923,9 @@ export class PeerManager implements PeerManagerInterface {
       // Check to see that this validator address isn't already allocated to a different peer
       const peerForAddress = this.authenticatedValidatorAddressToPeerId.get(sender.toString());
       if (peerForAddress !== undefined && peerForAddress.toString() !== peerIdString) {
-        this.logger.debug(
+        this.logger.verbose(
           `Received auth for validator ${sender.toString()} from peer ${peerIdString}, but this validator is already authenticated to peer ${peerForAddress.toString()}`,
+          { ...logData, address: sender.toString() },
         );
         return;
       }
@@ -937,12 +935,13 @@ export class PeerManager implements PeerManagerInterface {
       this.authenticatedValidatorAddressToPeerId.set(sender.toString(), peerId);
       this.logger.info(
         `Successfully completed auth handshake with peer ${peerId}, validator address ${sender.toString()}`,
-        logData,
+        { ...logData, address: sender.toString() },
       );
     } catch (err: any) {
       //TODO: maybe hard ban these peers in the future
-      this.logger.debug(`Disconnecting peer ${peerId} due to error during auth handshake: ${err.message ?? err}`, {
+      this.logger.verbose(`Disconnecting peer ${peerId} due to error during auth handshake: ${err.message}`, {
         peerId,
+        err,
       });
       this.markAuthHandshakeFailed(peerId);
       this.markPeerForDisconnect(peerId);

package/src/services/reqresp/interface.ts

@@ -122,27 +122,6 @@ export type SubProtocolMap = {
   >;
 };
 
-/**
- * Default handler for unimplemented sub protocols, this SHOULD be overwritten
- * by the service, but is provided as a fallback
- */
-export const defaultHandler = (_msg: any): Promise<Buffer> => {
-  return Promise.resolve(Buffer.from('unimplemented'));
-};
-
-/**
- * Default sub protocol handlers - this SHOULD be overwritten by the service,
- */
-export const DEFAULT_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
-  [ReqRespSubProtocol.PING]: defaultHandler,
-  [ReqRespSubProtocol.STATUS]: defaultHandler,
-  [ReqRespSubProtocol.TX]: defaultHandler,
-  [ReqRespSubProtocol.GOODBYE]: defaultHandler,
-  [ReqRespSubProtocol.BLOCK]: defaultHandler,
-  [ReqRespSubProtocol.AUTH]: defaultHandler,
-  [ReqRespSubProtocol.BLOCK_TXS]: defaultHandler,
-};
-
 /**
  * The Request Response Pair interface defines the methods that each
  * request response pair must implement

package/src/services/reqresp/reqresp.ts

@@ -26,7 +26,6 @@ import {
 import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
 import { ConnectionSampler, RandomSampler } from './connection-sampler/connection_sampler.js';
 import {
-  DEFAULT_SUB_PROTOCOL_HANDLERS,
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
   type ReqRespInterface,
   type ReqRespResponse,
@@ -64,9 +63,8 @@ export class ReqResp implements ReqRespInterface {
   private individualRequestTimeoutMs: number = DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS;
   private dialTimeoutMs: number = DEFAULT_REQRESP_DIAL_TIMEOUT_MS;
 
-  // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
-  private subProtocolHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
-  private subProtocolValidators: ReqRespSubProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
+  private subProtocolHandlers: Partial<ReqRespSubProtocolHandlers> = {};
+  private subProtocolValidators: Partial<ReqRespSubProtocolValidators> = {};
 
   private connectionSampler: ConnectionSampler;
   private rateLimiter: RequestResponseRateLimiter;
@@ -117,11 +115,12 @@ export class ReqResp implements ReqRespInterface {
    * Start the reqresp service
    */
   async start(subProtocolHandlers: ReqRespSubProtocolHandlers, subProtocolValidators: ReqRespSubProtocolValidators) {
-    this.subProtocolHandlers = subProtocolHandlers;
-    this.subProtocolValidators = subProtocolValidators;
+    Object.assign(this.subProtocolHandlers, subProtocolHandlers);
+    Object.assign(this.subProtocolValidators, subProtocolValidators);
 
     // Register all protocol handlers
-    for (const subProtocol of Object.keys(this.subProtocolHandlers)) {
+    for (const subProtocol of Object.keys(subProtocolHandlers)) {
+      this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
       await this.libp2p.handle(
         subProtocol,
         (data: IncomingStreamData) =>
@@ -140,6 +139,7 @@ export class ReqResp implements ReqRespInterface {
   ): Promise<void> {
     this.subProtocolHandlers[subProtocol] = handler;
     this.subProtocolValidators[subProtocol] = validator;
+    this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
     await this.libp2p.handle(
       subProtocol,
       (data: IncomingStreamData) =>
@@ -209,7 +209,7 @@ export class ReqResp implements ReqRespInterface {
     maxPeers = Math.max(10, Math.ceil(requests.length / 3)),
     maxRetryAttempts = 3,
   ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
-    const responseValidator = this.subProtocolValidators[subProtocol];
+    const responseValidator = this.subProtocolValidators[subProtocol] ?? DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol];
     const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = new Array(requests.length);
     const requestBuffers = requests.map(req => req.toBuffer());
 
@@ -594,7 +594,11 @@ export class ReqResp implements ReqRespInterface {
    *
    * */
   private async processStream(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData): Promise<void> {
-    const handler = this.subProtocolHandlers[protocol]!;
+    const handler = this.subProtocolHandlers[protocol];
+    if (!handler) {
+      throw new Error(`No handler defined for reqresp subprotocol ${protocol}`);
+    }
+
     const snappy = this.snappyTransform;
     const SUCCESS = Uint8Array.of(ReqRespStatus.SUCCESS);
 

package/src/services/tx_provider.ts

@@ -45,7 +45,7 @@ export class TxProvider implements ITxProvider {
       if (tx === undefined) {
         missingTxs.push(txHashes[i]);
       } else {
-        txs.push(tx.setTxHash(txHashes[i]));
+        txs.push(tx);
       }
     }
 

package/src/testbench/p2p_client_testbench_worker.ts

@@ -54,6 +54,7 @@ function mockTxPool(): TxPool {
     hasTxs: () => Promise.resolve([]),
     updateConfig: () => {},
     markTxsAsNonEvictable: () => Promise.resolve(),
+    cleanupDeletedMinedTxs: () => Promise.resolve(0),
   };
   return Object.assign(new EventEmitter(), pool);
 }