@aztec-labs/p2p 6.0.0-nightly.20260829

package/dest/services/data_store.js

@@ -0,0 +1,192 @@
+import { filter, map, sort, take } from '@aztec-labs/foundation/iterable';
+import { Key } from 'interface-datastore';
+class KeyNotFoundError extends Error {
+    code;
+    constructor(message){
+        super(message);
+        this.code = 'ERR_NOT_FOUND';
+    }
+}
+export class AztecDatastore {
+    #db;
+    #memoryDatastore;
+    #dbDatastore;
+    maxMemoryItems;
+    constructor(db, { maxMemoryItems } = {
+        maxMemoryItems: 50
+    }){
+        this.#db = db;
+        this.#memoryDatastore = new Map();
+        this.#dbDatastore = db.openMap('p2p_datastore');
+        this.maxMemoryItems = maxMemoryItems;
+    }
+    async has(key) {
+        return this.#memoryDatastore.has(key.toString()) || await this.#dbDatastore.hasAsync(key.toString());
+    }
+    async get(key) {
+        const keyStr = key.toString();
+        const memoryItem = this.#memoryDatastore.get(keyStr);
+        if (memoryItem) {
+            memoryItem.lastAccessedMs = Date.now();
+            return memoryItem.data;
+        }
+        const dbItem = await this.#dbDatastore.getAsync(keyStr);
+        if (!dbItem) {
+            throw new KeyNotFoundError(`Key not found`);
+        }
+        return Uint8Array.from(dbItem);
+    }
+    put(key, val) {
+        return this._put(key, val);
+    }
+    async *putMany(source) {
+        for await (const { key, value } of source){
+            await this.put(key, value);
+            yield key;
+        }
+    }
+    async *getMany(source) {
+        for await (const key of source){
+            yield {
+                key,
+                value: await this.get(key)
+            };
+        }
+    }
+    async *deleteMany(source) {
+        for await (const key of source){
+            await this.delete(key);
+            yield key;
+        }
+    }
+    async delete(key) {
+        this.#memoryDatastore.delete(key.toString());
+        await this.#dbDatastore.delete(key.toString());
+    }
+    batch() {
+        const ops = [];
+        return {
+            put: (key, value)=>{
+                ops.push({
+                    type: 'put',
+                    key,
+                    value
+                });
+            },
+            delete: (key)=>{
+                ops.push({
+                    type: 'del',
+                    key
+                });
+            },
+            commit: async ()=>{
+                await this.#db.transactionAsync(async ()=>{
+                    for (const op of ops){
+                        if (op.type === 'put' && op.value) {
+                            await this.put(op.key, op.value);
+                        } else if (op.type === 'del') {
+                            await this.delete(op.key);
+                        }
+                    }
+                });
+                ops.length = 0;
+            }
+        };
+    }
+    query(q) {
+        let it = this.all(); //
+        const { prefix, filters, orders, offset, limit } = q;
+        if (prefix != null) {
+            it = filter(it, (e)=>e.key.toString().startsWith(`${prefix}`));
+        }
+        if (Array.isArray(filters)) {
+            it = filters.reduce((it, f)=>filter(it, f), it);
+        }
+        if (Array.isArray(orders)) {
+            it = orders.reduce((it, f)=>sort(it, f), it);
+        }
+        if (offset != null) {
+            let i = 0;
+            it = filter(it, ()=>i++ >= offset);
+        }
+        if (limit != null) {
+            it = take(it, limit);
+        }
+        return it;
+    }
+    queryKeys(q) {
+        let it = map(this.all(), ({ key })=>key);
+        const { prefix, filters, orders, offset, limit } = q;
+        if (prefix != null) {
+            it = filter(it, (e)=>e.toString().startsWith(`${prefix}`));
+        }
+        if (Array.isArray(filters)) {
+            it = filters.reduce((it, f)=>filter(it, f), it);
+        }
+        if (Array.isArray(orders)) {
+            it = orders.reduce((it, f)=>sort(it, f), it);
+        }
+        if (offset != null) {
+            let i = 0;
+            it = filter(it, ()=>i++ >= offset);
+        }
+        if (limit != null) {
+            it = take(it, limit);
+        }
+        return it;
+    }
+    async _put(key, val) {
+        const keyStr = key.toString();
+        while(this.#memoryDatastore.size >= this.maxMemoryItems){
+            this.pruneMemoryDatastore();
+        }
+        const memoryItem = this.#memoryDatastore.get(keyStr);
+        if (memoryItem) {
+            // update existing
+            memoryItem.lastAccessedMs = Date.now();
+            memoryItem.data = val;
+        } else {
+            // new entry
+            this.#memoryDatastore.set(keyStr, {
+                data: val,
+                lastAccessedMs: Date.now()
+            });
+        }
+        // Always add to DB
+        await this.#dbDatastore.set(keyStr, val);
+        return key;
+    }
+    async *all() {
+        for (const [key, value] of this.#memoryDatastore.entries()){
+            yield {
+                key: new Key(key),
+                value: value.data
+            };
+        }
+        for await (const [key, value] of this.#dbDatastore.entriesAsync()){
+            if (!this.#memoryDatastore.has(key)) {
+                yield {
+                    key: new Key(key),
+                    value
+                };
+            }
+        }
+    }
+    /**
+   * Prune memory store
+   */ pruneMemoryDatastore() {
+        let oldestAccessedMs = Date.now() + 1000;
+        let oldestKey = undefined;
+        let oldestValue = undefined;
+        for (const [key, value] of this.#memoryDatastore){
+            if (value.lastAccessedMs < oldestAccessedMs) {
+                oldestAccessedMs = value.lastAccessedMs;
+                oldestKey = key;
+                oldestValue = value.data;
+            }
+        }
+        if (oldestKey && oldestValue) {
+            this.#memoryDatastore.delete(oldestKey);
+        }
+    }
+}

package/dest/services/discv5/discV5_service.d.ts

@@ -0,0 +1,54 @@
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import { type TelemetryClient } from '@aztec-labs/telemetry-client';
+import type { PeerId } from '@libp2p/interface';
+import { type IDiscv5CreateOptions } from '@nethermindeth/discv5';
+import { ENR } from '@nethermindeth/enr';
+import EventEmitter from 'events';
+import type { P2PConfig } from '../../config.js';
+import { type PeerDiscoveryService, PeerDiscoveryState } from '../service.js';
+/**
+ * Peer discovery service using Discv5.
+ */
+export declare class DiscV5Service extends EventEmitter implements PeerDiscoveryService {
+    private peerId;
+    private config;
+    private readonly packageVersion;
+    private logger;
+    private readonly dateProvider;
+    /** The Discv5 instance */
+    private discv5;
+    /** This instance's ENR */
+    private enr;
+    /** Version identifiers. */
+    private versions;
+    private currentState;
+    private bootstrapNodePeerIds;
+    bootstrapNodeEnrs: ENR[];
+    private trustedPeerEnrs;
+    /** Node IDs of all config-provided peers (bootstrap, trusted, private); these are never persisted. */
+    private readonly configProvidedNodeIds;
+    private startTime;
+    private currentIp;
+    /** Persistent store of discovered peer ENRs, used to re-seed discovery after a restart. */
+    private readonly persistedEnrs?;
+    private handlers;
+    constructor(peerId: PeerId, config: P2PConfig, packageVersion: string, telemetry?: TelemetryClient, logger?: import("@aztec-labs/foundation/log").Logger, store?: AztecAsyncKVStore, configOverrides?: Partial<IDiscv5CreateOptions>, dateProvider?: DateProvider);
+    private onMultiaddrUpdated;
+    start(): Promise<void>;
+    runRandomNodesQuery(): Promise<void>;
+    getKadValues(): ENR[];
+    getEnr(): ENR;
+    getPeerId(): PeerId;
+    getStatus(): PeerDiscoveryState;
+    isBootstrapPeer(peerId: PeerId): boolean;
+    stop(): Promise<void>;
+    private onEnrAdded;
+    private onPeerDiscovered;
+    /** Whether an ENR belongs in the persisted store: a validated, non-config peer that isn't ourselves. */
+    private shouldPersist;
+    private isOurBootnode;
+    private onDiscovered;
+    private validateEnr;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/services/discv5/discV5_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discV5_service.d.ts","sourceRoot":"","sources":["../../../src/services/discv5/discV5_service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EAAsB,KAAK,eAAe,EAAsB,MAAM,8BAA8B,CAAC;AAC5G,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAmC,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AACnG,OAAO,EAAE,GAAG,EAAe,MAAM,oBAAoB,CAAC;AACtD,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAIjD,OAAO,EAAE,KAAK,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAQ9E;;GAEG;AACH,qBAAa,aAAc,SAAQ,YAAa,YAAW,oBAAoB;IAgC3E,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,MAAM;IAGd,OAAO,CAAC,QAAQ,CAAC,YAAY;IAtC/B,0BAA0B;IAC1B,OAAO,CAAC,MAAM,CAAqB;IAEnC,0BAA0B;IAC1B,OAAO,CAAC,GAAG,CAAc;IAEzB,2BAA2B;IAC3B,OAAO,CAAC,QAAQ,CAAqB;IAErC,OAAO,CAAC,YAAY,CAA8B;IAElD,OAAO,CAAC,oBAAoB,CAAgB;IACrC,iBAAiB,EAAE,GAAG,EAAE,CAAM;IACrC,OAAO,CAAC,eAAe,CAAa;IACpC,sGAAsG;IACtG,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAc;IAEpD,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,SAAS,CAAqB;IAEtC,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAoB;IAEnD,OAAO,CAAC,QAAQ,CAId;IAEF,YACU,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACR,cAAc,EAAE,MAAM,EACvC,SAAS,GAAE,eAAsC,EACzC,MAAM,8CAAqC,EACnD,KAAK,CAAC,EAAE,iBAAiB,EACzB,eAAe,GAAE,OAAO,CAAC,oBAAoB,CAAM,EAClC,YAAY,GAAE,YAAiC,EAsFjE;IAED,OAAO,CAAC,kBAAkB;IA+Bb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CA8ElC;IAEY,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBhD;IAEM,YAAY,IAAI,GAAG,EAAE,CAE3B;IAEM,MAAM,IAAI,GAAG,CAEnB;IAEM,SAAS,IAAI,MAAM,CAEzB;IAEM,SAAS,IAAI,kBAAkB,CAErC;IAEM,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9C;IAEY,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAWjC;YAEa,UAAU;YAkBV,gBAAgB;IAU9B,wGAAwG;IACxG,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,WAAW;CAqCpB"}

package/dest/services/discv5/discV5_service.js

@@ -0,0 +1,337 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { sleep } from '@aztec-labs/foundation/sleep';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { checkCompressedComponentVersion } from '@aztec-labs/stdlib/versioning';
+import { OtelMetricsAdapter, getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { multiaddr } from '@multiformats/multiaddr';
+import { Discv5 } from '@nethermindeth/discv5';
+import { ENR } from '@nethermindeth/enr';
+import EventEmitter from 'events';
+import { createNodeENR } from '../../enr/generate-enr.js';
+import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../../types/index.js';
+import { convertToMultiaddr } from '../../util.js';
+import { PeerDiscoveryState } from '../service.js';
+import { PersistedEnrStore } from './persisted_enr_store.js';
+const delayBeforeStart = 2000; // 2sec
+/** Upper bound on persisted peer ENRs, to keep the store bounded as peers churn. */ const MAX_PERSISTED_PEER_ENRS = 100;
+/**
+ * Peer discovery service using Discv5.
+ */ export class DiscV5Service extends EventEmitter {
+    peerId;
+    config;
+    packageVersion;
+    logger;
+    dateProvider;
+    /** The Discv5 instance */ discv5;
+    /** This instance's ENR */ enr;
+    /** Version identifiers. */ versions;
+    currentState;
+    bootstrapNodePeerIds;
+    bootstrapNodeEnrs;
+    trustedPeerEnrs;
+    /** Node IDs of all config-provided peers (bootstrap, trusted, private); these are never persisted. */ configProvidedNodeIds;
+    startTime;
+    currentIp;
+    /** Persistent store of discovered peer ENRs, used to re-seed discovery after a restart. */ persistedEnrs;
+    handlers;
+    constructor(peerId, config, packageVersion, telemetry = getTelemetryClient(), logger = createLogger('p2p:discv5_service'), store, configOverrides = {}, dateProvider = new DateProvider()){
+        super(), this.peerId = peerId, this.config = config, this.packageVersion = packageVersion, this.logger = logger, this.dateProvider = dateProvider, this.currentState = PeerDiscoveryState.STOPPED, this.bootstrapNodePeerIds = [], this.bootstrapNodeEnrs = [], this.trustedPeerEnrs = [], this.startTime = 0, this.handlers = {
+            onMultiaddrUpdated: this.onMultiaddrUpdated.bind(this),
+            onPeerDiscovered: this.onPeerDiscovered.bind(this),
+            onEnrAdded: this.onEnrAdded.bind(this)
+        };
+        this.persistedEnrs = store ? new PersistedEnrStore(store, MAX_PERSISTED_PEER_ENRS, createLogger(`${this.logger.module}:enr-store`)) : undefined;
+        const { p2pIp, p2pPort, p2pBroadcastPort, bootstrapNodes, trustedPeers, privatePeers } = config;
+        this.currentIp = p2pIp;
+        this.bootstrapNodeEnrs = bootstrapNodes.map((x)=>ENR.decodeTxt(x));
+        const privatePeerEnrs = new Set(privatePeers);
+        this.trustedPeerEnrs = trustedPeers.filter((x)=>!privatePeerEnrs.has(x)).map((x)=>ENR.decodeTxt(x));
+        // Peers supplied via config are re-injected from config on every start, so they must never end up
+        // in the persisted (discovered-peer) store — private peers especially must not be written there.
+        this.configProvidedNodeIds = new Set([
+            ...bootstrapNodes,
+            ...trustedPeers,
+            ...privatePeers
+        ].map((x)=>ENR.decodeTxt(x).nodeId));
+        // If no overridden broadcast port is provided, use the p2p port as the broadcast port
+        if (!p2pBroadcastPort) {
+            this.logger.warn('No p2pBroadcastPort provided, using p2pPort as broadcast port');
+            config.p2pBroadcastPort = p2pPort;
+        }
+        const bindAddrs = {
+            ip4: multiaddr(convertToMultiaddr(config.listenAddress, p2pPort, 'udp'))
+        };
+        let multiAddrUdp, multiAddrTcp;
+        if (p2pIp) {
+            multiAddrTcp = multiaddr(`${convertToMultiaddr(p2pIp, config.p2pBroadcastPort, 'tcp')}/p2p/${peerId.toString()}`);
+            multiAddrUdp = multiaddr(`${convertToMultiaddr(p2pIp, config.p2pBroadcastPort, 'udp')}/p2p/${peerId.toString()}`);
+        }
+        ({ enr: this.enr, versions: this.versions } = createNodeENR(peerId, multiAddrUdp, multiAddrTcp, config, this.packageVersion));
+        const metricsRegistry = new OtelMetricsAdapter(telemetry, this.logger.getBindings());
+        this.discv5 = Discv5.create({
+            enr: this.enr,
+            peerId,
+            bindAddrs,
+            config: {
+                lookupTimeout: 2000,
+                requestTimeout: 2000,
+                allowUnverifiedSessions: true,
+                enrUpdate: config.queryForIp || !p2pIp,
+                pingInterval: config.queryForIp ? 10_000 : 300_000,
+                ...configOverrides.config
+            },
+            metricsRegistry
+        });
+        // Hook onto the onEstablished method to check the peer's version from the ENR,
+        // so we don't add it to our dht if it doesn't have the correct version.
+        // In addition, we'll hook onto onDiscovered to to repeat the same check there,
+        // just in case. Note that not adding the peer to the dht could lead to it
+        // being "readded" constantly, we'll need to keep an eye on whether this
+        // turns out to be a problem or not.
+        const origOnEstablished = this.discv5.onEstablished.bind(this.discv5);
+        this.discv5.onEstablished = (...args)=>{
+            const enr = args[1];
+            // A special case is for bootnodes. If this is a bootnode and we have been told to skip version checks
+            // then proceed straight to handling the event
+            if (!this.config.bootstrapNodeEnrVersionCheck && this.isOurBootnode(enr)) {
+                return origOnEstablished(...args);
+            }
+            if (this.validateEnr(enr)) {
+                return origOnEstablished(...args);
+            }
+        };
+        this.discv5.on(Discv5Event.DISCOVERED, this.handlers.onPeerDiscovered);
+        this.discv5.on(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+        this.discv5.on(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
+    }
+    onMultiaddrUpdated(m) {
+        const newIp = m.nodeAddress().address;
+        const previousIp = this.currentIp;
+        if (newIp === previousIp) {
+            this.logger.debug('Discv5 confirmed current IP (no change)', {
+                ip: newIp
+            });
+            return;
+        }
+        const multiAddrTcp = multiaddr(convertToMultiaddr(newIp, this.config.p2pBroadcastPort, 'tcp'));
+        this.enr.setLocationMultiaddr(multiAddrTcp);
+        this.currentIp = newIp;
+        if (previousIp) {
+            this.logger.info('IP address changed, ENR updated', {
+                previousIp,
+                newIp,
+                multiaddr: multiAddrTcp.toString(),
+                enr: this.enr.encodeTxt()
+            });
+        } else {
+            this.logger.info('Initial IP discovered via discv5, ENR updated', {
+                ip: newIp,
+                multiaddr: multiAddrTcp.toString(),
+                enr: this.enr.encodeTxt()
+            });
+        }
+        this.emit('ip:changed', newIp);
+    }
+    async start() {
+        if (this.currentState === PeerDiscoveryState.RUNNING) {
+            throw new Error('DiscV5Service already started');
+        }
+        this.logger.debug('Starting DiscV5');
+        await this.discv5.start();
+        this.startTime = this.dateProvider.now();
+        const enrUpdateEnabled = this.config.queryForIp || !this.config.p2pIp;
+        this.logger.info(`DiscV5 service started`, {
+            nodeId: this.enr.nodeId,
+            peerId: this.peerId,
+            enrUdp: await this.enr.getFullMultiaddr('udp'),
+            enrTcp: await this.enr.getFullMultiaddr('tcp'),
+            versions: this.versions,
+            enrUpdateEnabled,
+            queryForIp: this.config.queryForIp,
+            configuredIp: this.config.p2pIp ?? 'none',
+            pingIntervalMs: this.config.queryForIp ? 10_000 : 300_000
+        });
+        this.currentState = PeerDiscoveryState.RUNNING;
+        // Add bootnode ENR if provided
+        if (this.bootstrapNodeEnrs?.length) {
+            // Do this conversion once since it involves an async function call
+            this.bootstrapNodePeerIds = await Promise.all(this.bootstrapNodeEnrs.map((enr)=>enr.peerId()));
+            this.logger.info(`Adding ${this.bootstrapNodeEnrs.length} bootstrap nodes ENRs: ${this.bootstrapNodeEnrs.map((enr)=>enr.encodeTxt()).join(', ')}`);
+            for (const enr of this.bootstrapNodeEnrs){
+                try {
+                    if (this.config.bootstrapNodeEnrVersionCheck) {
+                        const value = enr.kvs.get(AZTEC_ENR_KEY);
+                        if (!value) {
+                            throw new Error('ENR does not contain aztec key');
+                        }
+                        checkCompressedComponentVersion(Buffer.from(value).toString(), this.versions);
+                    }
+                    this.discv5.addEnr(enr);
+                } catch (e) {
+                    this.logger.error(`Error adding bootratrap node ${enr.encodeTxt()}`, e);
+                }
+            }
+        }
+        // Add trusted peer ENRs if provided
+        if (this.trustedPeerEnrs?.length) {
+            this.logger.info(`Adding ${this.trustedPeerEnrs.length} trusted peer ENRs: ${this.trustedPeerEnrs.map((enr)=>enr.encodeTxt()).join(', ')}`);
+            for (const enr of this.trustedPeerEnrs){
+                this.discv5.addEnr(enr);
+            }
+        }
+        // Re-seed discovery from peers persisted on previous runs. This lets a node rejoin the network
+        // after a restart even when no bootstrap node is reachable: discv5 has no on-disk routing table,
+        // so without this its DHT would start empty and rediscovery would depend on inbound dials alone.
+        if (this.persistedEnrs) {
+            // Drop peers that are now config-provided (re-injected above) or fail version checks.
+            const enrs = await this.persistedEnrs.load((enr)=>this.validateEnr(enr) && !this.configProvidedNodeIds.has(enr.nodeId));
+            for (const enr of enrs){
+                try {
+                    this.discv5.addEnr(enr);
+                } catch (err) {
+                    this.logger.debug(`Error re-seeding persisted ENR ${enr.nodeId}`, err);
+                }
+            }
+            if (enrs.length > 0) {
+                this.logger.info(`Re-seeded discovery with ${enrs.length} persisted peer ENRs`);
+            }
+        }
+    }
+    async runRandomNodesQuery() {
+        if (this.currentState !== PeerDiscoveryState.RUNNING) {
+            return;
+        }
+        // First, wait some time before starting the peer discovery
+        // reference: https://github.com/ChainSafe/lodestar/issues/3423
+        const msSinceStart = this.dateProvider.now() - this.startTime;
+        if (this.dateProvider.now() - this.startTime <= delayBeforeStart) {
+            await sleep(delayBeforeStart - msSinceStart);
+        }
+        try {
+            await this.discv5.findRandomNode();
+        } catch (err) {
+            this.logger.error(`Error running discV5 random node query: ${err}`);
+        }
+    }
+    getKadValues() {
+        return this.discv5.kadValues();
+    }
+    getEnr() {
+        return this.enr.toENR();
+    }
+    getPeerId() {
+        return this.peerId;
+    }
+    getStatus() {
+        return this.currentState;
+    }
+    isBootstrapPeer(peerId) {
+        return this.bootstrapNodePeerIds.some((node)=>node.equals(peerId));
+    }
+    async stop() {
+        if (this.currentState !== PeerDiscoveryState.RUNNING) {
+            return;
+        }
+        await this.discv5.off(Discv5Event.DISCOVERED, this.handlers.onPeerDiscovered);
+        await this.discv5.off(Discv5Event.ENR_ADDED, this.handlers.onEnrAdded);
+        await this.discv5.off(Discv5Event.MULTIADDR_UPDATED, this.handlers.onMultiaddrUpdated);
+        await this.discv5.stop();
+        this.currentState = PeerDiscoveryState.STOPPED;
+    }
+    async onEnrAdded(enr) {
+        try {
+            const multiAddrTcp = await enr.getFullMultiaddr('tcp');
+            const multiAddrUdp = await enr.getFullMultiaddr('udp');
+            this.logger.debug(`Added ENR ${enr.encodeTxt()}`, {
+                multiAddrTcp,
+                multiAddrUdp,
+                nodeId: enr.nodeId
+            });
+            // A peer just entered the routing table — persist it so we can re-seed discovery after a restart.
+            if (this.persistedEnrs && this.shouldPersist(enr)) {
+                await this.persistedEnrs.persist(enr);
+            }
+            this.onDiscovered(enr);
+        } catch (err) {
+            // A malformed ENR address field (e.g. a 3-byte TCP port) makes @nethermindeth/enr throw while
+            // parsing the multiaddr. This is an async event listener, so an unhandled rejection would crash
+            // the process — catch, log, and drop the ENR instead.
+            this.logger.warn(`Dropping ENR with unparseable address`, {
+                nodeId: enr.nodeId,
+                err
+            });
+        }
+    }
+    async onPeerDiscovered(enr) {
+        // discv5 updates an existing routing-table entry on an ENR sequence bump without emitting enrAdded,
+        // so DISCOVERED is our only signal that a peer we already track may have changed address. Refresh
+        // the persisted copy (a no-op for peers we don't already store) so we don't keep dialing a stale ENR.
+        if (this.persistedEnrs && this.shouldPersist(enr)) {
+            await this.persistedEnrs.refresh(enr);
+        }
+        this.onDiscovered(enr);
+    }
+    /** Whether an ENR belongs in the persisted store: a validated, non-config peer that isn't ourselves. */ shouldPersist(enr) {
+        return !this.configProvidedNodeIds.has(enr.nodeId) && enr.nodeId !== this.enr.nodeId && this.validateEnr(enr);
+    }
+    isOurBootnode(enr) {
+        return this.bootstrapNodeEnrs.some((x)=>x.nodeId === enr.nodeId);
+    }
+    onDiscovered(enr) {
+        // Find out if this is one of our bootnodes
+        if (this.isOurBootnode(enr)) {
+            // it is, what we do here depends
+            if (!this.config.bootstrapNodesAsFullPeers) {
+                // we don't consider bootnodes as full peers, don't perform any checks and don't emit anything
+                return;
+            }
+            if (!this.config.bootstrapNodeEnrVersionCheck) {
+                // we do consider bootnodes to be full peers and we have been told to NOT version check them, so emit
+                this.logger.trace(`Skipping version check for bootnode ${enr.nodeId}`);
+                this.emit(PeerEvent.DISCOVERED, enr);
+                return;
+            }
+        // here, we do consider bootnodes as full peers and we must version check so we continue to regular validation
+        }
+        if (this.validateEnr(enr)) {
+            this.emit(PeerEvent.DISCOVERED, enr);
+        }
+    }
+    validateEnr(enr) {
+        // Check the peer is an aztec peer
+        const value = enr.kvs.get(AZTEC_ENR_KEY);
+        if (!value) {
+            this.logger.debug(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
+            return false;
+        }
+        // A malformed TCP field (e.g. a non-2-byte port) makes @nethermindeth/enr throw while building the
+        // multiaddr. Reject such an ENR here so it's never emitted as a full peer or re-parsed by an
+        // unguarded listener (which would crash the process). A missing TCP addr is allowed — those peers
+        // are simply skipped at dial time.
+        try {
+            enr.getLocationMultiaddr('tcp');
+        } catch (err) {
+            this.logger.debug(`Peer node ${enr.nodeId} has an unparseable TCP address`, {
+                err
+            });
+            return false;
+        }
+        // And check it has the correct version
+        let compressedVersion;
+        try {
+            compressedVersion = Buffer.from(value).toString();
+            checkCompressedComponentVersion(compressedVersion, this.versions);
+            return true;
+        } catch (err) {
+            if (err.name === 'ComponentsVersionsError') {
+                this.logger.debug(`Peer node ${enr.nodeId} has incorrect version: ${err.message}`, {
+                    compressedVersion,
+                    expected: this.versions
+                });
+            } else {
+                this.logger.error(`Error checking peer version`, err);
+            }
+        }
+        return false;
+    }
+}

package/dest/services/discv5/persisted_enr_store.d.ts

@@ -0,0 +1,38 @@
+import { type Logger } from '@aztec-labs/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import { ENR } from '@nethermindeth/enr';
+/**
+ * A bounded, transactional store of discovered peer ENRs used to re-seed discovery after a restart.
+ *
+ * Entries are keyed by nodeId (so re-seeing a peer dedups in place) and carry a monotonic sequence so
+ * the store behaves as a FIFO: when it exceeds its cap, the oldest-seen peers are evicted first. All
+ * writes run in a transaction so concurrent discovery events can't race the size check.
+ */
+export declare class PersistedEnrStore {
+    private readonly store;
+    private readonly maxEntries;
+    private readonly logger;
+    private readonly enrs;
+    /** Monotonic sequence stamped on each entry; seeded from the store's max in {@link load}. */
+    private seq;
+    constructor(store: AztecAsyncKVStore, maxEntries: number, logger?: Logger);
+    /** Adds or replaces a peer's ENR, stamping it as most-recently-seen and evicting the oldest if over cap. */
+    persist(enr: ENR): Promise<void>;
+    /**
+     * Refreshes an already-persisted peer's stored ENR when a newer one (higher ENR sequence) is seen.
+     * A no-op for peers we don't already track — we never add new peers via this path, only update.
+     *
+     * This exists because discv5 updates an existing routing-table entry on an ENR sequence bump without
+     * emitting an `enrAdded` event, so a peer that changes address would otherwise keep its stale ENR
+     * persisted until evicted.
+     */
+    refresh(enr: ENR): Promise<void>;
+    /**
+     * Loads all persisted ENRs, decoding each and keeping those the `accept` predicate allows. Entries
+     * that fail to decode or are rejected are removed from the store. The FIFO sequence resumes from the
+     * highest persisted value so eviction order survives restarts.
+     */
+    load(accept: (enr: ENR) => boolean): Promise<ENR[]>;
+    private decodeStoredEnr;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyc2lzdGVkX2Vucl9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NlcnZpY2VzL2Rpc2N2NS9wZXJzaXN0ZWRfZW5yX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSw0QkFBNEIsQ0FBQztBQUN2RSxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBaUIsTUFBTSxzQkFBc0IsQ0FBQztBQUM3RSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUEwQnpDOzs7Ozs7R0FNRztBQUNILHFCQUFhLGlCQUFpQjtJQU0xQixPQUFPLENBQUMsUUFBUSxDQUFDLEtBQUs7SUFDdEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxVQUFVO0lBQzNCLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQVB6QixPQUFPLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBZ0M7SUFDckQsNkZBQTZGO0lBQzdGLE9BQU8sQ0FBQyxHQUFHLENBQUs7SUFFaEIsWUFDbUIsS0FBSyxFQUFFLGlCQUFpQixFQUN4QixVQUFVLEVBQUUsTUFBTSxFQUNsQixNQUFNLEdBQUUsTUFBNkMsRUFHdkU7SUFFRCw0R0FBNEc7SUFDL0YsT0FBTyxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXdCNUM7SUFFRDs7Ozs7OztPQU9HO0lBQ1UsT0FBTyxDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXVCNUM7SUFFRDs7OztPQUlHO0lBQ1UsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLEdBQUcsRUFBRSxHQUFHLEtBQUssT0FBTyxHQUFHLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQThCL0Q7SUFFRCxPQUFPLENBQUMsZUFBZTtDQVd4QiJ9

package/dest/services/discv5/persisted_enr_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted_enr_store.d.ts","sourceRoot":"","sources":["../../../src/services/discv5/persisted_enr_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AA0BzC;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgC;IACrD,6FAA6F;IAC7F,OAAO,CAAC,GAAG,CAAK;IAEhB,YACmB,KAAK,EAAE,iBAAiB,EACxB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAA6C,EAGvE;IAED,4GAA4G;IAC/F,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB5C;IAED;;;;;;;OAOG;IACU,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5C;IAED;;;;OAIG;IACU,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CA8B/D;IAED,OAAO,CAAC,eAAe;CAWxB"}