@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.24de95ac

package/dest/test-helpers/reqresp-nodes.js

@@ -1,8 +1,10 @@
 import { timesParallel } from '@aztec/foundation/collection';
+import { SecretValue } from '@aztec/foundation/config';
+import { createLogger } from '@aztec/foundation/log';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { emptyChainConfig } from '@aztec/stdlib/config';
+import { compressComponentVersions } from '@aztec/stdlib/versioning';
 import { getTelemetryClient } from '@aztec/telemetry-client';
-import { SignableENR } from '@chainsafe/enr';
 import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
@@ -11,15 +13,19 @@ import { identify } from '@libp2p/identify';
 import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { multiaddr } from '@multiformats/multiaddr';
+import { SignableENR } from '@nethermindeth/enr';
 import getPort from 'get-port';
 import { createLibp2p } from 'libp2p';
 import { BootstrapNode } from '../bootstrap/bootstrap.js';
 import { DiscV5Service } from '../services/discv5/discV5_service.js';
 import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import { PeerManager } from '../services/peer-manager/peer_manager.js';
+import { PeerScoring } from '../services/peer-manager/peer_scoring.js';
 import { ReqRespSubProtocol, noopValidator } from '../services/reqresp/interface.js';
-import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
+import { pingHandler } from '../services/reqresp/protocols/index.js';
 import { ReqResp } from '../services/reqresp/reqresp.js';
 import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+import { getVersions } from '../versioning.js';
 /**
  * Creates a libp2p node, pre configured.
  * @param boostrapAddrs - an optional list of bootstrap addresses
@@ -30,10 +36,10 @@ import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js
         start,
         addresses: {
             listen: [
-                `/ip4/0.0.0.0/tcp/${port}`
+                `/ip4/127.0.0.1/tcp/${port}`
             ],
             announce: [
-                `/ip4/0.0.0.0/tcp/${port}`
+                `/ip4/127.0.0.1/tcp/${port}`
             ]
         },
         connectionEncryption: [
@@ -73,34 +79,42 @@ import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js
  * P2P functionality is operational, however everything else is default
  *
  *
- */ export async function createTestLibP2PService(clientType, boostrapAddrs = [], l2BlockSource, worldStateSynchronizer, epochCache, mempools, telemetry, port = 0, peerId, chainConfig = emptyChainConfig) {
+ */ export async function createTestLibP2PService(clientType, boostrapAddrs = [], archiver, worldStateSynchronizer, epochCache, mempools, telemetry, port = 0, peerId, chainConfig = emptyChainConfig) {
     peerId = peerId ?? await createSecp256k1PeerId();
     const config = {
-        tcpAnnounceAddress: `127.0.0.1:${port}`,
-        udpAnnounceAddress: `127.0.0.1:${port}`,
-        tcpListenAddress: `0.0.0.0:${port}`,
-        udpListenAddress: `0.0.0.0:${port}`,
+        p2pIp: `127.0.0.1`,
+        p2pPort: port,
         bootstrapNodes: boostrapAddrs,
         peerCheckIntervalMS: 1000,
         maxPeerCount: 5,
         p2pEnabled: true,
-        peerIdPrivateKey: Buffer.from(peerId.privateKey).toString('hex'),
+        peerIdPrivateKey: new SecretValue(Buffer.from(peerId.privateKey).toString('hex')),
         bootstrapNodeEnrVersionCheck: false,
         ...chainConfig
     };
-    const discoveryService = new DiscV5Service(peerId, config, telemetry);
+    const discoveryService = new DiscV5Service(peerId, config, 'test-reqresp-node', telemetry);
     const proofVerifier = new AlwaysTrueCircuitVerifier();
     // No bootstrap nodes provided as the libp2p service will register them in the constructor
     const p2pNode = await createLibp2pNode([], peerId, port, /*enable gossip */ true, /**start */ false);
-    return new LibP2PService(clientType, config, p2pNode, discoveryService, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, telemetry);
+    // Duplicated setup code from Libp2pService.new
+    const peerScoring = new PeerScoring(config);
+    const reqresp = new ReqResp(config, p2pNode, peerScoring);
+    const versions = getVersions(config);
+    const protocolVersion = compressComponentVersions(versions);
+    const peerManager = new PeerManager(p2pNode, discoveryService, config, telemetry, createLogger(`p2p:peer_manager`), peerScoring, reqresp, worldStateSynchronizer, protocolVersion, epochCache);
+    p2pNode.services.pubsub.score.params.appSpecificWeight = 10;
+    p2pNode.services.pubsub.score.params.appSpecificScore = (peerId)=>peerManager.shouldDisableP2PGossip(peerId) ? -Infinity : peerManager.getPeerScore(peerId);
+    return new LibP2PService(clientType, config, p2pNode, discoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry);
 }
 // Mock sub protocol handlers
 export const MOCK_SUB_PROTOCOL_HANDLERS = {
     [ReqRespSubProtocol.PING]: pingHandler,
-    [ReqRespSubProtocol.STATUS]: statusHandler,
+    [ReqRespSubProtocol.STATUS]: (_msg)=>Promise.resolve(Buffer.from('status')),
     [ReqRespSubProtocol.TX]: (_msg)=>Promise.resolve(Buffer.from('tx')),
     [ReqRespSubProtocol.GOODBYE]: (_msg)=>Promise.resolve(Buffer.from('goodbye')),
-    [ReqRespSubProtocol.BLOCK]: (_msg)=>Promise.resolve(Buffer.from('block'))
+    [ReqRespSubProtocol.BLOCK]: (_msg)=>Promise.resolve(Buffer.from('block')),
+    [ReqRespSubProtocol.AUTH]: (_msg)=>Promise.resolve(Buffer.from('auth')),
+    [ReqRespSubProtocol.BLOCK_TXS]: (_msg)=>Promise.resolve(Buffer.from('block_txs'))
 };
 // By default, all requests are valid
 // If you want to test an invalid response, you can override the validator
@@ -109,13 +123,15 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS = {
     [ReqRespSubProtocol.STATUS]: noopValidator,
     [ReqRespSubProtocol.TX]: noopValidator,
     [ReqRespSubProtocol.GOODBYE]: noopValidator,
-    [ReqRespSubProtocol.BLOCK]: noopValidator
+    [ReqRespSubProtocol.BLOCK]: noopValidator,
+    [ReqRespSubProtocol.AUTH]: noopValidator,
+    [ReqRespSubProtocol.BLOCK_TXS]: noopValidator
 };
 /**
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
- */ export const createNodes = (peerScoring, numberOfNodes)=>{
-    return timesParallel(numberOfNodes, ()=>createReqResp(peerScoring));
+ */ export const createNodes = (peerScoring, numberOfNodes, rateLimits = {})=>{
+    return timesParallel(numberOfNodes, ()=>createReqResp(peerScoring, rateLimits));
 };
 export const startNodes = async (nodes, subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS, subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS)=>{
     for (const node of nodes){
@@ -130,13 +146,15 @@ export const stopNodes = async (nodes)=>{
     await Promise.all(stopPromises);
 };
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (peerScoring)=>{
+export const createReqResp = async (peerScoring, rateLimits = {})=>{
     const p2p = await createLibp2pNode();
     const config = {
         overallRequestTimeoutMs: 4000,
-        individualRequestTimeoutMs: 2000
+        individualRequestTimeoutMs: 2000,
+        dialTimeoutMs: 1000,
+        p2pOptimisticNegotiation: false
     };
-    const req = new ReqResp(config, p2p, peerScoring);
+    const req = new ReqResp(config, p2p, peerScoring, undefined, rateLimits);
     return {
         p2p,
         req
@@ -156,25 +174,41 @@ export const connectToPeers = async (nodes)=>{
 };
 // Mock circuit verifier for testing - reimplementation from bb to avoid dependency
 export class AlwaysTrueCircuitVerifier {
+    stop() {
+        return Promise.resolve();
+    }
     verifyProof(_tx) {
-        return Promise.resolve(true);
+        return Promise.resolve({
+            valid: true,
+            durationMs: 0,
+            totalDurationMs: 0
+        });
     }
 }
 export class AlwaysFalseCircuitVerifier {
+    stop() {
+        return Promise.resolve();
+    }
     verifyProof(_tx) {
-        return Promise.resolve(false);
+        return Promise.resolve({
+            valid: false,
+            durationMs: 0,
+            totalDurationMs: 0
+        });
     }
 }
 // Bootnodes
 export function createBootstrapNodeConfig(privateKey, port, chainConfig) {
     return {
         l1ChainId: chainConfig.l1ChainId,
-        udpListenAddress: `0.0.0.0:${port}`,
-        udpAnnounceAddress: `127.0.0.1:${port}`,
-        peerIdPrivateKey: privateKey,
+        p2pIp: '127.0.0.1',
+        p2pPort: port,
+        peerIdPrivateKey: new SecretValue(privateKey),
         dataDirectory: undefined,
-        dataStoreMapSizeKB: 0,
-        bootstrapNodes: []
+        dataStoreMapSizeKb: 0,
+        bootstrapNodes: [],
+        listenAddress: '127.0.0.1',
+        queryForIp: false
     };
 }
 export function createBootstrapNodeFromPrivateKey(privateKey, port, telemetry = getTelemetryClient(), chainConfig = emptyChainConfig) {
@@ -189,7 +223,7 @@ export function createBootstrapNodeFromPrivateKey(privateKey, port, telemetry =
  */ export async function getBootstrapNodeEnr(privateKey, port) {
     const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
     const enr = SignableENR.createFromPeerId(peerId);
-    const listenAddrUdp = multiaddr(convertToMultiaddr(`127.0.0.1:${port}`, 'udp'));
+    const listenAddrUdp = multiaddr(convertToMultiaddr('127.0.0.1', port, 'udp'));
     enr.setLocationMultiaddr(listenAddrUdp);
     return enr;
 }

package/dest/testbench/p2p_client_testbench_worker.js

@@ -7,15 +7,20 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { P2PClientType } from '@aztec/stdlib/p2p';
+import { P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
 import { Tx, TxStatus } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { TopicValidatorResult } from '@libp2p/interface';
+import EventEmitter from 'events';
 import { createP2PClient } from '../index.js';
+import { LibP2PService } from '../services/libp2p/libp2p_service.js';
 import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
 // Simple mock implementation
 function mockTxPool() {
     // Mock all methods
-    return {
-        addTxs: ()=>Promise.resolve(),
+    const pool = {
+        isEmpty: ()=>Promise.resolve(false),
+        addTxs: ()=>Promise.resolve(1),
         getTxByHash: ()=>Promise.resolve(undefined),
         getArchivedTxByHash: ()=>Promise.resolve(undefined),
         markAsMined: ()=>Promise.resolve(),
@@ -24,23 +29,41 @@ function mockTxPool() {
         getAllTxs: ()=>Promise.resolve([]),
         getAllTxHashes: ()=>Promise.resolve([]),
         getPendingTxHashes: ()=>Promise.resolve([]),
+        getPendingTxCount: ()=>Promise.resolve(0),
         getMinedTxHashes: ()=>Promise.resolve([]),
-        getTxStatus: ()=>Promise.resolve(TxStatus.PENDING)
+        getTxStatus: ()=>Promise.resolve(TxStatus.PENDING),
+        getTxsByHash: ()=>Promise.resolve([]),
+        hasTxs: ()=>Promise.resolve([]),
+        hasTx: ()=>Promise.resolve(false),
+        updateConfig: ()=>{},
+        markTxsAsNonEvictable: ()=>Promise.resolve(),
+        cleanupDeletedMinedTxs: ()=>Promise.resolve(0)
     };
+    return Object.assign(new EventEmitter(), pool);
 }
 function mockAttestationPool() {
     return {
+        isEmpty: ()=>Promise.resolve(false),
         addAttestations: ()=>Promise.resolve(),
         deleteAttestations: ()=>Promise.resolve(),
         deleteAttestationsOlderThan: ()=>Promise.resolve(),
         deleteAttestationsForSlot: ()=>Promise.resolve(),
         deleteAttestationsForSlotAndProposal: ()=>Promise.resolve(),
-        getAttestationsForSlot: ()=>Promise.resolve([])
+        getAttestationsForSlot: ()=>Promise.resolve([]),
+        getAttestationsForSlotAndProposal: ()=>Promise.resolve([]),
+        addBlockProposal: ()=>Promise.resolve(),
+        getBlockProposal: ()=>Promise.resolve(undefined),
+        hasBlockProposal: ()=>Promise.resolve(false),
+        hasAttestation: ()=>Promise.resolve(false)
     };
 }
 function mockEpochCache() {
     return {
-        getCommittee: ()=>Promise.resolve([]),
+        getCommittee: ()=>Promise.resolve({
+                committee: [],
+                seed: 1n,
+                epoch: 0n
+            }),
         getProposerIndexEncoding: ()=>'0x',
         getEpochAndSlotNow: ()=>({
                 epoch: 0n,
@@ -48,15 +71,73 @@ function mockEpochCache() {
                 ts: 0n
             }),
         computeProposerIndex: ()=>0n,
-        getProposerInCurrentOrNextSlot: ()=>Promise.resolve({
+        getProposerAttesterAddressInCurrentOrNextSlot: ()=>Promise.resolve({
                 currentProposer: EthAddress.ZERO,
                 nextProposer: EthAddress.ZERO,
                 currentSlot: 0n,
                 nextSlot: 0n
             }),
-        isInCommittee: ()=>Promise.resolve(false)
+        getEpochAndSlotInNextL1Slot: ()=>({
+                epoch: 0n,
+                slot: 0n,
+                ts: 0n,
+                now: 0n
+            }),
+        isInCommittee: ()=>Promise.resolve(false),
+        getRegisteredValidators: ()=>Promise.resolve([]),
+        filterInCommittee: ()=>Promise.resolve([])
     };
 }
+function mockWorldStateSynchronizer() {
+    return {
+        status: ()=>Promise.resolve({
+                syncSummary: {
+                    latestBlockNumber: 0,
+                    latestBlockHash: '',
+                    finalizedBlockNumber: 0,
+                    treesAreSynched: false,
+                    oldestHistoricBlockNumber: 0
+                }
+            })
+    };
+}
+class TestLibP2PService extends LibP2PService {
+    disableTxValidation;
+    gossipMessageCount = 0;
+    constructor(clientType, config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger = createLogger('p2p:test:libp2p_service'), disableTxValidation = true){
+        super(clientType, config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger);
+        this.disableTxValidation = disableTxValidation;
+    }
+    getGossipMessageCount() {
+        return this.gossipMessageCount;
+    }
+    setDisableTxValidation(disable) {
+        this.disableTxValidation = disable;
+    }
+    async handleGossipedTx(payload, msgId, source) {
+        if (this.disableTxValidation) {
+            const p2pMessage = P2PMessage.fromMessageData(payload);
+            const tx = Tx.fromBuffer(p2pMessage.payload);
+            this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Accept);
+            const txHash = tx.getTxHash();
+            const txHashString = txHash.toString();
+            this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
+            await this.mempools.txPool.addTxs([
+                tx
+            ]);
+        } else {
+            await super.handleGossipedTx(payload, msgId, source);
+        }
+    }
+    async handleNewGossipMessage(msg, msgId, source) {
+        this.gossipMessageCount++;
+        process.send({
+            type: 'GOSSIP_RECEIVED',
+            count: this.gossipMessageCount
+        });
+        await super.handleNewGossipMessage(msg, msgId, source);
+    }
+}
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 process.on('message', async (msg)=>{
     const { type, config, clientIndex } = msg;
@@ -65,33 +146,23 @@ process.on('message', async (msg)=>{
             const txPool = mockTxPool();
             const attestationPool = mockAttestationPool();
             const epochCache = mockEpochCache();
-            const worldState = {};
+            const worldState = mockWorldStateSynchronizer();
             const l2BlockSource = new MockL2BlockSource();
-            await l2BlockSource.createBlocks(100);
             const proofVerifier = new AlwaysTrueCircuitVerifier();
             const kvStore = await openTmpStore(`test-${clientIndex}`);
             const logger = createLogger(`p2p:${clientIndex}`);
+            const telemetry = getTelemetryClient();
             const deps = {
                 txPool,
                 attestationPool,
                 store: kvStore,
                 logger
             };
-            const client = await createP2PClient(P2PClientType.Full, config, l2BlockSource, proofVerifier, worldState, epochCache, undefined, deps);
-            // Create spy for gossip messages
-            let gossipMessageCount = 0;
-            client.p2pService.handleNewGossipMessage = (msg, msgId, source)=>{
-                gossipMessageCount++;
-                process.send({
-                    type: 'GOSSIP_RECEIVED',
-                    count: gossipMessageCount
-                });
-                return client.p2pService.constructor.prototype.handleNewGossipMessage.apply(client.p2pService, [
-                    msg,
-                    msgId,
-                    source
-                ]);
-            };
+            const client = await createP2PClient(P2PClientType.Full, config, l2BlockSource, proofVerifier, worldState, epochCache, 'test-p2p-bench-worker', undefined, telemetry, deps);
+            // Create test service with validation disabled
+            const testService = new TestLibP2PService(P2PClientType.Full, config, client.p2pService.node, client.p2pService.peerDiscoveryService, client.p2pService.mempools, client.p2pService.reqresp, client.p2pService.peerManager, client.p2pService.archiver, epochCache, proofVerifier, worldState, telemetry, logger, true);
+            // Replace the existing p2pService with our test version
+            client.p2pService = testService;
             await client.start();
             // Wait until the client is ready
             for(let i = 0; i < 100; i++){

package/dest/testbench/parse_log_file.js

@@ -14,7 +14,7 @@ function getTimestamp(line) {
     return parseInt(timestampMatch[1], 10);
 }
 /**
- * Parses a single log line. If the line contains an "rpc.from" event,
+ * Parses a single log line. If the line contains an "Received tx" event,
  * it extracts the timestamp and the peer ID.
  */ function parseReceivedTx(line) {
     if (!line.includes('Received tx')) {
@@ -26,9 +26,9 @@ function getTimestamp(line) {
         logger.error('No timestamp found in received tx log');
         return null;
     }
-    // TODO: this is not correct - it is just the tx hash for now
-    // Extract the peer ID after "Received tx"
-    const peerIdMatch = line.match(/p2p:(\d+):/);
+    // Extract the peer ID from the log line
+    // Example format: "module":"p2p:1","msg":"Received tx 0x0feeafa65f25fd8d613fe4aca44fd65fe41c149ef1941e2019d40925c40748f9 from external peer 16Uiu2HAm8w4oxXF3TwDKoGL9U66thMXWqCgPnb2CgkYwmUqFCWbC."
+    const peerIdMatch = line.match(/"module":"p2p:(\d+)"/);
     if (!peerIdMatch) {
         logger.error('No peer Number found in received tx log');
         return null;

package/dest/testbench/testbench.js

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import { mockTx } from '@aztec/stdlib/testing';
 import assert from 'assert';
 import path from 'path';
@@ -17,7 +17,7 @@ async function main() {
         }
         const configPath = path.join(__dirname, '../../testbench/configurations', configFile);
         const config = await import(configPath, {
-            assert: {
+            with: {
                 type: 'json'
             }
         });
@@ -34,7 +34,7 @@ async function main() {
         logger.info('Workers Ready');
         // Send tx from client 0
         const tx = await mockTx(1, {
-            clientIvcProof: ClientIvcProof.random()
+            chonkProof: ChonkProof.random()
         });
         workerClientManager.processes[0].send({
             type: 'SEND_TX',
@@ -42,7 +42,7 @@ async function main() {
         });
         logger.info('Transaction sent from client 0');
         // Give time for message propagation
-        await sleep(30000);
+        await sleep(10000);
         logger.info('Checking message propagation results');
         // Check message propagation results
         const numberOfClientsThatReceivedMessage = workerClientManager.numberOfClientsThatReceivedMessage();

package/dest/testbench/worker_client_manager.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { Logger } from '@aztec/foundation/log';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { type ChildProcess } from 'child_process';
@@ -14,10 +13,6 @@ declare class WorkerClientManager {
     private messageReceivedByClient;
     constructor(logger: Logger, p2pConfig: Partial<P2PConfig>);
     destroy(): void;
-    /**
-     * Creates address strings from a port
-     */
-    private getAddresses;
     /**
      * Creates a client configuration object
      */

package/dest/testbench/worker_client_manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker_client_manager.d.ts","sourceRoot":"","sources":["../../src/testbench/worker_client_manager.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,eAAe,CAAC;AAIxD,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,cAAc,CAAC;AAQnE,QAAA,MAAM,eAAe,EAAE,WAMtB,CAAC;AAEF,cAAM,mBAAmB;IAChB,SAAS,EAAE,YAAY,EAAE,CAAM;IAC/B,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAM;IACxB,KAAK,EAAE,MAAM,EAAE,CAAM;IAC5B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,uBAAuB,CAAgB;gBAEnC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC;IAKzD,OAAO;IAOP;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoD1B;;;;;;OAMG;IACG,iBAAiB,CAAC,eAAe,EAAE,MAAM;IA2C/C,4BAA4B;IAI5B,kCAAkC;IAIlC;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IA4CrD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;OAEG;IACG,OAAO;CAiCd;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"worker_client_manager.d.ts","sourceRoot":"","sources":["../../src/testbench/worker_client_manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,eAAe,CAAC;AAIxD,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,cAAc,CAAC;AAQnE,QAAA,MAAM,eAAe,EAAE,WAMtB,CAAC;AAEF,cAAM,mBAAmB;IAChB,SAAS,EAAE,YAAY,EAAE,CAAM;IAC/B,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAM;IACxB,KAAK,EAAE,MAAM,EAAE,CAAM;IAC5B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,uBAAuB,CAAgB;gBAEnC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC;IAKzD,OAAO;IAOP;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoD1B;;;;;;OAMG;IACG,iBAAiB,CAAC,eAAe,EAAE,MAAM;IA2C/C,4BAA4B;IAI5B,kCAAkC;IAIlC;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IA8CrD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;OAEG;IACG,OAAO;CAiCd;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC"}

package/dest/testbench/worker_client_manager.js

@@ -1,3 +1,4 @@
+import { SecretValue } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { sleep } from '@aztec/foundation/sleep';
 import { fork } from 'child_process';
@@ -11,7 +12,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerPath = path.join(__dirname, '../../dest/testbench/p2p_client_testbench_worker.js');
 const testChainConfig = {
     l1ChainId: 31337,
-    version: 1,
+    rollupVersion: 1,
     l1Contracts: {
         rollupAddress: EthAddress.random()
     }
@@ -35,25 +36,15 @@ class WorkerClientManager {
         });
     }
     /**
-   * Creates address strings from a port
-   */ getAddresses(port) {
-        return {
-            addr: `127.0.0.1:${port}`,
-            listenAddr: `0.0.0.0:${port}`
-        };
-    }
-    /**
    * Creates a client configuration object
    */ createClientConfig(clientIndex, port, otherNodes) {
-        const { addr, listenAddr } = this.getAddresses(port);
         return {
             ...getP2PDefaultConfig(),
             p2pEnabled: true,
-            peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
-            tcpListenAddress: listenAddr,
-            udpListenAddress: listenAddr,
-            tcpAnnounceAddress: addr,
-            udpAnnounceAddress: addr,
+            peerIdPrivateKey: new SecretValue(this.peerIdPrivateKeys[clientIndex]),
+            listenAddress: '127.0.0.1',
+            p2pIp: '127.0.0.1',
+            p2pPort: port,
             bootstrapNodes: [
                 ...otherNodes
             ],
@@ -177,6 +168,7 @@ class WorkerClientManager {
             this.peerEnrs[clientIndex] = await makeEnr(this.peerIdPrivateKeys[clientIndex], newPort, testChainConfig);
             // Maximum seed with 10 other peers to allow peer discovery to connect them at a smoother rate
             const otherNodes = this.peerEnrs.filter((_, ind)=>ind !== clientIndex && ind < Math.min(this.peerEnrs.length, 10));
+            this.logger.info(`Changing port for client ${clientIndex} to ${newPort} with other nodes `, otherNodes);
             const config = this.createClientConfig(clientIndex, newPort, otherNodes);
             const [childProcess, readySignal] = this.spawnWorkerProcess(config, clientIndex);
             this.processes[clientIndex] = childProcess;
@@ -207,7 +199,7 @@ class WorkerClientManager {
                 } catch (e) {
                     this.logger.error(`Error force killing process ${index}:`, e);
                 }
-            }, 10000); // 10 second timeout for graceful exit
+            }, 5000); // 5 second timeout for graceful exit
             // Listen for process exit
             process1.once('exit', ()=>{
                 clearTimeout(forceKillTimeout);
@@ -218,7 +210,7 @@ class WorkerClientManager {
                 process1.send({
                     type: 'STOP'
                 });
-            } catch (e) {
+            } catch  {
                 // If sending the message fails, force kill immediately
                 clearTimeout(forceKillTimeout);
                 try {
@@ -248,12 +240,12 @@ class WorkerClientManager {
                                 if (!p.killed) {
                                     p.kill('SIGKILL');
                                 }
-                            } catch (e) {
+                            } catch  {
                             // Ignore errors when force killing
                             }
                         });
                         resolve();
-                    }, 30000); // 30 second timeout for all processes
+                    }, 10000); // 10 second timeout for all processes
                 })
             ]);
         } catch (error) {

package/dest/types/index.d.ts

@@ -14,7 +14,8 @@ export declare enum PeerEvent {
  */
 export declare enum Discv5Event {
     DISCOVERED = "discovered",
-    ENR_ADDED = "enrAdded"
+    ENR_ADDED = "enrAdded",
+    MULTIADDR_UPDATED = "multiaddrUpdated"
 }
 /**
  * Events emitted from the GossipSub protocol.
@@ -29,4 +30,5 @@ export declare enum GossipSubEvent {
  * Aztec network specific types
  */
 export declare const AZTEC_ENR_KEY = "aztec";
+export declare const AZTEC_ENR_CLIENT_VERSION_KEY = "ver";
 //# sourceMappingURL=index.d.ts.map

package/dest/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;qDAEqD;AAErD;;GAEG;AACH,oBAAY,SAAS;IACnB,UAAU,oBAAoB;IAC9B,SAAS,iBAAiB;IAC1B,YAAY,oBAAoB;CACjC;AAED;;GAEG;AACH,oBAAY,WAAW;IACrB,UAAU,eAAe;IACzB,SAAS,aAAa;CACvB;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB,OAAO,sBAAsB;CAC9B;AAED;;qDAEqD;AAErD;;GAEG;AACH,eAAO,MAAM,aAAa,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;qDAEqD;AAErD;;GAEG;AACH,oBAAY,SAAS;IACnB,UAAU,oBAAoB;IAC9B,SAAS,iBAAiB;IAC1B,YAAY,oBAAoB;CACjC;AAED;;GAEG;AACH,oBAAY,WAAW;IACrB,UAAU,eAAe;IACzB,SAAS,aAAa;IACtB,iBAAiB,qBAAqB;CACvC;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB,OAAO,sBAAsB;CAC9B;AAED;;qDAEqD;AAErD;;GAEG;AACH,eAAO,MAAM,aAAa,UAAU,CAAC;AACrC,eAAO,MAAM,4BAA4B,QAAQ,CAAC"}

package/dest/types/index.js

@@ -13,6 +13,7 @@
  */ export var Discv5Event = /*#__PURE__*/ function(Discv5Event) {
     Discv5Event["DISCOVERED"] = "discovered";
     Discv5Event["ENR_ADDED"] = "enrAdded";
+    Discv5Event["MULTIADDR_UPDATED"] = "multiaddrUpdated";
     return Discv5Event;
 }({});
 /**
@@ -26,3 +27,4 @@
  ***************************************************/ /**
  * Aztec network specific types
  */ export const AZTEC_ENR_KEY = 'aztec';
+export const AZTEC_ENR_CLIENT_VERSION_KEY = 'ver';

package/dest/util.d.ts

@@ -1,18 +1,27 @@
+import { SecretValue } from '@aztec/foundation/config';
+import type { Logger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
+import type { Identify } from '@libp2p/identify';
 import type { PeerId } from '@libp2p/interface';
 import type { ConnectionManager } from '@libp2p/interface-internal';
 import type { Libp2p } from 'libp2p';
 import type { P2PConfig } from './config.js';
-export interface PubSubLibp2p extends Libp2p {
+export interface PubSubLibp2p extends Pick<Libp2p, 'status' | 'start' | 'stop' | 'peerId'> {
     services: {
-        pubsub: GossipSub;
-        components: {
-            connectionManager: ConnectionManager;
+        pubsub: Pick<GossipSub, 'addEventListener' | 'removeEventListener' | 'publish' | 'subscribe' | 'reportMessageValidationResult' | 'direct'> & {
+            score: Pick<GossipSub['score'], 'score'>;
         };
     };
 }
+export type FullLibp2p = Libp2p<{
+    identify: Identify;
+    pubsub: GossipSub;
+    components: {
+        connectionManager: ConnectionManager;
+    };
+}>;
 /**
  * Converts an address string to a multiaddr string.
  * Example usage:
@@ -21,29 +30,27 @@ export interface PubSubLibp2p extends Libp2p {
  * @param address - The address string to convert. Has to be in the format <addr>:<port>.
  * @param protocol - The protocol to use in the multiaddr string.
  * @returns A multiaddr compliant string.  */
-export declare function convertToMultiaddr(address: string, protocol: 'tcp' | 'udp'): string;
-/**
- * Splits an <address>:<port> string into its components.
- * @returns The ip6 or ip4 address & port separately
- */
-export declare function splitAddressPort(address: string, allowEmptyAddress: boolean): [string, string];
+export declare function convertToMultiaddr(address: string, port: number, protocol: 'tcp' | 'udp'): string;
 /**
  * Queries the public IP address of the machine.
  */
 export declare function getPublicIp(): Promise<string>;
-export declare function resolveAddressIfNecessary(address: string): Promise<string>;
+export declare function resolveAddressIfNecessary(address: string, port: string): Promise<string>;
 export declare function configureP2PClientAddresses(_config: P2PConfig & DataStoreConfig): Promise<P2PConfig & DataStoreConfig>;
 /**
  * Get the peer id private key
  *
  * 1. Check if we have a peer id private key in the config
- * 2. If not, check we have a peer id private key persisted in the node
- * 3. If not, create a new one, then persist it in the node
+ * 2. If not, check if we have a peer id private key persisted in a file
+ * 3. If no file path or data directory is provided, check if we have a peer id private key in the node's store
+ * 4. If not, create a new one, then persist it in a file if a file path or data directory is provided or in the node's store otherwise
  *
  */
 export declare function getPeerIdPrivateKey(config: {
-    peerIdPrivateKey?: string;
-}, store: AztecAsyncKVStore): Promise<string>;
+    peerIdPrivateKey?: SecretValue<string>;
+    peerIdPrivateKeyPath?: string;
+    dataDirectory?: string;
+}, store: AztecAsyncKVStore, logger: Logger): Promise<SecretValue<string>>;
 /**
  * Create a libp2p peer ID from the private key.
  * @param privateKey - peer ID private key as hex string