@aztec/p2p 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/services/libp2p/libp2p_service.js

@@ -1,11 +1,18 @@
-import { __esDecorate, __runInitializers } from "tslib";
-import { BlockAttestation, BlockProposal, MerkleTreeId, P2PClientType, PeerErrorSeverity, TopicTypeMap, Tx, getTopicTypeForClientType, metricsTopicStrToLabels, } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
-import { createLogger } from '@aztec/foundation/log';
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Fr } from '@aztec/foundation/fields';
+import { createLibp2pComponentLogger, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { BlockAttestation, BlockProposal, P2PClientType, PeerErrorSeverity, TopicTypeMap, getTopicTypeForClientType, metricsTopicStrToLabels } from '@aztec/stdlib/p2p';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { Tx } from '@aztec/stdlib/tx';
 import { Attributes, OtelMetricsAdapter, WithTracer, trackSpan } from '@aztec/telemetry-client';
-import { gossipsub, } from '@chainsafe/libp2p-gossipsub';
+import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { createPeerScoreParams, createTopicScoreParams } from '@chainsafe/libp2p-gossipsub/score';
 import { SignaturePolicy } from '@chainsafe/libp2p-gossipsub/types';
 import { noise } from '@chainsafe/libp2p-noise';
@@ -18,689 +25,691 @@ import { mplex } from '@libp2p/mplex';
 import { tcp } from '@libp2p/tcp';
 import { createLibp2p } from 'libp2p';
 import { AttestationValidator, BlockProposalValidator } from '../../msg_validators/index.js';
-import { DataTxValidator, DoubleSpendTxValidator, MetadataTxValidator, TxProofValidator, } from '../../msg_validators/tx_validator/index.js';
+import { DataTxValidator, DoubleSpendTxValidator, MetadataTxValidator, TxProofValidator } from '../../msg_validators/tx_validator/index.js';
+import { GossipSubEvent } from '../../types/index.js';
 import { convertToMultiaddr } from '../../util.js';
 import { AztecDatastore } from '../data_store.js';
 import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from '../encoding.js';
+import { gossipScoreThresholds } from '../gossipsub/scoring.js';
 import { PeerManager } from '../peer-manager/peer_manager.js';
 import { PeerScoring } from '../peer-manager/peer_scoring.js';
 import { DEFAULT_SUB_PROTOCOL_VALIDATORS, ReqRespSubProtocol } from '../reqresp/interface.js';
 import { reqGoodbyeHandler } from '../reqresp/protocols/goodbye.js';
 import { pingHandler, reqRespBlockHandler, reqRespTxHandler, statusHandler } from '../reqresp/protocols/index.js';
 import { ReqResp } from '../reqresp/reqresp.js';
-import { GossipSubEvent } from '../types.js';
-import { createLibp2pComponentLogger } from './libp2p_logger.js';
 /**
  * Lib P2P implementation of the P2PService interface.
- */
-let LibP2PService = (() => {
-    var _a;
-    let _classSuper = WithTracer;
-    let _instanceExtraInitializers = [];
-    let _processAttestationFromPeer_decorators;
-    let _processBlockFromPeer_decorators;
-    let _broadcastAttestation_decorators;
-    let _validateRequestedTx_decorators;
-    let _validatePropagatedTx_decorators;
-    let _validateAttestation_decorators;
-    let _validateBlockProposal_decorators;
-    return _a = class LibP2PService extends _classSuper {
-            constructor(clientType, config, node, peerDiscoveryService, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger = createLogger('p2p:libp2p_service')) {
-                super(telemetry, 'LibP2PService');
-                this.clientType = (__runInitializers(this, _instanceExtraInitializers), clientType);
-                this.config = config;
-                this.node = node;
-                this.peerDiscoveryService = peerDiscoveryService;
-                this.mempools = mempools;
-                this.l2BlockSource = l2BlockSource;
-                this.proofVerifier = proofVerifier;
-                this.worldStateSynchronizer = worldStateSynchronizer;
-                this.logger = logger;
-                this.jobQueue = new SerialQueue();
-                const peerScoring = new PeerScoring(config);
-                this.reqresp = new ReqResp(config, node, peerScoring);
-                this.peerManager = new PeerManager(node, peerDiscoveryService, config, telemetry, createLogger(`${logger.module}:peer_manager`), peerScoring, this.reqresp);
-                // Update gossipsub score params
-                this.node.services.pubsub.score.params.appSpecificScore = (peerId) => {
-                    return this.peerManager.getPeerScore(peerId);
-                };
-                this.node.services.pubsub.score.params.appSpecificWeight = 10;
-                this.attestationValidator = new AttestationValidator(epochCache);
-                this.blockProposalValidator = new BlockProposalValidator(epochCache);
-                this.blockReceivedCallback = async (block) => {
-                    this.logger.warn(`Handler not yet registered: Block received callback not set. Received block for slot ${block.slotNumber.toNumber()} from peer.`, { p2pMessageIdentifier: await block.p2pMessageIdentifier() });
-                    return undefined;
-                };
-            }
-            /**
-             * Creates an instance of the LibP2P service.
-             * @param config - The configuration to use when creating the service.
-             * @param txPool - The transaction pool to be accessed by the service.
-             * @returns The new service.
-             */
-            static async new(clientType, config, peerDiscoveryService, peerId, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, store, telemetry, logger = createLogger('p2p:libp2p_service')) {
-                const { tcpListenAddress, tcpAnnounceAddress, 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(store);
-                const otelMetricsAdapter = new OtelMetricsAdapter(telemetry);
-                // If bootstrap nodes are provided, also provide them to the p2p service
-                const peerDiscovery = [];
-                if (peerDiscoveryService.bootstrapNodes.length > 0) {
-                    peerDiscovery.push(bootstrap({ list: peerDiscoveryService.bootstrapNodes }));
-                }
-                const node = await createLibp2p({
-                    start: false,
-                    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,
-                    peerDiscovery,
-                    streamMuxers: [mplex(), yamux()],
-                    connectionEncryption: [noise()],
-                    connectionManager: {
-                        minConnections: 0,
-                        maxConnections: maxPeerCount,
-                        maxParallelDials: 100,
-                        maxPeerAddrsToDial: 5,
-                        maxIncomingPendingConnections: 5,
-                    },
-                    services: {
-                        identify: identify({
-                            protocolPrefix: 'aztec',
-                        }),
-                        pubsub: gossipsub({
-                            debugName: 'gossipsub',
-                            globalSignaturePolicy: SignaturePolicy.StrictNoSign,
-                            allowPublishToZeroTopicPeers: true,
-                            floodPublish: config.gossipsubFloodPublish,
-                            D: config.gossipsubD,
-                            Dlo: config.gossipsubDlo,
-                            Dhi: config.gossipsubDhi,
-                            Dlazy: config.gossipsubDLazy,
-                            heartbeatInterval: config.gossipsubInterval,
-                            mcacheLength: config.gossipsubMcacheLength,
-                            mcacheGossip: config.gossipsubMcacheGossip,
-                            // Increased from default 3s to give time for input lag: configuration and rationale from lodestar
-                            gossipsubIWantFollowupMs: 12 * 1000,
-                            msgIdFn: getMsgIdFn,
-                            msgIdToStrFn: msgIdToStrFn,
-                            fastMsgIdFn: fastMsgIdFn,
-                            dataTransform: new SnappyTransform(),
-                            metricsRegister: otelMetricsAdapter,
-                            metricsTopicStrToLabel: metricsTopicStrToLabels(),
-                            asyncValidation: true,
-                            scoreParams: createPeerScoreParams({
-                                // IPColocation factor can be disabled for local testing - default to -5
-                                IPColocationFactorWeight: config.debugDisableColocationPenalty ? 0 : -5.0,
-                                topics: {
-                                    [Tx.p2pTopic]: createTopicScoreParams({
-                                        topicWeight: 1,
-                                        invalidMessageDeliveriesWeight: -20,
-                                        invalidMessageDeliveriesDecay: 0.5,
-                                    }),
-                                    [BlockAttestation.p2pTopic]: createTopicScoreParams({
-                                        topicWeight: 1,
-                                        invalidMessageDeliveriesWeight: -20,
-                                        invalidMessageDeliveriesDecay: 0.5,
-                                    }),
-                                    [BlockAttestation.p2pTopic]: createTopicScoreParams({
-                                        topicWeight: 1,
-                                        invalidMessageDeliveriesWeight: -20,
-                                        invalidMessageDeliveriesDecay: 0.5,
-                                    }),
-                                },
-                            }),
-                        }),
-                        components: (components) => ({
-                            connectionManager: components.connectionManager,
-                        }),
-                    },
-                    // Fix the peer id in libp2p logs so we can see the source of the log
-                    logger: createLibp2pComponentLogger(logger.module, { sourcePeerId: peerId }),
-                });
-                return new _a(clientType, config, node, peerDiscoveryService, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger);
-            }
-            /**
-             * Starts the LibP2P service.
-             * @returns An empty promise.
-             */
-            async start() {
-                // Check if service is already started
-                if (this.node.status === 'started') {
-                    throw new Error('P2P service already started');
-                }
-                // Get listen & announce addresses for logging
-                const { tcpListenAddress, tcpAnnounceAddress } = this.config;
-                if (!tcpAnnounceAddress) {
-                    throw new Error('Announce address not provided.');
-                }
-                const announceTcpMultiaddr = convertToMultiaddr(tcpAnnounceAddress, 'tcp');
-                // Start job queue, peer discovery service and libp2p node
-                this.jobQueue.start();
-                await this.peerDiscoveryService.start();
-                await this.node.start();
-                // Subscribe to standard GossipSub topics by default
-                for (const topic of getTopicTypeForClientType(this.clientType)) {
-                    this.subscribeToTopic(TopicTypeMap[topic].p2pTopic);
-                }
-                // Create request response protocol handlers
-                const txHandler = reqRespTxHandler(this.mempools);
-                const goodbyeHandler = reqGoodbyeHandler(this.peerManager);
-                const blockHandler = reqRespBlockHandler(this.l2BlockSource);
-                const requestResponseHandlers = {
-                    [ReqRespSubProtocol.PING]: pingHandler,
-                    [ReqRespSubProtocol.STATUS]: statusHandler,
-                    [ReqRespSubProtocol.TX]: txHandler.bind(this),
-                    [ReqRespSubProtocol.GOODBYE]: goodbyeHandler.bind(this),
-                    [ReqRespSubProtocol.BLOCK]: blockHandler.bind(this),
-                };
-                // Add p2p topic validators
-                // As they are stored within a kv pair, there is no need to register them conditionally
-                // based on the client type
-                const topicValidators = {
-                    [Tx.p2pTopic]: this.validatePropagatedTxFromMessage.bind(this),
-                    [BlockAttestation.p2pTopic]: this.validatePropagatedAttestationFromMessage.bind(this),
-                    [BlockProposal.p2pTopic]: this.validatePropagatedBlockFromMessage.bind(this),
-                };
-                // When running bandwidth benchmarks, we use send blobs of data we do not want to validate
-                // NEVER switch this off in production
-                if (!this.config.debugDisableMessageValidation) {
-                    for (const [topic, validator] of Object.entries(topicValidators)) {
-                        this.node.services.pubsub.topicValidators.set(topic, validator);
+ */ export class LibP2PService extends WithTracer {
+    clientType;
+    config;
+    node;
+    peerDiscoveryService;
+    mempools;
+    l2BlockSource;
+    proofVerifier;
+    worldStateSynchronizer;
+    logger;
+    jobQueue;
+    peerManager;
+    discoveryRunningPromise;
+    // Message validators
+    attestationValidator;
+    blockProposalValidator;
+    // Request and response sub service
+    reqresp;
+    /**
+   * Callback for when a block is received from a peer.
+   * @param block - The block received from the peer.
+   * @returns The attestation for the block, if any.
+   */ blockReceivedCallback;
+    constructor(clientType, config, node, peerDiscoveryService, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger = createLogger('p2p:libp2p_service')){
+        super(telemetry, 'LibP2PService'), this.clientType = clientType, this.config = config, this.node = node, this.peerDiscoveryService = peerDiscoveryService, this.mempools = mempools, this.l2BlockSource = l2BlockSource, this.proofVerifier = proofVerifier, this.worldStateSynchronizer = worldStateSynchronizer, this.logger = logger, this.jobQueue = new SerialQueue();
+        const peerScoring = new PeerScoring(config);
+        this.reqresp = new ReqResp(config, node, peerScoring);
+        this.peerManager = new PeerManager(node, peerDiscoveryService, config, telemetry, createLogger(`${logger.module}:peer_manager`), peerScoring, this.reqresp);
+        // Update gossipsub score params
+        this.node.services.pubsub.score.params.appSpecificScore = (peerId)=>{
+            return this.peerManager.getPeerScore(peerId);
+        };
+        this.node.services.pubsub.score.params.appSpecificWeight = 10;
+        this.attestationValidator = new AttestationValidator(epochCache);
+        this.blockProposalValidator = new BlockProposalValidator(epochCache);
+        this.blockReceivedCallback = async (block)=>{
+            this.logger.warn(`Handler not yet registered: Block received callback not set. Received block for slot ${block.slotNumber.toNumber()} from peer.`, {
+                p2pMessageIdentifier: await block.p2pMessageIdentifier()
+            });
+            return undefined;
+        };
+    }
+    /**
+   * Creates an instance of the LibP2P service.
+   * @param config - The configuration to use when creating the service.
+   * @param txPool - The transaction pool to be accessed by the service.
+   * @returns The new service.
+   */ static async new(clientType, config, peerDiscoveryService, peerId, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, store, telemetry, logger = createLogger('p2p:libp2p_service')) {
+        const { tcpListenAddress, tcpAnnounceAddress, 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(store);
+        const otelMetricsAdapter = new OtelMetricsAdapter(telemetry);
+        // If bootstrap nodes are provided, also provide them to the p2p service
+        const peerDiscovery = [];
+        if (peerDiscoveryService.bootstrapNodes.length > 0) {
+            peerDiscovery.push(bootstrap({
+                list: peerDiscoveryService.bootstrapNodes
+            }));
+        }
+        const node = await createLibp2p({
+            start: false,
+            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
                     }
-                }
-                else {
-                    this.logger.warn('MESSAGE VALIDATION DISABLED - IF YOU SEE THIS LOG AND ARE NOT DEBUGGING AND ARE RUNNING IN A PRODUCTION ENVIRONMENT, PLEASE RE-ENABLE MESSAGE VALIDATION');
-                }
-                // add GossipSub listener
-                this.node.services.pubsub.addEventListener(GossipSubEvent.MESSAGE, this.handleGossipSubEvent.bind(this));
-                // Start running promise for peer discovery
-                this.discoveryRunningPromise = new RunningPromise(() => this.peerManager.heartbeat(), this.logger, this.config.peerCheckIntervalMS);
-                this.discoveryRunningPromise.start();
-                // Define the sub protocol validators - This is done within this start() method to gain a callback to the existing validateTx function
-                const reqrespSubProtocolValidators = {
-                    ...DEFAULT_SUB_PROTOCOL_VALIDATORS,
-                    // TODO(#11336): A request validator for blocks
-                    [ReqRespSubProtocol.TX]: this.validateRequestedTx.bind(this),
-                };
-                await this.reqresp.start(requestResponseHandlers, reqrespSubProtocolValidators);
-                this.logger.info(`Started P2P service`, {
-                    listen: tcpListenAddress,
-                    announce: announceTcpMultiaddr,
-                    peerId: this.node.peerId.toString(),
-                });
-            }
-            /**
-             * Stops the LibP2P service.
-             * @returns An empty promise.
-             */
-            async stop() {
-                // Remove gossip sub listener
-                this.node.services.pubsub.removeEventListener(GossipSubEvent.MESSAGE, this.handleGossipSubEvent.bind(this));
-                // Stop peer manager
-                this.logger.debug('Stopping peer manager...');
-                await this.peerManager.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('Request response service stopped...');
-                await this.reqresp.stop();
-                this.logger.debug('Stopping LibP2P...');
-                await this.stopLibP2P();
-                this.logger.info('LibP2P service stopped');
-            }
-            getPeers(includePending) {
-                return this.peerManager.getPeers(includePending);
-            }
-            handleGossipSubEvent(e) {
-                const { msg } = e.detail;
-                this.logger.trace(`Received PUBSUB message.`);
-                void this.jobQueue
-                    .put(() => this.handleNewGossipMessage(msg))
-                    .catch(err => this.logger.error(`Error processing gossip message`, err));
-            }
-            /**
-             * Send Request via the ReqResp service
-             * The subprotocol defined will determine the request and response types
-             *
-             * See the subProtocolMap for the mapping of subprotocols to request/response types in `interface.ts`
-             *
-             * @param protocol The request response protocol to use
-             * @param request The request type to send
-             * @returns
-             */
-            sendRequest(protocol, request) {
-                return this.reqresp.sendRequest(protocol, request);
-            }
-            /**
-             * Send a batch of requests to peers, and return the responses
-             * @param protocol - The request response protocol to use
-             * @param requests - The requests to send to the peers
-             * @returns The responses to the requests
-             */
-            sendBatchRequest(protocol, requests) {
-                return this.reqresp.sendBatchRequest(protocol, requests);
-            }
-            /**
-             * Get the ENR of the node
-             * @returns The ENR of the node
-             */
-            getEnr() {
-                return this.peerDiscoveryService.getEnr();
-            }
-            registerBlockReceivedCallback(callback) {
-                this.blockReceivedCallback = callback;
-                this.logger.verbose('Block received callback registered');
-            }
-            /**
-             * Subscribes to a topic.
-             * @param topic - The topic to subscribe to.
-             */
-            subscribeToTopic(topic) {
-                if (!this.node.services.pubsub) {
-                    throw new Error('Pubsub service not available.');
-                }
-                void this.node.services.pubsub.subscribe(topic);
-            }
-            /**
-             * Publishes data to a topic.
-             * @param topic - The topic to publish to.
-             * @param data - The data to publish.
-             * @returns The number of recipients the data was sent to.
-             */
-            async publishToTopic(topic, data) {
-                if (!this.node.services.pubsub) {
-                    throw new Error('Pubsub service not available.');
-                }
-                const result = await this.node.services.pubsub.publish(topic, data);
-                return result.recipients.length;
-            }
-            /**
-             * Handles a new gossip message that was received by the client.
-             * @param topic - The message's topic.
-             * @param data - The message data
-             */
-            async handleNewGossipMessage(message) {
-                if (message.topic === Tx.p2pTopic) {
-                    const tx = Tx.fromBuffer(Buffer.from(message.data));
-                    await this.processTxFromPeer(tx);
-                }
-                if (message.topic === BlockAttestation.p2pTopic && this.clientType === P2PClientType.Full) {
-                    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.
-             */
-            async processAttestationFromPeer(attestation) {
-                this.logger.debug(`Received attestation for block ${attestation.blockNumber.toNumber()} slot ${attestation.slotNumber.toNumber()} from external peer.`, {
-                    p2pMessageIdentifier: await attestation.p2pMessageIdentifier(),
-                    slot: attestation.slotNumber.toNumber(),
-                    archive: attestation.archive.toString(),
-                    block: attestation.blockNumber.toNumber(),
-                });
-                await this.mempools.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
-            async processBlockFromPeer(block) {
-                this.logger.verbose(`Received block ${block.blockNumber.toNumber()} for slot ${block.slotNumber.toNumber()} from external peer.`, {
-                    p2pMessageIdentifier: await block.p2pMessageIdentifier(),
-                    slot: block.slotNumber.toNumber(),
-                    archive: block.archive.toString(),
-                    block: block.blockNumber.toNumber(),
-                });
-                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.logger.verbose(`Broadcasting attestation for block ${attestation.blockNumber.toNumber()} slot ${attestation.slotNumber.toNumber()}`, {
-                        p2pMessageIdentifier: await attestation.p2pMessageIdentifier(),
-                        slot: attestation.slotNumber.toNumber(),
-                        archive: attestation.archive.toString(),
-                        block: attestation.blockNumber.toNumber(),
-                    });
-                    await this.broadcastAttestation(attestation);
-                }
-            }
-            /**
-             * Broadcast an attestation to all peers.
-             * @param attestation - The attestation to broadcast.
-             */
-            async broadcastAttestation(attestation) {
-                await this.propagate(attestation);
-            }
-            /**
-             * Propagates provided message to peers.
-             * @param message - The message to propagate.
-             */
-            async propagate(message) {
-                const p2pMessageIdentifier = await message.p2pMessageIdentifier();
-                this.logger.trace(`Message ${p2pMessageIdentifier} queued`, { p2pMessageIdentifier });
-                void this.jobQueue.put(async () => {
-                    await this.sendToPeers(message);
-                });
-            }
-            async processTxFromPeer(tx) {
-                const txHash = await tx.getTxHash();
-                const txHashString = txHash.toString();
-                this.logger.verbose(`Received tx ${txHashString} from external peer.`);
-                await this.mempools.txPool.addTxs([tx]);
+                })
+            ],
+            datastore,
+            peerDiscovery,
+            streamMuxers: [
+                mplex(),
+                yamux()
+            ],
+            connectionEncryption: [
+                noise()
+            ],
+            connectionManager: {
+                minConnections: 0,
+                maxParallelDials: 100,
+                dialTimeout: 30_000,
+                maxPeerAddrsToDial: 5,
+                maxIncomingPendingConnections: 5
+            },
+            services: {
+                identify: identify({
+                    protocolPrefix: 'aztec'
+                }),
+                pubsub: gossipsub({
+                    debugName: 'gossipsub',
+                    globalSignaturePolicy: SignaturePolicy.StrictNoSign,
+                    allowPublishToZeroTopicPeers: true,
+                    floodPublish: config.gossipsubFloodPublish,
+                    D: config.gossipsubD,
+                    Dlo: config.gossipsubDlo,
+                    Dhi: config.gossipsubDhi,
+                    Dlazy: config.gossipsubDLazy,
+                    heartbeatInterval: config.gossipsubInterval,
+                    mcacheLength: config.gossipsubMcacheLength,
+                    mcacheGossip: config.gossipsubMcacheGossip,
+                    msgIdFn: getMsgIdFn,
+                    msgIdToStrFn: msgIdToStrFn,
+                    fastMsgIdFn: fastMsgIdFn,
+                    dataTransform: new SnappyTransform(),
+                    metricsRegister: otelMetricsAdapter,
+                    metricsTopicStrToLabel: metricsTopicStrToLabels(),
+                    asyncValidation: true,
+                    scoreThresholds: gossipScoreThresholds,
+                    scoreParams: createPeerScoreParams({
+                        // IPColocation factor can be disabled for local testing - default to -5
+                        IPColocationFactorWeight: config.debugDisableColocationPenalty ? 0 : -5.0,
+                        topics: {
+                            [Tx.p2pTopic]: createTopicScoreParams({
+                                topicWeight: 1,
+                                invalidMessageDeliveriesWeight: -20,
+                                invalidMessageDeliveriesDecay: 0.5
+                            }),
+                            [BlockAttestation.p2pTopic]: createTopicScoreParams({
+                                topicWeight: 1,
+                                invalidMessageDeliveriesWeight: -20,
+                                invalidMessageDeliveriesDecay: 0.5
+                            }),
+                            [BlockProposal.p2pTopic]: createTopicScoreParams({
+                                topicWeight: 1,
+                                invalidMessageDeliveriesWeight: -20,
+                                invalidMessageDeliveriesDecay: 0.5
+                            })
+                        }
+                    })
+                }),
+                components: (components)=>({
+                        connectionManager: components.connectionManager
+                    })
+            },
+            logger: createLibp2pComponentLogger(logger.module)
+        });
+        return new LibP2PService(clientType, config, node, peerDiscoveryService, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger);
+    }
+    /**
+   * Starts the LibP2P service.
+   * @returns An empty promise.
+   */ async start() {
+        // Check if service is already started
+        if (this.node.status === 'started') {
+            throw new Error('P2P service already started');
+        }
+        // Get listen & announce addresses for logging
+        const { tcpListenAddress, tcpAnnounceAddress } = this.config;
+        if (!tcpAnnounceAddress) {
+            throw new Error('Announce address not provided.');
+        }
+        const announceTcpMultiaddr = convertToMultiaddr(tcpAnnounceAddress, 'tcp');
+        // Start job queue, peer discovery service and libp2p node
+        this.jobQueue.start();
+        await this.peerDiscoveryService.start();
+        await this.node.start();
+        // Subscribe to standard GossipSub topics by default
+        for (const topic of getTopicTypeForClientType(this.clientType)){
+            this.subscribeToTopic(TopicTypeMap[topic].p2pTopic);
+        }
+        // Create request response protocol handlers
+        const txHandler = reqRespTxHandler(this.mempools);
+        const goodbyeHandler = reqGoodbyeHandler(this.peerManager);
+        const blockHandler = reqRespBlockHandler(this.l2BlockSource);
+        const requestResponseHandlers = {
+            [ReqRespSubProtocol.PING]: pingHandler,
+            [ReqRespSubProtocol.STATUS]: statusHandler,
+            [ReqRespSubProtocol.TX]: txHandler.bind(this),
+            [ReqRespSubProtocol.GOODBYE]: goodbyeHandler.bind(this),
+            [ReqRespSubProtocol.BLOCK]: blockHandler.bind(this)
+        };
+        // add GossipSub listener
+        this.node.services.pubsub.addEventListener(GossipSubEvent.MESSAGE, this.handleGossipSubEvent.bind(this));
+        // Start running promise for peer discovery
+        this.discoveryRunningPromise = new RunningPromise(()=>this.peerManager.heartbeat(), this.logger, this.config.peerCheckIntervalMS);
+        this.discoveryRunningPromise.start();
+        // Define the sub protocol validators - This is done within this start() method to gain a callback to the existing validateTx function
+        const reqrespSubProtocolValidators = {
+            ...DEFAULT_SUB_PROTOCOL_VALIDATORS,
+            // TODO(#11336): A request validator for blocks
+            [ReqRespSubProtocol.TX]: this.validateRequestedTx.bind(this)
+        };
+        await this.reqresp.start(requestResponseHandlers, reqrespSubProtocolValidators);
+        this.logger.info(`Started P2P service`, {
+            listen: tcpListenAddress,
+            announce: announceTcpMultiaddr,
+            peerId: this.node.peerId.toString()
+        });
+    }
+    /**
+   * Stops the LibP2P service.
+   * @returns An empty promise.
+   */ async stop() {
+        // Remove gossip sub listener
+        this.node.services.pubsub.removeEventListener(GossipSubEvent.MESSAGE, this.handleGossipSubEvent.bind(this));
+        // Stop peer manager
+        this.logger.debug('Stopping peer manager...');
+        await this.peerManager.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('Request response service stopped...');
+        await this.reqresp.stop();
+        this.logger.debug('Stopping LibP2P...');
+        await this.stopLibP2P();
+        this.logger.info('LibP2P service stopped');
+    }
+    getPeers(includePending) {
+        return this.peerManager.getPeers(includePending);
+    }
+    handleGossipSubEvent(e) {
+        this.logger.trace(`Received PUBSUB message.`);
+        const safeJob = async ()=>{
+            try {
+                await this.handleNewGossipMessage(e.detail.msg, e.detail.msgId, e.detail.propagationSource);
+            } catch (err) {
+                this.logger.error(`Error handling gossipsub message: ${err}`);
             }
-            /**
-             * Validate a tx that has been requested from a peer.
-             *
-             * The core component of this validator is that the tx hash MUST match the requested tx hash,
-             * In order to perform this check, the tx proof must be verified.
-             *
-             * Note: This function is called from within `ReqResp.sendRequest` as part of the
-             * ReqRespSubProtocol.TX subprotocol validation.
-             *
-             * @param requestedTxHash - The hash of the tx that was requested.
-             * @param responseTx - The tx that was received as a response to the request.
-             * @param peerId - The peer ID of the peer that sent the tx.
-             * @returns True if the tx is valid, false otherwise.
-             */
-            async validateRequestedTx(requestedTxHash, responseTx, peerId) {
-                const proofValidator = new TxProofValidator(this.proofVerifier);
-                const validProof = await proofValidator.validateTx(responseTx);
-                // If the node returns the wrong data, we penalize it
-                if (!requestedTxHash.equals(await responseTx.getTxHash())) {
-                    // Returning the wrong data is a low tolerance error
-                    this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
-                    return false;
-                }
-                if (validProof.result === 'invalid') {
-                    // If the proof is invalid, but the txHash is correct, then this is an active attack and we severly punish
-                    this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
-                    return false;
-                }
+        };
+        setImmediate(()=>void safeJob());
+    }
+    /**
+   * Send Request via the ReqResp service
+   * The subprotocol defined will determine the request and response types
+   *
+   * See the subProtocolMap for the mapping of subprotocols to request/response types in `interface.ts`
+   *
+   * @param protocol The request response protocol to use
+   * @param request The request type to send
+   * @returns
+   */ sendRequest(protocol, request) {
+        return this.reqresp.sendRequest(protocol, request);
+    }
+    /**
+   * Send a batch of requests to peers, and return the responses
+   * @param protocol - The request response protocol to use
+   * @param requests - The requests to send to the peers
+   * @returns The responses to the requests
+   */ sendBatchRequest(protocol, requests) {
+        return this.reqresp.sendBatchRequest(protocol, requests);
+    }
+    /**
+   * Get the ENR of the node
+   * @returns The ENR of the node
+   */ getEnr() {
+        return this.peerDiscoveryService.getEnr();
+    }
+    registerBlockReceivedCallback(callback) {
+        this.blockReceivedCallback = callback;
+        this.logger.verbose('Block received callback registered');
+    }
+    /**
+   * Subscribes to a topic.
+   * @param topic - The topic to subscribe to.
+   */ subscribeToTopic(topic) {
+        if (!this.node.services.pubsub) {
+            throw new Error('Pubsub service not available.');
+        }
+        void this.node.services.pubsub.subscribe(topic);
+    }
+    /**
+   * Publishes data to a topic.
+   * @param topic - The topic to publish to.
+   * @param data - The data to publish.
+   * @returns The number of recipients the data was sent to.
+   */ async publishToTopic(topic, data) {
+        if (!this.node.services.pubsub) {
+            throw new Error('Pubsub service not available.');
+        }
+        const result = await this.node.services.pubsub.publish(topic, data);
+        return result.recipients.length;
+    }
+    /**
+   * Handles a new gossip message that was received by the client.
+   * @param topic - The message's topic.
+   * @param data - The message data
+   */ async handleNewGossipMessage(msg, msgId, source) {
+        if (msg.topic === Tx.p2pTopic) {
+            await this.handleGossipedTx(msg, msgId, source);
+        }
+        if (msg.topic === BlockAttestation.p2pTopic && this.clientType === P2PClientType.Full) {
+            await this.processAttestationFromPeer(msg, msgId, source);
+        }
+        if (msg.topic == BlockProposal.p2pTopic) {
+            await this.processBlockFromPeer(msg, msgId, source);
+        }
+        return;
+    }
+    async validateReceivedMessage(validationFunc, msgId, source) {
+        let resultAndObj = {
+            result: false,
+            obj: undefined
+        };
+        try {
+            resultAndObj = await validationFunc();
+        } catch (err) {
+            this.logger.error(`Error deserialising and validating message `, err);
+        }
+        this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), resultAndObj.result && resultAndObj.obj ? TopicValidatorResult.Accept : TopicValidatorResult.Reject);
+        return resultAndObj;
+    }
+    async handleGossipedTx(msg, msgId, source) {
+        const validationFunc = async ()=>{
+            const tx = Tx.fromBuffer(Buffer.from(msg.data));
+            const result = await this.validatePropagatedTx(tx, source);
+            return {
+                result,
+                obj: tx
+            };
+        };
+        const { result, obj: tx } = await this.validateReceivedMessage(validationFunc, msgId, source);
+        if (!result || !tx) {
+            return;
+        }
+        const txHash = await tx.getTxHash();
+        const txHashString = txHash.toString();
+        this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
+        await this.mempools.txPool.addTxs([
+            tx
+        ]);
+    }
+    /**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.
+   */ async processAttestationFromPeer(msg, msgId, source) {
+        const validationFunc = async ()=>{
+            const attestation = BlockAttestation.fromBuffer(Buffer.from(msg.data));
+            const result = await this.validateAttestation(source, attestation);
+            this.logger.trace(`validatePropagatedAttestation: ${result}`, {
+                [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
+                [Attributes.P2P_ID]: source.toString()
+            });
+            return {
+                result,
+                obj: attestation
+            };
+        };
+        const { result, obj: attestation } = await this.validateReceivedMessage(validationFunc, msgId, source);
+        if (!result || !attestation) {
+            return;
+        }
+        this.logger.debug(`Received attestation for block ${attestation.blockNumber.toNumber()} slot ${attestation.slotNumber.toNumber()} from external peer.`, {
+            p2pMessageIdentifier: await attestation.p2pMessageIdentifier(),
+            slot: attestation.slotNumber.toNumber(),
+            archive: attestation.archive.toString(),
+            block: attestation.blockNumber.toNumber()
+        });
+        await this.mempools.attestationPool.addAttestations([
+            attestation
+        ]);
+    }
+    async processBlockFromPeer(msg, msgId, source) {
+        const validationFunc = async ()=>{
+            const block = BlockProposal.fromBuffer(Buffer.from(msg.data));
+            const result = await this.validateBlockProposal(source, block);
+            this.logger.trace(`validatePropagatedBlock: ${result}`, {
+                [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
+                [Attributes.P2P_ID]: source.toString()
+            });
+            return {
+                result,
+                obj: block
+            };
+        };
+        const { result, obj: block } = await this.validateReceivedMessage(validationFunc, msgId, source);
+        if (!result || !block) {
+            return;
+        }
+        await this.processValidBlockProposal(block);
+    }
+    // REVIEW: callback pattern https://github.com/AztecProtocol/aztec-packages/issues/7963
+    async processValidBlockProposal(block) {
+        this.logger.verbose(`Received block ${block.blockNumber.toNumber()} for slot ${block.slotNumber.toNumber()} from external peer.`, {
+            p2pMessageIdentifier: await block.p2pMessageIdentifier(),
+            slot: block.slotNumber.toNumber(),
+            archive: block.archive.toString(),
+            block: block.blockNumber.toNumber()
+        });
+        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.logger.verbose(`Broadcasting attestation for block ${attestation.blockNumber.toNumber()} slot ${attestation.slotNumber.toNumber()}`, {
+                p2pMessageIdentifier: await attestation.p2pMessageIdentifier(),
+                slot: attestation.slotNumber.toNumber(),
+                archive: attestation.archive.toString(),
+                block: attestation.blockNumber.toNumber()
+            });
+            await this.broadcastAttestation(attestation);
+        }
+    }
+    /**
+   * Broadcast an attestation to all peers.
+   * @param attestation - The attestation to broadcast.
+   */ async broadcastAttestation(attestation) {
+        await this.propagate(attestation);
+    }
+    /**
+   * Propagates provided message to peers.
+   * @param message - The message to propagate.
+   */ async propagate(message) {
+        const p2pMessageIdentifier = await message.p2pMessageIdentifier();
+        this.logger.trace(`Message ${p2pMessageIdentifier} queued`, {
+            p2pMessageIdentifier
+        });
+        void this.jobQueue.put(async ()=>{
+            await this.sendToPeers(message);
+        }).catch((error)=>{
+            this.logger.error(`Error propagating message ${p2pMessageIdentifier}`, {
+                error
+            });
+        });
+    }
+    /**
+   * Validate a tx that has been requested from a peer.
+   *
+   * The core component of this validator is that the tx hash MUST match the requested tx hash,
+   * In order to perform this check, the tx proof must be verified.
+   *
+   * Note: This function is called from within `ReqResp.sendRequest` as part of the
+   * ReqRespSubProtocol.TX subprotocol validation.
+   *
+   * @param requestedTxHash - The hash of the tx that was requested.
+   * @param responseTx - The tx that was received as a response to the request.
+   * @param peerId - The peer ID of the peer that sent the tx.
+   * @returns True if the tx is valid, false otherwise.
+   */ async validateRequestedTx(requestedTxHash, responseTx, peerId) {
+        const proofValidator = new TxProofValidator(this.proofVerifier);
+        const validProof = await proofValidator.validateTx(responseTx);
+        // If the node returns the wrong data, we penalize it
+        if (!requestedTxHash.equals(await responseTx.getTxHash())) {
+            // Returning the wrong data is a low tolerance error
+            this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
+            return false;
+        }
+        if (validProof.result === 'invalid') {
+            // If the proof is invalid, but the txHash is correct, then this is an active attack and we severly punish
+            this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
+            return false;
+        }
+        return true;
+    }
+    async validatePropagatedTx(tx, peerId) {
+        const blockNumber = await this.l2BlockSource.getBlockNumber() + 1;
+        const messageValidators = this.createMessageValidators(blockNumber);
+        const outcome = await this.runValidations(tx, messageValidators);
+        if (outcome.allPassed) {
+            return true;
+        }
+        const { name, severity } = outcome.failure;
+        // Double spend validator has a special case handler
+        if (name === 'doubleSpendValidator') {
+            const isValid = await this.handleDoubleSpendFailure(tx, blockNumber, peerId);
+            if (isValid) {
                 return true;
             }
-            /**
-             * Validate a tx from a peer.
-             * @param propagationSource - The peer ID of the peer that sent the tx.
-             * @param msg - The tx message.
-             * @returns True if the tx is valid, false otherwise.
-             */
-            async validatePropagatedTxFromMessage(propagationSource, msg) {
-                const tx = Tx.fromBuffer(Buffer.from(msg.data));
-                const isValid = await this.validatePropagatedTx(tx, propagationSource);
-                this.logger.trace(`validatePropagatedTx: ${isValid}`, {
-                    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
-                    [Attributes.P2P_ID]: propagationSource.toString(),
-                });
-                return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
-            }
-            /**
-             * Validate an attestation from a peer.
-             * @param propagationSource - The peer ID of the peer that sent the attestation.
-             * @param msg - The attestation message.
-             * @returns True if the attestation is valid, false otherwise.
-             */
-            async validatePropagatedAttestationFromMessage(propagationSource, msg) {
-                const attestation = BlockAttestation.fromBuffer(Buffer.from(msg.data));
-                const isValid = await this.validateAttestation(propagationSource, attestation);
-                this.logger.trace(`validatePropagatedAttestation: ${isValid}`, {
-                    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
-                    [Attributes.P2P_ID]: propagationSource.toString(),
-                });
-                return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
-            }
-            /**
-             * Validate a block proposal from a peer.
-             * @param propagationSource - The peer ID of the peer that sent the block.
-             * @param msg - The block proposal message.
-             * @returns True if the block proposal is valid, false otherwise.
-             */
-            async validatePropagatedBlockFromMessage(propagationSource, msg) {
-                const block = BlockProposal.fromBuffer(Buffer.from(msg.data));
-                const isValid = await this.validateBlockProposal(propagationSource, block);
-                this.logger.trace(`validatePropagatedBlock: ${isValid}`, {
-                    [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
-                    [Attributes.P2P_ID]: propagationSource.toString(),
-                });
-                return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
-            }
-            async validatePropagatedTx(tx, peerId) {
-                const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
-                const messageValidators = this.createMessageValidators(blockNumber);
-                const outcome = await this.runValidations(tx, messageValidators);
-                if (outcome.allPassed) {
-                    return true;
-                }
-                const { name, severity } = outcome.failure;
-                // Double spend validator has a special case handler
-                if (name === 'doubleSpendValidator') {
-                    const isValid = await this.handleDoubleSpendFailure(tx, blockNumber, peerId);
-                    if (isValid) {
-                        return true;
-                    }
-                }
-                this.peerManager.penalizePeer(peerId, severity);
-                return false;
-            }
-            /**
-             * Create message validators for the given block number.
-             *
-             * Each validator is a pair of a validator and a severity.
-             * If a validator fails, the peer is penalized with the severity of the validator.
-             *
-             * @param blockNumber - The block number to create validators for.
-             * @returns The message validators.
-             */
-            createMessageValidators(blockNumber) {
-                return {
-                    dataValidator: {
-                        validator: new DataTxValidator(),
-                        severity: PeerErrorSeverity.HighToleranceError,
-                    },
-                    metadataValidator: {
-                        validator: new MetadataTxValidator(new Fr(this.config.l1ChainId), new Fr(blockNumber)),
-                        severity: PeerErrorSeverity.HighToleranceError,
-                    },
-                    proofValidator: {
-                        validator: new TxProofValidator(this.proofVerifier),
-                        severity: PeerErrorSeverity.MidToleranceError,
-                    },
-                    doubleSpendValidator: {
-                        validator: new DoubleSpendTxValidator({
-                            nullifiersExist: async (nullifiers) => {
-                                const merkleTree = this.worldStateSynchronizer.getCommitted();
-                                const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
-                                return indices.map(index => index !== undefined);
-                            },
-                        }),
-                        severity: PeerErrorSeverity.HighToleranceError,
-                    },
-                };
-            }
-            /**
-             * Run validations on a tx.
-             * @param tx - The tx to validate.
-             * @param messageValidators - The message validators to run.
-             * @returns The validation outcome.
-             */
-            async runValidations(tx, messageValidators) {
-                const validationPromises = Object.entries(messageValidators).map(async ([name, { validator, severity }]) => {
-                    const { result } = await validator.validateTx(tx);
-                    return { name, isValid: result === 'valid', severity };
-                });
-                // A promise that resolves when all validations have been run
-                const allValidations = Promise.all(validationPromises);
-                // A promise that resolves when the first validation fails
-                const firstFailure = Promise.race(validationPromises.map(async (promise) => {
-                    const result = await promise;
-                    return result.isValid ? new Promise(() => { }) : result;
-                }));
-                // Wait for the first validation to fail or all validations to pass
-                const result = await Promise.race([
-                    allValidations.then(() => ({ allPassed: true })),
-                    firstFailure.then(failure => ({ allPassed: false, failure: failure })),
-                ]);
-                // If all validations pass, allPassed will be true, if failed, then the failure will be the first validation to fail
-                return result;
-            }
-            /**
-             * Handle a double spend failure.
-             *
-             * Double spend failures are managed on their own because they are a special case.
-             * We must check if the double spend is recent or old, if it is past a threshold, then we heavily penalize the peer.
-             *
-             * @param tx - The tx that failed the double spend validator.
-             * @param blockNumber - The block number of the tx.
-             * @param peerId - The peer ID of the peer that sent the tx.
-             * @returns True if the tx is valid, false otherwise.
-             */
-            async handleDoubleSpendFailure(tx, blockNumber, peerId) {
-                if (blockNumber <= this.config.severePeerPenaltyBlockLength) {
-                    return false;
-                }
-                const snapshotValidator = new DoubleSpendTxValidator({
-                    nullifiersExist: async (nullifiers) => {
-                        const merkleTree = this.worldStateSynchronizer.getSnapshot(blockNumber - this.config.severePeerPenaltyBlockLength);
+        }
+        this.peerManager.penalizePeer(peerId, severity);
+        return false;
+    }
+    /**
+   * Create message validators for the given block number.
+   *
+   * Each validator is a pair of a validator and a severity.
+   * If a validator fails, the peer is penalized with the severity of the validator.
+   *
+   * @param blockNumber - The block number to create validators for.
+   * @returns The message validators.
+   */ createMessageValidators(blockNumber) {
+        return {
+            dataValidator: {
+                validator: new DataTxValidator(),
+                severity: PeerErrorSeverity.HighToleranceError
+            },
+            metadataValidator: {
+                validator: new MetadataTxValidator(new Fr(this.config.l1ChainId), new Fr(blockNumber)),
+                severity: PeerErrorSeverity.HighToleranceError
+            },
+            proofValidator: {
+                validator: new TxProofValidator(this.proofVerifier),
+                severity: PeerErrorSeverity.MidToleranceError
+            },
+            doubleSpendValidator: {
+                validator: new DoubleSpendTxValidator({
+                    nullifiersExist: async (nullifiers)=>{
+                        const merkleTree = this.worldStateSynchronizer.getCommitted();
                         const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
-                        return indices.map(index => index !== undefined);
-                    },
-                });
-                const validSnapshot = await snapshotValidator.validateTx(tx);
-                if (validSnapshot.result !== 'valid') {
-                    this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
-                    return false;
-                }
-                return true;
-            }
-            /**
-             * Validate an attestation.
-             *
-             * @param attestation - The attestation to validate.
-             * @returns True if the attestation is valid, false otherwise.
-             */
-            async validateAttestation(peerId, attestation) {
-                const severity = await this.attestationValidator.validate(attestation);
-                if (severity) {
-                    this.peerManager.penalizePeer(peerId, severity);
-                    return false;
-                }
-                return true;
-            }
-            /**
-             * Validate a block proposal.
-             *
-             * @param block - The block proposal to validate.
-             * @returns True if the block proposal is valid, false otherwise.
-             */
-            async validateBlockProposal(peerId, block) {
-                const severity = await this.blockProposalValidator.validate(block);
-                if (severity) {
-                    this.peerManager.penalizePeer(peerId, severity);
-                    return false;
-                }
-                return true;
-            }
-            getPeerScore(peerId) {
-                return this.node.services.pubsub.score.score(peerId.toString());
-            }
-            async sendToPeers(message) {
-                const parent = message.constructor;
-                const identifier = await message.p2pMessageIdentifier().then(i => i.toString());
-                this.logger.trace(`Sending message ${identifier}`, { p2pMessageIdentifier: identifier });
-                const recipientsNum = await this.publishToTopic(parent.p2pTopic, message.toBuffer());
-                this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`, {
-                    p2pMessageIdentifier: identifier,
-                    sourcePeer: this.node.peerId.toString(),
-                });
+                        return indices.map((index)=>index !== undefined);
+                    }
+                }),
+                severity: PeerErrorSeverity.HighToleranceError
             }
-            // Libp2p seems to hang sometimes if new peers are initiating connections.
-            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);
-                }
+        };
+    }
+    /**
+   * Run validations on a tx.
+   * @param tx - The tx to validate.
+   * @param messageValidators - The message validators to run.
+   * @returns The validation outcome.
+   */ async runValidations(tx, messageValidators) {
+        const validationPromises = Object.entries(messageValidators).map(async ([name, { validator, severity }])=>{
+            const { result } = await validator.validateTx(tx);
+            return {
+                name,
+                isValid: result === 'valid',
+                severity
+            };
+        });
+        // A promise that resolves when all validations have been run
+        const allValidations = Promise.all(validationPromises);
+        // A promise that resolves when the first validation fails
+        const firstFailure = Promise.race(validationPromises.map(async (promise)=>{
+            const result = await promise;
+            return result.isValid ? new Promise(()=>{}) : result;
+        }));
+        // Wait for the first validation to fail or all validations to pass
+        const result = await Promise.race([
+            allValidations.then(()=>({
+                    allPassed: true
+                })),
+            firstFailure.then((failure)=>({
+                    allPassed: false,
+                    failure: failure
+                }))
+        ]);
+        // If all validations pass, allPassed will be true, if failed, then the failure will be the first validation to fail
+        return result;
+    }
+    /**
+   * Handle a double spend failure.
+   *
+   * Double spend failures are managed on their own because they are a special case.
+   * We must check if the double spend is recent or old, if it is past a threshold, then we heavily penalize the peer.
+   *
+   * @param tx - The tx that failed the double spend validator.
+   * @param blockNumber - The block number of the tx.
+   * @param peerId - The peer ID of the peer that sent the tx.
+   * @returns True if the tx is valid, false otherwise.
+   */ async handleDoubleSpendFailure(tx, blockNumber, peerId) {
+        if (blockNumber <= this.config.severePeerPenaltyBlockLength) {
+            return false;
+        }
+        const snapshotValidator = new DoubleSpendTxValidator({
+            nullifiersExist: async (nullifiers)=>{
+                const merkleTree = this.worldStateSynchronizer.getSnapshot(blockNumber - this.config.severePeerPenaltyBlockLength);
+                const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+                return indices.map((index)=>index !== undefined);
             }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _processAttestationFromPeer_decorators = [trackSpan('Libp2pService.processAttestationFromPeer', async (attestation) => ({
-                    [Attributes.BLOCK_NUMBER]: attestation.payload.header.globalVariables.blockNumber.toNumber(),
-                    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toNumber(),
-                    [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
-                    [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then(i => i.toString()),
-                }))];
-            _processBlockFromPeer_decorators = [trackSpan('Libp2pService.processBlockFromPeer', async (block) => ({
-                    [Attributes.BLOCK_NUMBER]: block.blockNumber.toNumber(),
-                    [Attributes.SLOT_NUMBER]: block.slotNumber.toNumber(),
-                    [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
-                    [Attributes.P2P_ID]: await block.p2pMessageIdentifier().then(i => i.toString()),
-                }))];
-            _broadcastAttestation_decorators = [trackSpan('Libp2pService.broadcastAttestation', async (attestation) => ({
-                    [Attributes.BLOCK_NUMBER]: attestation.payload.header.globalVariables.blockNumber.toNumber(),
-                    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toNumber(),
-                    [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
-                    [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then(i => i.toString()),
-                }))];
-            _validateRequestedTx_decorators = [trackSpan('Libp2pService.validateRequestedTx', (requestedTxHash, _responseTx) => ({
-                    [Attributes.TX_HASH]: requestedTxHash.toString(),
-                }))];
-            _validatePropagatedTx_decorators = [trackSpan('Libp2pService.validatePropagatedTx', async (tx) => ({
-                    [Attributes.TX_HASH]: (await tx.getTxHash()).toString(),
-                }))];
-            _validateAttestation_decorators = [trackSpan('Libp2pService.validateAttestation', (_peerId, attestation) => ({
-                    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
-                }))];
-            _validateBlockProposal_decorators = [trackSpan('Libp2pService.validateBlockProposal', (_peerId, block) => ({
-                    [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
-                }))];
-            __esDecorate(_a, null, _processAttestationFromPeer_decorators, { kind: "method", name: "processAttestationFromPeer", static: false, private: false, access: { has: obj => "processAttestationFromPeer" in obj, get: obj => obj.processAttestationFromPeer }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _processBlockFromPeer_decorators, { kind: "method", name: "processBlockFromPeer", static: false, private: false, access: { has: obj => "processBlockFromPeer" in obj, get: obj => obj.processBlockFromPeer }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _broadcastAttestation_decorators, { kind: "method", name: "broadcastAttestation", static: false, private: false, access: { has: obj => "broadcastAttestation" in obj, get: obj => obj.broadcastAttestation }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _validateRequestedTx_decorators, { kind: "method", name: "validateRequestedTx", static: false, private: false, access: { has: obj => "validateRequestedTx" in obj, get: obj => obj.validateRequestedTx }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _validatePropagatedTx_decorators, { kind: "method", name: "validatePropagatedTx", static: false, private: false, access: { has: obj => "validatePropagatedTx" in obj, get: obj => obj.validatePropagatedTx }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _validateAttestation_decorators, { kind: "method", name: "validateAttestation", static: false, private: false, access: { has: obj => "validateAttestation" in obj, get: obj => obj.validateAttestation }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _validateBlockProposal_decorators, { kind: "method", name: "validateBlockProposal", static: false, private: false, access: { has: obj => "validateBlockProposal" in obj, get: obj => obj.validateBlockProposal }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-export { LibP2PService };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"libp2p_service.js","sourceRoot":"","sources":["../../../src/services/libp2p/libp2p_service.ts"],"names":[],"mappings":"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"}
+        });
+        const validSnapshot = await snapshotValidator.validateTx(tx);
+        if (validSnapshot.result !== 'valid') {
+            this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
+            return false;
+        }
+        return true;
+    }
+    /**
+   * Validate an attestation.
+   *
+   * @param attestation - The attestation to validate.
+   * @returns True if the attestation is valid, false otherwise.
+   */ async validateAttestation(peerId, attestation) {
+        const severity = await this.attestationValidator.validate(attestation);
+        if (severity) {
+            this.peerManager.penalizePeer(peerId, severity);
+            return false;
+        }
+        return true;
+    }
+    /**
+   * Validate a block proposal.
+   *
+   * @param block - The block proposal to validate.
+   * @returns True if the block proposal is valid, false otherwise.
+   */ async validateBlockProposal(peerId, block) {
+        const severity = await this.blockProposalValidator.validate(block);
+        if (severity) {
+            this.peerManager.penalizePeer(peerId, severity);
+            return false;
+        }
+        return true;
+    }
+    getPeerScore(peerId) {
+        return this.node.services.pubsub.score.score(peerId.toString());
+    }
+    async sendToPeers(message) {
+        const parent = message.constructor;
+        const identifier = await message.p2pMessageIdentifier().then((i)=>i.toString());
+        this.logger.trace(`Sending message ${identifier}`, {
+            p2pMessageIdentifier: identifier
+        });
+        const recipientsNum = await this.publishToTopic(parent.p2pTopic, message.toBuffer());
+        this.logger.debug(`Sent message ${identifier} to ${recipientsNum} peers`, {
+            p2pMessageIdentifier: identifier,
+            sourcePeer: this.node.peerId.toString()
+        });
+    }
+    // Libp2p seems to hang sometimes if new peers are initiating connections.
+    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);
+        }
+    }
+}
+_ts_decorate([
+    trackSpan('Libp2pService.processValidBlockProposal', async (block)=>({
+            [Attributes.BLOCK_NUMBER]: block.blockNumber.toNumber(),
+            [Attributes.SLOT_NUMBER]: block.slotNumber.toNumber(),
+            [Attributes.BLOCK_ARCHIVE]: block.archive.toString(),
+            [Attributes.P2P_ID]: await block.p2pMessageIdentifier().then((i)=>i.toString())
+        }))
+], LibP2PService.prototype, "processValidBlockProposal", null);
+_ts_decorate([
+    trackSpan('Libp2pService.broadcastAttestation', async (attestation)=>({
+            [Attributes.BLOCK_NUMBER]: attestation.payload.header.globalVariables.blockNumber.toNumber(),
+            [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toNumber(),
+            [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
+            [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then((i)=>i.toString())
+        }))
+], LibP2PService.prototype, "broadcastAttestation", null);
+_ts_decorate([
+    trackSpan('Libp2pService.validateRequestedTx', (requestedTxHash, _responseTx)=>({
+            [Attributes.TX_HASH]: requestedTxHash.toString()
+        }))
+], LibP2PService.prototype, "validateRequestedTx", null);
+_ts_decorate([
+    trackSpan('Libp2pService.validatePropagatedTx', async (tx)=>({
+            [Attributes.TX_HASH]: (await tx.getTxHash()).toString()
+        }))
+], LibP2PService.prototype, "validatePropagatedTx", null);
+_ts_decorate([
+    trackSpan('Libp2pService.validateAttestation', async (_, attestation)=>({
+            [Attributes.BLOCK_NUMBER]: attestation.payload.header.globalVariables.blockNumber.toNumber(),
+            [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toNumber(),
+            [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
+            [Attributes.P2P_ID]: await attestation.p2pMessageIdentifier().then((i)=>i.toString())
+        }))
+], LibP2PService.prototype, "validateAttestation", null);
+_ts_decorate([
+    trackSpan('Libp2pService.validateBlockProposal', (_peerId, block)=>({
+            [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString()
+        }))
+], LibP2PService.prototype, "validateBlockProposal", null);