@aztec/p2p 0.0.0-test.0

package/dest/types/index.d.ts

@@ -0,0 +1,32 @@
+/***************************************************
+ *                    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"
+}
+/**
+ * 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";
+//# sourceMappingURL=index.d.ts.map

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;CACvB;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB,OAAO,sBAAsB;CAC9B;AAED;;qDAEqD;AAErD;;GAEG;AACH,eAAO,MAAM,aAAa,UAAU,CAAC"}

package/dest/types/index.js

@@ -0,0 +1,28 @@
+/***************************************************
+ *                    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";
+    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';

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,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"}

package/dest/util.js

@@ -0,0 +1,140 @@
+import { generateKeyPair, marshalPrivateKey, unmarshalPrivateKey } from '@libp2p/crypto/keys';
+import { createFromPrivKey } from '@libp2p/peer-id-factory';
+import { resolve } from 'dns/promises';
+/**
+ * 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 function convertToMultiaddr(address, protocol) {
+    const [addr, port] = splitAddressPort(address, false);
+    const multiaddrPrefix = addressToMultiAddressType(addr);
+    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
+    ];
+}
+/**
+ * Queries the public IP address of the machine.
+ */ export async function getPublicIp() {
+    const resp = await fetch('http://checkip.amazonaws.com/');
+    const text = await resp.text();
+    return text.trim();
+}
+export async function resolveAddressIfNecessary(address) {
+    const [addr, port] = splitAddressPort(address, false);
+    const multiaddrPrefix = addressToMultiAddressType(addr);
+    if (multiaddrPrefix === 'dns') {
+        const resolvedAddresses = await resolve(addr);
+        if (resolvedAddresses.length === 0) {
+            throw new Error(`Could not resolve address: ${addr}`);
+        }
+        return `${resolvedAddresses[0]}:${port}`;
+    } else {
+        return address;
+    }
+}
+// Not public because it is not used outside of this file.
+// Plus, it relies on `splitAddressPort` being called on the address first.
+function addressToMultiAddressType(address) {
+    if (address.includes(':')) {
+        return 'ip6';
+    } else if (address.match(/^[\d.]+$/)) {
+        return 'ip4';
+    } 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;
+    // create variable for re-use if needed
+    let publicIp;
+    // check if no announce IP was provided
+    const splitTcpAnnounceAddress = splitAddressPort(configTcpAnnounceAddress || '', true);
+    if (splitTcpAnnounceAddress.length == 2 && splitTcpAnnounceAddress[0] === '') {
+        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;
+        }
+    }
+    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
+ *
+ */ export async function getPeerIdPrivateKey(config, store) {
+    const peerIdPrivateKeySingleton = store.openSingleton('peerIdPrivateKey');
+    if (config.peerIdPrivateKey) {
+        await peerIdPrivateKeySingleton.set(config.peerIdPrivateKey);
+        return config.peerIdPrivateKey;
+    }
+    const storedPeerIdPrivateKey = await peerIdPrivateKeySingleton.getAsync();
+    if (storedPeerIdPrivateKey) {
+        return storedPeerIdPrivateKey;
+    }
+    const newPeerIdPrivateKey = await generateKeyPair('secp256k1');
+    const privateKeyString = Buffer.from(marshalPrivateKey(newPeerIdPrivateKey)).toString('hex');
+    await peerIdPrivateKeySingleton.set(privateKeyString);
+    return privateKeyString;
+}
+/**
+ * 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) {
+    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);
+}

package/dest/versioning.d.ts

@@ -0,0 +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';
+/** 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":";;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"}

package/dest/versioning.js

@@ -0,0 +1,33 @@
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } 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';
+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);
+}

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@aztec/p2p",
+  "version": "0.0.0-test.0",
+  "type": "module",
+  "exports": {
+    ".": "./dest/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",
+    "./enr": "./dest/enr/index.js",
+    "./types": "./dest/types/index.js"
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "P2P",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "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'"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.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",
+    "@chainsafe/libp2p-gossipsub": "13.0.0",
+    "@chainsafe/libp2p-noise": "^15.0.0",
+    "@chainsafe/libp2p-yamux": "^6.0.2",
+    "@libp2p/bootstrap": "10.0.0",
+    "@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",
+    "@libp2p/peer-store": "10.0.16",
+    "@libp2p/prometheus-metrics": "^4.2.4",
+    "@libp2p/tcp": "9.0.24",
+    "@multiformats/multiaddr": "12.1.14",
+    "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",
+    "snappy": "^7.2.2",
+    "tslib": "^2.4.0",
+    "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",
+    "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",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4",
+    "uint8arrays": "^5.0.3",
+    "viem": "2.22.8"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/bootstrap/bootstrap.ts

@@ -0,0 +1,146 @@
+import { createLogger } from '@aztec/foundation/log';
+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 type { BootnodeConfig } from '../config.js';
+import { createBootnodeENRandPeerId } from '../enr/generate-enr.js';
+import { convertToMultiaddr, getPeerIdPrivateKey } 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 peerId?: PeerId;
+
+  constructor(
+    private store: AztecAsyncKVStore,
+    private telemetry: TelemetryClient,
+    private logger = createLogger('p2p:bootstrap'),
+  ) {}
+
+  /**
+   * Starts the bootstrap node.
+   * @param config - A partial P2P configuration. No need for TCP values as well as aztec node specific values.
+   * @returns An empty promise.
+   */
+  public async start(config: BootnodeConfig) {
+    const { udpListenAddress, udpAnnounceAddress } = config;
+    const listenAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
+
+    if (!udpAnnounceAddress) {
+      throw new Error('You need to provide a UDP announce address.');
+    }
+
+    const peerIdPrivateKey = await getPeerIdPrivateKey(config, this.store);
+
+    const { enr: ourEnr, peerId } = await createBootnodeENRandPeerId(
+      peerIdPrivateKey,
+      udpAnnounceAddress,
+      config.l1ChainId,
+    );
+    this.peerId = peerId;
+
+    this.logger.debug(`Starting bootstrap node ${peerId} listening on ${listenAddrUdp.toString()}`);
+
+    const metricsRegistry = new OtelMetricsAdapter(this.telemetry);
+    this.node = Discv5.create({
+      enr: ourEnr,
+      peerId,
+      bindAddrs: { ip4: listenAddrUdp },
+      config: {
+        lookupTimeout: 2000,
+        allowUnverifiedSessions: true,
+      },
+      metricsRegistry,
+    });
+
+    this.node.on('multiaddrUpdated', (addr: Multiaddr) => {
+      this.logger.info('Advertised socket address updated', { addr: addr.toString() });
+    });
+    this.node.on('discovered', async (enr: SignableENR) => {
+      const addr = await enr.getFullMultiaddr('udp');
+      this.logger.verbose(`Discovered new peer`, { enr: enr.encodeTxt(), addr: addr?.toString() });
+    });
+
+    try {
+      this.logger.info('Starting bootnode');
+      await this.node.start();
+      this.logger.info('Bootstrap node started', {
+        peerId,
+        enr: ourEnr.encodeTxt(),
+        addr: listenAddrUdp.toString(),
+      });
+    } catch (e) {
+      this.logger.error('Error starting Discv5', e);
+    }
+
+    // Add bootnode ENRs if provided, making sure we filter our own
+    if (config.bootstrapNodes?.length) {
+      const otherBootnodeENRs = config.bootstrapNodes
+        .map(x => ENR.decodeTxt(x))
+        .filter(b => b.nodeId !== ourEnr.nodeId);
+      this.logger.info(`Adding bootstrap nodes ENRs: ${otherBootnodeENRs.map(x => x.encodeTxt()).join(', ')}`);
+      try {
+        otherBootnodeENRs.forEach(enr => {
+          this.node.addEnr(enr);
+        });
+      } catch (e) {
+        this.logger.error(`Error adding bootnode ENRs: ${e}`);
+      }
+    }
+  }
+
+  /**
+   * Stops the bootstrap node.
+   * @returns And empty promise.
+   */
+  public async stop() {
+    // stop libp2p
+    this.logger.debug('Stopping bootstrap node');
+    await this.node?.stop();
+    this.logger.info('Bootstrap node stopped');
+  }
+
+  private assertNodeStarted() {
+    if (!this.node) {
+      throw new Error('Node not started');
+    }
+  }
+
+  private assertPeerId() {
+    if (!this.peerId) {
+      throw new Error('No peerId found');
+    }
+  }
+
+  /**
+   * Returns the peerId of this node.
+   * @returns The node's peer Id
+   */
+  public getPeerId() {
+    this.assertPeerId();
+    return this.peerId!;
+  }
+
+  public getENR() {
+    this.assertNodeStarted();
+    return this.node?.enr.toENR();
+  }
+
+  public getEncodedEnr() {
+    this.assertNodeStarted();
+    return Promise.resolve(this.node!.enr.encodeTxt());
+  }
+
+  public getRoutingTable() {
+    this.assertNodeStarted();
+    return Promise.resolve(this.node!.kadValues().map((enr: ENR) => enr.encodeTxt()));
+  }
+}

package/src/client/factory.ts

@@ -0,0 +1,89 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+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 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 { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
+
+type P2PClientDeps<T extends P2PClientType> = {
+  txPool?: TxPool;
+  store?: AztecAsyncKVStore;
+  attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
+  logger?: Logger;
+};
+
+export const createP2PClient = async <T extends P2PClientType>(
+  clientType: T,
+  _config: P2PConfig & DataStoreConfig,
+  l2BlockSource: L2BlockSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  epochCache: EpochCacheInterface,
+  telemetry: TelemetryClient = getTelemetryClient(),
+  deps: P2PClientDeps<T> = {},
+) => {
+  let config = { ..._config };
+  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'));
+
+  const mempools: MemPools<T> = {
+    txPool: deps.txPool ?? new AztecKVTxPool(store, archive, telemetry, config.archivedTxLimit),
+    attestationPool:
+      clientType === P2PClientType.Full
+        ? ((deps.attestationPool ?? new InMemoryAttestationPool(telemetry)) as T extends P2PClientType.Full
+            ? AttestationPool
+            : undefined)
+        : undefined,
+  };
+
+  let p2pService;
+
+  if (_config.p2pEnabled) {
+    logger.verbose('P2P is enabled. Using LibP2P service.');
+    config = await configureP2PClientAddresses(_config);
+
+    // 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`),
+    );
+
+    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, l2BlockSource, mempools, p2pService, config, telemetry);
+};