@aztec/p2p 0.49.2 → 0.50.1

package/src/service/libp2p_service.ts

@@ -1,4 +1,12 @@
-import { type Gossipable, type RawGossipMessage, TopicType, TopicTypeMap, Tx } from '@aztec/circuit-types';
+import {
+  BlockAttestation,
+  BlockProposal,
+  type Gossipable,
+  type RawGossipMessage,
+  TopicType,
+  TopicTypeMap,
+  Tx,
+} from '@aztec/circuit-types';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -15,6 +23,7 @@ import { createFromJSON, createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { type Libp2p, createLibp2p } from 'libp2p';
 
+import { type AttestationPool } from '../attestation_pool/attestation_pool.js';
 import { type P2PConfig } from '../config.js';
 import { type TxPool } from '../tx_pool/index.js';
 import { convertToMultiaddr } from '../util.js';
@@ -50,14 +59,25 @@ export class LibP2PService implements P2PService {
   private jobQueue: SerialQueue = new SerialQueue();
   private peerManager: PeerManager;
   private discoveryRunningPromise?: RunningPromise;
+
+  private blockReceivedCallback: (block: BlockProposal) => Promise<BlockAttestation | undefined>;
+
   constructor(
     private config: P2PConfig,
     private node: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
     private txPool: TxPool,
+    private attestationPool: AttestationPool,
     private logger = createDebugLogger('aztec:libp2p_service'),
   ) {
     this.peerManager = new PeerManager(node, peerDiscoveryService, config, logger);
+
+    this.blockReceivedCallback = (block: BlockProposal): Promise<BlockAttestation | undefined> => {
+      this.logger.verbose(
+        `[WARNING] handler not yet registered: Block received callback not set. Received block ${block.p2pMessageIdentifier()} from peer.`,
+      );
+      return Promise.resolve(undefined);
+    };
   }
 
   /**
@@ -132,6 +152,7 @@ export class LibP2PService implements P2PService {
     peerDiscoveryService: PeerDiscoveryService,
     peerId: PeerId,
     txPool: TxPool,
+    attestationPool: AttestationPool,
     store: AztecKVStore,
   ) {
     const { tcpListenAddress, tcpAnnounceAddress, minPeerCount, maxPeerCount } = config;
@@ -184,7 +205,12 @@ export class LibP2PService implements P2PService {
       },
     });
 
-    return new LibP2PService(config, node, peerDiscoveryService, txPool);
+    return new LibP2PService(config, node, peerDiscoveryService, txPool, attestationPool);
+  }
+
+  public registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>) {
+    this.blockReceivedCallback = callback;
+    this.logger.verbose('Block received callback registered');
   }
 
   /**
@@ -223,16 +249,52 @@ export class LibP2PService implements P2PService {
       const tx = Tx.fromBuffer(Buffer.from(message.data));
       await this.processTxFromPeer(tx);
     }
+    if (message.topic === BlockAttestation.p2pTopic) {
+      const attestation = BlockAttestation.fromBuffer(Buffer.from(message.data));
+      await this.processAttestationFromPeer(attestation);
+    }
+    if (message.topic == BlockProposal.p2pTopic) {
+      const block = BlockProposal.fromBuffer(Buffer.from(message.data));
+      await this.processBlockFromPeer(block);
+    }
 
     return;
   }
 
+  /**Process Attestation From Peer
+   * When a proposal is received from a peer, we add it to the attestation pool, so it can be accessed by other services.
+   *
+   * @param attestation - The attestation to process.
+   */
+  private async processAttestationFromPeer(attestation: BlockAttestation): Promise<void> {
+    this.logger.verbose(`Received attestation ${attestation.p2pMessageIdentifier()} from external peer.`);
+    await this.attestationPool.addAttestations([attestation]);
+  }
+
+  /**Process block from peer
+   *
+   * Pass the received block to the validator client
+   *
+   * @param block - The block to process.
+   */
+  // REVIEW: callback pattern https://github.com/AztecProtocol/aztec-packages/issues/7963
+  private async processBlockFromPeer(block: BlockProposal): Promise<void> {
+    this.logger.verbose(`Received block ${block.p2pMessageIdentifier()} from external peer.`);
+    const attestation = await this.blockReceivedCallback(block);
+
+    // TODO: fix up this pattern - the abstraction is not nice
+    // The attestation can be undefined if no handler is registered / the validator deems the block invalid
+    if (attestation != undefined) {
+      this.propagate(attestation);
+    }
+  }
+
   /**
-   * Propagates the provided transaction to peers.
-   * @param tx - The transaction to propagate.
+   * Propagates provided message to peers.
+   * @param message - The message to propagate.
    */
-  public propagateTx(tx: Tx): void {
-    void this.jobQueue.put(() => Promise.resolve(this.sendToPeers(tx)));
+  public propagate<T extends Gossipable>(message: T): void {
+    void this.jobQueue.put(() => Promise.resolve(this.sendToPeers(message)));
   }
 
   private async processTxFromPeer(tx: Tx): Promise<void> {
@@ -246,7 +308,7 @@ export class LibP2PService implements P2PService {
     const parent = message.constructor as typeof Gossipable;
 
     const identifier = message.p2pMessageIdentifier().toString();
-    this.logger.verbose(`Sending tx ${identifier} to peers`);
+    this.logger.verbose(`Sending message ${identifier} to peers`);
 
     const recipientsNum = await this.publishToTopic(parent.p2pTopic, message.toBuffer());
     this.logger.verbose(`Sent tx ${identifier} to ${recipientsNum} peers`);

package/src/service/service.ts

@@ -1,4 +1,4 @@
-import type { Tx } from '@aztec/circuit-types';
+import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/circuit-types';
 
 import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
@@ -27,9 +27,12 @@ export interface P2PService {
 
   /**
    * Called to have the given transaction propagated through the P2P network.
-   * @param tx - The transaction to be propagated.
+   * @param message - The message to be propagated.
    */
-  propagateTx(tx: Tx): void;
+  propagate<T extends Gossipable>(message: T): void;
+
+  // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
+  registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation>): void;
 }
 
 /**