@waku/core/dist/lib/connection_manager/discovery_dialer.js

TypeScript implementation of the Waku v2 protocol

import { Logger } from "@waku/utils";
const log = new Logger("discovery-dialer");
/**
 * This class is responsible for dialing peers that are discovered by the libp2p node.
 * Managing limits for the peers is out of scope for this class.
 * Dialing after discovery is needed to identify the peer and get all other information: metadata, protocols, etc.
 */
export class DiscoveryDialer {
    libp2p;
    dialer;
    constructor(options) {
        this.libp2p = options.libp2p;
        this.dialer = options.dialer;
        this.onPeerDiscovery = this.onPeerDiscovery.bind(this);
    }
    start() {
        this.libp2p.addEventListener("peer:discovery", this.onPeerDiscovery);
    }
    stop() {
        this.libp2p.removeEventListener("peer:discovery", this.onPeerDiscovery);
    }
    async onPeerDiscovery(event) {
        const peerId = event.detail.id;
        log.info(`Discovered new peer: ${peerId}`);
        try {
            await this.updatePeerStore(peerId, event.detail.multiaddrs);
            await this.dialer.dial(peerId);
        }
        catch (error) {
            log.error(`Error dialing peer ${peerId}`, error);
        }
    }
    async updatePeerStore(peerId, multiaddrs) {
        try {
            log.info(`Updating peer store for ${peerId}`);
            const peer = await this.getPeer(peerId);
            if (!peer) {
                log.info(`Peer ${peerId} not found in store, saving`);
                await this.libp2p.peerStore.save(peerId, {
                    multiaddrs: multiaddrs
                });
                return;
            }
            const hasSameAddr = multiaddrs.every((addr) => peer.addresses.some((a) => a.multiaddr.equals(addr)));
            if (hasSameAddr) {
                log.info(`Peer ${peerId} has same addresses in peer store, skipping`);
                return;
            }
            log.info(`Merging peer ${peerId} addresses in peer store`);
            await this.libp2p.peerStore.merge(peerId, {
                multiaddrs: multiaddrs
            });
        }
        catch (error) {
            log.error(`Error updating peer store for ${peerId}`, error);
        }
    }
    async getPeer(peerId) {
        try {
            return await this.libp2p.peerStore.get(peerId);
        }
        catch (error) {
            log.error(`Error getting peer info for ${peerId}`, error);
            return undefined;
        }
    }
}
//# sourceMappingURL=discovery_dialer.js.map