@aztec/p2p 0.49.2 → 0.51.0

package/dest/util.js

@@ -1,25 +1,17 @@
+import { resolve } from 'dns/promises';
 /**
  * Converts an address string to a multiaddr string.
  * Example usage:
  * const tcpAddr = '123.456.7.8:80' -> /ip4/123.456.7.8/tcp/80
  * const udpAddr = '[2001:db8::1]:8080' -> /ip6/2001:db8::1/udp/8080
- * const dnsAddr = 'example.com:443' -> /dns4/example.com/tcp/443
  * @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.
  */
 export function convertToMultiaddr(address, protocol) {
     const [addr, port] = splitAddressPort(address, false);
-    let multiaddrPrefix;
-    if (addr.includes(':')) {
-        // IPv6 address
-        multiaddrPrefix = 'ip6';
-    }
-    else if (addr.match(/^[\d.]+$/)) {
-        // IPv4 address
-        multiaddrPrefix = 'ip4';
-    }
-    else {
+    const multiaddrPrefix = addressToMultiAddressType(addr);
+    if (multiaddrPrefix === 'dns') {
         throw new Error('Invalid address format. Expected an IPv4 or IPv6 address.');
     }
     return `/${multiaddrPrefix}/${addr}/${protocol}/${port}`;
@@ -56,4 +48,31 @@ export async function getPublicIp() {
     const text = await resp.text();
     return text.trim();
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxPQUFlLEVBQUUsUUFBdUI7SUFDekUsTUFBTSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsR0FBRyxnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFFdEQsSUFBSSxlQUF1QixDQUFDO0lBRTVCLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3ZCLGVBQWU7UUFDZixlQUFlLEdBQUcsS0FBSyxDQUFDO0lBQzFCLENBQUM7U0FBTSxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQztRQUNsQyxlQUFlO1FBQ2YsZUFBZSxHQUFHLEtBQUssQ0FBQztJQUMxQixDQUFDO1NBQU0sQ0FBQztRQUNOLE1BQU0sSUFBSSxLQUFLLENBQUMsMkRBQTJELENBQUMsQ0FBQztJQUMvRSxDQUFDO0lBRUQsT0FBTyxJQUFJLGVBQWUsSUFBSSxJQUFJLElBQUksUUFBUSxJQUFJLElBQUksRUFBRSxDQUFDO0FBQzNELENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsT0FBZSxFQUFFLGlCQUEwQjtJQUMxRSxJQUFJLElBQVksQ0FBQztJQUNqQixJQUFJLElBQVksQ0FBQztJQUVqQixJQUFJLE9BQU8sQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUM1QiwyQ0FBMkM7UUFDM0MsTUFBTSxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO1FBQ3BELElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsK0JBQStCLE9BQU8sb0NBQW9DLENBQUMsQ0FBQztRQUM5RixDQUFDO1FBQ0QsQ0FBQyxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsR0FBRyxLQUFLLENBQUM7SUFDekIsQ0FBQztTQUFNLENBQUM7UUFDTixlQUFlO1FBQ2YsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNsQyxJQUFJLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDM0MsTUFBTSxJQUFJLEtBQUssQ0FBQywyQkFBMkIsT0FBTyxrQ0FBa0MsQ0FBQyxDQUFDO1FBQ3hGLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztBQUN0QixDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFdBQVc7SUFDL0IsTUFBTSxJQUFJLEdBQUcsTUFBTSxLQUFLLENBQUMsK0JBQStCLENBQUMsQ0FBQztJQUMxRCxNQUFNLElBQUksR0FBRyxNQUFNLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUMvQixPQUFPLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztBQUNyQixDQUFDIn0=
+export async function resolveAddressIfNecessary(address) {
+    const [addr, port] = splitAddressPort(address, false);
+    const multiaddrPrefix = addressToMultiAddressType(addr);
+    if (multiaddrPrefix === 'dns') {
+        const resolvedAddresses = await resolve(addr);
+        if (resolvedAddresses.length === 0) {
+            throw new Error(`Could not resolve address: ${addr}`);
+        }
+        return `${resolvedAddresses[0]}:${port}`;
+    }
+    else {
+        return address;
+    }
+}
+// Not public because it is not used outside of this file.
+// Plus, it relies on `splitAddressPort` being called on the address first.
+function addressToMultiAddressType(address) {
+    if (address.includes(':')) {
+        return 'ip6';
+    }
+    else if (address.match(/^[\d.]+$/)) {
+        return 'ip4';
+    }
+    else {
+        return 'dns';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.49.2",
+  "version": "0.51.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -56,11 +56,11 @@
     "testTimeout": 15000
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.49.2",
-    "@aztec/circuits.js": "0.49.2",
-    "@aztec/foundation": "0.49.2",
-    "@aztec/kv-store": "0.49.2",
-    "@aztec/telemetry-client": "0.49.2",
+    "@aztec/circuit-types": "0.51.0",
+    "@aztec/circuits.js": "0.51.0",
+    "@aztec/foundation": "0.51.0",
+    "@aztec/kv-store": "0.51.0",
+    "@aztec/telemetry-client": "0.51.0",
     "@chainsafe/discv5": "9.0.0",
     "@chainsafe/enr": "3.0.0",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
@@ -95,7 +95,8 @@
     "jest-mock-extended": "^3.0.4",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4",
-    "uint8arrays": "^5.0.3"
+    "uint8arrays": "^5.0.3",
+    "viem": "^2.7.15"
   },
   "files": [
     "dest",

package/src/attestation_pool/attestation_pool.ts

@@ -0,0 +1,42 @@
+import { type BlockAttestation } from '@aztec/circuit-types';
+
+/**
+ * An Attestation Pool contains attestations collected by a validator
+ *
+ * Attestations that are observed via the p2p network are stored for requests
+ * from the validator to produce a block, or to serve to other peers.
+ */
+export interface AttestationPool {
+  /**
+   * AddAttestation
+   *
+   * @param attestations - Attestations to add into the pool
+   */
+  addAttestations(attestations: BlockAttestation[]): Promise<void>;
+
+  /**
+   * DeleteAttestation
+   *
+   * @param attestations - Attestations to remove from the pool
+   */
+  deleteAttestations(attestations: BlockAttestation[]): Promise<void>;
+
+  /**
+   * Delete Attestations for slot
+   *
+   * Removes all attestations associated with a slot
+   *
+   * @param slot - The slot to delete.
+   */
+  deleteAttestationsForSlot(slot: bigint): Promise<void>;
+
+  /**
+   * Get Attestations for slot
+   *
+   * Retrieve all of the attestations observed pertaining to a given slot
+   *
+   * @param slot - The slot to query
+   * @return BlockAttestations
+   */
+  getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]>;
+}

package/src/attestation_pool/index.ts

@@ -0,0 +1,2 @@
+export * from './attestation_pool.js';
+export * from './memory_attestation_pool.js';

package/src/attestation_pool/memory_attestation_pool.ts

@@ -0,0 +1,70 @@
+import { type BlockAttestation } from '@aztec/circuit-types';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import { type AttestationPool } from './attestation_pool.js';
+
+export class InMemoryAttestationPool implements AttestationPool {
+  private attestations: Map</*slot=*/ bigint, Map</*address=*/ string, BlockAttestation>>;
+
+  constructor(private log = createDebugLogger('aztec:attestation_pool')) {
+    this.attestations = new Map();
+  }
+
+  public getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
+    const slotAttestationMap = this.attestations.get(slot);
+    if (slotAttestationMap) {
+      return Promise.resolve(Array.from(slotAttestationMap.values()));
+    } else {
+      return Promise.resolve([]);
+    }
+  }
+
+  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
+    for (const attestation of attestations) {
+      // Perf: order and group by slot before insertion
+      const slotNumber = attestation.header.globalVariables.slotNumber;
+
+      const address = await attestation.getSender();
+
+      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
+      slotAttestationMap.set(address.toString(), attestation);
+
+      this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
+    }
+  }
+
+  public deleteAttestationsForSlot(slot: bigint): Promise<void> {
+    // TODO(md): check if this will free the memory of the inner hash map
+    this.attestations.delete(slot);
+    this.log.verbose(`Removed attestation for slot ${slot}`);
+    return Promise.resolve();
+  }
+
+  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
+    for (const attestation of attestations) {
+      const slotNumber = attestation.header.globalVariables.slotNumber;
+      const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
+      if (slotAttestationMap) {
+        const address = await attestation.getSender();
+        slotAttestationMap.delete(address.toString());
+        this.log.verbose(`Deleted attestation for slot ${slotNumber} from ${address}`);
+      }
+    }
+    return Promise.resolve();
+  }
+}
+
+/**
+ * Get Slot or Default
+ *
+ * Fetch the slot mapping, if it does not exist, then create a mapping and return it
+ */
+function getSlotOrDefault(
+  map: Map<bigint, Map<string, BlockAttestation>>,
+  slot: bigint,
+): Map<string, BlockAttestation> {
+  if (!map.has(slot)) {
+    map.set(slot, new Map<string, BlockAttestation>());
+  }
+  return map.get(slot)!;
+}

package/src/attestation_pool/mocks.ts

@@ -0,0 +1,33 @@
+import { BlockAttestation, Signature } from '@aztec/circuit-types';
+import { makeHeader } from '@aztec/circuits.js/testing';
+import { Fr } from '@aztec/foundation/fields';
+
+import { type PrivateKeyAccount } from 'viem';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+
+/** Generate Account
+ *
+ * Create a random signer
+ * @returns A random viem signer
+ */
+export const generateAccount = () => {
+  const privateKey = generatePrivateKey();
+  return privateKeyToAccount(privateKey);
+};
+
+/** Mock Attestation
+ *
+ * @param signer A viem signer to create a signature
+ * @param slot The slot number the attestation is for
+ * @returns A Block Attestation
+ */
+export const mockAttestation = async (signer: PrivateKeyAccount, slot: number = 0): Promise<BlockAttestation> => {
+  // Use arbitrary numbers for all other than slot
+  const header = makeHeader(1, 2, slot);
+  const archive = Fr.random();
+  const message = archive.toString();
+  const sigString = await signer.signMessage({ message });
+
+  const signature = Signature.from0xString(sigString);
+  return new BlockAttestation(header, archive, signature);
+};

package/src/client/index.ts

@@ -1,13 +1,14 @@
 import { type L2BlockSource } from '@aztec/circuit-types';
 import { type AztecKVStore } from '@aztec/kv-store';
 
+import { type AttestationPool } from '../attestation_pool/attestation_pool.js';
 import { P2PClient } from '../client/p2p_client.js';
 import { type P2PConfig } from '../config.js';
 import { DiscV5Service } from '../service/discV5_service.js';
 import { DummyP2PService } from '../service/dummy_service.js';
 import { LibP2PService, createLibP2PPeerId } from '../service/index.js';
 import { type TxPool } from '../tx_pool/index.js';
-import { getPublicIp, splitAddressPort } from '../util.js';
+import { getPublicIp, resolveAddressIfNecessary, splitAddressPort } from '../util.js';
 
 export * from './p2p_client.js';
 
@@ -15,6 +16,7 @@ export const createP2PClient = async (
   config: P2PConfig,
   store: AztecKVStore,
   txPool: TxPool,
+  attestationsPool: AttestationPool,
   l2BlockSource: L2BlockSource,
 ) => {
   let p2pService;
@@ -27,6 +29,13 @@ export const createP2PClient = async (
       queryForIp,
     } = config;
 
+    config.tcpAnnounceAddress = configTcpAnnounceAddress
+      ? await resolveAddressIfNecessary(configTcpAnnounceAddress)
+      : undefined;
+    config.udpAnnounceAddress = configUdpAnnounceAddress
+      ? await resolveAddressIfNecessary(configUdpAnnounceAddress)
+      : undefined;
+
     // create variable for re-use if needed
     let publicIp;
 
@@ -59,9 +68,9 @@ export const createP2PClient = async (
     // Create peer discovery service
     const peerId = await createLibP2PPeerId(config.peerIdPrivateKey);
     const discoveryService = new DiscV5Service(peerId, config);
-    p2pService = await LibP2PService.new(config, discoveryService, peerId, txPool, store);
+    p2pService = await LibP2PService.new(config, discoveryService, peerId, txPool, attestationsPool, store);
   } else {
     p2pService = new DummyP2PService();
   }
-  return new P2PClient(store, l2BlockSource, txPool, p2pService, config.keepProvenTxsInPoolFor);
+  return new P2PClient(store, l2BlockSource, txPool, attestationsPool, p2pService, config.keepProvenTxsInPoolFor);
 };

package/src/client/p2p_client.ts

@@ -1,8 +1,19 @@
-import { type L2Block, L2BlockDownloader, type L2BlockSource, type Tx, type TxHash } from '@aztec/circuit-types';
+import {
+  type BlockAttestation,
+  type BlockProposal,
+  type L2Block,
+  L2BlockDownloader,
+  type L2BlockSource,
+  type Tx,
+  type TxHash,
+} from '@aztec/circuit-types';
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type AztecKVStore, type AztecSingleton } from '@aztec/kv-store';
 
+import { type ENR } from '@chainsafe/enr';
+
+import { type AttestationPool } from '../attestation_pool/attestation_pool.js';
 import { getP2PConfigEnvVars } from '../config.js';
 import type { P2PService } from '../service/service.js';
 import { type TxPool } from '../tx_pool/index.js';
@@ -35,6 +46,31 @@ export interface P2PSyncState {
  * Interface of a P2P client.
  **/
 export interface P2P {
+  /**
+   * Broadcasts a block proposal to other peers.
+   *
+   * @param proposal - the block proposal
+   */
+  broadcastProposal(proposal: BlockProposal): void;
+
+  /**
+   * Queries the Attestation pool for attestations for the given slot
+   *
+   * @param slot - the slot to query
+   * @returns BlockAttestations
+   */
+  getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]>;
+
+  /**
+   * Registers a callback from the validator client that determines how to behave when
+   * foreign block proposals are received
+   *
+   * @param handler - A function taking a received block proposal and producing an attestation
+   */
+  // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
+  // ^ This pattern is not my favorite (md)
+  registerBlockProposalHandler(handler: (block: BlockProposal) => Promise<BlockAttestation>): void;
+
   /**
    * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
    * @param tx - The transaction.
@@ -90,6 +126,11 @@ export interface P2P {
    * Returns the current status of the p2p client.
    */
   getStatus(): Promise<P2PSyncState>;
+
+  /**
+   * Returns the ENR for this node, if any.
+   */
+  getEnr(): ENR | undefined;
 }
 
 /**
@@ -130,6 +171,7 @@ export class P2PClient implements P2P {
     store: AztecKVStore,
     private l2BlockSource: L2BlockSource,
     private txPool: TxPool,
+    private attestationPool: AttestationPool,
     private p2pService: P2PService,
     private keepProvenTxsFor: number,
     private log = createDebugLogger('aztec:p2p'),
@@ -220,6 +262,20 @@ export class P2PClient implements P2P {
     this.log.info('P2P client stopped.');
   }
 
+  public broadcastProposal(proposal: BlockProposal): void {
+    return this.p2pService.propagate(proposal);
+  }
+
+  public getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
+    return Promise.resolve(this.attestationPool.getAttestationsForSlot(slot));
+  }
+
+  // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
+  // ^ This pattern is not my favorite (md)
+  public registerBlockProposalHandler(handler: (block: BlockProposal) => Promise<BlockAttestation>): void {
+    this.p2pService.registerBlockReceivedCallback(handler);
+  }
+
   /**
    * Returns all transactions in the transaction pool.
    * @returns An array of Txs.
@@ -263,7 +319,7 @@ export class P2PClient implements P2P {
       throw new Error('P2P client not ready');
     }
     await this.txPool.addTxs([tx]);
-    this.p2pService.propagateTx(tx);
+    this.p2pService.propagate(tx);
   }
 
   /**
@@ -275,6 +331,10 @@ export class P2PClient implements P2P {
     return this.txPool.getTxStatus(txHash);
   }
 
+  public getEnr(): ENR | undefined {
+    return this.p2pService.getEnr();
+  }
+
   /**
    * Deletes the 'txs' from the pool.
    * NOT used if we use sendTx as reconcileTxPool will handle this.
@@ -425,7 +485,7 @@ export class P2PClient implements P2P {
     const txs = this.txPool.getAllTxs();
     if (txs.length > 0) {
       this.log.debug(`Publishing ${txs.length} previously stored txs`);
-      await Promise.all(txs.map(tx => this.p2pService.propagateTx(tx)));
+      await Promise.all(txs.map(tx => this.p2pService.propagate(tx)));
     }
   }
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './client/index.js';
 export * from './config.js';
 export * from './tx_pool/index.js';
+export * from './attestation_pool/index.js';
 export * from './service/index.js';
 export * from './bootstrap/bootstrap.js';

package/src/service/discV5_service.ts

@@ -84,12 +84,11 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       const multiAddrTcp = await enr.getFullMultiaddr('tcp');
       const multiAddrUdp = await enr.getFullMultiaddr('udp');
       this.logger.debug(`ENR multiaddr: ${multiAddrTcp?.toString()}, ${multiAddrUdp?.toString()}`);
+      this.onDiscovered(enr);
     });
   }
 
   public async start(): Promise<void> {
-    // Do this conversion once since it involves an async function call
-    this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodes.map(enr => ENR.decodeTxt(enr).peerId()));
     if (this.currentState === PeerDiscoveryState.RUNNING) {
       throw new Error('DiscV5Service already started');
     }
@@ -102,6 +101,8 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
 
     // 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(', ')}`);
       try {
         this.bootstrapNodes.forEach(enr => {

package/src/service/dummy_service.ts

@@ -1,4 +1,4 @@
-import type { Tx, TxHash } from '@aztec/circuit-types';
+import type { BlockAttestation, BlockProposal, Gossipable, TxHash } from '@aztec/circuit-types';
 
 import type { PeerId } from '@libp2p/interface';
 import EventEmitter from 'events';
@@ -26,16 +26,25 @@ export class DummyP2PService implements P2PService {
   }
 
   /**
-   * Called to have the given transaction propagated through the P2P network.
-   * @param _ - The transaction to be propagated.
+   * Called to have the given message propagated through the P2P network.
+   * @param _ - The message to be propagated.
    */
-  public propagateTx(_: Tx) {}
+  public propagate<T extends Gossipable>(_: T) {}
 
   /**
    * Called upon receipt of settled transactions.
    * @param _ - The hashes of the settled transactions.
    */
   public settledTxs(_: TxHash[]) {}
+
+  /**
+   * Register a callback into the validator client for when a block proposal is received
+   */
+  public registerBlockReceivedCallback(_: (block: BlockProposal) => Promise<BlockAttestation>) {}
+
+  public getEnr(): undefined {
+    return undefined;
+  }
 }
 
 /**
@@ -78,4 +87,8 @@ export class DummyPeerDiscoveryService extends EventEmitter implements PeerDisco
   public getStatus(): PeerDiscoveryState {
     return this.currentState;
   }
+
+  public getEnr(): undefined {
+    return undefined;
+  }
 }

package/src/service/libp2p_service.ts

@@ -1,9 +1,18 @@
-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';
 import type { AztecKVStore } from '@aztec/kv-store';
 
+import { type ENR } from '@chainsafe/enr';
 import { type GossipsubEvents, gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
@@ -15,6 +24,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 +60,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 +153,7 @@ export class LibP2PService implements P2PService {
     peerDiscoveryService: PeerDiscoveryService,
     peerId: PeerId,
     txPool: TxPool,
+    attestationPool: AttestationPool,
     store: AztecKVStore,
   ) {
     const { tcpListenAddress, tcpAnnounceAddress, minPeerCount, maxPeerCount } = config;
@@ -184,7 +206,16 @@ export class LibP2PService implements P2PService {
       },
     });
 
-    return new LibP2PService(config, node, peerDiscoveryService, txPool);
+    return new LibP2PService(config, node, peerDiscoveryService, txPool, attestationPool);
+  }
+
+  public getEnr(): ENR | undefined {
+    return this.peerDiscoveryService.getEnr();
+  }
+
+  public registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>) {
+    this.blockReceivedCallback = callback;
+    this.logger.verbose('Block received callback registered');
   }
 
   /**
@@ -223,16 +254,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 +313,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/reqresp/handlers.ts

@@ -0,0 +1,7 @@
+export function pingHandler(_msg: any) {
+  return Uint8Array.from(Buffer.from('pong'));
+}
+
+export function statusHandler(_msg: any) {
+  return Uint8Array.from(Buffer.from('ok'));
+}

package/src/service/reqresp/index.ts

@@ -0,0 +1,4 @@
+/**
+ * Request Response protocol allows nodes to ask their peers for data
+ * that they missed via the traditional gossip protocol.
+ */

package/src/service/reqresp/interface.ts

@@ -0,0 +1,13 @@
+export enum ReqRespType {
+  Status = 'status',
+  Ping = 'ping',
+  /** Ask peers for specific transactions */
+  TxsByHash = 'txs_by_hash',
+}
+
+export const PING_PROTOCOL = '/aztec/ping/0.1.0';
+export const STATUS_PROTOCOL = '/aztec/status/0.1.0';
+
+export type SubProtocol = typeof PING_PROTOCOL | typeof STATUS_PROTOCOL;
+
+export type SubProtocolHandler = (msg: string) => Uint8Array;