fix(autonat-v2): spurious exceptions (libp2p#3400)

* Fix spurious exceptions

* chore: use isNetworkAddress instead of try catch

* fix(protocol-autonat-v2): skip non-ip4/ip6 addresses without throwing

Replace isNetworkAddress + getNetConfig pairs with tryGetNetConfig so
each call site parses the multiaddr once, and skip connections whose
remoteAddr is not ip4/ip6 (p2p-circuit, dns, etc.) since getNetworkSegment
can only derive a stable segment from ip4/ip6 addresses.

Adds tests covering:
- non-network local addresses
- non-network remote addresses (p2p-circuit)
- DNS remote addresses (pass isNetworkAddress but not ip4/ip6)
- non-network entries in peer.addresses when checking IPv6 support

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

---------

Co-authored-by: dozyio <github@dozy.io>
Co-authored-by: dozyio <37986489+dozyio@users.noreply.github.com>
Co-authored-by: tabcat <tabcat00@proton.me>
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: 4 people

packages/protocol-autonat-v2/src/client.ts

@@ -1,6 +1,6 @@
 import { InvalidParametersError, ProtocolError, serviceCapabilities, serviceDependencies } from '@libp2p/interface'
 import { peerSet } from '@libp2p/peer-collections'
-import { createScalableCuckooFilter, isGlobalUnicast, isPrivate, PeerQueue, repeatingTask, trackedMap, pbStream, getNetConfig } from '@libp2p/utils'
+import { createScalableCuckooFilter, isGlobalUnicast, isPrivate, PeerQueue, repeatingTask, trackedMap, pbStream, getNetConfig, tryGetNetConfig } from '@libp2p/utils'
 import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
 import { DEFAULT_CONNECTION_THRESHOLD, DIAL_DATA_CHUNK_SIZE, MAX_DIAL_DATA_BYTES, MAX_INBOUND_STREAMS, MAX_MESSAGE_SIZE, MAX_OUTBOUND_STREAMS, TIMEOUT } from './constants.ts'
@@ -288,7 +288,12 @@ export class AutoNATv2Client implements Startable {
           return false
         }
 
-        const options = getNetConfig(addr.multiaddr)
+        const options = tryGetNetConfig(addr.multiaddr)
+
+        if (options == null) {
+          // skip non-network addresses
+          return false
+        }
 
         if (options.type === 'ip6') {
           // do not send IPv6 addresses to peers without IPv6 addresses
@@ -402,9 +407,15 @@ export class AutoNATv2Client implements Startable {
     // if the remote peer has IPv6 addresses, we can probably send them an IPv6
     // address to verify, otherwise only send them IPv4 addresses
     const supportsIPv6 = peer.addresses.some(({ multiaddr }) => {
-      return getNetConfig(multiaddr).type === 'ip6'
+      return tryGetNetConfig(multiaddr)?.type === 'ip6'
     })
 
+    // only ip4/ip6 remote addrs can be mapped to a stable network segment
+    const remoteAddrConfig = tryGetNetConfig(connection.remoteAddr)
+    if (remoteAddrConfig?.type !== 'ip4' && remoteAddrConfig?.type !== 'ip6') {
+      return
+    }
+
     // get multiaddrs this peer is eligible to verify
     const segment = this.getNetworkSegment(connection.remoteAddr)
     const results = this.getUnverifiedMultiaddrs(segment, supportsIPv6)

packages/protocol-autonat-v2/test/client.spec.ts

@@ -911,6 +911,129 @@ describe('autonat v2 - client', () => {
       .to.be.true('Did not verify external multiaddr')
   })
 
+  it('should skip non-network addresses', async () => {
+    const peerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
+    const nonNetworkAddress = multiaddr(`/p2p/${peerId.toString()}`)
+
+    addressManager.getAddressesWithMetadata.returns([{
+      multiaddr: nonNetworkAddress,
+      verified: false,
+      type: 'observed',
+      expires: 0
+    }])
+
+    const connection = await stubPeerResponse({
+      host: '123.123.123.123',
+      messages: {}
+    })
+
+    await service.client.verifyExternalAddresses(connection)
+    await delay(100)
+
+    expect((connection.newStream as sinon.SinonStub).called)
+      .to.be.false('Opened a stream for a non-network local address')
+    expect(addressManager.confirmObservedAddr.called)
+      .to.be.false('Attempted to verify a non-network address')
+  })
+
+  it('should skip verification when the remote address is not a network address', async () => {
+    const observedAddress = multiaddr('/ip4/123.123.123.123/tcp/28319')
+    addressManager.getAddressesWithMetadata.returns([{
+      multiaddr: observedAddress,
+      verified: false,
+      type: 'observed',
+      expires: 0
+    }])
+
+    const connection = await stubPeerResponse({
+      host: '124.124.124.124',
+      messages: {}
+    })
+
+    // override with a p2p-circuit remote addr - no IP component, so no network
+    // segment can be derived
+    connection.remoteAddr = multiaddr(`/p2p/${connection.remotePeer.toString()}/p2p-circuit/p2p/${connection.remotePeer.toString()}`)
+
+    await service.client.verifyExternalAddresses(connection)
+    await delay(100)
+
+    expect((connection.newStream as sinon.SinonStub).called)
+      .to.be.false('Opened a stream for a non-network remote address')
+    expect(addressManager.confirmObservedAddr.called).to.be.false()
+  })
+
+  it('should skip verification when the remote address is not an IP address', async () => {
+    const observedAddress = multiaddr('/ip4/123.123.123.123/tcp/28319')
+    addressManager.getAddressesWithMetadata.returns([{
+      multiaddr: observedAddress,
+      verified: false,
+      type: 'observed',
+      expires: 0
+    }])
+
+    const connection = await stubPeerResponse({
+      host: '124.124.124.124',
+      messages: {}
+    })
+
+    // DNS remote addrs are network addresses but cannot be mapped to a stable
+    // network segment
+    connection.remoteAddr = multiaddr(`/dns4/example.com/tcp/443/p2p/${connection.remotePeer.toString()}`)
+
+    await service.client.verifyExternalAddresses(connection)
+    await delay(100)
+
+    expect((connection.newStream as sinon.SinonStub).called)
+      .to.be.false('Opened a stream for a DNS remote address')
+    expect(addressManager.confirmObservedAddr.called).to.be.false()
+  })
+
+  it('should skip non-network entries in peer addresses when checking IPv6 support', async () => {
+    const observedAddress = multiaddr('/ip4/123.123.123.123/tcp/28319')
+    addressManager.getAddressesWithMetadata.returns([{
+      multiaddr: observedAddress,
+      verified: false,
+      type: 'observed',
+      expires: 0
+    }])
+
+    const connection = await stubPeerResponse({
+      host: '124.124.124.124',
+      messages: {
+        [observedAddress.toString()]: {
+          dialResponse: {
+            addrIdx: 0,
+            status: DialResponse.ResponseStatus.OK,
+            dialStatus: DialStatus.OK
+          }
+        }
+      }
+    })
+
+    // override peer.addresses to include a non-network multiaddr - computing
+    // supportsIPv6 must not throw when it encounters it
+    peerStore.get.withArgs(connection.remotePeer).resolves({
+      id: connection.remotePeer,
+      addresses: [
+        { multiaddr: multiaddr(`/p2p/${connection.remotePeer.toString()}`), isCertified: false },
+        { multiaddr: multiaddr('/ip4/124.124.124.124/tcp/28319'), isCertified: true }
+      ],
+      protocols: [
+        '/libp2p/autonat/2/dial-request',
+        '/libp2p/autonat/2/dial-back'
+      ],
+      metadata: new Map(),
+      tags: new Map()
+    })
+
+    // should not throw - verification should proceed normally
+    await service.client.verifyExternalAddresses(connection)
+    await delay(100)
+
+    expect((connection.newStream as sinon.SinonStub).called)
+      .to.be.true('Did not attempt verification despite valid remote address')
+  })
+
   it('should time out when verifying an observed address', async () => {
     const observedAddress = multiaddr('/ip4/123.123.123.123/tcp/28319')
     addressManager.getAddressesWithMetadata.returns([{