add this to be a method on peerstore

Author: sukunrt

core/peerstore/peerstore.go

@@ -70,6 +70,11 @@ type Peerstore interface {
 	// RemovePeer removes all the peer related information except its addresses. To remove the
 	// addresses use `AddrBook.ClearAddrs` or set the address ttls to 0.
 	RemovePeer(peer.ID)
+
+	// UpdateHostAddrs updates the addresses of the host in the peerstore. It also adds the signed
+	// peer record for the host if there's a private key available for the host in the KeyBook.
+	// This method should only be used to update the addresses of the Host that owns the peerstore.
+	UpdateHostAddrs(hostID peer.ID, currentAddrs, removedAddrs, peerRecordAddrs []ma.Multiaddr) error
 }
 
 // PeerMetadata can handle values of any type. Serializing values is

p2p/host/basic/addrs_manager.go

@@ -11,7 +11,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/libp2p/go-libp2p/core/event"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -74,10 +73,8 @@ type addrsManager struct {
 	addrsMx      sync.RWMutex
 	currentAddrs hostAddrs
 
-	signKey           crypto.PrivKey
-	addrStore         addrStore
-	signedRecordStore peerstore.CertifiedAddrBook
-	hostID            peer.ID
+	peerstore peerstore.Peerstore
+	hostID    peer.ID
 
 	wg        sync.WaitGroup
 	ctx       context.Context
@@ -94,9 +91,7 @@ func newAddrsManager(
 	client autonatv2Client,
 	enableMetrics bool,
 	registerer prometheus.Registerer,
-	disableSignedPeerRecord bool,
-	signKey crypto.PrivKey,
-	addrStore addrStore,
+	pstore peerstore.Peerstore,
 	hostID peer.ID,
 ) (*addrsManager, error) {
 	ctx, cancel := context.WithCancel(context.Background())
@@ -110,23 +105,14 @@ func newAddrsManager(
 		triggerAddrsUpdateChan:    make(chan chan struct{}, 1),
 		triggerReachabilityUpdate: make(chan struct{}, 1),
 		interfaceAddrs:            &interfaceAddrsCache{},
-		signKey:                   signKey,
-		addrStore:                 addrStore,
+		peerstore:                 pstore,
 		hostID:                    hostID,
 		ctx:                       ctx,
 		ctxCancel:                 cancel,
 	}
 	unknownReachability := network.ReachabilityUnknown
 	as.hostReachability.Store(&unknownReachability)
 
-	if !disableSignedPeerRecord {
-		var ok bool
-		as.signedRecordStore, ok = as.addrStore.(peerstore.CertifiedAddrBook)
-		if !ok {
-			return nil, errors.New("peerstore doesn't implement CertifiedAddrBook interface")
-		}
-	}
-
 	if client != nil {
 		var metricsTracker MetricsTracker
 		if enableMetrics {
@@ -347,26 +333,10 @@ func (a *addrsManager) updateAddrs(prevHostAddrs hostAddrs, relayAddrs []ma.Mult
 
 // updatePeerStore updates the peer store for the host
 func (a *addrsManager) updatePeerStore(currentAddrs []ma.Multiaddr, removedAddrs []ma.Multiaddr) {
-	// update host addresses in the peer store
-	a.addrStore.SetAddrs(a.hostID, currentAddrs, peerstore.PermanentAddrTTL)
-	a.addrStore.SetAddrs(a.hostID, removedAddrs, 0)
-
-	var sr *record.Envelope
-	// Our addresses have changed.
-	// store the signed peer record in the peer store.
-	if a.signedRecordStore != nil {
-		var err error
-		// add signed peer record to the event
-		// in case of an error drop this event.
-		sr, err = a.makeSignedPeerRecord(currentAddrs)
-		if err != nil {
-			log.Error("error creating a signed peer record from the set of current addresses", "err", err)
-			return
-		}
-		if _, err := a.signedRecordStore.ConsumePeerRecord(sr, peerstore.PermanentAddrTTL); err != nil {
-			log.Error("failed to persist signed peer record in peer store", "err", err)
-			return
-		}
+	peerRecordAddrs := trimHostAddrList(currentAddrs, maxPeerRecordSize-1024) // 1024 B of buffer for things other than addrs in peerstore
+	err := a.peerstore.UpdateHostAddrs(a.hostID, currentAddrs, removedAddrs, peerRecordAddrs)
+	if err != nil {
+		log.Error("error updating peer store", "err", err)
 	}
 }
 
@@ -378,7 +348,7 @@ func (a *addrsManager) notifyAddrsUpdated(emitter event.Emitter, localAddrsEmitt
 		}
 	}
 	if areAddrsDifferent(previous.addrs, current.addrs) {
-		log.Debug("host addresses updated", "addrs", current.localAddrs)
+		log.Debug("host addresses updated", "addrs", current.addrs)
 		a.emitLocalAddrsUpdated(localAddrsEmitter, current.addrs, previous.addrs)
 	}
 
@@ -562,30 +532,6 @@ func (a *addrsManager) appendObservedAddrs(dst []ma.Multiaddr, listenAddrs, ifac
 	return dst
 }
 
-// makeSignedPeerRecord creates a signed peer record for the given addresses
-func (a *addrsManager) makeSignedPeerRecord(addrs []ma.Multiaddr) (*record.Envelope, error) {
-	if a.signKey == nil {
-		return nil, errors.New("signKey is nil")
-	}
-	// Limit the length of currentAddrs to ensure that our signed peer records aren't rejected
-	peerRecordSize := 64 // HostID
-	k, err := a.signKey.Raw()
-	var nk int
-	if err == nil {
-		nk = len(k)
-	} else {
-		nk = 1024 // In case of error, use a large enough value.
-	}
-	peerRecordSize += 2 * nk // 1 for signature, 1 for public key
-	// we want the final address list to be small for keeping the signed peer record in size
-	addrs = trimHostAddrList(addrs, maxPeerRecordSize-peerRecordSize-256) // 256 B of buffer
-	rec := peer.PeerRecordFromAddrInfo(peer.AddrInfo{
-		ID:    a.hostID,
-		Addrs: addrs,
-	})
-	return record.Seal(rec, a.signKey)
-}
-
 // emitLocalAddrsUpdated emits an EvtLocalAddressesUpdated event and updates the addresses in the peerstore.
 func (a *addrsManager) emitLocalAddrsUpdated(emitter event.Emitter, currentAddrs []ma.Multiaddr, lastAddrs []ma.Multiaddr) {
 	added, maintained, removed := diffAddrs(lastAddrs, currentAddrs)
@@ -594,8 +540,11 @@ func (a *addrsManager) emitLocalAddrsUpdated(emitter event.Emitter, currentAddrs
 	}
 
 	var sr *record.Envelope
-	if a.signedRecordStore != nil {
-		sr = a.signedRecordStore.GetPeerRecord(a.hostID)
+	if a.peerstore != nil {
+		ca, ok := a.peerstore.(peerstore.CertifiedAddrBook)
+		if ok {
+			sr = ca.GetPeerRecord(a.hostID)
+		}
 	}
 
 	evt := &event.EvtLocalAddressesUpdated{

p2p/host/basic/addrs_manager_test.go

@@ -57,11 +57,10 @@ func (m *mockObservedAddrs) AddrsFor(local ma.Multiaddr) []ma.Multiaddr { return
 
 var _ ObservedAddrsManager = &mockObservedAddrs{}
 
-type addrStoreArgs struct {
-	AddrStore               addrStore
-	SignKey                 crypto.PrivKey
-	HostID                  peer.ID
-	DisableSignedPeerRecord bool
+type peerstoreArgs struct {
+	Peerstore peerstore.Peerstore
+	HostID    peer.ID
+	SignKey   crypto.PrivKey
 }
 
 type addrsManagerArgs struct {
@@ -72,7 +71,7 @@ type addrsManagerArgs struct {
 	AddCertHashes        func([]ma.Multiaddr) []ma.Multiaddr
 	AutoNATClient        autonatv2Client
 	Bus                  event.Bus
-	AddrStoreArgs        addrStoreArgs
+	PeerstoreArgs        peerstoreArgs
 }
 
 type addrsManagerTestCase struct {
@@ -96,14 +95,14 @@ func newAddrsManagerTestCase(tb testing.TB, args addrsManagerArgs) addrsManagerT
 	if args.AddCertHashes != nil {
 		addCertHashes = args.AddCertHashes
 	}
-	signKey := args.AddrStoreArgs.SignKey
-	addrStore := args.AddrStoreArgs.AddrStore
-	pid := args.AddrStoreArgs.HostID
-	if args.AddrStoreArgs == (addrStoreArgs{}) {
+	peerstore := args.PeerstoreArgs.Peerstore
+	pid := args.PeerstoreArgs.HostID
+	signKey := args.PeerstoreArgs.SignKey
+	if peerstore == nil {
 		var err error
 		signKey, _, err = crypto.GenerateEd25519Key(rand.Reader)
 		require.NoError(tb, err)
-		addrStore, err = pstoremem.NewPeerstore()
+		peerstore, err = pstoremem.NewPeerstore()
 		require.NoError(tb, err)
 		pid, err = peer.IDFromPrivateKey(signKey)
 		require.NoError(tb, err)
@@ -118,9 +117,7 @@ func newAddrsManagerTestCase(tb testing.TB, args addrsManagerArgs) addrsManagerT
 		args.AutoNATClient,
 		true,
 		prometheus.DefaultRegisterer,
-		false,
-		signKey,
-		addrStore,
+		peerstore,
 		pid,
 	)
 	require.NoError(tb, err)
@@ -456,6 +453,7 @@ func TestAddrsManagerPeerstoreUpdated(t *testing.T) {
 	require.NoError(t, err)
 	pid, err := peer.IDFromPrivateKey(signKey)
 	require.NoError(t, err)
+	require.NoError(t, pstore.AddPrivKey(pid, signKey))
 
 	var update atomic.Bool
 	am := newAddrsManagerTestCase(t, addrsManagerArgs{
@@ -466,15 +464,16 @@ func TestAddrsManagerPeerstoreUpdated(t *testing.T) {
 			}
 			return []ma.Multiaddr{quic2}
 		},
-		AddrStoreArgs: addrStoreArgs{
-			AddrStore: pstore,
+		PeerstoreArgs: peerstoreArgs{
+			Peerstore: pstore,
 			HostID:    pid,
 			SignKey:   signKey,
 		},
 	})
 	defer am.Close()
 	matest.AssertEqualMultiaddrs(t, []ma.Multiaddr{quic1}, pstore.Addrs(pid))
 	ev := cab.GetPeerRecord(pid)
+	require.NotNil(t, ev)
 	pr := peerRecordFromEnvelope(t, ev)
 	require.Equal(t, pr.Addrs, []ma.Multiaddr{quic1})
 	update.Store(true)

p2p/host/basic/basic_host.go

@@ -237,8 +237,6 @@ func NewHost(n network.Network, opts *HostOpts) (*BasicHost, error) {
 		autonatv2Client,
 		opts.EnableMetrics,
 		opts.PrometheusRegisterer,
-		opts.DisableSignedPeerRecord,
-		h.Peerstore().PrivKey(h.ID()),
 		h.Peerstore(),
 		h.ID(),
 	)

p2p/host/peerstore/pstoreds/peerstore.go

@@ -8,11 +8,13 @@ import (
 
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/peerstore"
+	"github.com/libp2p/go-libp2p/core/record"
 	pstore "github.com/libp2p/go-libp2p/p2p/host/peerstore"
 
 	ds "github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/query"
 	"github.com/multiformats/go-base32"
+	ma "github.com/multiformats/go-multiaddr"
 )
 
 // Configuration object for the peerstore.
@@ -177,6 +179,33 @@ func (ps *pstoreds) PeerInfo(p peer.ID) peer.AddrInfo {
 	}
 }
 
+func (ps *pstoreds) UpdateHostAddrs(hostID peer.ID, currentAddrs, removedAddrs, peerRecordAddrs []ma.Multiaddr) error {
+	// update host addresses in the peer store
+	ps.dsAddrBook.SetAddrs(hostID, currentAddrs, peerstore.PermanentAddrTTL)
+	ps.dsAddrBook.SetAddrs(hostID, removedAddrs, 0)
+
+	signKey := ps.dsKeyBook.PrivKey(hostID)
+	if signKey == nil {
+		log.Debug("no sign key found for host", "host", hostID)
+		// don't return an error here. It's fine to not have a signed peer record.
+		return nil
+	}
+
+	pr := peer.PeerRecordFromAddrInfo(peer.AddrInfo{
+		ID:    hostID,
+		Addrs: peerRecordAddrs,
+	})
+	rec, err := record.Seal(pr, signKey)
+	if err != nil {
+		return fmt.Errorf("error sealing peer record: %s", err)
+	}
+	_, err = ps.dsAddrBook.ConsumePeerRecord(rec, peerstore.PermanentAddrTTL)
+	if err != nil {
+		return fmt.Errorf("error consuming peer record: %s", err)
+	}
+	return nil
+}
+
 // RemovePeer removes entries associated with a peer from:
 // * the KeyBook
 // * the ProtoBook

p2p/host/peerstore/pstoremem/peerstore.go

@@ -6,7 +6,9 @@ import (
 
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/peerstore"
+	"github.com/libp2p/go-libp2p/core/record"
 	pstore "github.com/libp2p/go-libp2p/p2p/host/peerstore"
+	ma "github.com/multiformats/go-multiaddr"
 )
 
 type pstoremem struct {
@@ -98,6 +100,33 @@ func (ps *pstoremem) PeerInfo(p peer.ID) peer.AddrInfo {
 	}
 }
 
+func (ps *pstoremem) UpdateHostAddrs(hostID peer.ID, currentAddrs, removedAddrs, peerRecordAddrs []ma.Multiaddr) error {
+	// update host addresses in the peer store
+	ps.memoryAddrBook.SetAddrs(hostID, currentAddrs, peerstore.PermanentAddrTTL)
+	ps.memoryAddrBook.SetAddrs(hostID, removedAddrs, 0)
+
+	signKey := ps.memoryKeyBook.PrivKey(hostID)
+	if signKey == nil {
+		log.Debug("no sign key found for host", "host", hostID)
+		// don't return an error here. It's fine to not have a signed peer record.
+		return nil
+	}
+
+	pr := peer.PeerRecordFromAddrInfo(peer.AddrInfo{
+		ID:    hostID,
+		Addrs: peerRecordAddrs,
+	})
+	rec, err := record.Seal(pr, signKey)
+	if err != nil {
+		return fmt.Errorf("error sealing peer record: %s", err)
+	}
+	_, err = ps.memoryAddrBook.ConsumePeerRecord(rec, peerstore.PermanentAddrTTL)
+	if err != nil {
+		return fmt.Errorf("error consuming peer record: %s", err)
+	}
+	return nil
+}
+
 // RemovePeer removes entries associated with a peer from:
 // * the KeyBook
 // * the ProtoBook