@aztec/p2p 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

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

@@ -0,0 +1,183 @@
+import { emptyChainConfig } from '@aztec/circuit-types/config';
+import { timesParallel } from '@aztec/foundation/collection';
+import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { gossipsub } from '@chainsafe/libp2p-gossipsub';
+import { noise } from '@chainsafe/libp2p-noise';
+import { yamux } from '@chainsafe/libp2p-yamux';
+import { bootstrap } from '@libp2p/bootstrap';
+import { identify } from '@libp2p/identify';
+import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+import { tcp } from '@libp2p/tcp';
+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 { ReqRespSubProtocol, noopValidator, } from '../services/reqresp/interface.js';
+import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
+import { ReqResp } from '../services/reqresp/reqresp.js';
+/**
+ * Creates a libp2p node, pre configured.
+ * @param boostrapAddrs - an optional list of bootstrap addresses
+ * @returns Lip2p node
+ */
+export async function createLibp2pNode(boostrapAddrs = [], peerId, port, enableGossipSub = false, start = true) {
+    port = port ?? (await getPort());
+    const options = {
+        start,
+        addresses: {
+            listen: [`/ip4/0.0.0.0/tcp/${port}`],
+            announce: [`/ip4/0.0.0.0/tcp/${port}`],
+        },
+        connectionEncryption: [noise()],
+        streamMuxers: [yamux()],
+        transports: [tcp()],
+        services: {
+            identify: identify({
+                protocolPrefix: 'aztec',
+            }),
+        },
+    };
+    if (boostrapAddrs.length > 0) {
+        options.peerDiscovery = [
+            bootstrap({
+                list: boostrapAddrs,
+            }),
+        ];
+    }
+    if (peerId) {
+        options.peerId = peerId;
+    }
+    if (enableGossipSub) {
+        options.services.pubsub = gossipsub({
+            allowPublishToZeroTopicPeers: true,
+        });
+    }
+    return await createLibp2p(options);
+}
+/**
+ * Test Libp2p service
+ * 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) {
+    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}`,
+        bootstrapNodes: boostrapAddrs,
+        peerCheckIntervalMS: 1000,
+        maxPeerCount: 5,
+        p2pEnabled: true,
+        peerIdPrivateKey: Buffer.from(peerId.privateKey).toString('hex'),
+        bootstrapNodeEnrVersionCheck: false,
+        ...chainConfig,
+    };
+    const discoveryService = new DiscV5Service(peerId, config, 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);
+}
+// Mock sub protocol handlers
+export const MOCK_SUB_PROTOCOL_HANDLERS = {
+    [ReqRespSubProtocol.PING]: pingHandler,
+    [ReqRespSubProtocol.STATUS]: statusHandler,
+    [ReqRespSubProtocol.TX]: (_msg) => Promise.resolve(Buffer.from('tx')),
+    [ReqRespSubProtocol.GOODBYE]: (_msg) => Promise.resolve(Buffer.from('goodbye')),
+    [ReqRespSubProtocol.BLOCK]: (_msg) => Promise.resolve(Buffer.from('block')),
+};
+// By default, all requests are valid
+// If you want to test an invalid response, you can override the validator
+export const MOCK_SUB_PROTOCOL_VALIDATORS = {
+    [ReqRespSubProtocol.PING]: noopValidator,
+    [ReqRespSubProtocol.STATUS]: noopValidator,
+    [ReqRespSubProtocol.TX]: noopValidator,
+    [ReqRespSubProtocol.GOODBYE]: noopValidator,
+    [ReqRespSubProtocol.BLOCK]: 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 startNodes = async (nodes, subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS, subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS) => {
+    for (const node of nodes) {
+        await node.req.start(subProtocolHandlers, subProtocolValidators);
+    }
+};
+export const stopNodes = async (nodes) => {
+    const stopPromises = nodes.flatMap(node => [node.req.stop(), node.p2p.stop()]);
+    await Promise.all(stopPromises);
+};
+// Create a req resp node, exposing the underlying p2p node
+export const createReqResp = async (peerScoring) => {
+    const p2p = await createLibp2pNode();
+    const config = {
+        overallRequestTimeoutMs: 4000,
+        individualRequestTimeoutMs: 2000,
+    };
+    const req = new ReqResp(config, p2p, peerScoring);
+    return {
+        p2p,
+        req,
+    };
+};
+// Given a node list; hand shake all of the nodes with each other
+export const connectToPeers = async (nodes) => {
+    for (const node of nodes) {
+        for (const otherNode of nodes) {
+            if (node === otherNode) {
+                continue;
+            }
+            const addr = otherNode.p2p.getMultiaddrs()[0];
+            await node.p2p.dial(addr);
+        }
+    }
+};
+// Mock circuit verifier for testing - reimplementation from bb to avoid dependency
+export class AlwaysTrueCircuitVerifier {
+    verifyProof(_tx) {
+        return Promise.resolve(true);
+    }
+}
+export class AlwaysFalseCircuitVerifier {
+    verifyProof(_tx) {
+        return Promise.resolve(false);
+    }
+}
+// Bootnodes
+export function createBootstrapNodeConfig(privateKey, port, chainConfig) {
+    return {
+        udpListenAddress: `0.0.0.0:${port}`,
+        udpAnnounceAddress: `127.0.0.1:${port}`,
+        peerIdPrivateKey: privateKey,
+        maxPeerCount: 100,
+        dataDirectory: undefined,
+        dataStoreMapSizeKB: 0,
+        ...chainConfig,
+    };
+}
+export function createBootstrapNodeFromPrivateKey(privateKey, port, telemetry = getTelemetryClient(), chainConfig = emptyChainConfig) {
+    const config = createBootstrapNodeConfig(privateKey, port, chainConfig);
+    return startBootstrapNode(config, telemetry);
+}
+export async function createBootstrapNode(port, telemetry = getTelemetryClient(), chainConfig = emptyChainConfig) {
+    const peerId = await createSecp256k1PeerId();
+    const config = createBootstrapNodeConfig(Buffer.from(peerId.privateKey).toString('hex'), port, chainConfig);
+    return startBootstrapNode(config, telemetry);
+}
+async function startBootstrapNode(config, telemetry) {
+    // Open an ephemeral store that will only exist in memory
+    const store = await openTmpStore('bootstrap-node', true);
+    const bootstrapNode = new BootstrapNode(store, telemetry);
+    await bootstrapNode.start(config);
+    return bootstrapNode;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reqresp-nodes.js","sourceRoot":"","sources":["../../src/test-helpers/reqresp-nodes.ts"],"names":[],"mappings":"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"}

package/dest/testbench/p2p_client_testbench_worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=p2p_client_testbench_worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"p2p_client_testbench_worker.d.ts","sourceRoot":"","sources":["../../src/testbench/p2p_client_testbench_worker.ts"],"names":[],"mappings":""}

package/dest/testbench/p2p_client_testbench_worker.js

@@ -0,0 +1,125 @@
+/**
+ * A testbench worker that creates a p2p client and listens for commands from the parent.
+ *
+ * Used when running testbench commands
+ */
+import { MockL2BlockSource } from '@aztec/archiver/test';
+import { P2PClientType, Tx, TxStatus } from '@aztec/circuit-types';
+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 { createP2PClient } from '../index.js';
+import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+// Simple mock implementation
+function mockTxPool() {
+    // Mock all methods
+    return {
+        addTxs: () => Promise.resolve(),
+        getTxByHash: () => Promise.resolve(undefined),
+        getArchivedTxByHash: () => Promise.resolve(undefined),
+        markAsMined: () => Promise.resolve(),
+        markMinedAsPending: () => Promise.resolve(),
+        deleteTxs: () => Promise.resolve(),
+        getAllTxs: () => Promise.resolve([]),
+        getAllTxHashes: () => Promise.resolve([]),
+        getPendingTxHashes: () => Promise.resolve([]),
+        getMinedTxHashes: () => Promise.resolve([]),
+        getTxStatus: () => Promise.resolve(TxStatus.PENDING),
+    };
+}
+function mockAttestationPool() {
+    return {
+        addAttestations: () => Promise.resolve(),
+        deleteAttestations: () => Promise.resolve(),
+        deleteAttestationsOlderThan: () => Promise.resolve(),
+        deleteAttestationsForSlot: () => Promise.resolve(),
+        deleteAttestationsForSlotAndProposal: () => Promise.resolve(),
+        getAttestationsForSlot: () => Promise.resolve([]),
+    };
+}
+function mockEpochProofQuotePool() {
+    return {
+        addQuote: () => { },
+        getQuotes: () => [],
+        deleteQuotesToEpoch: () => { },
+    };
+}
+function mockEpochCache() {
+    return {
+        getCommittee: () => Promise.resolve([]),
+        getProposerIndexEncoding: () => '0x',
+        getEpochAndSlotNow: () => ({ epoch: 0n, slot: 0n, ts: 0n }),
+        computeProposerIndex: () => 0n,
+        getProposerInCurrentOrNextSlot: () => Promise.resolve({
+            currentProposer: EthAddress.ZERO,
+            nextProposer: EthAddress.ZERO,
+            currentSlot: 0n,
+            nextSlot: 0n,
+        }),
+        isInCommittee: () => Promise.resolve(false),
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-misused-promises
+process.on('message', async (msg) => {
+    const { type, config, clientIndex } = msg;
+    try {
+        if (type === 'START') {
+            const txPool = mockTxPool();
+            const attestationPool = mockAttestationPool();
+            const epochProofQuotePool = mockEpochProofQuotePool();
+            const epochCache = mockEpochCache();
+            const worldState = {};
+            const l2BlockSource = new MockL2BlockSource();
+            await l2BlockSource.createBlocks(100);
+            const proofVerifier = new AlwaysTrueCircuitVerifier();
+            const kvStore = await openTmpStore(`test-${clientIndex}`);
+            const logger = createLogger(`p2p:${clientIndex}`);
+            const deps = {
+                txPool,
+                attestationPool,
+                epochProofQuotePool,
+                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 = (...args) => {
+                gossipMessageCount++;
+                process.send({ type: 'GOSSIP_RECEIVED', count: gossipMessageCount });
+                return client.p2pService.constructor.prototype.handleNewGossipMessage.apply(client.p2pService, args);
+            };
+            await client.start();
+            // Wait until the client is ready
+            for (let i = 0; i < 100; i++) {
+                const isReady = client.isReady();
+                logger.debug(`Client ${clientIndex} isReady: ${isReady}`);
+                if (isReady) {
+                    break;
+                }
+                await sleep(1000);
+            }
+            // Listen for commands from parent
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            process.on('message', async (cmd) => {
+                switch (cmd.type) {
+                    case 'STOP':
+                        await client.stop();
+                        process.exit(0);
+                        break;
+                    case 'SEND_TX':
+                        await client.sendTx(Tx.fromBuffer(Buffer.from(cmd.tx)));
+                        process.send({ type: 'TX_SENT' });
+                        break;
+                }
+            });
+            process.send({ type: 'READY' });
+        }
+    }
+    catch (err) {
+        process.send({ type: 'ERROR', error: err.message });
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dest/util.d.ts

@@ -0,0 +1,53 @@
+import { type AztecAsyncKVStore } from '@aztec/kv-store';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
+import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
+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 {
+    services: {
+        pubsub: GossipSub;
+        components: {
+            connectionManager: ConnectionManager;
+        };
+    };
+}
+/**
+ * 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, 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];
+/**
+ * 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 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
+ *
+ */
+export declare function getPeerIdPrivateKey(config: {
+    peerIdPrivateKey?: string;
+}, store: AztecAsyncKVStore): Promise<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=util.d.ts.map

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,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,KAAK,MAAM,EAAmB,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,WAAW,YAAa,SAAQ,MAAM;IAC1C,QAAQ,EAAE;QACR,MAAM,EAAE,SAAS,CAAC;QAClB,UAAU,EAAE;YACV,iBAAiB,EAAE,iBAAiB,CAAC;SACtC,CAAC;KACH,CAAC;CACH;AAED;;;;;;;6CAO6C;AAC7C,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CASnF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAoB9F;AAED;;GAEG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAInD;AAED,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAYhF;AAcD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,SAAS,GAAG,eAAe,GACnC,OAAO,CAAC,SAAS,GAAG,eAAe,CAAC,CA6CtC;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE,EACrC,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,MAAM,CAAC,CAiBjB;AAED;;;;GAIG;AACH,wBAAsB,gCAAgC,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAS1F"}

package/dest/util.js

@@ -8,7 +8,8 @@ import { resolve } from 'dns/promises';
  * 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 function convertToMultiaddr(address, protocol) {
+ * @returns A multiaddr compliant string.  */
+export function convertToMultiaddr(address, protocol) {
     const [addr, port] = splitAddressPort(address, false);
     const multiaddrPrefix = addressToMultiAddressType(addr);
     if (multiaddrPrefix === 'dns') {
@@ -19,7 +20,8 @@ import { resolve } from 'dns/promises';
 /**
  * Splits an <address>:<port> string into its components.
  * @returns The ip6 or ip4 address & port separately
- */ export function splitAddressPort(address, allowEmptyAddress) {
+ */
+export function splitAddressPort(address, allowEmptyAddress) {
     let addr;
     let port;
     if (address.startsWith('[')) {
@@ -29,21 +31,20 @@ import { resolve } from 'dns/promises';
             throw new Error(`Invalid IPv6 address format:${address}. Expected format: [<addr>]:<port>`);
         }
         [, addr, port] = match;
-    } else {
+    }
+    else {
         // IPv4 address
         [addr, port] = address.split(':');
-        if (!addr && !allowEmptyAddress || !port) {
+        if ((!addr && !allowEmptyAddress) || !port) {
             throw new Error(`Invalid address format: ${address}. Expected format: <addr>:<port>`);
         }
     }
-    return [
-        addr,
-        port
-    ];
+    return [addr, port];
 }
 /**
  * Queries the public IP address of the machine.
- */ export async function getPublicIp() {
+ */
+export async function getPublicIp() {
     const resp = await fetch('http://checkip.amazonaws.com/');
     const text = await resp.text();
     return text.trim();
@@ -57,7 +58,8 @@ export async function resolveAddressIfNecessary(address) {
             throw new Error(`Could not resolve address: ${addr}`);
         }
         return `${resolvedAddresses[0]}:${port}`;
-    } else {
+    }
+    else {
         return address;
     }
 }
@@ -66,19 +68,23 @@ export async function resolveAddressIfNecessary(address) {
 function addressToMultiAddressType(address) {
     if (address.includes(':')) {
         return 'ip6';
-    } else if (address.match(/^[\d.]+$/)) {
+    }
+    else if (address.match(/^[\d.]+$/)) {
         return 'ip4';
-    } else {
+    }
+    else {
         return 'dns';
     }
 }
 export async function configureP2PClientAddresses(_config) {
-    const config = {
-        ..._config
-    };
-    const { tcpAnnounceAddress: configTcpAnnounceAddress, udpAnnounceAddress: configUdpAnnounceAddress, queryForIp } = config;
-    config.tcpAnnounceAddress = configTcpAnnounceAddress ? await resolveAddressIfNecessary(configTcpAnnounceAddress) : undefined;
-    config.udpAnnounceAddress = configUdpAnnounceAddress ? await resolveAddressIfNecessary(configUdpAnnounceAddress) : undefined;
+    const config = { ..._config };
+    const { tcpAnnounceAddress: configTcpAnnounceAddress, udpAnnounceAddress: configUdpAnnounceAddress, queryForIp, } = config;
+    config.tcpAnnounceAddress = configTcpAnnounceAddress
+        ? await resolveAddressIfNecessary(configTcpAnnounceAddress)
+        : undefined;
+    config.udpAnnounceAddress = configUdpAnnounceAddress
+        ? await resolveAddressIfNecessary(configUdpAnnounceAddress)
+        : undefined;
     // create variable for re-use if needed
     let publicIp;
     // check if no announce IP was provided
@@ -88,7 +94,8 @@ export async function configureP2PClientAddresses(_config) {
             publicIp = await getPublicIp();
             const tcpAnnounceAddress = `${publicIp}:${splitTcpAnnounceAddress[1]}`;
             config.tcpAnnounceAddress = tcpAnnounceAddress;
-        } else {
+        }
+        else {
             throw new Error(`Invalid announceTcpAddress provided: ${configTcpAnnounceAddress}. Expected format: <addr>:<port>`);
         }
     }
@@ -97,8 +104,9 @@ export async function configureP2PClientAddresses(_config) {
         // If announceUdpAddress is not provided, use announceTcpAddress
         if (!queryForIp && config.tcpAnnounceAddress) {
             config.udpAnnounceAddress = config.tcpAnnounceAddress;
-        } else if (queryForIp) {
-            const udpPublicIp = publicIp || await getPublicIp();
+        }
+        else if (queryForIp) {
+            const udpPublicIp = publicIp || (await getPublicIp());
             const udpAnnounceAddress = `${udpPublicIp}:${splitUdpAnnounceAddress[1]}`;
             config.udpAnnounceAddress = udpAnnounceAddress;
         }
@@ -112,7 +120,8 @@ export async function configureP2PClientAddresses(_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
  *
- */ export async function getPeerIdPrivateKey(config, store) {
+ */
+export async function getPeerIdPrivateKey(config, store) {
     const peerIdPrivateKeySingleton = store.openSingleton('peerIdPrivateKey');
     if (config.peerIdPrivateKey) {
         await peerIdPrivateKeySingleton.set(config.peerIdPrivateKey);
@@ -131,10 +140,12 @@ export async function configureP2PClientAddresses(_config) {
  * Create a libp2p peer ID from the private key.
  * @param privateKey - peer ID private key as hex string
  * @returns The peer ID.
- */ export async function createLibP2PPeerIdFromPrivateKey(privateKey) {
+ */
+export async function createLibP2PPeerIdFromPrivateKey(privateKey) {
     if (!privateKey?.length) {
         throw new Error('No peer private key provided');
     }
     const asLibp2pPrivateKey = await unmarshalPrivateKey(new Uint8Array(Buffer.from(privateKey, 'hex')));
     return await createFromPrivKey(asLibp2pPrivateKey);
 }
+//# sourceMappingURL=data:application/json;base64,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

package/dest/versioning.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type ComponentsVersions } from '@aztec/circuit-types';
+import { type ChainConfig } from '@aztec/circuit-types/config';
+import { type SignableENR } from '@chainsafe/enr';
+/** Returns the component versions based on config and this build. */
+export declare function getVersions(config: ChainConfig): ComponentsVersions;
+/** Sets the aztec key on the ENR record with versioning info. */
+export declare function setAztecEnrKey(enr: SignableENR, config: ChainConfig, useXxHash?: boolean): ComponentsVersions;
+/** Checks the given value from an ENR record against the expected versions. */
+export declare function checkAztecEnrVersion(enrValue: Buffer, expectedVersions: ComponentsVersions): void;
+//# sourceMappingURL=versioning.d.ts.map

package/dest/versioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioning.d.ts","sourceRoot":"","sources":["../src/versioning.ts"],"names":[],"mappings":";;AAAA,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAK/D,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AASlD,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,sBAE9C;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,UAAc,sBAK5F;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,kBAAkB,QAU1F"}

package/dest/versioning.js

@@ -0,0 +1,38 @@
+import { checkCompressedComponentVersion, compressComponentVersions, getComponentsVersionsFromConfig, } from '@aztec/circuit-types';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import xxhashFactory from 'xxhash-wasm';
+import { AZTEC_ENR_KEY } from './services/types.js';
+const USE_XX_HASH = false; // Enable to reduce the size of the ENR record for production
+const XX_HASH_LEN = 8;
+const xxhash = await xxhashFactory();
+/** Returns the component versions based on config and this build. */
+export function getVersions(config) {
+    return getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot());
+}
+/** Sets the aztec key on the ENR record with versioning info. */
+export function setAztecEnrKey(enr, config, useXxHash = USE_XX_HASH) {
+    const versions = getVersions(config);
+    const value = versionsToEnrValue(versions, useXxHash);
+    enr.set(AZTEC_ENR_KEY, value);
+    return versions;
+}
+/** Checks the given value from an ENR record against the expected versions. */
+export function checkAztecEnrVersion(enrValue, expectedVersions) {
+    if (enrValue.length === XX_HASH_LEN) {
+        const expected = versionsToEnrValue(expectedVersions, true);
+        if (!Buffer.from(enrValue).equals(expected)) {
+            throw new Error(`Expected ENR version ${expected.toString('hex')} but received ${enrValue.toString('hex')}`);
+        }
+    }
+    else {
+        const actual = Buffer.from(enrValue).toString();
+        checkCompressedComponentVersion(actual, expectedVersions);
+    }
+}
+function versionsToEnrValue(versions, useXxHash) {
+    const compressed = compressComponentVersions(versions);
+    return useXxHash ? toBufferBE(xxhash.h64(compressed), XX_HASH_LEN) : Buffer.from(compressed);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+  "version": "0.76.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
-    "./mocks": "./dest/mocks/index.js",
+    "./test-helpers": "./dest/test-helpers/index.js",
     "./bootstrap": "./dest/bootstrap/bootstrap.js",
     "./config": "./dest/config.js",
     "./msg_validators": "./dest/msg_validators/index.js"
@@ -22,7 +22,7 @@
     "clean": "rm -rf ./dest .tsbuildinfo",
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
-    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "test": "HARDWARE_CONCURRENCY=${HARDWARE_CONCURRENCY:-16} RAYON_NUM_THREADS=${RAYON_NUM_THREADS:-4} NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
     "start": "node ./dest",
     "start:dev": "tsc-watch -p tsconfig.json --onSuccess 'yarn start'"
   },
@@ -63,12 +63,14 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
-    "@aztec/circuits.js": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
-    "@aztec/epoch-cache": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
-    "@aztec/foundation": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
-    "@aztec/kv-store": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
-    "@aztec/telemetry-client": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/circuit-types": "0.76.0",
+    "@aztec/circuits.js": "0.76.0",
+    "@aztec/epoch-cache": "0.76.0",
+    "@aztec/foundation": "0.76.0",
+    "@aztec/kv-store": "0.76.0",
+    "@aztec/noir-protocol-circuits-types": "0.76.0",
+    "@aztec/protocol-contracts": "0.76.0",
+    "@aztec/telemetry-client": "0.76.0",
     "@chainsafe/discv5": "9.0.0",
     "@chainsafe/enr": "3.0.0",
     "@chainsafe/libp2p-gossipsub": "13.0.0",