feat: track failed/successful dials per-address

packages/interface/src/peer-store/index.ts

@@ -13,7 +13,17 @@ export interface Address {
   /**
    * Obtained from a signed peer record
    */
-  isCertified: boolean
+  isCertified?: true
+
+  /**
+   * A timestamp of the last successful dial of this multiaddr
+   */
+  lastSuccess?: number
+
+  /**
+   * A timestamp of the last unsuccessful dial of this multiaddr
+   */
+  lastFailure?: number
 }
 
 /**

packages/libp2p/src/connection-manager/dial-queue.ts

@@ -170,8 +170,7 @@ export class DialQueue {
     const { peerId, multiaddrs } = getPeerAddress(peerIdOrMultiaddr)
 
     const addrs: Address[] = multiaddrs.map(multiaddr => ({
-      multiaddr,
-      isCertified: false
+      multiaddr
     }))
 
     // create abort conditions - need to do this before `calculateMultiaddrs` as we may be about to
@@ -317,8 +316,7 @@ export class DialQueue {
         }
 
         return result.map(multiaddr => ({
-          multiaddr,
-          isCertified: false
+          multiaddr
         }))
       })
     ))
@@ -346,12 +344,6 @@ export class DialQueue {
 
     for (const addr of filteredAddrs) {
       const maStr = addr.multiaddr.toString()
-      const existing = dedupedAddrs.get(maStr)
-
-      if (existing != null) {
-        existing.isCertified = existing.isCertified || addr.isCertified || false
-        continue
-      }
 
       dedupedAddrs.set(maStr, addr)
     }
@@ -464,10 +456,25 @@ export class DialQueue {
               // update dial status
               pendingDial.status = 'active'
 
-              const conn = await this.transportManager.dial(addr, {
-                ...options,
-                signal
-              })
+              let conn: Connection
+
+              try {
+                conn = await this.transportManager.dial(addr, {
+                  ...options,
+                  signal
+                })
+
+                // mark multiaddr dial as successful
+                await this._updateAddressStatus(conn.remotePeer, addr, true)
+              } catch (err: any) {
+                if (pendingDial.peerId != null) {
+                  // mark multiaddr dial as failure
+                  await this._updateAddressStatus(pendingDial.peerId, addr, false)
+                }
+
+                // rethrow error
+                throw err
+              }
 
               if (controller.signal.aborted) {
                 // another dial succeeded faster than this one
@@ -514,7 +521,9 @@ export class DialQueue {
           signal.clear()
         })
 
-        return deferred.promise
+        const connection = await deferred.promise
+
+        return connection
       }))
 
       // dial succeeded or failed
@@ -537,6 +546,25 @@ export class DialQueue {
       throw err
     }
   }
+
+  /**
+   * Record the last dial success/failure status of the passed multiaddr
+   */
+  private async _updateAddressStatus (peerId: PeerId, multiaddr: Multiaddr, success: boolean): Promise<void> {
+    const addr: Address = {
+      multiaddr
+    }
+
+    if (success) {
+      addr.lastSuccess = Date.now()
+    } else {
+      addr.lastFailure = Date.now()
+    }
+
+    await this.peerStore.merge(peerId, {
+      addresses: [addr]
+    })
+  }
 }
 
 /**

packages/libp2p/src/identify/identify.ts

@@ -430,7 +430,6 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
     const peer = {
       addresses: message.listenAddrs.map(buf => ({
-        isCertified: false,
         multiaddr: multiaddr(buf)
       })),
       protocols: message.protocols,

packages/libp2p/test/connection-manager/direct.spec.ts

@@ -212,7 +212,7 @@ describe('dialing (direct, WebSockets)', () => {
     await connectionManager.openConnection(remoteComponents.peerId)
 
     const sortedAddresses = peerMultiaddrs
-      .map((m) => ({ multiaddr: m, isCertified: false }))
+      .map((m) => ({ multiaddr: m }))
       .sort(defaultAddressSort)
 
     expect(localTMDialStub.getCall(0).args[0].equals(sortedAddresses[0].multiaddr))

packages/libp2p/test/content-routing/content-routing.node.ts

@@ -269,7 +269,6 @@ describe('content-routing', () => {
       await drain(node.contentRouting.findProviders(CID.parse('QmU621oD8AhHw6t25vVyfYKmL9VV3PTgc52FngEhTGACFB')))
 
       await expect(node.peerStore.get(providerPeerId)).to.eventually.have.property('addresses').that.deep.include({
-        isCertified: false,
         multiaddr: result.multiaddrs[0]
       })
     })
@@ -376,10 +375,8 @@ describe('content-routing', () => {
       await drain(node.contentRouting.findProviders(CID.parse('QmU621oD8AhHw6t25vVyfYKmL9VV3PTgc52FngEhTGACFB')))
 
       await expect(node.peerStore.get(providerPeerId)).to.eventually.have.property('addresses').that.deep.include({
-        isCertified: false,
         multiaddr: result1.multiaddrs[0]
       }).and.to.deep.include({
-        isCertified: false,
         multiaddr: result2.multiaddrs[0]
       })
     })

packages/libp2p/test/identify/index.spec.ts

@@ -444,7 +444,6 @@ describe('identify', () => {
     expect(peer.metadata.get('ProtocolVersion')).to.equalBytes(uint8ArrayFromString(message.protocolVersion))
     expect(peer.protocols).to.deep.equal(message.protocols)
     expect(peer.addresses).to.deep.equal([{
-      isCertified: false,
       multiaddr: multiaddr('/ip4/127.0.0.1/tcp/1234')
     }])
     expect(peer.id.publicKey).to.equalBytes(remoteComponents.peerId.publicKey)

packages/peer-store/src/pb/peer.proto

@@ -26,6 +26,12 @@ message Address {
 
   // Flag to indicate if the address comes from a certified source
   optional bool isCertified = 2;
+
+  // ms timestamp when we last succesfully dialed this address
+  optional uint64 lastSuccess = 3;
+
+  // ms timestamp when we last failed to dial this address
+  optional uint64 lastFailure = 4;
 }
 
 message Tag {

packages/peer-store/src/pb/peer.ts

@@ -264,6 +264,8 @@ export namespace Peer {
 export interface Address {
   multiaddr: Uint8Array
   isCertified?: boolean
+  lastSuccess?: bigint
+  lastFailure?: bigint
 }
 
 export namespace Address {
@@ -286,6 +288,16 @@ export namespace Address {
           w.bool(obj.isCertified)
         }
 
+        if (obj.lastSuccess != null) {
+          w.uint32(24)
+          w.uint64(obj.lastSuccess)
+        }
+
+        if (obj.lastFailure != null) {
+          w.uint32(32)
+          w.uint64(obj.lastFailure)
+        }
+
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
@@ -306,6 +318,12 @@ export namespace Address {
             case 2:
               obj.isCertified = reader.bool()
               break
+            case 3:
+              obj.lastSuccess = reader.uint64()
+              break
+            case 4:
+              obj.lastFailure = reader.uint64()
+              break
             default:
               reader.skipType(tag & 7)
               break

packages/peer-store/src/utils/bytes-to-peer.ts

@@ -2,7 +2,7 @@ import { peerIdFromPeerId } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { Peer as PeerPB } from '../pb/peer.js'
 import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Peer, Tag } from '@libp2p/interface/peer-store'
+import type { Address, Peer, Tag } from '@libp2p/interface/peer-store'
 
 export function bytesToPeer (peerId: PeerId, buf: Uint8Array): Peer {
   const peer = PeerPB.decode(buf)
@@ -30,11 +30,24 @@ export function bytesToPeer (peerId: PeerId, buf: Uint8Array): Peer {
   return {
     ...peer,
     id: peerId,
-    addresses: peer.addresses.map(({ multiaddr: ma, isCertified }) => {
-      return {
-        multiaddr: multiaddr(ma),
-        isCertified: isCertified ?? false
+    addresses: peer.addresses.map(({ multiaddr: ma, isCertified, lastFailure, lastSuccess }) => {
+      const addr: Address = {
+        multiaddr: multiaddr(ma)
       }
+
+      if (isCertified === true) {
+        addr.isCertified = true
+      }
+
+      if (lastFailure != null) {
+        addr.lastFailure = Number(lastFailure)
+      }
+
+      if (lastSuccess != null) {
+        addr.lastSuccess = Number(lastSuccess)
+      }
+
+      return addr
     }),
     metadata: peer.metadata,
     peerRecordEnvelope: peer.peerRecordEnvelope ?? undefined,

packages/peer-store/src/utils/dedupe-addresses.ts

@@ -26,26 +26,51 @@ export async function dedupeFilterAndSortAddresses (peerId: PeerId, filter: Addr
       continue
     }
 
-    const isCertified = addr.isCertified ?? false
     const maStr = addr.multiaddr.toString()
-    const existingAddr = addressMap.get(maStr)
+    let existingAddr = addressMap.get(maStr)
 
-    if (existingAddr != null) {
-      addr.isCertified = existingAddr.isCertified || isCertified
-    } else {
-      addressMap.set(maStr, {
-        multiaddr: addr.multiaddr,
-        isCertified
-      })
+    if (existingAddr == null) {
+      existingAddr = {
+        multiaddr: addr.multiaddr
+      }
+
+      addressMap.set(maStr, existingAddr)
+    }
+
+    if (addr.isCertified === true) {
+      existingAddr.isCertified = true
+    }
+
+    if (addr.lastFailure != null) {
+      existingAddr.lastFailure = Number(addr.lastFailure)
+    }
+
+    if (addr.lastSuccess != null) {
+      existingAddr.lastSuccess = Number(addr.lastSuccess)
     }
   }
 
   return [...addressMap.values()]
     .sort((a, b) => {
       return a.multiaddr.toString().localeCompare(b.multiaddr.toString())
     })
-    .map(({ isCertified, multiaddr }) => ({
-      isCertified,
-      multiaddr: multiaddr.bytes
-    }))
+    .map(({ isCertified, multiaddr, lastFailure, lastSuccess }) => {
+      const addr: AddressPB = {
+        multiaddr: multiaddr.bytes
+      }
+
+      if (isCertified) {
+        addr.isCertified = true
+      }
+
+      if (lastFailure != null) {
+        addr.lastFailure = BigInt(lastFailure)
+      }
+
+      if (lastSuccess != null) {
+        addr.lastSuccess = BigInt(lastSuccess)
+      }
+
+      return addr
+    })
 }

packages/peer-store/src/utils/peer-data-to-datastore-peer.ts

@@ -20,7 +20,7 @@ export function toDatastorePeer (peerId: PeerId, data: PeerData): PeerPB {
 
   const output: PeerPB = {
     addresses: (data.addresses ?? [])
-      .concat((data.multiaddrs ?? []).map(multiaddr => ({ multiaddr, isCertified: false })))
+      .concat((data.multiaddrs ?? []).map(multiaddr => ({ multiaddr })))
       .filter(address => {
         if (!isMultiaddr(address.multiaddr)) {
           throw new CodeError('Invalid mulitaddr', codes.ERR_INVALID_PARAMETERS)
@@ -36,9 +36,11 @@ export function toDatastorePeer (peerId: PeerId, data: PeerData): PeerPB {
       .sort((a, b) => {
         return a.multiaddr.toString().localeCompare(b.multiaddr.toString())
       })
-      .map(({ multiaddr, isCertified }) => ({
+      .map(({ multiaddr, isCertified, lastFailure, lastSuccess }) => ({
         multiaddr: multiaddr.bytes,
-        isCertified
+        isCertified,
+        lastFailure: lastFailure != null ? BigInt(lastFailure) : undefined,
+        lastSuccess: lastSuccess != null ? BigInt(lastSuccess) : undefined
       })),
     protocols: (data.protocols ?? []).sort(),
     metadata: new Map(),

packages/peer-store/src/utils/to-peer-pb.ts

@@ -40,7 +40,6 @@ export async function toPeerPB (peerId: PeerId, data: Partial<PeerData>, strateg
 
       if (data.multiaddrs != null) {
         addresses.push(...data.multiaddrs.map(multiaddr => ({
-          isCertified: false,
           multiaddr
         })))
       }
@@ -80,7 +79,6 @@ export async function toPeerPB (peerId: PeerId, data: Partial<PeerData>, strateg
   if (strategy === 'merge') {
     if (data.multiaddrs != null) {
       addresses.push(...data.multiaddrs.map(multiaddr => ({
-        isCertified: false,
         multiaddr
       })))
     }