@aztec/p2p 0.0.0-test.0

package/dest/msg_validators/tx_validator/tx_proof_validator.js

@@ -0,0 +1,25 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Tx } from '@aztec/stdlib/tx';
+export class TxProofValidator {
+    verifier;
+    #log;
+    constructor(verifier){
+        this.verifier = verifier;
+        this.#log = createLogger('p2p:tx_validator:private_proof');
+    }
+    async validateTx(tx) {
+        if (!await this.verifier.verifyProof(tx)) {
+            this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for invalid proof`);
+            return {
+                result: 'invalid',
+                reason: [
+                    'Invalid proof'
+                ]
+            };
+        }
+        this.#log.trace(`Accepted ${Tx.getHash(tx)} with valid proof`);
+        return {
+            result: 'valid'
+        };
+    }
+}

package/dest/services/data_store.d.ts

@@ -0,0 +1,27 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { type Batch, type Datastore, Key, type KeyQuery, type Pair, type Query } from 'interface-datastore';
+import type { AwaitIterable } from 'interface-store';
+export declare class AztecDatastore implements Datastore {
+    #private;
+    private maxMemoryItems;
+    constructor(db: AztecAsyncKVStore, { maxMemoryItems }?: {
+        maxMemoryItems: number;
+    });
+    has(key: Key): Promise<boolean>;
+    get(key: Key): Promise<Uint8Array>;
+    put(key: Key, val: Uint8Array): Promise<Key>;
+    putMany(source: AwaitIterable<Pair>): AwaitIterable<Key>;
+    getMany(source: AwaitIterable<Key>): AwaitIterable<Pair>;
+    deleteMany(source: AwaitIterable<Key>): AwaitIterable<Key>;
+    delete(key: Key): Promise<void>;
+    batch(): Batch;
+    query(q: Query): AwaitIterable<Pair>;
+    queryKeys(q: KeyQuery): AsyncIterable<Key>;
+    private _put;
+    private all;
+    /**
+     * Prune memory store
+     */
+    private pruneMemoryDatastore;
+}
+//# sourceMappingURL=data_store.d.ts.map

package/dest/services/data_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_store.d.ts","sourceRoot":"","sources":["../../src/services/data_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AAExE,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,GAAG,EAAE,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAqBrD,qBAAa,cAAe,YAAW,SAAS;;IAM9C,OAAO,CAAC,cAAc,CAAS;gBAEnB,EAAE,EAAE,iBAAiB,EAAE,EAAE,cAAc,EAAE;;KAAyB;IAOxE,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;IAI/B,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC;IAgBxC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IAIrC,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC;IAOxD,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,IAAI,CAAC;IASxD,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC;IAO3D,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAKrC,KAAK,IAAI,KAAK;IA4Bd,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC;IA4BpC,SAAS,CAAC,CAAC,EAAE,QAAQ,GAAG,aAAa,CAAC,GAAG,CAAC;YA2B5B,IAAI;YAqBH,GAAG;IAkBlB;;OAEG;IACH,OAAO,CAAC,oBAAoB;CAiB7B"}

package/dest/services/data_store.js

@@ -0,0 +1,188 @@
+import { filter, map, sort, take } from '@aztec/foundation/iterable';
+import { Key } from 'interface-datastore';
+class KeyNotFoundError extends Error {
+    code;
+    constructor(message){
+        super(message);
+        this.code = 'ERR_NOT_FOUND';
+    }
+}
+export class AztecDatastore {
+    #memoryDatastore;
+    #dbDatastore;
+    #batchOps = [];
+    maxMemoryItems;
+    constructor(db, { maxMemoryItems } = {
+        maxMemoryItems: 50
+    }){
+        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() {
+        return {
+            put: (key, value)=>{
+                this.#batchOps.push({
+                    type: 'put',
+                    key,
+                    value
+                });
+            },
+            delete: (key)=>{
+                this.#batchOps.push({
+                    type: 'del',
+                    key
+                });
+            },
+            commit: async ()=>{
+                for (const op of this.#batchOps){
+                    if (op.type === 'put' && op.value) {
+                        await this.put(op.key, op.value);
+                    } else if (op.type === 'del') {
+                        await this.delete(op.key);
+                    }
+                }
+                this.#batchOps = []; // Clear operations after commit
+            }
+        };
+    }
+    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,42 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { ENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
+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 logger;
+    /** The Discv5 instance */
+    private discv5;
+    /** This instance's ENR */
+    private enr;
+    /** Version identifiers. */
+    private versions;
+    /** UDP listen addr */
+    private listenMultiAddrUdp;
+    private currentState;
+    readonly bootstrapNodes: string[];
+    private bootstrapNodePeerIds;
+    private bootstrapNodeEnrs;
+    private startTime;
+    constructor(peerId: PeerId, config: P2PConfig, telemetry?: TelemetryClient, logger?: import("@aztec/foundation/log").Logger);
+    start(): Promise<void>;
+    runRandomNodesQuery(): Promise<void>;
+    getAllPeers(): ENR[];
+    getEnr(): ENR;
+    getPeerId(): PeerId;
+    getStatus(): PeerDiscoveryState;
+    isBootstrapPeer(peerId: PeerId): boolean;
+    stop(): Promise<void>;
+    private onEnrAdded;
+    private isOurBootnode;
+    private onDiscovered;
+    private validateEnr;
+}
+//# sourceMappingURL=discV5_service.d.ts.map

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":";AAGA,OAAO,EAAsB,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAGvG,OAAO,EAAE,GAAG,EAAe,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,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;AAI9E;;GAEG;AACH,qBAAa,aAAc,SAAQ,YAAa,YAAW,oBAAoB;IAsB3E,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,MAAM;IAxBhB,0BAA0B;IAC1B,OAAO,CAAC,MAAM,CAA8B;IAE5C,0BAA0B;IAC1B,OAAO,CAAC,GAAG,CAAc;IAEzB,2BAA2B;IAC3B,OAAO,CAAC,QAAQ,CAAqB;IAErC,sBAAsB;IACtB,OAAO,CAAC,kBAAkB,CAAY;IAEtC,OAAO,CAAC,YAAY,CAA8B;IAElD,SAAgB,cAAc,EAAE,MAAM,EAAE,CAAM;IAC9C,OAAO,CAAC,oBAAoB,CAAgB;IAC5C,OAAO,CAAC,iBAAiB,CAAa;IAEtC,OAAO,CAAC,SAAS,CAAK;gBAGZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,SAAS,EACzB,SAAS,GAAE,eAAsC,EACzC,MAAM,yCAAqC;IA+DxC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuCtB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB1C,WAAW,IAAI,GAAG,EAAE;IAIpB,MAAM,IAAI,GAAG;IAIb,SAAS,IAAI,MAAM;IAInB,SAAS,IAAI,kBAAkB;IAI/B,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YASpB,UAAU;IAOxB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,WAAW;CA0BpB"}

package/dest/services/discv5/discV5_service.js

@@ -0,0 +1,214 @@
+import { createLogger } from '@aztec/foundation/log';
+import { sleep } from '@aztec/foundation/sleep';
+import { checkCompressedComponentVersion } from '@aztec/stdlib/versioning';
+import { OtelMetricsAdapter, getTelemetryClient } from '@aztec/telemetry-client';
+import { Discv5 } from '@chainsafe/discv5';
+import { ENR, SignableENR } from '@chainsafe/enr';
+import { multiaddr } from '@multiformats/multiaddr';
+import EventEmitter from 'events';
+import { AZTEC_ENR_KEY, Discv5Event, PeerEvent } from '../../types/index.js';
+import { convertToMultiaddr } from '../../util.js';
+import { setAztecEnrKey } from '../../versioning.js';
+import { PeerDiscoveryState } from '../service.js';
+const delayBeforeStart = 2000; // 2sec
+/**
+ * Peer discovery service using Discv5.
+ */ export class DiscV5Service extends EventEmitter {
+    peerId;
+    config;
+    logger;
+    /** The Discv5 instance */ discv5;
+    /** This instance's ENR */ enr;
+    /** Version identifiers. */ versions;
+    /** UDP listen addr */ listenMultiAddrUdp;
+    currentState;
+    bootstrapNodes;
+    bootstrapNodePeerIds;
+    bootstrapNodeEnrs;
+    startTime;
+    constructor(peerId, config, telemetry = getTelemetryClient(), logger = createLogger('p2p:discv5_service')){
+        super(), this.peerId = peerId, this.config = config, this.logger = logger, this.currentState = PeerDiscoveryState.STOPPED, this.bootstrapNodes = [], this.bootstrapNodePeerIds = [], this.bootstrapNodeEnrs = [], this.startTime = 0;
+        const { tcpAnnounceAddress, udpAnnounceAddress, udpListenAddress, bootstrapNodes } = config;
+        this.bootstrapNodes = bootstrapNodes ?? [];
+        this.bootstrapNodeEnrs = this.bootstrapNodes.map((x)=>ENR.decodeTxt(x));
+        // create ENR from PeerId
+        this.enr = SignableENR.createFromPeerId(peerId);
+        // Add aztec identification to ENR
+        this.versions = setAztecEnrKey(this.enr, config);
+        if (!tcpAnnounceAddress) {
+            throw new Error('You need to provide at least a TCP announce address.');
+        }
+        const multiAddrTcp = multiaddr(`${convertToMultiaddr(tcpAnnounceAddress, 'tcp')}/p2p/${peerId.toString()}`);
+        // if no udp announce address is provided, use the tcp announce address
+        const multiAddrUdp = multiaddr(`${convertToMultiaddr(udpAnnounceAddress || tcpAnnounceAddress, 'udp')}/p2p/${peerId.toString()}`);
+        this.listenMultiAddrUdp = multiaddr(convertToMultiaddr(udpListenAddress, 'udp'));
+        // set location multiaddr in ENR record
+        this.enr.setLocationMultiaddr(multiAddrUdp);
+        this.enr.setLocationMultiaddr(multiAddrTcp);
+        const metricsRegistry = new OtelMetricsAdapter(telemetry);
+        this.discv5 = Discv5.create({
+            enr: this.enr,
+            peerId,
+            bindAddrs: {
+                ip4: this.listenMultiAddrUdp
+            },
+            config: {
+                lookupTimeout: 2000,
+                requestTimeout: 2000,
+                allowUnverifiedSessions: true
+            },
+            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.onDiscovered.bind(this));
+        this.discv5.on(Discv5Event.ENR_ADDED, this.onEnrAdded.bind(this));
+    }
+    async start() {
+        if (this.currentState === PeerDiscoveryState.RUNNING) {
+            throw new Error('DiscV5Service already started');
+        }
+        this.logger.debug('Starting DiscV5');
+        await this.discv5.start();
+        this.startTime = Date.now();
+        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
+        });
+        this.currentState = PeerDiscoveryState.RUNNING;
+        // Add bootnode ENR if provided
+        if (this.bootstrapNodes?.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.bootstrapNodes} bootstrap nodes ENRs: ${this.bootstrapNodes.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);
+                }
+            }
+        }
+    }
+    async runRandomNodesQuery() {
+        if (this.currentState !== PeerDiscoveryState.RUNNING) {
+            throw new Error('DiscV5Service not running');
+        }
+        // First, wait some time before starting the peer discovery
+        // reference: https://github.com/ChainSafe/lodestar/issues/3423
+        const msSinceStart = Date.now() - this.startTime;
+        if (Date.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}`);
+        }
+    }
+    getAllPeers() {
+        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() {
+        await this.discv5.off(Discv5Event.DISCOVERED, this.onDiscovered);
+        await this.discv5.off(Discv5Event.ENR_ADDED, this.onEnrAdded);
+        await this.discv5.stop();
+        this.currentState = PeerDiscoveryState.STOPPED;
+    }
+    async onEnrAdded(enr) {
+        const multiAddrTcp = await enr.getFullMultiaddr('tcp');
+        const multiAddrUdp = await enr.getFullMultiaddr('udp');
+        this.logger.debug(`Added ENR ${enr.encodeTxt()}`, {
+            multiAddrTcp,
+            multiAddrUdp,
+            nodeId: enr.nodeId
+        });
+        this.onDiscovered(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.warn(`Peer node ${enr.nodeId} does not have aztec key in ENR`);
+            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/dummy_service.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
+import { TxHash } from '@aztec/stdlib/tx';
+import type { PeerId } from '@libp2p/interface';
+import EventEmitter from 'events';
+import type { ReqRespSubProtocol, SubProtocolMap } from './reqresp/interface.js';
+import { type P2PService, type PeerDiscoveryService, PeerDiscoveryState } from './service.js';
+/**
+ * A dummy implementation of the P2P Service.
+ */
+export declare class DummyP2PService implements P2PService {
+    /** Returns an empty array for peers. */
+    getPeers(): PeerInfo[];
+    /**
+     * Starts the dummy implementation.
+     * @returns A resolved promise.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the dummy implementation.
+     * @returns A resolved promise.
+     */
+    stop(): Promise<void>;
+    /**
+     * Called to have the given message propagated through the P2P network.
+     * @param _ - The message to be propagated.
+     */
+    propagate<T extends Gossipable>(_: T): void;
+    /**
+     * Called upon receipt of settled transactions.
+     * @param _ - The hashes of the settled transactions.
+     */
+    settledTxs(_: TxHash[]): void;
+    /**
+     * Register a callback into the validator client for when a block proposal is received
+     */
+    registerBlockReceivedCallback(_: (block: BlockProposal) => Promise<BlockAttestation>): void;
+    /**
+     * Sends a request to a peer.
+     * @param _protocol - The protocol to send the request on.
+     * @param _request - The request to send.
+     * @returns The response from the peer, otherwise undefined.
+     */
+    sendRequest<Protocol extends ReqRespSubProtocol>(_protocol: Protocol, _request: InstanceType<SubProtocolMap[Protocol]['request']>): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
+    /**
+     * Sends a batch request to a peer.
+     * @param _protocol - The protocol to send the request on.
+     * @param _requests - The requests to send.
+     * @returns The responses from the peer, otherwise undefined.
+     */
+    sendBatchRequest<Protocol extends ReqRespSubProtocol>(_protocol: Protocol, _requests: InstanceType<SubProtocolMap[Protocol]['request']>[]): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]>;
+    /**
+     * Returns the ENR of the peer.
+     * @returns The ENR of the peer, otherwise undefined.
+     */
+    getEnr(): undefined;
+}
+/**
+ * A dummy implementation of the Peer Discovery Service.
+ */
+export declare class DummyPeerDiscoveryService extends EventEmitter implements PeerDiscoveryService {
+    private currentState;
+    bootstrapNodes: string[];
+    /**
+     * Starts the dummy implementation.
+     * @returns A resolved promise.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the dummy implementation.
+     * @returns A resolved promise.
+     */
+    stop(): Promise<void>;
+    /**
+     * Called to discover peers in the network.
+     * @returns An array of discovered peer addresses.
+     */
+    getAllPeers(): never[];
+    runRandomNodesQuery(): Promise<void>;
+    isBootstrapPeer(_: PeerId): boolean;
+    getStatus(): PeerDiscoveryState;
+    getEnr(): undefined;
+}
+//# sourceMappingURL=dummy_service.d.ts.map

package/dest/services/dummy_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dummy_service.d.ts","sourceRoot":"","sources":["../../src/services/dummy_service.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACrF,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAE9F;;GAEG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAChD,wCAAwC;IACxC,QAAQ,IAAI,QAAQ,EAAE;IAItB;;;OAGG;IACI,KAAK;IAIZ;;;OAGG;IACI,IAAI;IAIX;;;OAGG;IACI,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,EAAE,CAAC;IAE3C;;;OAGG;IACI,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE;IAE7B;;OAEG;IACI,6BAA6B,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,gBAAgB,CAAC;IAE3F;;;;;OAKG;IACI,WAAW,CAAC,QAAQ,SAAS,kBAAkB,EACpD,SAAS,EAAE,QAAQ,EACnB,QAAQ,EAAE,YAAY,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,GAC1D,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC;IAI1E;;;;;OAKG;IACI,gBAAgB,CAAC,QAAQ,SAAS,kBAAkB,EACzD,SAAS,EAAE,QAAQ,EACnB,SAAS,EAAE,YAAY,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAC7D,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;IAIhE;;;OAGG;IACI,MAAM,IAAI,SAAS;CAG3B;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,YAAa,YAAW,oBAAoB;IACzF,OAAO,CAAC,YAAY,CAA8B;IAC3C,cAAc,EAAE,MAAM,EAAE,CAAM;IAErC;;;OAGG;IACI,KAAK;IAIZ;;;OAGG;IACI,IAAI;IAIX;;;OAGG;IACI,WAAW;IAIX,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIpC,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAInC,SAAS,IAAI,kBAAkB;IAI/B,MAAM,IAAI,SAAS;CAG3B"}