feat(tm2): implement address book (gnolang#5861)

Closes: gnolang#5859

Discovered peers are now persisted to a local address book file and
reloaded on node restart, so the node can reconnect to previously
discovered peers without re-running the full discovery process.

---------

Co-authored-by: Thomas <thomas.bruyelle@tendermint.com>

Author: julienrbrt

tm2/pkg/bft/node/node.go

@@ -9,6 +9,7 @@ import (
 	"log/slog"
 	"net"
 	"net/http"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -42,6 +43,7 @@ import (
 	dbm "github.com/gnolang/gno/tm2/pkg/db"
 	"github.com/gnolang/gno/tm2/pkg/errors"
 	"github.com/gnolang/gno/tm2/pkg/events"
+	osm "github.com/gnolang/gno/tm2/pkg/os"
 	"github.com/gnolang/gno/tm2/pkg/p2p"
 	"github.com/gnolang/gno/tm2/pkg/service"
 	verset "github.com/gnolang/gno/tm2/pkg/versionset"
@@ -509,7 +511,24 @@ func NewNode(config *cfg.Config,
 	var discoveryReactor *discovery.Reactor
 
 	if config.P2P.PeerExchange {
-		discoveryReactor = discovery.NewReactor()
+		// Set up the persistent peer store so discovered peers survive restarts.
+		// The store file lives in the config directory alongside the node key.
+		addrBookPath := config.P2P.AddrBookFile()
+
+		if err := osm.EnsureDir(filepath.Dir(addrBookPath), cfg.DefaultDirPerm); err != nil {
+			return nil, fmt.Errorf("unable to create address book directory, %w", err)
+		}
+
+		discoveryStore, err := discovery.NewStore(
+			addrBookPath,
+			*nodeInfo.NetAddress,
+			discovery.WithLogger(logger.With("module", discoveryModuleName)),
+		)
+		if err != nil {
+			return nil, fmt.Errorf("unable to initialize peer store, %w", err)
+		}
+
+		discoveryReactor = discovery.NewReactor(discoveryStore)
 
 		discoveryReactor.SetLogger(logger.With("module", discoveryModuleName))
 

tm2/pkg/p2p/config/config.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"errors"
+	"path/filepath"
 	"time"
 )
 
@@ -12,6 +13,9 @@ var (
 	ErrInvalidReceiveRate          = errors.New("invalid packet receive rate")
 )
 
+// defaultAddrBookPath is the default relative path for the persisted peer address book
+var defaultAddrBookPath = "config/addrbook.json"
+
 // P2PConfig defines the configuration options for the Tendermint peer-to-peer networking layer
 type P2PConfig struct {
 	RootDir string `json:"rpc" toml:"home"`
@@ -51,6 +55,10 @@ type P2PConfig struct {
 
 	// Comma separated list of peer IDs to keep private (will not be gossiped to other peers)
 	PrivatePeerIDs string `json:"private_peer_ids" toml:"private_peer_ids" comment:"Comma separated list of peer IDs to keep private (will not be gossiped to other peers)"`
+
+	// Path to the address book file used to persist discovered peers across restarts.
+	// When empty, a default path relative to the root directory is used.
+	AddrBook string `json:"addr_book_file" toml:"addr_book_file" comment:"Path to the address book file used to persist discovered peers across restarts"`
 }
 
 // DefaultP2PConfig returns a default configuration for the peer-to-peer layer
@@ -65,6 +73,7 @@ func DefaultP2PConfig() *P2PConfig {
 		SendRate:                5120000, // 5 mB/s
 		RecvRate:                5120000, // 5 mB/s
 		PeerExchange:            true,
+		AddrBook:                defaultAddrBookPath,
 	}
 }
 
@@ -89,3 +98,19 @@ func (cfg *P2PConfig) ValidateBasic() error {
 
 	return nil
 }
+
+// AddrBookFile returns the absolute path to the address book file.
+// When AddrBook is a relative path, it is resolved against RootDir.
+// When AddrBook is empty, the default path is used.
+func (cfg *P2PConfig) AddrBookFile() string {
+	path := cfg.AddrBook
+	if path == "" {
+		path = defaultAddrBookPath
+	}
+
+	if filepath.IsAbs(path) {
+		return path
+	}
+
+	return filepath.Join(cfg.RootDir, path)
+}

tm2/pkg/p2p/config/config_test.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -57,3 +58,46 @@ func TestP2PConfig_ValidateBasic(t *testing.T) {
 		assert.NoError(t, cfg.ValidateBasic())
 	})
 }
+
+func TestP2PConfig_AddrBookFile(t *testing.T) {
+	t.Parallel()
+
+	t.Run("default relative path", func(t *testing.T) {
+		t.Parallel()
+
+		cfg := DefaultP2PConfig()
+		cfg.RootDir = "/root"
+
+		assert.Equal(t, filepath.Join("/root", defaultAddrBookPath), cfg.AddrBookFile())
+	})
+
+	t.Run("empty uses default", func(t *testing.T) {
+		t.Parallel()
+
+		cfg := DefaultP2PConfig()
+		cfg.RootDir = "/root"
+		cfg.AddrBook = ""
+
+		assert.Equal(t, filepath.Join("/root", defaultAddrBookPath), cfg.AddrBookFile())
+	})
+
+	t.Run("absolute path preserved", func(t *testing.T) {
+		t.Parallel()
+
+		cfg := DefaultP2PConfig()
+		cfg.RootDir = "/root"
+		cfg.AddrBook = "/custom/addrbook.json"
+
+		assert.Equal(t, "/custom/addrbook.json", cfg.AddrBookFile())
+	})
+
+	t.Run("custom relative path", func(t *testing.T) {
+		t.Parallel()
+
+		cfg := DefaultP2PConfig()
+		cfg.RootDir = "/root"
+		cfg.AddrBook = "peers/book.json"
+
+		assert.Equal(t, filepath.Join("/root", "peers/book.json"), cfg.AddrBookFile())
+	})
+}

tm2/pkg/p2p/discovery/discovery.go

@@ -48,16 +48,21 @@ type Reactor struct {
 	cancelFn context.CancelFunc
 
 	discoveryInterval time.Duration
+
+	// store persists discovered peers to disk.
+	store *Store
 }
 
-// NewReactor creates a new peer discovery reactor
-func NewReactor(opts ...Option) *Reactor {
+// NewReactor creates a new peer discovery reactor.
+// The store is used to persist discovered peers across restarts.
+func NewReactor(store *Store, opts ...Option) *Reactor {
 	ctx, cancelFn := context.WithCancel(context.Background())
 
 	r := &Reactor{
 		ctx:               ctx,
 		cancelFn:          cancelFn,
 		discoveryInterval: discoveryInterval,
+		store:             store,
 	}
 
 	r.BaseReactor = *p2p.NewBaseReactor("Reactor", r)
@@ -72,6 +77,11 @@ func NewReactor(opts ...Option) *Reactor {
 
 // OnStart runs the peer discovery protocol
 func (r *Reactor) OnStart() error {
+	// Dial peers loaded from the persistent store.
+	// This allows the node to reconnect to previously discovered peers
+	// without going through the full discovery process again.
+	r.dialPersistedPeers()
+
 	go func() {
 		ticker := time.NewTicker(r.discoveryInterval)
 		defer ticker.Stop()
@@ -102,16 +112,39 @@ func (r *Reactor) OnStart() error {
 
 				// Request peers, async
 				go r.requestPeers(peers[randomPeer.Int64()])
+
+				// Persist any newly discovered peers to disk.
+				// Save is a no-op when the store hasn't changed.
+				if err := r.store.Save(); err != nil {
+					r.Logger.Error("unable to save peer store", "err", err)
+				}
 			}
 		}
 	}()
 
 	return nil
 }
 
+// dialPersistedPeers loads peers from the store and queues them for dialing
+func (r *Reactor) dialPersistedPeers() {
+	peers := r.store.GetPeers()
+	if len(peers) == 0 {
+		return
+	}
+
+	r.Logger.Info("dialing persisted peers", "count", len(peers))
+
+	r.Switch.DialPeers(peers...)
+}
+
 // OnStop stops the peer discovery protocol
 func (r *Reactor) OnStop() {
 	r.cancelFn()
+
+	// Flush the peer store to disk so discovered peers survive a restart
+	if err := r.store.Flush(); err != nil {
+		r.Logger.Error("unable to save peer store", "err", err)
+	}
 }
 
 // requestPeers requests the peer set from the given peer
@@ -171,6 +204,9 @@ func (r *Reactor) Receive(chID byte, peer p2p.PeerConn, msgBytes []byte) {
 			r.Logger.Warn("unable to handle discovery request", "err", err)
 		}
 	case *Response:
+		// Persist the discovered peers so they survive a restart
+		r.store.AddPeers(msg.Peers...)
+
 		// Make the peers available for dialing on the switch
 		r.Switch.DialPeers(msg.Peers...)
 	default: