libp2p 0.42.2 → 0.43.0

package/dist/src/address-manager/index.d.ts

@@ -60,19 +60,10 @@ export declare class DefaultAddressManager extends EventEmitter<AddressManagerEv
     getObservedAddrs(): Multiaddr[];
     /**
      * Add peer observed addresses
-     * Signal that we have confidence an observed multiaddr is publicly dialable -
-     * this will make it appear in the output of getAddresses()
      */
+    addObservedAddr(addr: Multiaddr): void;
     confirmObservedAddr(addr: Multiaddr): void;
-    /**
-     * Signal that we do not have confidence an observed multiaddr is publicly dialable -
-     * this will remove it from the output of getObservedAddrs()
-     */
     removeObservedAddr(addr: Multiaddr): void;
-    /**
-     * Add peer observed addresses
-     */
-    addObservedAddr(addr: string | Multiaddr): void;
     getAddresses(): Multiaddr[];
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/src/address-manager/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/address-manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAA;AAC7E,OAAO,EAAe,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,cAAc,CAAC,EAAE,aAAa,CAAA;IAE9B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IAEnB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE,gBAAgB,CAAA;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAAA;CAClC;AAID,qBAAa,qBAAsB,SAAQ,YAAY,CAAC,oBAAoB,CAAC;IAC3E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IAE5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAe;IAE9C;;;;;OAKG;gBACU,UAAU,EAAE,+BAA+B,EAAE,IAAI,EAAE,kBAAkB;IAYlF;;OAEG;IACH,cAAc,IAAK,SAAS,EAAE;IAI9B;;OAEG;IACH,gBAAgB,IAAK,SAAS,EAAE;IAIhC;;OAEG;IACH,gBAAgB,IAAK,SAAS,EAAE;IAIhC;;;;OAIG;IACH,mBAAmB,CAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAI3C;;;OAGG;IACH,kBAAkB,CAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAI1C;;OAEG;IACH,eAAe,CAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAyBhD,YAAY,IAAK,SAAS,EAAE;CA6B7B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/address-manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAA;AAC7E,OAAO,EAAe,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,cAAc,CAAC,EAAE,aAAa,CAAA;IAE9B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IAEnB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CACtB;AAED,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,MAAM,CAAA;IACd,gBAAgB,EAAE,gBAAgB,CAAA;CACnC;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAAA;CAClC;AA2BD,qBAAa,qBAAsB,SAAQ,YAAY,CAAC,oBAAoB,CAAC;IAC3E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IAE5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAC/D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAe;IAE9C;;;;;OAKG;gBACU,UAAU,EAAE,+BAA+B,EAAE,IAAI,EAAE,kBAAkB;IAYlF;;OAEG;IACH,cAAc,IAAK,SAAS,EAAE;IAI9B;;OAEG;IACH,gBAAgB,IAAK,SAAS,EAAE;IAIhC;;OAEG;IACH,gBAAgB,IAAK,SAAS,EAAE;IAIhC;;OAEG;IACH,eAAe,CAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAcvC,mBAAmB,CAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAoB3C,kBAAkB,CAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAO1C,YAAY,IAAK,SAAS,EAAE;CAkC7B"}

package/dist/src/address-manager/index.js

@@ -2,6 +2,21 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events';
 import { multiaddr } from '@multiformats/multiaddr';
 import { peerIdFromString } from '@libp2p/peer-id';
 const defaultAddressFilter = (addrs) => addrs;
+/**
+ * If the passed multiaddr contains the passed peer id, remove it
+ */
+function stripPeerId(ma, peerId) {
+    const observedPeerIdStr = ma.getPeerId();
+    // strip our peer id if it has been passed
+    if (observedPeerIdStr != null) {
+        const observedPeerId = peerIdFromString(observedPeerIdStr);
+        // use same encoding for comparison
+        if (observedPeerId.equals(peerId)) {
+            ma = ma.decapsulate(multiaddr(`/p2p/${peerId.toString()}`));
+        }
+    }
+    return ma;
+}
 export class DefaultAddressManager extends EventEmitter {
     /**
      * Responsible for managing the peer addresses.
@@ -15,7 +30,7 @@ export class DefaultAddressManager extends EventEmitter {
         this.components = components;
         this.listen = listen.map(ma => ma.toString());
         this.announce = new Set(announce.map(ma => ma.toString()));
-        this.observed = new Set();
+        this.observed = new Map();
         this.announceFilter = init.announceFilter ?? defaultAddressFilter;
     }
     /**
@@ -34,42 +49,41 @@ export class DefaultAddressManager extends EventEmitter {
      * Get observed multiaddrs
      */
     getObservedAddrs() {
-        return Array.from(this.observed).map((a) => multiaddr(a));
-    }
-    /**
-     * Add peer observed addresses
-     * Signal that we have confidence an observed multiaddr is publicly dialable -
-     * this will make it appear in the output of getAddresses()
-     */
-    confirmObservedAddr(addr) {
-    }
-    /**
-     * Signal that we do not have confidence an observed multiaddr is publicly dialable -
-     * this will remove it from the output of getObservedAddrs()
-     */
-    removeObservedAddr(addr) {
+        return Array.from(this.observed).map(([a]) => multiaddr(a));
     }
     /**
      * Add peer observed addresses
      */
     addObservedAddr(addr) {
-        let ma = multiaddr(addr);
-        const remotePeer = ma.getPeerId();
-        // strip our peer id if it has been passed
-        if (remotePeer != null) {
-            const remotePeerId = peerIdFromString(remotePeer);
-            // use same encoding for comparison
-            if (remotePeerId.equals(this.components.peerId)) {
-                ma = ma.decapsulate(multiaddr(`/p2p/${this.components.peerId.toString()}`));
-            }
-        }
-        const addrString = ma.toString();
+        addr = stripPeerId(addr, this.components.peerId);
+        const addrString = addr.toString();
         // do not trigger the change:addresses event if we already know about this address
         if (this.observed.has(addrString)) {
             return;
         }
-        this.observed.add(addrString);
-        this.dispatchEvent(new CustomEvent('change:addresses'));
+        this.observed.set(addrString, {
+            confident: false
+        });
+    }
+    confirmObservedAddr(addr) {
+        addr = stripPeerId(addr, this.components.peerId);
+        const addrString = addr.toString();
+        const metadata = this.observed.get(addrString) ?? {
+            confident: false
+        };
+        const startingConfidence = metadata.confident;
+        this.observed.set(addrString, {
+            confident: true
+        });
+        // only trigger the change:addresses event if our confidence in an address has changed
+        if (!startingConfidence) {
+            this.dispatchEvent(new CustomEvent('change:addresses'));
+        }
+    }
+    removeObservedAddr(addr) {
+        addr = stripPeerId(addr, this.components.peerId);
+        const addrString = addr.toString();
+        this.observed.delete(addrString);
     }
     getAddresses() {
         let addrs = this.getAnnounceAddrs().map(ma => ma.toString());
@@ -77,7 +91,10 @@ export class DefaultAddressManager extends EventEmitter {
             // no configured announce addrs, add configured listen addresses
             addrs = this.components.transportManager.getAddrs().map(ma => ma.toString());
         }
-        addrs = addrs.concat(this.getObservedAddrs().map(ma => ma.toString()));
+        // add observed addresses we are confident in
+        addrs = addrs.concat(Array.from(this.observed)
+            .filter(([ma, metadata]) => metadata.confident)
+            .map(([ma]) => ma));
         // dedupe multiaddrs
         const addrSet = new Set(addrs);
         // Create advertising list

package/dist/src/address-manager/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/address-manager/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/address-manager/index.ts"],"names":[],"mappings":"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"}

package/dist/src/autonat/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const PROTOCOL = "/libp2p/autonat/1.0.0";
+export declare const PROTOCOL_VERSION = "1.0.0";
+export declare const PROTOCOL_NAME = "autonat";
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/autonat/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/autonat/constants.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,0BAA0B,CAAA;AAC/C,eAAO,MAAM,gBAAgB,UAAU,CAAA;AACvC,eAAO,MAAM,aAAa,YAAY,CAAA"}

package/dist/src/autonat/constants.js

@@ -0,0 +1,4 @@
+export const PROTOCOL = '/libp2p/autonat/1.0.0';
+export const PROTOCOL_VERSION = '1.0.0';
+export const PROTOCOL_NAME = 'autonat';
+//# sourceMappingURL=constants.js.map

package/dist/src/autonat/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/autonat/constants.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,QAAQ,GAAG,uBAAuB,CAAA;AAC/C,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAA;AACvC,MAAM,CAAC,MAAM,aAAa,GAAG,SAAS,CAAA"}

package/dist/src/autonat/index.d.ts

@@ -0,0 +1,64 @@
+import type { AddressManager } from '@libp2p/interface-address-manager';
+import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager';
+import type { PeerId } from '@libp2p/interface-peer-id';
+import type { PeerRouting } from '@libp2p/interface-peer-routing';
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar';
+import type { TransportManager } from '@libp2p/interface-transport';
+import type { Startable } from '@libp2p/interfaces/startable';
+export interface AutonatServiceInit {
+    /**
+     * Allows overriding the protocol prefix used
+     */
+    protocolPrefix: string;
+    /**
+     * How long we should wait for a remote peer to verify our external address
+     */
+    timeout: number;
+    /**
+     * How long to wait after startup before trying to verify our external address
+     */
+    startupDelay: number;
+    /**
+     * Verify our external addresses this often
+     */
+    refreshInterval: number;
+    /**
+     * How many parallel inbound autonat streams we allow per-connection
+     */
+    maxInboundStreams: number;
+    /**
+     * How many parallel outbound autonat streams we allow per-connection
+     */
+    maxOutboundStreams: number;
+}
+export interface DefaultAutonatComponents {
+    registrar: Registrar;
+    addressManager: AddressManager;
+    transportManager: TransportManager;
+    dialer: Dialer;
+    peerId: PeerId;
+    connectionManager: ConnectionManager;
+    peerRouting: PeerRouting;
+}
+export declare class AutonatService implements Startable {
+    private readonly components;
+    private readonly _init;
+    private readonly startupDelay;
+    private readonly refreshInterval;
+    private verifyAddressTimeout?;
+    private started;
+    constructor(components: DefaultAutonatComponents, init: AutonatServiceInit);
+    isStarted(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Handle an incoming autonat request
+     */
+    handleIncomingAutonatStream(data: IncomingStreamData): Promise<void>;
+    _verifyExternalAddresses(): void;
+    /**
+     * Our multicodec topology noticed a new peer that supports autonat
+     */
+    verifyExternalAddresses(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/autonat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/autonat/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAEvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAA;AACrF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAgC7D,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IAEtB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAA;IAEf;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;IAEvB;;OAEG;IACH,iBAAiB,EAAE,MAAM,CAAA;IAEzB;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,SAAS,CAAA;IACpB,cAAc,EAAE,cAAc,CAAA;IAC9B,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,WAAW,EAAE,WAAW,CAAA;CACzB;AAED,qBAAa,cAAe,YAAW,SAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0B;IACrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;IACxC,OAAO,CAAC,oBAAoB,CAAC,CAA+B;IAC5D,OAAO,CAAC,OAAO,CAAS;gBAEX,UAAU,EAAE,wBAAwB,EAAE,IAAI,EAAE,kBAAkB;IAU3E,SAAS,IAAK,OAAO;IAIf,KAAK,IAAK,OAAO,CAAC,IAAI,CAAC;IAoBvB,IAAI,IAAK,OAAO,CAAC,IAAI,CAAC;IAO5B;;OAEG;IACG,2BAA2B,CAAE,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8O3E,wBAAwB,IAAK,IAAI;IAOjC;;OAEG;IACG,uBAAuB,IAAK,OAAO,CAAC,IAAI,CAAC;CAwLhD"}

package/dist/src/autonat/index.js

@@ -0,0 +1,417 @@
+import { logger } from '@libp2p/logger';
+import { peerIdFromBytes } from '@libp2p/peer-id';
+import { createEd25519PeerId } from '@libp2p/peer-id-factory';
+import { multiaddr, protocols } from '@multiformats/multiaddr';
+import { abortableDuplex } from 'abortable-iterator';
+import { setMaxListeners } from 'events';
+import first from 'it-first';
+import * as lp from 'it-length-prefixed';
+import map from 'it-map';
+import parallel from 'it-parallel';
+import { pipe } from 'it-pipe';
+import isPrivateIp from 'private-ip';
+import { TimeoutController } from 'timeout-abort-controller';
+import { PROTOCOL } from './constants.js';
+import { Message } from './pb/index.js';
+const log = logger('libp2p:autonat');
+// if more than 3 peers manage to dial us on what we believe to be our external
+// IP then we are convinced that it is, in fact, our external IP
+// https://github.com/libp2p/specs/blob/master/autonat/README.md#autonat-protocol
+const REQUIRED_SUCCESSFUL_DIALS = 4;
+// Wait this long before we start to query autonat nodes
+const AUTONAT_STARTUP_DELAY = 5000;
+// Only try to verify our external address this often
+const AUTONAT_REFRESH_INTERVAL = 60000;
+export class AutonatService {
+    constructor(components, init) {
+        this.components = components;
+        this.started = false;
+        this._init = init;
+        this.startupDelay = init.startupDelay ?? AUTONAT_STARTUP_DELAY;
+        this.refreshInterval = init.refreshInterval ?? AUTONAT_REFRESH_INTERVAL;
+        this._verifyExternalAddresses = this._verifyExternalAddresses.bind(this);
+    }
+    isStarted() {
+        return this.started;
+    }
+    async start() {
+        if (this.started) {
+            return;
+        }
+        await this.components.registrar.handle(PROTOCOL, (data) => {
+            void this.handleIncomingAutonatStream(data)
+                .catch(err => {
+                log.error(err);
+            });
+        }, {
+            maxInboundStreams: this._init.maxInboundStreams,
+            maxOutboundStreams: this._init.maxOutboundStreams
+        });
+        this.verifyAddressTimeout = setTimeout(this._verifyExternalAddresses, this.startupDelay);
+        this.started = true;
+    }
+    async stop() {
+        await this.components.registrar.unhandle(PROTOCOL);
+        clearTimeout(this.verifyAddressTimeout);
+        this.started = false;
+    }
+    /**
+     * Handle an incoming autonat request
+     */
+    async handleIncomingAutonatStream(data) {
+        const controller = new TimeoutController(this._init.timeout);
+        // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
+        // appearing in the console
+        try {
+            // fails on node < 15.4
+            setMaxListeners?.(Infinity, controller.signal);
+        }
+        catch { }
+        const ourHosts = this.components.addressManager.getAddresses()
+            .map(ma => ma.toOptions().host);
+        try {
+            const source = abortableDuplex(data.stream, controller.signal);
+            const self = this;
+            await pipe(source, lp.decode(), async function* (stream) {
+                const buf = await first(stream);
+                if (buf == null) {
+                    log('No message received');
+                    yield Message.encode({
+                        type: Message.MessageType.DIAL_RESPONSE,
+                        dialResponse: {
+                            status: Message.ResponseStatus.E_BAD_REQUEST,
+                            statusText: 'No message was sent'
+                        }
+                    });
+                    return;
+                }
+                let request;
+                try {
+                    request = Message.decode(buf);
+                }
+                catch (err) {
+                    log.error('Could not decode message', err);
+                    yield Message.encode({
+                        type: Message.MessageType.DIAL_RESPONSE,
+                        dialResponse: {
+                            status: Message.ResponseStatus.E_BAD_REQUEST,
+                            statusText: 'Could not decode message'
+                        }
+                    });
+                    return;
+                }
+                const dialRequest = request.dial;
+                if (dialRequest == null) {
+                    log.error('Dial was missing from message');
+                    yield Message.encode({
+                        type: Message.MessageType.DIAL_RESPONSE,
+                        dialResponse: {
+                            status: Message.ResponseStatus.E_BAD_REQUEST,
+                            statusText: 'No Dial message found in message'
+                        }
+                    });
+                    return;
+                }
+                let peerId;
+                const peer = dialRequest.peer;
+                if (peer == null || peer.id == null) {
+                    log.error('PeerId missing from message');
+                    yield Message.encode({
+                        type: Message.MessageType.DIAL_RESPONSE,
+                        dialResponse: {
+                            status: Message.ResponseStatus.E_BAD_REQUEST,
+                            statusText: 'missing peer info'
+                        }
+                    });
+                    return;
+                }
+                try {
+                    peerId = peerIdFromBytes(peer.id);
+                }
+                catch (err) {
+                    log.error('Invalid PeerId', err);
+                    yield Message.encode({
+                        type: Message.MessageType.DIAL_RESPONSE,
+                        dialResponse: {
+                            status: Message.ResponseStatus.E_BAD_REQUEST,
+                            statusText: 'bad peer id'
+                        }
+                    });
+                    return;
+                }
+                log('Incoming request from %p', peerId);
+                // reject any dial requests that arrive via relays
+                if (!data.connection.remotePeer.equals(peerId)) {
+                    log('Target peer %p did not equal sending peer %p', peerId, data.connection.remotePeer);
+                    yield Message.encode({
+                        type: Message.MessageType.DIAL_RESPONSE,
+                        dialResponse: {
+                            status: Message.ResponseStatus.E_BAD_REQUEST,
+                            statusText: 'peer id mismatch'
+                        }
+                    });
+                    return;
+                }
+                // get a list of multiaddrs to dial
+                const multiaddrs = peer.addrs
+                    .map(buf => multiaddr(buf))
+                    .filter(ma => {
+                    const isFromSameHost = ma.toOptions().host === data.connection.remoteAddr.toOptions().host;
+                    log.trace('Request to dial %s was sent from %s is same host %s', ma, data.connection.remoteAddr, isFromSameHost);
+                    // skip any Multiaddrs where the target node's IP does not match the sending node's IP
+                    return isFromSameHost;
+                })
+                    .filter(ma => {
+                    const host = ma.toOptions().host;
+                    const isPublicIp = !(isPrivateIp(host) ?? false);
+                    log.trace('Host %s was public %s', host, isPublicIp);
+                    // don't try to dial private addresses
+                    return isPublicIp;
+                })
+                    .filter(ma => {
+                    const host = ma.toOptions().host;
+                    const isNotOurHost = !ourHosts.includes(host);
+                    log.trace('Host %s was not our host %s', host, isNotOurHost);
+                    // don't try to dial nodes on the same host as us
+                    return isNotOurHost;
+                })
+                    .filter(ma => {
+                    const isSupportedTransport = Boolean(self.components.transportManager.transportForMultiaddr(ma));
+                    log.trace('Transport for %s is supported %s', ma, isSupportedTransport);
+                    // skip any Multiaddrs that have transports we do not support
+                    return isSupportedTransport;
+                })
+                    .map(ma => {
+                    if (ma.getPeerId() == null) {
+                        // make sure we have the PeerId as part of the Multiaddr
+                        ma = ma.encapsulate(`/p2p/${peerId.toString()}`);
+                    }
+                    return ma;
+                });
+                // make sure we have something to dial
+                if (multiaddrs.length === 0) {
+                    log('No valid multiaddrs for %p in message', peerId);
+                    yield Message.encode({
+                        type: Message.MessageType.DIAL_RESPONSE,
+                        dialResponse: {
+                            status: Message.ResponseStatus.E_DIAL_REFUSED,
+                            statusText: 'no dialable addresses'
+                        }
+                    });
+                    return;
+                }
+                log('Dial multiaddrs %s for peer %p', multiaddrs.map(ma => ma.toString()).join(', '), peerId);
+                let errorMessage = '';
+                let lastMultiaddr = multiaddrs[0];
+                for await (const multiaddr of multiaddrs) {
+                    let connection;
+                    lastMultiaddr = multiaddr;
+                    try {
+                        // use the dialer so we can dial a specific multiaddr instead of every known
+                        // multiaddr for the peer
+                        connection = await self.components.dialer.dial(multiaddr, {
+                            signal: controller.signal
+                        });
+                        if (!connection.remoteAddr.equals(multiaddr)) {
+                            log.error('Tried to dial %s but dialed %s', multiaddr, connection.remoteAddr);
+                            throw new Error('Unexpected remote address');
+                        }
+                        log('Success %p', peerId);
+                        yield Message.encode({
+                            type: Message.MessageType.DIAL_RESPONSE,
+                            dialResponse: {
+                                status: Message.ResponseStatus.OK,
+                                addr: connection.remoteAddr.decapsulateCode(protocols('p2p').code).bytes
+                            }
+                        });
+                        return;
+                    }
+                    catch (err) {
+                        log('Could not dial %p', peerId, err);
+                        errorMessage = err.message;
+                    }
+                    finally {
+                        if (connection != null) {
+                            await connection.close();
+                        }
+                    }
+                }
+                yield Message.encode({
+                    type: Message.MessageType.DIAL_RESPONSE,
+                    dialResponse: {
+                        status: Message.ResponseStatus.E_DIAL_ERROR,
+                        statusText: errorMessage,
+                        addr: lastMultiaddr.bytes
+                    }
+                });
+            }, lp.encode(), 
+            // pipe to the stream, not the abortable source other wise we
+            // can't tell the remote when a dial timed out..
+            data.stream);
+        }
+        finally {
+            controller.clear();
+        }
+    }
+    _verifyExternalAddresses() {
+        void this.verifyExternalAddresses()
+            .catch(err => {
+            log.error(err);
+        });
+    }
+    /**
+     * Our multicodec topology noticed a new peer that supports autonat
+     */
+    async verifyExternalAddresses() {
+        clearTimeout(this.verifyAddressTimeout);
+        // Do not try to push if we are not running
+        if (!this.isStarted()) {
+            return;
+        }
+        const addressManager = this.components.addressManager;
+        const multiaddrs = addressManager.getObservedAddrs()
+            .filter(ma => {
+            const options = ma.toOptions();
+            return !(isPrivateIp(options.host) ?? false);
+        });
+        if (multiaddrs.length === 0) {
+            log('No public addresses found, not requesting verification');
+            this.verifyAddressTimeout = setTimeout(this._verifyExternalAddresses, this.refreshInterval);
+            return;
+        }
+        const controller = new TimeoutController(this._init.timeout);
+        // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
+        // appearing in the console
+        try {
+            // fails on node < 15.4
+            setMaxListeners?.(Infinity, controller.signal);
+        }
+        catch { }
+        const self = this;
+        try {
+            log('verify multiaddrs %s', multiaddrs.map(ma => ma.toString()).join(', '));
+            const request = Message.encode({
+                type: Message.MessageType.DIAL,
+                dial: {
+                    peer: {
+                        id: this.components.peerId.toBytes(),
+                        addrs: multiaddrs.map(map => map.bytes)
+                    }
+                }
+            });
+            // find some random peers
+            const randomPeer = await createEd25519PeerId();
+            const randomCid = randomPeer.toBytes();
+            const results = {};
+            const networkSegments = [];
+            async function verifyAddress(peer) {
+                try {
+                    log('Asking %p to verify multiaddr', peer.id);
+                    const connection = await self.components.connectionManager.openConnection(peer.id, {
+                        signal: controller.signal
+                    });
+                    const stream = await connection.newStream(PROTOCOL, {
+                        signal: controller.signal
+                    });
+                    const source = abortableDuplex(stream, controller.signal);
+                    const buf = await pipe([request], lp.encode(), source, lp.decode(), async (stream) => await first(stream));
+                    if (buf == null) {
+                        log('No response received from %s', connection.remotePeer);
+                        return undefined;
+                    }
+                    const response = Message.decode(buf);
+                    if (response.type !== Message.MessageType.DIAL_RESPONSE || response.dialResponse == null) {
+                        log('Invalid autonat response from %s', connection.remotePeer);
+                        return undefined;
+                    }
+                    if (response.dialResponse.status === Message.ResponseStatus.OK) {
+                        // make sure we use different network segments
+                        const options = connection.remoteAddr.toOptions();
+                        let segment;
+                        if (options.family === 4) {
+                            const octets = options.host.split('.');
+                            segment = octets[0];
+                        }
+                        else if (options.family === 6) {
+                            const octets = options.host.split(':');
+                            segment = octets[0];
+                        }
+                        else {
+                            log('Remote address "%s" was not IP4 or IP6?', options.host);
+                            return undefined;
+                        }
+                        if (networkSegments.includes(segment)) {
+                            log('Already have response from network segment %d - %s', segment, options.host);
+                            return undefined;
+                        }
+                        networkSegments.push(segment);
+                    }
+                    return response.dialResponse;
+                }
+                catch (err) {
+                    log.error(err);
+                }
+            }
+            for await (const dialResponse of parallel(map(this.components.peerRouting.getClosestPeers(randomCid, {
+                signal: controller.signal
+            }), (peer) => async () => await verifyAddress(peer)), {
+                concurrency: REQUIRED_SUCCESSFUL_DIALS
+            })) {
+                try {
+                    if (dialResponse == null) {
+                        continue;
+                    }
+                    // they either told us which address worked/didn't work, or we only sent them one address
+                    const addr = dialResponse.addr == null ? multiaddrs[0] : multiaddr(dialResponse.addr);
+                    log('Autonat response for %s is %s', addr, dialResponse.status);
+                    if (dialResponse.status === Message.ResponseStatus.E_BAD_REQUEST) {
+                        // the remote could not parse our request
+                        continue;
+                    }
+                    if (dialResponse.status === Message.ResponseStatus.E_DIAL_REFUSED) {
+                        // the remote could not honour our request
+                        continue;
+                    }
+                    if (dialResponse.addr == null && multiaddrs.length > 1) {
+                        // we sent the remote multiple addrs but they didn't tell us which ones worked/didn't work
+                        continue;
+                    }
+                    if (!multiaddrs.some(ma => ma.equals(addr))) {
+                        log('Peer reported %s as %s but it was not in our observed address list', addr, dialResponse.status);
+                        continue;
+                    }
+                    const addrStr = addr.toString();
+                    if (results[addrStr] == null) {
+                        results[addrStr] = { success: 0, failure: 0 };
+                    }
+                    if (dialResponse.status === Message.ResponseStatus.OK) {
+                        results[addrStr].success++;
+                    }
+                    else if (dialResponse.status === Message.ResponseStatus.E_DIAL_ERROR) {
+                        results[addrStr].failure++;
+                    }
+                    if (results[addrStr].success === REQUIRED_SUCCESSFUL_DIALS) {
+                        // we are now convinced
+                        log('%s is externally dialable', addr);
+                        addressManager.confirmObservedAddr(addr);
+                        return;
+                    }
+                    if (results[addrStr].failure === REQUIRED_SUCCESSFUL_DIALS) {
+                        // we are now unconvinced
+                        log('%s is not externally dialable', addr);
+                        addressManager.removeObservedAddr(addr);
+                        return;
+                    }
+                }
+                catch (err) {
+                    log.error('Could not verify external address', err);
+                }
+            }
+        }
+        finally {
+            controller.clear();
+            this.verifyAddressTimeout = setTimeout(this._verifyExternalAddresses, this.refreshInterval);
+        }
+    }
+}
+//# sourceMappingURL=index.js.map