@aztec-labs/p2p 6.0.0-nightly.20260829

package/dest/util.js

@@ -0,0 +1,167 @@
+import { SecretValue } from '@aztec-labs/foundation/config';
+import { createLogger } from '@aztec-labs/foundation/log';
+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 net from 'net';
+import path from 'path';
+import { DEFAULT_PUBLIC_IP_SERVICES } from './config.js';
+const PEER_ID_DATA_DIR_FILE = 'p2p-private-key';
+/**
+ * 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, port, protocol) {
+    const multiaddrPrefix = addressToMultiAddressType(address);
+    if (multiaddrPrefix === 'dns') {
+        throw new Error('Invalid address format. Expected an IPv4 or IPv6 address.');
+    }
+    return `/${multiaddrPrefix}/${address}/${protocol}/${port}`;
+}
+/**
+ * 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 async function getPublicIp(services = DEFAULT_PUBLIC_IP_SERVICES) {
+    const errors = [];
+    for (const url of services){
+        try {
+            const resp = await fetch(url, {
+                signal: AbortSignal.timeout(5000)
+            });
+            const text = await resp.text();
+            const address = text.trim();
+            if (isValidIpAddress(address)) {
+                return address;
+            }
+            errors.push(`${url}: invalid IP "${address}"`);
+        } catch (err) {
+            errors.push(`${url}: ${err.message ?? err}`);
+        }
+    }
+    throw new Error(`Failed to determine public IP from all services:\n${errors.join('\n')}`);
+}
+export function isValidIpAddress(address) {
+    const netType = net.isIP(address);
+    return netType === 4;
+}
+export async function resolveAddressIfNecessary(address, port) {
+    const multiaddrPrefix = addressToMultiAddressType(address);
+    if (multiaddrPrefix === 'dns') {
+        const resolvedAddresses = await resolve(address);
+        if (resolvedAddresses.length === 0) {
+            throw new Error(`Could not resolve address: ${address}`);
+        }
+        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 { p2pIp, queryForIp, p2pBroadcastPort, p2pPort } = config;
+    const logger = createLogger('p2p:config');
+    // If no broadcast port is provided, use the given p2p port as the broadcast port
+    if (!p2pBroadcastPort) {
+        config.p2pBroadcastPort = p2pPort;
+    }
+    // Resolve the initial public IP so the ENR and announce address are set at startup.
+    // If queryForIp is enabled, discv5 will also track IP changes at runtime via enrUpdate.
+    if (!p2pIp && queryForIp) {
+        config.p2pIp = await getPublicIp(config.publicIpServices);
+        logger.info('Resolved initial public IP for P2P', {
+            ip: config.p2pIp,
+            queryForIp
+        });
+    } else if (p2pIp) {
+        logger.info('Using configured static P2P IP', {
+            ip: p2pIp,
+            queryForIp
+        });
+    }
+    // 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 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, 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;
+    }
+    // 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) {
+        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');
+    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.
+ * @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,9 @@
+import type { ChainConfig } from '@aztec-labs/stdlib/config';
+import type { SignableENR } from '@nethermindeth/enr';
+/** Returns the component versions based on config and this build. */
+export declare function getVersions(config: ChainConfig): import("@aztec-labs/stdlib/versioning").ComponentsVersions;
+/** Sets the aztec key on the ENR record with versioning info. */
+export declare function setAztecEnrKey(enr: SignableENR, config: ChainConfig): import("@aztec-labs/stdlib/versioning").ComponentsVersions;
+/** Sets the Aztec client version on ENR record **/
+export declare function setAztecClientVersionEnrKey(enr: SignableENR, clientVersion: string): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbmluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3ZlcnNpb25pbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFN0QsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFJdEQscUVBQXFFO0FBQ3JFLHdCQUFnQixXQUFXLENBQUMsTUFBTSxFQUFFLFdBQVcsOERBRTlDO0FBRUQsaUVBQWlFO0FBQ2pFLHdCQUFnQixjQUFjLENBQUMsR0FBRyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsV0FBVyw4REFJbkU7QUFFRCxtREFBbUQ7QUFDbkQsd0JBQWdCLDJCQUEyQixDQUFDLEdBQUcsRUFBRSxXQUFXLEVBQUUsYUFBYSxFQUFFLE1BQU0sUUFJbEYifQ==

package/dest/versioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioning.d.ts","sourceRoot":"","sources":["../src/versioning.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAItD,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,8DAE9C;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,8DAInE;AAED,mDAAmD;AACnD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,QAIlF"}

package/dest/versioning.js

@@ -0,0 +1,17 @@
+import { getVKTreeRoot } from '@aztec-labs/noir-protocol-circuits-types/vk-tree';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { compressComponentVersions, getComponentsVersionsFromConfig } from '@aztec-labs/stdlib/versioning';
+import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from './types/index.js';
+/** Returns the component versions based on config and this build. */ export function getVersions(config) {
+    return getComponentsVersionsFromConfig(config, protocolContractsHash, getVKTreeRoot());
+}
+/** Sets the aztec key on the ENR record with versioning info. */ export function setAztecEnrKey(enr, config) {
+    const versions = getVersions(config);
+    enr.set(AZTEC_ENR_KEY, Buffer.from(compressComponentVersions(versions)));
+    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));
+    }
+}

package/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "@aztec-labs/p2p",
+  "version": "6.0.0-nightly.20260829",
+  "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 && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
+    "start": "node ./dest",
+    "start:dev": "concurrently -k \"../scripts/tsc.sh --watch\" \"nodemon --watch dest --exec 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"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec-labs/archiver": "6.0.0-nightly.20260829",
+    "@aztec-labs/constants": "6.0.0-nightly.20260829",
+    "@aztec-labs/epoch-cache": "6.0.0-nightly.20260829",
+    "@aztec-labs/ethereum": "6.0.0-nightly.20260829",
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/kv-store": "6.0.0-nightly.20260829",
+    "@aztec-labs/noir-protocol-circuits-types": "6.0.0-nightly.20260829",
+    "@aztec-labs/protocol-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/simulator": "6.0.0-nightly.20260829",
+    "@aztec-labs/standard-contracts": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@aztec-labs/telemetry-client": "6.0.0-nightly.20260829",
+    "@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/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",
+    "@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",
+    "libp2p": "1.5.0",
+    "semver": "^7.6.0",
+    "sha3": "^2.1.4",
+    "snappy": "7.2.2",
+    "tslib": "^2.4.0"
+  },
+  "devDependencies": {
+    "@aztec-labs/world-state": "6.0.0-nightly.20260829",
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.17",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "get-port": "^7.1.0",
+    "it-drain": "^3.0.5",
+    "it-length": "^3.0.6",
+    "jest": "^30.0.0",
+    "jest-mock-extended": "^4.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3",
+    "uint8arrays": "^5.0.3",
+    "viem": "npm:@aztec/viem@2.38.2"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=20.10"
+  }
+}

package/src/bootstrap/bootstrap.ts

@@ -0,0 +1,178 @@
+import { type Logger, type LoggerBindings, createLogger } from '@aztec-labs/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import type { P2PBootstrapApi } from '@aztec-labs/stdlib/interfaces/server';
+import { OtelMetricsAdapter, type TelemetryClient } from '@aztec-labs/telemetry-client';
+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, 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?: Discv5EventEmitter = undefined;
+  private peerId?: PeerId;
+  private logger: Logger;
+
+  constructor(
+    private store: AztecAsyncKVStore,
+    private telemetry: TelemetryClient,
+    bindings?: LoggerBindings,
+  ) {
+    this.logger = createLogger('p2p:bootstrap', bindings);
+  }
+
+  /**
+   * 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 { 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(config.publicIpServices);
+        p2pIp = publicIp;
+        this.logger.info(`Found public IP address: ${publicIp}`);
+      }
+    }
+
+    if (!p2pIp) {
+      throw new Error('You need to provide a P2P IP address.');
+    }
+
+    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.getValue(),
+      p2pIp,
+      config.p2pBroadcastPort!,
+      config.l1ChainId,
+    );
+    this.peerId = peerId;
+
+    this.logger.debug(`Starting bootstrap node ${peerId} listening on ${listenAddrUdp.toString()}`);
+
+    const metricsRegistry = new OtelMetricsAdapter(this.telemetry, this.logger.getBindings());
+    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) => {
+      try {
+        const addr = await enr.getFullMultiaddr('udp');
+        this.logger.verbose(`Discovered new peer`, { enr: enr.encodeTxt(), addr: addr?.toString() });
+        // discv5's discovered() only updates routing table entries that already exist. Nodes that
+        // established a session with an empty-IP ENR are never inserted, so even after their ENR
+        // gains a valid socket address the routing table stays empty and FINDNODE always returns 0
+        // peers. Calling addEnr() here does an insertOrUpdate regardless of prior state, fixing
+        // the routing table so these nodes become discoverable to other peers.
+        if (addr) {
+          this.node.addEnr(enr);
+        }
+      } catch (err) {
+        // A malformed ENR address field makes the parser throw. As an async listener this would crash
+        // the bootnode on an unhandled rejection — catch, log, and drop the ENR instead.
+        this.logger.warn(`Dropping discovered ENR with unparseable address`, { err });
+      }
+    });
+
+    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()));
+  }
+}