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

package/dest/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,KAAK,EAAE,MAAM,EAAc,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,EAAE,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"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,iBAAiB,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,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,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C,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,EACT,kBAAkB,GAAG,qBAAqB,GAAG,SAAS,GAAG,WAAW,GAAG,+BAA+B,GAAG,QAAQ,CAClH,GAAG;YAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAA;SAAE,CAAC;KAClD,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;KACtC,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;;GAEG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAInD;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,CAmBtC;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"}

package/dest/util.js

@@ -1,6 +1,10 @@
+import { SecretValue } from '@aztec/foundation/config';
 import { generateKeyPair, marshalPrivateKey, unmarshalPrivateKey } from '@libp2p/crypto/keys';
 import { createFromPrivKey } from '@libp2p/peer-id-factory';
 import { resolve } from 'dns/promises';
+import { promises as fs } from 'fs';
+import path from 'path';
+const PEER_ID_DATA_DIR_FILE = 'p2p-private-key';
 /**
  * Converts an address string to a multiaddr string.
  * Example usage:
@@ -8,38 +12,12 @@ 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) {
-    const [addr, port] = splitAddressPort(address, false);
-    const multiaddrPrefix = addressToMultiAddressType(addr);
+ * @returns A multiaddr compliant string.  */ export function convertToMultiaddr(address, port, protocol) {
+    const multiaddrPrefix = addressToMultiAddressType(address);
     if (multiaddrPrefix === 'dns') {
         throw new Error('Invalid address format. Expected an IPv4 or IPv6 address.');
     }
-    return `/${multiaddrPrefix}/${addr}/${protocol}/${port}`;
-}
-/**
- * Splits an <address>:<port> string into its components.
- * @returns The ip6 or ip4 address & port separately
- */ export function splitAddressPort(address, allowEmptyAddress) {
-    let addr;
-    let port;
-    if (address.startsWith('[')) {
-        // IPv6 address enclosed in square brackets
-        const match = address.match(/^\[([^\]]+)\]:(\d+)$/);
-        if (!match) {
-            throw new Error(`Invalid IPv6 address format:${address}. Expected format: [<addr>]:<port>`);
-        }
-        [, addr, port] = match;
-    } else {
-        // IPv4 address
-        [addr, port] = address.split(':');
-        if (!addr && !allowEmptyAddress || !port) {
-            throw new Error(`Invalid address format: ${address}. Expected format: <addr>:<port>`);
-        }
-    }
-    return [
-        addr,
-        port
-    ];
+    return `/${multiaddrPrefix}/${address}/${protocol}/${port}`;
 }
 /**
  * Queries the public IP address of the machine.
@@ -48,13 +26,12 @@ import { resolve } from 'dns/promises';
     const text = await resp.text();
     return text.trim();
 }
-export async function resolveAddressIfNecessary(address) {
-    const [addr, port] = splitAddressPort(address, false);
-    const multiaddrPrefix = addressToMultiAddressType(addr);
+export async function resolveAddressIfNecessary(address, port) {
+    const multiaddrPrefix = addressToMultiAddressType(address);
     if (multiaddrPrefix === 'dns') {
-        const resolvedAddresses = await resolve(addr);
+        const resolvedAddresses = await resolve(address);
         if (resolvedAddresses.length === 0) {
-            throw new Error(`Could not resolve address: ${addr}`);
+            throw new Error(`Could not resolve address: ${address}`);
         }
         return `${resolvedAddresses[0]}:${port}`;
     } else {
@@ -76,56 +53,76 @@ 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;
-    // create variable for re-use if needed
-    let publicIp;
+    const { p2pIp, queryForIp, p2pBroadcastPort, p2pPort } = config;
+    // If no broadcast port is provided, use the given p2p port as the broadcast port
+    if (!p2pBroadcastPort) {
+        config.p2pBroadcastPort = p2pPort;
+    }
     // check if no announce IP was provided
-    const splitTcpAnnounceAddress = splitAddressPort(configTcpAnnounceAddress || '', true);
-    if (splitTcpAnnounceAddress.length == 2 && splitTcpAnnounceAddress[0] === '') {
+    if (!p2pIp) {
         if (queryForIp) {
-            publicIp = await getPublicIp();
-            const tcpAnnounceAddress = `${publicIp}:${splitTcpAnnounceAddress[1]}`;
-            config.tcpAnnounceAddress = tcpAnnounceAddress;
-        } else {
-            throw new Error(`Invalid announceTcpAddress provided: ${configTcpAnnounceAddress}. Expected format: <addr>:<port>`);
-        }
-    }
-    const splitUdpAnnounceAddress = splitAddressPort(configUdpAnnounceAddress || '', true);
-    if (splitUdpAnnounceAddress.length == 2 && splitUdpAnnounceAddress[0] === '') {
-        // If announceUdpAddress is not provided, use announceTcpAddress
-        if (!queryForIp && config.tcpAnnounceAddress) {
-            config.udpAnnounceAddress = config.tcpAnnounceAddress;
-        } else if (queryForIp) {
-            const udpPublicIp = publicIp || await getPublicIp();
-            const udpAnnounceAddress = `${udpPublicIp}:${splitUdpAnnounceAddress[1]}`;
-            config.udpAnnounceAddress = udpAnnounceAddress;
+            const publicIp = await getPublicIp();
+            config.p2pIp = publicIp;
         }
     }
+    // TODO(md): guard against setting a local ip address as the announce ip
     return config;
 }
 /**
  * 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 async function getPeerIdPrivateKey(config, store) {
-    const peerIdPrivateKeySingleton = store.openSingleton('peerIdPrivateKey');
-    if (config.peerIdPrivateKey) {
-        await peerIdPrivateKeySingleton.set(config.peerIdPrivateKey);
+ */ export async function getPeerIdPrivateKey(config, store, logger) {
+    const peerIdPrivateKeyFilePath = config.peerIdPrivateKeyPath ?? (config.dataDirectory ? path.join(config.dataDirectory, PEER_ID_DATA_DIR_FILE) : undefined);
+    let peerIdPrivateKeySingleton;
+    const writePrivateKeyToFile = async (filePath, privateKey)=>{
+        await fs.mkdir(path.dirname(filePath), {
+            recursive: true
+        });
+        await fs.writeFile(filePath, privateKey);
+    };
+    // If the peerIdPrivateKey is provided in the config, we use it and persist it in either a file or the node's store
+    if (config.peerIdPrivateKey && config.peerIdPrivateKey.getValue().trim()) {
+        if (peerIdPrivateKeyFilePath) {
+            await writePrivateKeyToFile(peerIdPrivateKeyFilePath, config.peerIdPrivateKey.getValue());
+        } else {
+            peerIdPrivateKeySingleton = store.openSingleton('peerIdPrivateKey');
+            await peerIdPrivateKeySingleton.set(config.peerIdPrivateKey.getValue());
+        }
         return config.peerIdPrivateKey;
     }
-    const storedPeerIdPrivateKey = await peerIdPrivateKeySingleton.getAsync();
+    // Check to see if we have a peer id private key stored in a file or the node's store
+    let storedPeerIdPrivateKey;
+    const privateKeyFileExists = peerIdPrivateKeyFilePath && await fs.access(peerIdPrivateKeyFilePath).then(()=>true).catch(()=>false);
+    if (peerIdPrivateKeyFilePath && privateKeyFileExists) {
+        await fs.access(peerIdPrivateKeyFilePath);
+        storedPeerIdPrivateKey = await fs.readFile(peerIdPrivateKeyFilePath, 'utf8');
+    } else {
+        peerIdPrivateKeySingleton = store.openSingleton('peerIdPrivateKey');
+        storedPeerIdPrivateKey = await peerIdPrivateKeySingleton.getAsync();
+    }
     if (storedPeerIdPrivateKey) {
-        return storedPeerIdPrivateKey;
+        if (peerIdPrivateKeyFilePath && !privateKeyFileExists) {
+            logger.verbose(`Peer ID private key found in the node's store, persisting it to ${peerIdPrivateKeyFilePath}`);
+            await writePrivateKeyToFile(peerIdPrivateKeyFilePath, storedPeerIdPrivateKey);
+        }
+        return new SecretValue(storedPeerIdPrivateKey);
     }
+    // Generate and persist a new private key
     const newPeerIdPrivateKey = await generateKeyPair('secp256k1');
     const privateKeyString = Buffer.from(marshalPrivateKey(newPeerIdPrivateKey)).toString('hex');
-    await peerIdPrivateKeySingleton.set(privateKeyString);
-    return privateKeyString;
+    if (peerIdPrivateKeyFilePath) {
+        logger.verbose(`Creating new peer ID private key and persisting it to ${peerIdPrivateKeyFilePath}`);
+        await writePrivateKeyToFile(peerIdPrivateKeyFilePath, privateKeyString);
+    } else {
+        logger.warn('Creating new peer ID private key and persisting it to the lmdb store. Key will be lost on rollup upgrade, specify the peer id private key path and restart the node to persist the peer id private key to a file');
+        await peerIdPrivateKeySingleton.set(privateKeyString);
+    }
+    return new SecretValue(privateKeyString);
 }
 /**
  * Create a libp2p peer ID from the private key.

package/dest/versioning.d.ts

@@ -1,12 +1,12 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { type ComponentsVersions } from '@aztec/stdlib/versioning';
-import type { SignableENR } from '@chainsafe/enr';
+import type { SignableENR } from '@nethermindeth/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;
+/** Sets the Aztec client version on ENR record **/
+export declare function setAztecClientVersionEnrKey(enr: SignableENR, clientVersion: string): void;
 /** 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

@@ -1 +1 @@
-{"version":3,"file":"versioning.d.ts","sourceRoot":"","sources":["../src/versioning.ts"],"names":[],"mappings":";;AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,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"}
+{"version":3,"file":"versioning.d.ts","sourceRoot":"","sources":["../src/versioning.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAStD,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,mDAAmD;AACnD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,QAIlF;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,kBAAkB,QAU1F"}

package/dest/versioning.js

@@ -1,14 +1,14 @@
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { checkCompressedComponentVersion, compressComponentVersions, getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 import xxhashFactory from 'xxhash-wasm';
-import { AZTEC_ENR_KEY } from './types/index.js';
+import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from './types/index.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());
+    return getComponentsVersionsFromConfig(config, protocolContractsHash, 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);
@@ -16,6 +16,11 @@ const xxhash = await xxhashFactory();
     enr.set(AZTEC_ENR_KEY, value);
     return versions;
 }
+/** Sets the Aztec client version on ENR record **/ export function setAztecClientVersionEnrKey(enr, clientVersion) {
+    if (clientVersion) {
+        enr.set(AZTEC_ENR_CLIENT_VERSION_KEY, Buffer.from(clientVersion));
+    }
+}
 /** 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.0.0-test.0",
+  "version": "0.0.1-commit.24de95ac",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -22,8 +22,6 @@
     "build": "yarn clean && tsc -b",
     "build:dev": "tsc -b --watch",
     "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}",
     "start": "node ./dest",
     "start:dev": "tsc-watch -p tsconfig.json --onSuccess 'yarn start'"
@@ -62,19 +60,24 @@
     "testTimeout": 120000,
     "setupFiles": [
       "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.0-test.0",
-    "@aztec/epoch-cache": "0.0.0-test.0",
-    "@aztec/foundation": "0.0.0-test.0",
-    "@aztec/kv-store": "0.0.0-test.0",
-    "@aztec/noir-protocol-circuits-types": "0.0.0-test.0",
-    "@aztec/protocol-contracts": "0.0.0-test.0",
-    "@aztec/stdlib": "0.0.0-test.0",
-    "@aztec/telemetry-client": "0.0.0-test.0",
-    "@chainsafe/discv5": "9.0.0",
-    "@chainsafe/enr": "3.0.0",
+    "@aztec/constants": "0.0.1-commit.24de95ac",
+    "@aztec/epoch-cache": "0.0.1-commit.24de95ac",
+    "@aztec/ethereum": "0.0.1-commit.24de95ac",
+    "@aztec/foundation": "0.0.1-commit.24de95ac",
+    "@aztec/kv-store": "0.0.1-commit.24de95ac",
+    "@aztec/noir-contracts.js": "0.0.1-commit.24de95ac",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.24de95ac",
+    "@aztec/protocol-contracts": "0.0.1-commit.24de95ac",
+    "@aztec/simulator": "0.0.1-commit.24de95ac",
+    "@aztec/stdlib": "0.0.1-commit.24de95ac",
+    "@aztec/telemetry-client": "0.0.1-commit.24de95ac",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
     "@chainsafe/libp2p-noise": "^15.0.0",
     "@chainsafe/libp2p-yamux": "^6.0.2",
@@ -82,7 +85,6 @@
     "@libp2p/crypto": "4.0.3",
     "@libp2p/identify": "1.0.18",
     "@libp2p/interface": "1.3.1",
-    "@libp2p/kad-dht": "10.0.4",
     "@libp2p/mplex": "10.0.16",
     "@libp2p/peer-id": "4.0.7",
     "@libp2p/peer-id-factory": "4.1.1",
@@ -90,9 +92,10 @@
     "@libp2p/prometheus-metrics": "^4.2.4",
     "@libp2p/tcp": "9.0.24",
     "@multiformats/multiaddr": "12.1.14",
+    "@nethermindeth/discv5": "9.0.0-backport-306-v4",
+    "@nethermindeth/enr": "3.0.0-backport-306-v4",
     "interface-datastore": "^8.2.11",
     "interface-store": "^5.1.8",
-    "it-pipe": "^3.0.1",
     "libp2p": "1.5.0",
     "semver": "^7.6.0",
     "sha3": "^2.1.4",
@@ -101,19 +104,20 @@
     "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.0-test.0",
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.0",
-    "@types/node": "^18.14.6",
+    "@aztec/archiver": "0.0.1-commit.24de95ac",
+    "@aztec/world-state": "0.0.1-commit.24de95ac",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
     "get-port": "^7.1.0",
     "it-drain": "^3.0.5",
     "it-length": "^3.0.6",
-    "jest": "^29.5.0",
-    "jest-mock-extended": "^3.0.4",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4",
+    "typescript": "^5.3.3",
     "uint8arrays": "^5.0.3",
-    "viem": "2.22.8"
+    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
   },
   "files": [
     "dest",
@@ -122,6 +126,6 @@
   ],
   "types": "./dest/index.d.ts",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.10"
   }
 }

package/src/bootstrap/bootstrap.ts

@@ -3,20 +3,20 @@ import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { P2PBootstrapApi } from '@aztec/stdlib/interfaces/server';
 import { OtelMetricsAdapter, type TelemetryClient } from '@aztec/telemetry-client';
 
-import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
-import { ENR, type SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import { Discv5, type Discv5EventEmitter } from '@nethermindeth/discv5';
+import { ENR, type SignableENR } from '@nethermindeth/enr';
 
 import type { BootnodeConfig } from '../config.js';
 import { createBootnodeENRandPeerId } from '../enr/generate-enr.js';
-import { convertToMultiaddr, getPeerIdPrivateKey } from '../util.js';
+import { convertToMultiaddr, getPeerIdPrivateKey, getPublicIp } from '../util.js';
 
 /**
  * Encapsulates a 'Bootstrap' node, used for the purpose of assisting new joiners in acquiring peers.
  */
 export class BootstrapNode implements P2PBootstrapApi {
-  private node?: Discv5 & Discv5EventEmitter = undefined;
+  private node?: Discv5EventEmitter = undefined;
   private peerId?: PeerId;
 
   constructor(
@@ -31,18 +31,34 @@ export class BootstrapNode implements P2PBootstrapApi {
    * @returns An empty promise.
    */
   public async start(config: BootnodeConfig) {
-    const { udpListenAddress, udpAnnounceAddress } = config;
-    const listenAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
+    const { p2pPort, listenAddress, p2pBroadcastPort, queryForIp } = config;
+    let p2pIp = config.p2pIp;
+    this.logger.info(`Starting bootstrap node with config: ${JSON.stringify(config)}`);
+    if (!p2pIp) {
+      if (queryForIp) {
+        this.logger.info('Querying for public IP address...');
+        const publicIp = await getPublicIp();
+        p2pIp = publicIp;
+        this.logger.info(`Found public IP address: ${publicIp}`);
+      }
+    }
 
-    if (!udpAnnounceAddress) {
-      throw new Error('You need to provide a UDP announce address.');
+    if (!p2pIp) {
+      throw new Error('You need to provide a P2P IP address.');
     }
 
-    const peerIdPrivateKey = await getPeerIdPrivateKey(config, this.store);
+    if (!p2pBroadcastPort) {
+      config.p2pBroadcastPort = p2pPort;
+    }
+
+    const listenAddrUdp = multiaddr(convertToMultiaddr(listenAddress, config.p2pBroadcastPort!, 'udp'));
+
+    const peerIdPrivateKey = await getPeerIdPrivateKey(config, this.store, this.logger);
 
     const { enr: ourEnr, peerId } = await createBootnodeENRandPeerId(
-      peerIdPrivateKey,
-      udpAnnounceAddress,
+      peerIdPrivateKey.getValue(),
+      p2pIp,
+      config.p2pBroadcastPort!,
       config.l1ChainId,
     );
     this.peerId = peerId;

package/src/client/factory.ts

@@ -1,9 +1,12 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
-import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { AztecLMDBStoreV2, createStore } from '@aztec/kv-store/lmdb-v2';
 import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { P2PClientType } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -11,79 +14,167 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-clien
 import { P2PClient } from '../client/p2p_client.js';
 import type { P2PConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { InMemoryAttestationPool } from '../mem_pools/attestation_pool/memory_attestation_pool.js';
+import { KvAttestationPool } from '../mem_pools/attestation_pool/kv_attestation_pool.js';
 import type { MemPools } from '../mem_pools/interface.js';
 import { AztecKVTxPool, type TxPool } from '../mem_pools/tx_pool/index.js';
-import { DiscV5Service } from '../services/discv5/discV5_service.js';
 import { DummyP2PService } from '../services/dummy_service.js';
 import { LibP2PService } from '../services/index.js';
+import { TxCollection } from '../services/tx_collection/tx_collection.js';
+import { type TxSource, createNodeRpcTxSources } from '../services/tx_collection/tx_source.js';
 import { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
 
-type P2PClientDeps<T extends P2PClientType> = {
+export type P2PClientDeps<T extends P2PClientType> = {
   txPool?: TxPool;
   store?: AztecAsyncKVStore;
   attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
   logger?: Logger;
+  txCollectionNodeSources?: TxSource[];
+  p2pServiceFactory?: (...args: Parameters<(typeof LibP2PService)['new']>) => Promise<LibP2PService<T>>;
 };
 
-export const createP2PClient = async <T extends P2PClientType>(
+export const P2P_STORE_NAME = 'p2p';
+export const P2P_ARCHIVE_STORE_NAME = 'p2p-archive';
+export const P2P_PEER_STORE_NAME = 'p2p-peers';
+export const P2P_ATTESTATION_STORE_NAME = 'p2p-attestation';
+
+export async function createP2PClient<T extends P2PClientType>(
   clientType: T,
-  _config: P2PConfig & DataStoreConfig,
-  l2BlockSource: L2BlockSource,
+  inputConfig: P2PConfig & DataStoreConfig & ChainConfig,
+  archiver: L2BlockSource & ContractDataSource,
   proofVerifier: ClientProtocolCircuitVerifier,
   worldStateSynchronizer: WorldStateSynchronizer,
   epochCache: EpochCacheInterface,
+  packageVersion: string,
+  dateProvider: DateProvider = new DateProvider(),
   telemetry: TelemetryClient = getTelemetryClient(),
   deps: P2PClientDeps<T> = {},
-) => {
-  let config = { ..._config };
+) {
+  const config = await configureP2PClientAddresses({
+    ...inputConfig,
+    dataStoreMapSizeKb: inputConfig.p2pStoreMapSizeKb ?? inputConfig.dataStoreMapSizeKb,
+  });
+
   const logger = deps.logger ?? createLogger('p2p');
-  const store = deps.store ?? (await createStore('p2p', 1, config, createLogger('p2p:lmdb-v2')));
-  const archive = await createStore('p2p-archive', 1, config, createLogger('p2p-archive:lmdb-v2'));
+
+  if (config.bootstrapNodes.length === 0) {
+    logger.warn(
+      'No bootstrap nodes have been provided. Set the BOOTSTRAP_NODES environment variable in order to join the P2P network',
+    );
+  }
+
+  const store = deps.store ?? (await createStore(P2P_STORE_NAME, 2, config, createLogger('p2p:lmdb-v2')));
+  const archive = await createStore(P2P_ARCHIVE_STORE_NAME, 1, config, createLogger('p2p-archive:lmdb-v2'));
+  const peerStore = await createStore(P2P_PEER_STORE_NAME, 1, config, createLogger('p2p-peer:lmdb-v2'));
+  const attestationStore = await createStore(
+    P2P_ATTESTATION_STORE_NAME,
+    1,
+    config,
+    createLogger('p2p-attestation:lmdb-v2'),
+  );
+  const l1Constants = await archiver.getL1Constants();
 
   const mempools: MemPools<T> = {
-    txPool: deps.txPool ?? new AztecKVTxPool(store, archive, telemetry, config.archivedTxLimit),
+    txPool:
+      deps.txPool ??
+      new AztecKVTxPool(store, archive, worldStateSynchronizer, telemetry, {
+        maxTxPoolSize: config.maxTxPoolSize,
+        archivedTxLimit: config.archivedTxLimit,
+      }),
     attestationPool:
       clientType === P2PClientType.Full
-        ? ((deps.attestationPool ?? new InMemoryAttestationPool(telemetry)) as T extends P2PClientType.Full
+        ? ((deps.attestationPool ?? new KvAttestationPool(attestationStore, telemetry)) as T extends P2PClientType.Full
             ? AttestationPool
             : undefined)
         : undefined,
   };
 
-  let p2pService;
+  const p2pService = await createP2PService<T>(
+    config,
+    clientType,
+    archiver,
+    proofVerifier,
+    worldStateSynchronizer,
+    epochCache,
+    store,
+    peerStore,
+    mempools,
+    deps.p2pServiceFactory,
+    packageVersion,
+    logger.createChild('libp2p_service'),
+    telemetry,
+  );
 
-  if (_config.p2pEnabled) {
-    logger.verbose('P2P is enabled. Using LibP2P service.');
-    config = await configureP2PClientAddresses(_config);
+  const nodeSources = [
+    ...createNodeRpcTxSources(config.txCollectionNodeRpcUrls, config),
+    ...(deps.txCollectionNodeSources ?? []),
+  ];
+  if (nodeSources.length > 0) {
+    logger.info(`Using ${nodeSources.length} node RPC sources for tx collection.`, {
+      nodes: nodeSources.map(n => n.getInfo()),
+    });
+  }
 
-    // Create peer discovery service
-    const peerIdPrivateKey = await getPeerIdPrivateKey(config, store);
-    const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey);
-    const discoveryService = new DiscV5Service(
-      peerId,
-      config,
-      telemetry,
-      createLogger(`${logger.module}:discv5_service`),
-    );
+  const txCollection = new TxCollection(
+    p2pService,
+    nodeSources,
+    l1Constants,
+    mempools.txPool,
+    config,
+    dateProvider,
+    telemetry,
+    logger.createChild('tx-collection'),
+  );
 
-    p2pService = await LibP2PService.new<T>(
-      clientType,
-      config,
-      discoveryService,
-      peerId,
-      mempools,
-      l2BlockSource,
-      epochCache,
-      proofVerifier,
-      worldStateSynchronizer,
-      store,
-      telemetry,
-      createLogger(`${logger.module}:libp2p_service`),
-    );
-  } else {
-    logger.verbose('P2P is disabled. Using dummy P2P service');
-    p2pService = new DummyP2PService();
+  return new P2PClient(
+    clientType,
+    store,
+    archiver,
+    mempools,
+    p2pService,
+    txCollection,
+    config,
+    dateProvider,
+    telemetry,
+  );
+}
+
+async function createP2PService<T extends P2PClientType>(
+  config: P2PConfig & DataStoreConfig,
+  clientType: T,
+  archiver: L2BlockSource & ContractDataSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  epochCache: EpochCacheInterface,
+  store: AztecAsyncKVStore,
+  peerStore: AztecLMDBStoreV2,
+  mempools: MemPools<T>,
+  p2pServiceFactory: P2PClientDeps<T>['p2pServiceFactory'],
+  packageVersion: string,
+  logger: Logger,
+  telemetry: TelemetryClient,
+) {
+  if (!config.p2pEnabled) {
+    logger.verbose('P2P is disabled. Using dummy P2P service.');
+    return new DummyP2PService();
   }
-  return new P2PClient(clientType, store, l2BlockSource, mempools, p2pService, config, telemetry);
-};
+
+  logger.verbose('P2P is enabled. Using LibP2P service.');
+
+  // Create peer discovery service
+  const peerIdPrivateKey = await getPeerIdPrivateKey(config, store, logger);
+  const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey.getValue());
+
+  const p2pService = await (p2pServiceFactory ?? LibP2PService.new<T>)(clientType, config, peerId, {
+    packageVersion,
+    mempools,
+    l2BlockSource: archiver,
+    epochCache,
+    proofVerifier,
+    worldStateSynchronizer,
+    peerStore,
+    telemetry,
+    logger: logger.createChild(`libp2p_service`),
+  });
+
+  return p2pService;
+}