@aztec-labs/p2p 6.0.0-nightly.20260829

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

@@ -0,0 +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,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,eAAe,CAAC;AAKxD,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,cAAc,CAAC;AAKnE,OAAO,KAAK,EAA2C,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AASrH,QAAA,MAAM,eAAe,EAAE,WAItB,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,mBAAmB,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,mBAAmB,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,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;IACrB,OAAO,EAAE,MAAM,EAAE,CAAM;IAC9B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,uBAAuB,CAAgB;IAE/C,YAAY,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,EAGxD;IAED,OAAO,SAIN;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAoB1B;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAkG1B;;;;;;;OAOG;IACG,iBAAiB,CACrB,eAAe,EAAE,MAAM,EACvB,OAAO,GAAE;QACP,aAAa,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAC;QACjC,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,YAAY,CAAC,EAAE,MAAM,CAAC;KAClB,qBA+DP;IAED,4BAA4B,SAE3B;IAED,kCAAkC,WAEjC;IAED;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBA8CpD;IAED;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAqCxB;;OAEG;IACG,OAAO,kBAgCZ;IAED;;;;OAIG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAE,MAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAkBvF;IAED,OAAO,CAAC,YAAY;IA8BpB;;;;;;;;;OASG;IACG,mBAAmB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAkEzF;IAED,OAAO,CAAC,iBAAiB;IAkCzB,OAAO,CAAC,kBAAkB;CAiC3B;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC;AAChD,YAAY,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC"}

package/dest/testbench/worker_client_manager.js

@@ -0,0 +1,492 @@
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { fork } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getP2PDefaultConfig } from '../config.js';
+import { generatePeerIdPrivateKeys } from '../test-helpers/generate-peer-id-private-keys.js';
+import { getPorts } from '../test-helpers/get-ports.js';
+import { makeEnr, makeEnrs } from '../test-helpers/make-enrs.js';
+import { BENCHMARK_CONSTANTS } from '../test-helpers/testbench-utils.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const p2pRoot = path.resolve(__dirname, '../..');
+// @dependency ./p2p_client_testbench_worker.ts
+const workerTsPath = path.join(__dirname, 'p2p_client_testbench_worker.ts');
+const workerJsPath = path.join(p2pRoot, 'dest/testbench/p2p_client_testbench_worker.js');
+const tsconfigPath = path.join(p2pRoot, 'tsconfig.json');
+const testChainConfig = {
+    l1ChainId: 31337,
+    rollupVersion: 1,
+    rollupAddress: EthAddress.random()
+};
+class WorkerClientManager {
+    processes = [];
+    peerIdPrivateKeys = [];
+    peerEnrs = [];
+    ports = [];
+    peerIds = [];
+    p2pConfig;
+    logger;
+    messageReceivedByClient = [];
+    constructor(logger, p2pConfig){
+        this.logger = logger;
+        this.p2pConfig = p2pConfig;
+    }
+    destroy() {
+        this.cleanup().catch((error)=>{
+            this.logger.error('Failed to cleanup worker client manager', error);
+        });
+    }
+    /**
+   * Creates a client configuration object for IPC.
+   * Note: We send the raw peerIdPrivateKey string instead of SecretValue
+   * because SecretValue.toJSON() returns '[Redacted]', losing the value.
+   * The worker must re-wrap it in SecretValue.
+   * We also omit priceBumpPercentage since it's a bigint and can't be
+   * serialized over IPC (which uses JSON under the hood).
+   */ createClientConfig(clientIndex, port, otherNodes) {
+        const { priceBumpPercentage: _, ...config } = {
+            ...getP2PDefaultConfig(),
+            p2pEnabled: true,
+            peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
+            listenAddress: '127.0.0.1',
+            p2pIp: '127.0.0.1',
+            p2pPort: port,
+            bootstrapNodes: [
+                ...otherNodes
+            ],
+            ...this.p2pConfig
+        };
+        return config;
+    }
+    /**
+   * Spawns a worker process and returns a promise that resolves when the worker is ready.
+   * Config uses raw string for peerIdPrivateKey (not SecretValue) for IPC serialization.
+   */ spawnWorkerProcess(config, clientIndex) {
+        const useCompiled = existsSync(workerJsPath);
+        const workerPath = useCompiled ? workerJsPath : workerTsPath;
+        const execArgv = [
+            ...process.execArgv
+        ];
+        if (!useCompiled && !execArgv.includes('ts-node/esm')) {
+            execArgv.push('--loader', 'ts-node/esm');
+        }
+        const env = {
+            ...process.env,
+            TS_NODE_PROJECT: tsconfigPath
+        };
+        const childProcess = fork(workerPath, {
+            cwd: p2pRoot,
+            execArgv,
+            env
+        });
+        childProcess.send({
+            type: 'START',
+            config,
+            clientIndex
+        });
+        // Handle unexpected child process exit
+        childProcess.on('exit', (code, signal)=>{
+            if (code !== 0) {
+                this.logger.warn(`Worker ${clientIndex} exited unexpectedly with code ${code} and signal ${signal}`);
+            }
+        });
+        childProcess.on('message', (msg)=>{
+            if (msg.type === 'GOSSIP_RECEIVED') {
+                this.messageReceivedByClient[clientIndex] = msg.count;
+            }
+        });
+        // Create ready signal promise
+        const readySignal = new Promise((resolve, reject)=>{
+            let resolved = false;
+            const timeout = setTimeout(()=>{
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                childProcess.off('message', messageHandler);
+                childProcess.off('exit', exitHandler);
+                reject(new Error(`Timeout waiting for worker ${clientIndex} to be ready`));
+            }, BENCHMARK_CONSTANTS.WORKER_READY_TIMEOUT_MS);
+            const messageHandler = (msg)=>{
+                if (resolved) {
+                    return;
+                }
+                // Only handle READY or ERROR messages; ignore others (e.g., GOSSIP_RECEIVED)
+                if (msg.type === 'READY') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    childProcess.off('message', messageHandler);
+                    childProcess.off('exit', exitHandler);
+                    if (typeof msg.peerId === 'string') {
+                        this.peerIds[clientIndex] = msg.peerId;
+                    }
+                    resolve();
+                } else if (msg.type === 'ERROR') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    childProcess.off('message', messageHandler);
+                    childProcess.off('exit', exitHandler);
+                    reject(new Error(msg.error));
+                }
+            // Ignore other message types and keep waiting for READY/ERROR
+            };
+            const exitHandler = (code)=>{
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                clearTimeout(timeout);
+                childProcess.off('message', messageHandler);
+                if (code === 0) {
+                    resolve();
+                } else {
+                    reject(new Error(`Worker ${clientIndex} exited with code ${code} before becoming ready`));
+                }
+            };
+            childProcess.on('message', messageHandler);
+            childProcess.once('exit', exitHandler);
+        });
+        return [
+            childProcess,
+            readySignal
+        ];
+    }
+    /**
+   * Creates a number of worker clients in separate processes.
+   * All are configured to connect to each other and overridden with the test-specific config.
+   *
+   * @param numberOfClients - The number of clients to create
+   * @param options - Optional overrides for seeding/bootstrapping strategy
+   * @returns The ENRs of the created clients
+   */ async makeWorkerClients(numberOfClients, options = {}) {
+        try {
+            const bootstrapMode = options.bootstrapMode ?? (this.p2pConfig.bootstrapNodesAsFullPeers ? 'all' : 'subset');
+            const seedPeerLimit = options.seedPeerLimit ?? 10;
+            const batchSize = options.batchSize ?? (bootstrapMode === 'all' ? Math.min(5, numberOfClients) : numberOfClients);
+            const batchDelayMs = options.batchDelayMs ?? (bootstrapMode === 'all' ? 500 : 0);
+            this.messageReceivedByClient = new Array(numberOfClients).fill(0);
+            this.peerIdPrivateKeys = generatePeerIdPrivateKeys(numberOfClients);
+            this.ports = await getPorts(numberOfClients);
+            this.peerEnrs = await makeEnrs(this.peerIdPrivateKeys, this.ports, testChainConfig);
+            this.peerIds = new Array(numberOfClients);
+            this.processes = [];
+            const readySignals = [];
+            for(let batchStart = 0; batchStart < numberOfClients; batchStart += batchSize){
+                const batchEnd = Math.min(batchStart + batchSize, numberOfClients);
+                const batchPromises = [];
+                for(let i = batchStart; i < batchEnd; i++){
+                    this.logger.info(`Creating client ${i}`);
+                    const otherNodes = bootstrapMode === 'all' ? this.peerEnrs.filter((_, ind)=>ind !== i) : this.peerEnrs.filter((_, ind)=>ind < Math.min(i, seedPeerLimit));
+                    const config = this.createClientConfig(i, this.ports[i], otherNodes);
+                    const [childProcess, readySignal] = this.spawnWorkerProcess(config, i);
+                    readySignals.push(readySignal);
+                    batchPromises.push(readySignal);
+                    this.processes.push(childProcess);
+                }
+                await Promise.all(batchPromises);
+                if (batchEnd < numberOfClients && batchDelayMs > 0) {
+                    await sleep(batchDelayMs);
+                }
+            }
+            await sleep(BENCHMARK_CONSTANTS.PEER_DISCOVERY_WAIT_MS);
+            await Promise.race([
+                Promise.all(readySignals),
+                new Promise((_, reject)=>setTimeout(()=>reject(new Error('Timeout waiting for all workers to be ready')), BENCHMARK_CONSTANTS.WORKER_READY_TIMEOUT_MS))
+            ]);
+            return this.peerEnrs;
+        } catch (error) {
+            // Clean up any processes that were created if there's an error
+            this.logger.error('Error during makeWorkerClients:', error);
+            await this.cleanup();
+            throw error;
+        }
+    }
+    purgeMessageReceivedByClient() {
+        this.messageReceivedByClient = new Array(this.processes.length).fill(0);
+    }
+    numberOfClientsThatReceivedMessage() {
+        return this.messageReceivedByClient.filter((count)=>count > 0).length;
+    }
+    /**
+   * Changes the port for a specific client
+   *
+   * @param clientIndex - The index of the client to change port for
+   * @param newPort - The new port to use
+   */ async changePort(clientIndex, newPort) {
+        try {
+            if (clientIndex < 0 || clientIndex >= this.processes.length) {
+                throw new Error(`Invalid client index: ${clientIndex}`);
+            }
+            this.processes[clientIndex].send({
+                type: 'STOP'
+            });
+            // Wait for the process to be ready with a timeout
+            await sleep(10000);
+            this.logger.info(`Changing port for client ${clientIndex} to ${newPort}`);
+            // Update the port in the ports array
+            this.ports[clientIndex] = newPort;
+            // Update the port in the peerEnrs array
+            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;
+            await Promise.race([
+                readySignal,
+                new Promise((_, reject)=>setTimeout(()=>reject(new Error(`Timeout waiting for client ${clientIndex} to be ready`)), BENCHMARK_CONSTANTS.WORKER_READY_TIMEOUT_MS))
+            ]);
+        } catch (error) {
+            this.logger.error(`Error during changePort for client ${clientIndex}:`, error);
+            // Only clean up the specific process that had an issue
+            await this.terminateProcess(this.processes[clientIndex], clientIndex);
+            throw error;
+        }
+    }
+    /**
+   * Terminate a single process with timeout and force kill if needed
+   */ terminateProcess(process1, index) {
+        if (!process1 || process1.killed) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve)=>{
+            const forceKillTimeout = setTimeout(()=>{
+                this.logger.warn(`Process ${index} didn't exit gracefully, force killing...`);
+                try {
+                    process1.kill('SIGKILL');
+                } catch (e) {
+                    this.logger.error(`Error force killing process ${index}:`, e);
+                }
+            }, BENCHMARK_CONSTANTS.GRACEFUL_SHUTDOWN_TIMEOUT_MS);
+            // Listen for process exit
+            process1.once('exit', ()=>{
+                clearTimeout(forceKillTimeout);
+                resolve();
+            });
+            // Try to gracefully stop the process
+            try {
+                process1.send({
+                    type: 'STOP'
+                });
+            } catch  {
+                // If sending the message fails, force kill immediately
+                clearTimeout(forceKillTimeout);
+                try {
+                    process1.kill('SIGKILL');
+                } catch (killError) {
+                    this.logger.error(`Error force killing process ${index}:`, killError);
+                }
+                resolve();
+            }
+        });
+    }
+    /**
+   * Cleans up all worker processes with timeout and force kill if needed
+   */ async cleanup() {
+        this.logger.info(`Cleaning up ${this.processes.length} worker processes`);
+        // Create array of promises for each process termination
+        const terminationPromises = this.processes.map((process1, index)=>this.terminateProcess(process1, index));
+        try {
+            await Promise.race([
+                Promise.all(terminationPromises),
+                new Promise((resolve)=>{
+                    setTimeout(()=>{
+                        this.logger.warn('Some processes did not terminate in time, force killing all remaining...');
+                        this.processes.forEach((p)=>{
+                            try {
+                                if (!p.killed) {
+                                    p.kill('SIGKILL');
+                                }
+                            } catch  {
+                            // Ignore errors when force killing
+                            }
+                        });
+                        resolve();
+                    }, BENCHMARK_CONSTANTS.CLEANUP_TIMEOUT_MS);
+                })
+            ]);
+        } catch (error) {
+            this.logger.error('Error during cleanup:', error);
+        }
+        this.processes = [];
+        this.peerIds = [];
+        this.logger.info('All worker processes cleaned up');
+    }
+    /**
+   * Checks that the aggregator (client 0) has sufficient peer connections before running a benchmark.
+   * This prevents benchmark cases from starting with degraded connectivity after a previous case
+   * caused connection failures.
+   */ async waitForConnectivity(minPeers, timeoutMs = 15_000) {
+        const waitInterval = 1000;
+        let waited = 0;
+        while(waited < timeoutMs){
+            const count = await this.getPeerCount(0, 5000);
+            if (count >= minPeers) {
+                this.logger.info(`Connectivity check passed: ${count}/${minPeers} peers connected`);
+                return count;
+            }
+            this.logger.debug(`Waiting for connectivity: ${count}/${minPeers} (waited ${waited}ms)`);
+            await sleep(waitInterval);
+            waited += waitInterval;
+        }
+        const finalCount = await this.getPeerCount(0, 5000);
+        this.logger.warn(`Connectivity check: only ${finalCount}/${minPeers} peers after ${timeoutMs}ms`);
+        return finalCount;
+    }
+    getPeerCount(clientIndex, timeoutMs) {
+        return new Promise((resolve)=>{
+            let resolved = false;
+            const handler = (msg)=>{
+                if (resolved) {
+                    return;
+                }
+                if (msg.type === 'PEER_COUNT') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    this.processes[clientIndex].off('message', handler);
+                    resolve(msg.count);
+                }
+            };
+            const timeout = setTimeout(()=>{
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                this.processes[clientIndex].off('message', handler);
+                resolve(0);
+            }, timeoutMs);
+            this.processes[clientIndex].on('message', handler);
+            this.processes[clientIndex].send({
+                type: 'GET_PEER_COUNT'
+            });
+        });
+    }
+    /**
+   * Run a req/resp benchmark across all worker clients.
+   *
+   * This sends a BENCH_REQRESP command to all workers:
+   * - Aggregator (client 0) runs the collector and returns timing results
+   * - Responders (clients 1..N) populate their tx pools based on distribution
+   *
+   * All workers generate the same txs deterministically from a shared seed,
+   * then filter based on their peerIndex and distribution pattern.
+   */ async runReqRespBenchmark(config) {
+        const peerCount = this.processes.length;
+        if (peerCount < 2) {
+            throw new Error('Need at least 2 peers to run req/resp benchmark');
+        }
+        const seed = config.seed ?? Date.now();
+        const blockNumber = config.blockNumber ?? 1;
+        const pinnedPeerId = config.pinnedPeerIndex !== undefined ? this.peerIds[config.pinnedPeerIndex] : undefined;
+        this.logger.info(`Starting req/resp benchmark: txCount=${config.txCount}, distribution=${config.distribution}`);
+        const readyPromises = [];
+        for(let i = 1; i < peerCount; i++){
+            const cmd = {
+                type: 'BENCH_REQRESP',
+                txCount: config.txCount,
+                peerCount,
+                distribution: config.distribution,
+                timeoutMs: config.timeoutMs,
+                isAggregator: false,
+                peerIndex: i,
+                pinnedPeerIndex: config.pinnedPeerIndex,
+                pinnedPeerId,
+                blockNumber,
+                seed
+            };
+            this.processes[i].send(cmd);
+            readyPromises.push(this.waitForBenchReady(i, 30000));
+        }
+        await Promise.all(readyPromises);
+        this.logger.info('All responder peers ready, starting aggregator benchmark...');
+        const aggregatorCmd = {
+            type: 'BENCH_REQRESP',
+            txCount: config.txCount,
+            peerCount,
+            distribution: config.distribution,
+            timeoutMs: config.timeoutMs,
+            isAggregator: true,
+            peerIndex: 0,
+            pinnedPeerIndex: config.pinnedPeerIndex,
+            pinnedPeerId,
+            blockNumber,
+            seed
+        };
+        this.processes[0].send(aggregatorCmd);
+        const aggregatorBudgetMs = config.timeoutMs + BENCHMARK_CONSTANTS.MAX_PEER_WAIT_MS + 30000;
+        const result = await this.waitForBenchResult(0, aggregatorBudgetMs);
+        this.logger.info(`Benchmark complete: fetched=${result.fetchedCount}/${config.txCount}, duration=${result.durationMs.toFixed(0)}ms, success=${result.success}`);
+        return {
+            txCount: config.txCount,
+            distribution: config.distribution,
+            durationMs: result.durationMs,
+            fetchedCount: result.fetchedCount,
+            success: result.success,
+            error: result.error
+        };
+    }
+    waitForBenchReady(clientIndex, timeoutMs) {
+        return new Promise((resolve, reject)=>{
+            let resolved = false;
+            const handler = (msg)=>{
+                if (resolved) {
+                    return;
+                }
+                if (msg.type === 'BENCH_READY') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    this.processes[clientIndex].off('message', handler);
+                    resolve();
+                } else if (msg.type === 'ERROR') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    this.processes[clientIndex].off('message', handler);
+                    reject(new Error(`Client ${clientIndex} error: ${msg.error}`));
+                }
+            };
+            const timeout = setTimeout(()=>{
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                this.processes[clientIndex].off('message', handler);
+                reject(new Error(`Timeout waiting for BENCH_READY from client ${clientIndex}`));
+            }, timeoutMs);
+            this.processes[clientIndex].on('message', handler);
+        });
+    }
+    waitForBenchResult(clientIndex, timeoutMs) {
+        return new Promise((resolve, reject)=>{
+            let resolved = false;
+            const handler = (msg)=>{
+                if (resolved) {
+                    return;
+                }
+                if (msg.type === 'BENCH_RESULT') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    this.processes[clientIndex].off('message', handler);
+                    resolve(msg);
+                } else if (msg.type === 'ERROR') {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    this.processes[clientIndex].off('message', handler);
+                    reject(new Error(`Client ${clientIndex} error: ${msg.error}`));
+                }
+            };
+            const timeout = setTimeout(()=>{
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                this.processes[clientIndex].off('message', handler);
+                reject(new Error(`Timeout waiting for BENCH_RESULT from client ${clientIndex}`));
+            }, timeoutMs);
+            this.processes[clientIndex].on('message', handler);
+        });
+    }
+}
+export { WorkerClientManager, testChainConfig };

package/dest/types/index.d.ts

@@ -0,0 +1,34 @@
+/***************************************************
+ *                    Events
+ ***************************************************/
+/**
+ * Events emitted from the libp2p node.
+ */
+export declare enum PeerEvent {
+    DISCOVERED = "peer:discovered",
+    CONNECTED = "peer:connect",
+    DISCONNECTED = "peer:disconnect"
+}
+/**
+ * Events emitted from the Discv5 service.
+ */
+export declare enum Discv5Event {
+    DISCOVERED = "discovered",
+    ENR_ADDED = "enrAdded",
+    MULTIADDR_UPDATED = "multiaddrUpdated"
+}
+/**
+ * Events emitted from the GossipSub protocol.
+ */
+export declare enum GossipSubEvent {
+    MESSAGE = "gossipsub:message"
+}
+/***************************************************
+ *                    Types
+ ***************************************************/
+/**
+ * Aztec network specific types
+ */
+export declare const AZTEC_ENR_KEY = "aztec";
+export declare const AZTEC_ENR_CLIENT_VERSION_KEY = "ver";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7cURBRXFEO0FBRXJEOztHQUVHO0FBQ0gsb0JBQVksU0FBUztJQUNuQixVQUFVLG9CQUFvQjtJQUM5QixTQUFTLGlCQUFpQjtJQUMxQixZQUFZLG9CQUFvQjtDQUNqQztBQUVEOztHQUVHO0FBQ0gsb0JBQVksV0FBVztJQUNyQixVQUFVLGVBQWU7SUFDekIsU0FBUyxhQUFhO0lBQ3RCLGlCQUFpQixxQkFBcUI7Q0FDdkM7QUFFRDs7R0FFRztBQUNILG9CQUFZLGNBQWM7SUFDeEIsT0FBTyxzQkFBc0I7Q0FDOUI7QUFFRDs7cURBRXFEO0FBRXJEOztHQUVHO0FBQ0gsZUFBTyxNQUFNLGFBQWEsVUFBVSxDQUFDO0FBQ3JDLGVBQU8sTUFBTSw0QkFBNEIsUUFBUSxDQUFDIn0=

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

@@ -0,0 +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;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

@@ -0,0 +1,30 @@
+/***************************************************
+ *                    Events
+ ***************************************************/ /**
+ * Events emitted from the libp2p node.
+ */ export var PeerEvent = /*#__PURE__*/ function(PeerEvent) {
+    PeerEvent["DISCOVERED"] = "peer:discovered";
+    PeerEvent["CONNECTED"] = "peer:connect";
+    PeerEvent["DISCONNECTED"] = "peer:disconnect";
+    return PeerEvent;
+}({});
+/**
+ * Events emitted from the Discv5 service.
+ */ export var Discv5Event = /*#__PURE__*/ function(Discv5Event) {
+    Discv5Event["DISCOVERED"] = "discovered";
+    Discv5Event["ENR_ADDED"] = "enrAdded";
+    Discv5Event["MULTIADDR_UPDATED"] = "multiaddrUpdated";
+    return Discv5Event;
+}({});
+/**
+ * Events emitted from the GossipSub protocol.
+ */ export var GossipSubEvent = /*#__PURE__*/ function(GossipSubEvent) {
+    GossipSubEvent["MESSAGE"] = "gossipsub:message";
+    return GossipSubEvent;
+}({});
+/***************************************************
+ *                    Types
+ ***************************************************/ /**
+ * Aztec network specific types
+ */ export const AZTEC_ENR_KEY = 'aztec';
+export const AZTEC_ENR_CLIENT_VERSION_KEY = 'ver';

package/dest/util.d.ts

@@ -0,0 +1,66 @@
+import { SecretValue } from '@aztec-labs/foundation/config';
+import { type Logger } from '@aztec-labs/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import type { DataStoreConfig } from '@aztec-labs/stdlib/kv-store';
+import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
+import type { Identify } from '@libp2p/identify';
+import type { PeerId } from '@libp2p/interface';
+import type { AddressManager, ConnectionManager } from '@libp2p/interface-internal';
+import type { Libp2p } from 'libp2p';
+import { type P2PConfig } from './config.js';
+export interface PubSubLibp2p extends Pick<Libp2p, 'status' | 'start' | 'stop' | 'peerId'> {
+    services: {
+        pubsub: Pick<GossipSub, 'addEventListener' | 'removeEventListener' | 'publish' | 'subscribe' | 'reportMessageValidationResult' | 'direct' | 'getMeshPeers'> & {
+            score: Pick<GossipSub['score'], 'score'>;
+        };
+        components: {
+            addressManager: Pick<AddressManager, 'addObservedAddr' | 'confirmObservedAddr' | 'removeObservedAddr'>;
+        };
+    };
+}
+export type FullLibp2p = Libp2p<{
+    identify: Identify;
+    pubsub: GossipSub;
+    components: {
+        connectionManager: ConnectionManager;
+        addressManager: AddressManager;
+    };
+}>;
+/**
+ * Converts an address string to a multiaddr string.
+ * Example usage:
+ * const tcpAddr = '123.456.7.8:80' -> /ip4/123.456.7.8/tcp/80
+ * const udpAddr = '[2001:db8::1]:8080' -> /ip6/2001:db8::1/udp/8080
+ * @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, port: number, protocol: 'tcp' | 'udp'): string;
+/**
+ * Queries the public IP address of the machine, trying multiple services in order.
+ * @param services - HTTPS URLs to try; defaults to {@link DEFAULT_PUBLIC_IP_SERVICES}.
+ */
+export declare function getPublicIp(services?: string[]): Promise<string>;
+export declare function isValidIpAddress(address: string): boolean;
+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 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?: 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
+ * @returns The peer ID.
+ */
+export declare function createLibP2PPeerIdFromPrivateKey(privateKey: string): Promise<PeerId>;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,sBAAsB,CAAC;AACnF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAc,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIpF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,OAAO,EAA8B,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAIzE,MAAM,WAAW,YAAa,SAAQ,IAAI,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACxF,QAAQ,EAAE;QACR,MAAM,EAAE,IAAI,CACV,SAAS,EACP,kBAAkB,GAClB,qBAAqB,GACrB,SAAS,GACT,WAAW,GACX,+BAA+B,GAC/B,QAAQ,GACR,cAAc,CACjB,GAAG;YAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAA;SAAE,CAAC;QACjD,UAAU,EAAE;YACV,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,iBAAiB,GAAG,qBAAqB,GAAG,oBAAoB,CAAC,CAAC;SACxG,CAAC;KACH,CAAC;CACH;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;IAC9B,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,EAAE,SAAS,CAAC;IAClB,UAAU,EAAE;QACV,iBAAiB,EAAE,iBAAiB,CAAC;QACrC,cAAc,EAAE,cAAc,CAAC;KAChC,CAAC;CACH,CAAC,CAAC;AAEH;;;;;;;6CAO6C;AAC7C,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAOjG;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,QAAQ,GAAE,MAAM,EAA+B,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBlG;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGzD;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAW9F;AAcD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,SAAS,GAAG,eAAe,GACnC,OAAO,CAAC,SAAS,GAAG,eAAe,CAAC,CAqBtC;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE;IAAE,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,EACzG,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CA2D9B;AAED;;;;GAIG;AACH,wBAAsB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAS1F"}