@aztec/p2p 0.0.0-test.0

package/dest/services/libp2p/libp2p_service.js

@@ -0,0 +1,712 @@
+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 { createPeerScoreParams, createTopicScoreParams } from '@chainsafe/libp2p-gossipsub/score';
+import { SignaturePolicy } from '@chainsafe/libp2p-gossipsub/types';
+import { noise } from '@chainsafe/libp2p-noise';
+import { yamux } from '@chainsafe/libp2p-yamux';
+import { bootstrap } from '@libp2p/bootstrap';
+import { identify } from '@libp2p/identify';
+import { TopicValidatorResult } from '@libp2p/interface';
+import '@libp2p/kad-dht';
+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 { 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';
+/**
+ * Lib P2P implementation of the P2PService interface.
+ */ 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.debug(`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,
+                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}`);
+            }
+        };
+        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 } = outcome.failure;
+        let { severity } = outcome.failure;
+        // Double spend validator has a special case handler
+        if (name === 'doubleSpendValidator') {
+            severity = await this.handleDoubleSpendFailure(tx, blockNumber);
+        }
+        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 Severity
+   */ async handleDoubleSpendFailure(tx, blockNumber) {
+        if (blockNumber <= this.config.doubleSpendSeverePeerPenaltyWindow) {
+            return PeerErrorSeverity.HighToleranceError;
+        }
+        const snapshotValidator = new DoubleSpendTxValidator({
+            nullifiersExist: async (nullifiers)=>{
+                const merkleTree = this.worldStateSynchronizer.getSnapshot(blockNumber - this.config.doubleSpendSeverePeerPenaltyWindow);
+                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') {
+            return PeerErrorSeverity.LowToleranceError;
+        }
+        return PeerErrorSeverity.HighToleranceError;
+    }
+    /**
+   * 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);