From a1126fcbb758af6c67b72b90bbf15be684c1c82b Mon Sep 17 00:00:00 2001 From: masih Date: Wed, 7 Oct 2026 14:10:13 +0000 Subject: [PATCH 1/3] Report only connected peers in /net_info n_peers and peers --- sei-tendermint/internal/p2p/peermanager.go | 3 +- sei-tendermint/internal/p2p/router.go | 1 - sei-tendermint/internal/p2p/testonly.go | 5 ++ sei-tendermint/internal/rpc/core/net.go | 32 ++++++------- sei-tendermint/internal/rpc/core/net_test.go | 49 ++++++++++++++++++++ 5 files changed, 69 insertions(+), 21 deletions(-) create mode 100644 sei-tendermint/internal/rpc/core/net_test.go diff --git a/sei-tendermint/internal/p2p/peermanager.go b/sei-tendermint/internal/p2p/peermanager.go index 36060ce156..a0c216e1d7 100644 --- a/sei-tendermint/internal/p2p/peermanager.go +++ b/sei-tendermint/internal/p2p/peermanager.go @@ -343,8 +343,7 @@ func (m *peerManager[C]) Advertise() []NodeAddress { return append(addrs, selfAddrs...) } -// All addresses in pools. -// Used by net_info endpoint, which is used by integration tests and for debugging. +// All addresses in pools: connected peers and addresses learned via PEX. func (m *peerManager[C]) AllAddrs() []NodeAddress { addrs := map[types.NodeID]NodeAddress{} for _, info := range m.ConnInfos() { diff --git a/sei-tendermint/internal/p2p/router.go b/sei-tendermint/internal/p2p/router.go index a10604481b..cfc899e487 100644 --- a/sei-tendermint/internal/p2p/router.go +++ b/sei-tendermint/internal/p2p/router.go @@ -147,7 +147,6 @@ func (r *Router) Advertise(maxAddrs int) []NodeAddress { } func (r *Router) ConnInfos() []PeerConnInfo { return r.peerManager.ConnInfos() } -func (r *Router) AllAddrs() []NodeAddress { return r.peerManager.AllAddrs() } // Giga returns the GigaRouter if Autobahn is enabled, None otherwise. // Consumers (e.g. the /status RPC handler) use this to reach Autobahn-specific diff --git a/sei-tendermint/internal/p2p/testonly.go b/sei-tendermint/internal/p2p/testonly.go index c2c89b7c00..bfac69b221 100644 --- a/sei-tendermint/internal/p2p/testonly.go +++ b/sei-tendermint/internal/p2p/testonly.go @@ -273,6 +273,11 @@ func (n *TestNode) WaitForConn(ctx context.Context, target types.NodeID, status return err } +// KnownAddrs returns all addresses known to the node, including ones learned via PEX. +func (n *TestNode) KnownAddrs() []NodeAddress { + return n.Router.peerManager.AllAddrs() +} + func (n *TestNode) Connect(ctx context.Context, target *TestNode) error { _ = n.Router.peerManager.PushPex(utils.Some(target.NodeID), utils.Slice(target.NodeAddress)) if err := n.WaitForConn(ctx, target.NodeID, true); err != nil { diff --git a/sei-tendermint/internal/rpc/core/net.go b/sei-tendermint/internal/rpc/core/net.go index db1315aa5f..814da2732a 100644 --- a/sei-tendermint/internal/rpc/core/net.go +++ b/sei-tendermint/internal/rpc/core/net.go @@ -4,41 +4,37 @@ import ( "context" "errors" "fmt" - "maps" - "slices" "github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes" - "github.com/sei-protocol/sei-chain/sei-tendermint/types" ) // NetInfo returns network info. // More: https://docs.tendermint.com/master/rpc/#/Info/net_info func (env *Environment) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) { - peers := map[types.NodeID]coretypes.Peer{} - for _, addr := range env.Router.AllAddrs() { - if _, ok := peers[addr.NodeID]; ok { - continue + infos := env.Router.ConnInfos() + peers := make([]coretypes.Peer, 0, len(infos)) + peerConnections := make([]coretypes.PeerConnection, 0, len(infos)) + for _, info := range infos { + peer := coretypes.Peer{ID: info.ID} + if addr, ok := info.DialedAddr.Get(); ok { + peer.URL = addr.String() + } else if addr, ok := info.SelfDeclaredAddr.Get(); ok { + peer.URL = addr.String() } - peers[addr.NodeID] = coretypes.Peer{ID: addr.NodeID, URL: addr.String()} - } - peerConnections := map[types.NodeID]coretypes.PeerConnection{} - for _, info := range env.Router.ConnInfos() { - if _, ok := peerConnections[info.ID]; ok { - continue - } - peerConnections[info.ID] = coretypes.PeerConnection{ + peers = append(peers, peer) + peerConnections = append(peerConnections, coretypes.PeerConnection{ ID: info.ID, State: "ready,connected", Score: 100, - } + }) } return &coretypes.ResultNetInfo{ Listening: env.IsListening, Listeners: env.Listeners, NPeers: len(peers), - Peers: slices.Collect(maps.Values(peers)), - PeerConnections: slices.Collect(maps.Values(peerConnections)), + Peers: peers, + PeerConnections: peerConnections, }, nil } diff --git a/sei-tendermint/internal/rpc/core/net_test.go b/sei-tendermint/internal/rpc/core/net_test.go new file mode 100644 index 0000000000..79cfb9cc4a --- /dev/null +++ b/sei-tendermint/internal/rpc/core/net_test.go @@ -0,0 +1,49 @@ +package core + +import ( + "slices" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/sei-protocol/sei-chain/sei-tendermint/internal/p2p" + "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" + "github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes" +) + +func TestNetInfo_ReportsConnectedPeersOnly(t *testing.T) { + ctx := t.Context() + network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{}) + opts := p2p.TestNodeOptions{PexOnHandshake: true, SelfAddress: true} + hub := network.MakeNode(t, opts) + a := network.MakeNode(t, opts) + opts.MaxConnected = utils.Some(1) + b := network.MakeNode(t, opts) + + require.NoError(t, a.Connect(ctx, hub)) + require.NoError(t, b.Connect(ctx, hub)) + + // b learns a's address from hub during the handshake, but cannot dial it. + require.Eventually(t, func() bool { + return slices.Contains(b.KnownAddrs(), a.NodeAddress) + }, 10*time.Second, 10*time.Millisecond) + + env := &Environment{Router: b.Router} + res, err := env.NetInfo(ctx) + require.NoError(t, err) + require.Equal(t, 1, res.NPeers) + require.Equal(t, []coretypes.Peer{{ID: hub.NodeID, URL: hub.NodeAddress.String()}}, res.Peers) + require.Len(t, res.PeerConnections, 1) + require.Equal(t, hub.NodeID, res.PeerConnections[0].ID) + + env = &Environment{Router: hub.Router} + res, err = env.NetInfo(ctx) + require.NoError(t, err) + require.Equal(t, 2, res.NPeers) + require.ElementsMatch(t, []coretypes.Peer{ + {ID: a.NodeID, URL: a.NodeAddress.String()}, + {ID: b.NodeID, URL: b.NodeAddress.String()}, + }, res.Peers) + require.Len(t, res.PeerConnections, 2) +} From 76afd58025f9a80a5bde267bf4e53818c093130d Mon Sep 17 00:00:00 2001 From: masih Date: Wed, 7 Oct 2026 14:21:44 +0000 Subject: [PATCH 2/3] Count every connection in n_peers and drop peerManager.AllAddrs --- sei-tendermint/internal/p2p/peermanager.go | 24 --------- sei-tendermint/internal/p2p/router_test.go | 2 +- sei-tendermint/internal/p2p/testonly.go | 26 +++++++++- sei-tendermint/internal/rpc/core/net.go | 19 ++++---- sei-tendermint/internal/rpc/core/net_test.go | 51 +++++++++++--------- 5 files changed, 63 insertions(+), 59 deletions(-) diff --git a/sei-tendermint/internal/p2p/peermanager.go b/sei-tendermint/internal/p2p/peermanager.go index a0c216e1d7..593da95ece 100644 --- a/sei-tendermint/internal/p2p/peermanager.go +++ b/sei-tendermint/internal/p2p/peermanager.go @@ -343,30 +343,6 @@ func (m *peerManager[C]) Advertise() []NodeAddress { return append(addrs, selfAddrs...) } -// All addresses in pools: connected peers and addresses learned via PEX. -func (m *peerManager[C]) AllAddrs() []NodeAddress { - addrs := map[types.NodeID]NodeAddress{} - for _, info := range m.ConnInfos() { - if addr, ok := info.DialedAddr.Get(); ok { - addrs[addr.NodeID] = addr - } else if addr, ok := info.SelfDeclaredAddr.Get(); ok { - addrs[addr.NodeID] = addr - } - } - for inner := range m.inner.Lock() { - for _, pool := range utils.Slice(inner.persistent, inner.regular) { - for e := range pool.pex.All() { - for _, pAddr := range e.addrs { - if _, ok := addrs[pAddr.NodeID]; !ok { - addrs[pAddr.NodeID] = pAddr.NodeAddress - } - } - } - } - } - return slices.Collect(maps.Values(addrs)) -} - // Infos of connections in the pool. func (m *peerManager[C]) ConnInfos() []PeerConnInfo { infos := map[types.NodeID]PeerConnInfo{} diff --git a/sei-tendermint/internal/p2p/router_test.go b/sei-tendermint/internal/p2p/router_test.go index f7780e0de9..d801685c81 100644 --- a/sei-tendermint/internal/p2p/router_test.go +++ b/sei-tendermint/internal/p2p/router_test.go @@ -240,7 +240,7 @@ func TestRouter_PexOnHandshake_DialerDisabled(t *testing.T) { // newNode should NOT learn about nodes[1] during handshake. require.True(t, slices.Index( - newNode.Router.peerManager.AllAddrs(), + newNode.KnownAddrs(), nodes[1].NodeAddress, ) == -1) } diff --git a/sei-tendermint/internal/p2p/testonly.go b/sei-tendermint/internal/p2p/testonly.go index bfac69b221..affe2c181a 100644 --- a/sei-tendermint/internal/p2p/testonly.go +++ b/sei-tendermint/internal/p2p/testonly.go @@ -3,8 +3,10 @@ package p2p import ( "context" "fmt" + "maps" "math/rand" "net/netip" + "slices" "testing" "time" @@ -273,9 +275,29 @@ func (n *TestNode) WaitForConn(ctx context.Context, target types.NodeID, status return err } -// KnownAddrs returns all addresses known to the node, including ones learned via PEX. +// KnownAddrs returns the addresses of connected peers and the addresses learned via PEX. func (n *TestNode) KnownAddrs() []NodeAddress { - return n.Router.peerManager.AllAddrs() + m := n.Router.peerManager + addrs := map[types.NodeID]NodeAddress{} + for _, info := range m.ConnInfos() { + if addr, ok := info.DialedAddr.Get(); ok { + addrs[addr.NodeID] = addr + } else if addr, ok := info.SelfDeclaredAddr.Get(); ok { + addrs[addr.NodeID] = addr + } + } + for inner := range m.inner.Lock() { + for _, pool := range utils.Slice(inner.persistent, inner.regular) { + for e := range pool.pex.All() { + for _, pAddr := range e.addrs { + if _, ok := addrs[pAddr.NodeID]; !ok { + addrs[pAddr.NodeID] = pAddr.NodeAddress + } + } + } + } + } + return slices.Collect(maps.Values(addrs)) } func (n *TestNode) Connect(ctx context.Context, target *TestNode) error { diff --git a/sei-tendermint/internal/rpc/core/net.go b/sei-tendermint/internal/rpc/core/net.go index 814da2732a..5e220a6133 100644 --- a/sei-tendermint/internal/rpc/core/net.go +++ b/sei-tendermint/internal/rpc/core/net.go @@ -8,31 +8,32 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes" ) -// NetInfo returns network info. +// NetInfo returns network info. NPeers and PeerConnections cover every +// connected peer; Peers lists the connected peers with a known address. // More: https://docs.tendermint.com/master/rpc/#/Info/net_info func (env *Environment) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) { infos := env.Router.ConnInfos() peers := make([]coretypes.Peer, 0, len(infos)) peerConnections := make([]coretypes.PeerConnection, 0, len(infos)) for _, info := range infos { - peer := coretypes.Peer{ID: info.ID} - if addr, ok := info.DialedAddr.Get(); ok { - peer.URL = addr.String() - } else if addr, ok := info.SelfDeclaredAddr.Get(); ok { - peer.URL = addr.String() - } - peers = append(peers, peer) peerConnections = append(peerConnections, coretypes.PeerConnection{ ID: info.ID, State: "ready,connected", Score: 100, }) + addr, ok := info.DialedAddr.Get() + if !ok { + addr, ok = info.SelfDeclaredAddr.Get() + } + if ok { + peers = append(peers, coretypes.Peer{ID: info.ID, URL: addr.String()}) + } } return &coretypes.ResultNetInfo{ Listening: env.IsListening, Listeners: env.Listeners, - NPeers: len(peers), + NPeers: len(peerConnections), Peers: peers, PeerConnections: peerConnections, }, nil diff --git a/sei-tendermint/internal/rpc/core/net_test.go b/sei-tendermint/internal/rpc/core/net_test.go index 79cfb9cc4a..cd4182b86d 100644 --- a/sei-tendermint/internal/rpc/core/net_test.go +++ b/sei-tendermint/internal/rpc/core/net_test.go @@ -1,7 +1,6 @@ package core import ( - "slices" "testing" "time" @@ -12,7 +11,28 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes" ) -func TestNetInfo_ReportsConnectedPeersOnly(t *testing.T) { +func TestNetInfo_ReportsConnectedPeers(t *testing.T) { + ctx := t.Context() + network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{}) + hub := network.MakeNode(t, p2p.TestNodeOptions{}) + a := network.MakeNode(t, p2p.TestNodeOptions{SelfAddress: true}) + // b declares no address, so hub has no URL to list for it. + b := network.MakeNode(t, p2p.TestNodeOptions{}) + require.NoError(t, a.Connect(ctx, hub)) + require.NoError(t, b.Connect(ctx, hub)) + + env := &Environment{Router: hub.Router} + res, err := env.NetInfo(ctx) + require.NoError(t, err) + require.Equal(t, 2, res.NPeers) + require.Equal(t, []coretypes.Peer{{ID: a.NodeID, URL: a.NodeAddress.String()}}, res.Peers) + require.ElementsMatch(t, []coretypes.PeerConnection{ + {ID: a.NodeID, State: "ready,connected", Score: 100}, + {ID: b.NodeID, State: "ready,connected", Score: 100}, + }, res.PeerConnections) +} + +func TestNetInfo_ExcludesPexAddresses(t *testing.T) { ctx := t.Context() network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{}) opts := p2p.TestNodeOptions{PexOnHandshake: true, SelfAddress: true} @@ -20,30 +40,15 @@ func TestNetInfo_ReportsConnectedPeersOnly(t *testing.T) { a := network.MakeNode(t, opts) opts.MaxConnected = utils.Some(1) b := network.MakeNode(t, opts) - require.NoError(t, a.Connect(ctx, hub)) require.NoError(t, b.Connect(ctx, hub)) - // b learns a's address from hub during the handshake, but cannot dial it. + // b learns both addresses via PEX but holds a single connection. + env := &Environment{Router: b.Router} require.Eventually(t, func() bool { - return slices.Contains(b.KnownAddrs(), a.NodeAddress) + res, err := env.NetInfo(ctx) + return err == nil && len(b.KnownAddrs()) == 2 && + res.NPeers == 1 && len(res.Peers) == 1 && len(res.PeerConnections) == 1 && + res.Peers[0].ID == res.PeerConnections[0].ID }, 10*time.Second, 10*time.Millisecond) - - env := &Environment{Router: b.Router} - res, err := env.NetInfo(ctx) - require.NoError(t, err) - require.Equal(t, 1, res.NPeers) - require.Equal(t, []coretypes.Peer{{ID: hub.NodeID, URL: hub.NodeAddress.String()}}, res.Peers) - require.Len(t, res.PeerConnections, 1) - require.Equal(t, hub.NodeID, res.PeerConnections[0].ID) - - env = &Environment{Router: hub.Router} - res, err = env.NetInfo(ctx) - require.NoError(t, err) - require.Equal(t, 2, res.NPeers) - require.ElementsMatch(t, []coretypes.Peer{ - {ID: a.NodeID, URL: a.NodeAddress.String()}, - {ID: b.NodeID, URL: b.NodeAddress.String()}, - }, res.Peers) - require.Len(t, res.PeerConnections, 2) } From 691d45b684d0aba11e74abe77ec321e9164b0e32 Mon Sep 17 00:00:00 2001 From: masih Date: Fri, 9 Oct 2026 10:21:18 +0000 Subject: [PATCH 3/3] Keep known addresses in /net_info peers and count only connected peers in n_peers --- sei-tendermint/internal/p2p/peermanager.go | 25 ++++++++++++++ sei-tendermint/internal/p2p/router.go | 1 + sei-tendermint/internal/p2p/router_test.go | 2 +- sei-tendermint/internal/p2p/testonly.go | 27 --------------- sei-tendermint/internal/rpc/core/net.go | 36 +++++++++++--------- sei-tendermint/internal/rpc/core/net_test.go | 11 +++--- 6 files changed, 51 insertions(+), 51 deletions(-) diff --git a/sei-tendermint/internal/p2p/peermanager.go b/sei-tendermint/internal/p2p/peermanager.go index 593da95ece..36060ce156 100644 --- a/sei-tendermint/internal/p2p/peermanager.go +++ b/sei-tendermint/internal/p2p/peermanager.go @@ -343,6 +343,31 @@ func (m *peerManager[C]) Advertise() []NodeAddress { return append(addrs, selfAddrs...) } +// All addresses in pools. +// Used by net_info endpoint, which is used by integration tests and for debugging. +func (m *peerManager[C]) AllAddrs() []NodeAddress { + addrs := map[types.NodeID]NodeAddress{} + for _, info := range m.ConnInfos() { + if addr, ok := info.DialedAddr.Get(); ok { + addrs[addr.NodeID] = addr + } else if addr, ok := info.SelfDeclaredAddr.Get(); ok { + addrs[addr.NodeID] = addr + } + } + for inner := range m.inner.Lock() { + for _, pool := range utils.Slice(inner.persistent, inner.regular) { + for e := range pool.pex.All() { + for _, pAddr := range e.addrs { + if _, ok := addrs[pAddr.NodeID]; !ok { + addrs[pAddr.NodeID] = pAddr.NodeAddress + } + } + } + } + } + return slices.Collect(maps.Values(addrs)) +} + // Infos of connections in the pool. func (m *peerManager[C]) ConnInfos() []PeerConnInfo { infos := map[types.NodeID]PeerConnInfo{} diff --git a/sei-tendermint/internal/p2p/router.go b/sei-tendermint/internal/p2p/router.go index cfc899e487..a10604481b 100644 --- a/sei-tendermint/internal/p2p/router.go +++ b/sei-tendermint/internal/p2p/router.go @@ -147,6 +147,7 @@ func (r *Router) Advertise(maxAddrs int) []NodeAddress { } func (r *Router) ConnInfos() []PeerConnInfo { return r.peerManager.ConnInfos() } +func (r *Router) AllAddrs() []NodeAddress { return r.peerManager.AllAddrs() } // Giga returns the GigaRouter if Autobahn is enabled, None otherwise. // Consumers (e.g. the /status RPC handler) use this to reach Autobahn-specific diff --git a/sei-tendermint/internal/p2p/router_test.go b/sei-tendermint/internal/p2p/router_test.go index d801685c81..f7780e0de9 100644 --- a/sei-tendermint/internal/p2p/router_test.go +++ b/sei-tendermint/internal/p2p/router_test.go @@ -240,7 +240,7 @@ func TestRouter_PexOnHandshake_DialerDisabled(t *testing.T) { // newNode should NOT learn about nodes[1] during handshake. require.True(t, slices.Index( - newNode.KnownAddrs(), + newNode.Router.peerManager.AllAddrs(), nodes[1].NodeAddress, ) == -1) } diff --git a/sei-tendermint/internal/p2p/testonly.go b/sei-tendermint/internal/p2p/testonly.go index affe2c181a..c2c89b7c00 100644 --- a/sei-tendermint/internal/p2p/testonly.go +++ b/sei-tendermint/internal/p2p/testonly.go @@ -3,10 +3,8 @@ package p2p import ( "context" "fmt" - "maps" "math/rand" "net/netip" - "slices" "testing" "time" @@ -275,31 +273,6 @@ func (n *TestNode) WaitForConn(ctx context.Context, target types.NodeID, status return err } -// KnownAddrs returns the addresses of connected peers and the addresses learned via PEX. -func (n *TestNode) KnownAddrs() []NodeAddress { - m := n.Router.peerManager - addrs := map[types.NodeID]NodeAddress{} - for _, info := range m.ConnInfos() { - if addr, ok := info.DialedAddr.Get(); ok { - addrs[addr.NodeID] = addr - } else if addr, ok := info.SelfDeclaredAddr.Get(); ok { - addrs[addr.NodeID] = addr - } - } - for inner := range m.inner.Lock() { - for _, pool := range utils.Slice(inner.persistent, inner.regular) { - for e := range pool.pex.All() { - for _, pAddr := range e.addrs { - if _, ok := addrs[pAddr.NodeID]; !ok { - addrs[pAddr.NodeID] = pAddr.NodeAddress - } - } - } - } - } - return slices.Collect(maps.Values(addrs)) -} - func (n *TestNode) Connect(ctx context.Context, target *TestNode) error { _ = n.Router.peerManager.PushPex(utils.Some(target.NodeID), utils.Slice(target.NodeAddress)) if err := n.WaitForConn(ctx, target.NodeID, true); err != nil { diff --git a/sei-tendermint/internal/rpc/core/net.go b/sei-tendermint/internal/rpc/core/net.go index 5e220a6133..4dbeb9028f 100644 --- a/sei-tendermint/internal/rpc/core/net.go +++ b/sei-tendermint/internal/rpc/core/net.go @@ -4,29 +4,33 @@ import ( "context" "errors" "fmt" + "maps" + "slices" "github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes" + "github.com/sei-protocol/sei-chain/sei-tendermint/types" ) -// NetInfo returns network info. NPeers and PeerConnections cover every -// connected peer; Peers lists the connected peers with a known address. +// NetInfo returns network info. NPeers counts connected peers, the same set as +// PeerConnections; Peers lists every known address, including those learned via PEX. // More: https://docs.tendermint.com/master/rpc/#/Info/net_info func (env *Environment) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) { - infos := env.Router.ConnInfos() - peers := make([]coretypes.Peer, 0, len(infos)) - peerConnections := make([]coretypes.PeerConnection, 0, len(infos)) - for _, info := range infos { - peerConnections = append(peerConnections, coretypes.PeerConnection{ + peers := map[types.NodeID]coretypes.Peer{} + for _, addr := range env.Router.AllAddrs() { + if _, ok := peers[addr.NodeID]; ok { + continue + } + peers[addr.NodeID] = coretypes.Peer{ID: addr.NodeID, URL: addr.String()} + } + peerConnections := map[types.NodeID]coretypes.PeerConnection{} + for _, info := range env.Router.ConnInfos() { + if _, ok := peerConnections[info.ID]; ok { + continue + } + peerConnections[info.ID] = coretypes.PeerConnection{ ID: info.ID, State: "ready,connected", Score: 100, - }) - addr, ok := info.DialedAddr.Get() - if !ok { - addr, ok = info.SelfDeclaredAddr.Get() - } - if ok { - peers = append(peers, coretypes.Peer{ID: info.ID, URL: addr.String()}) } } @@ -34,8 +38,8 @@ func (env *Environment) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, Listening: env.IsListening, Listeners: env.Listeners, NPeers: len(peerConnections), - Peers: peers, - PeerConnections: peerConnections, + Peers: slices.Collect(maps.Values(peers)), + PeerConnections: slices.Collect(maps.Values(peerConnections)), }, nil } diff --git a/sei-tendermint/internal/rpc/core/net_test.go b/sei-tendermint/internal/rpc/core/net_test.go index cd4182b86d..ff7be50f2b 100644 --- a/sei-tendermint/internal/rpc/core/net_test.go +++ b/sei-tendermint/internal/rpc/core/net_test.go @@ -11,13 +11,13 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes" ) -func TestNetInfo_ReportsConnectedPeers(t *testing.T) { +func TestNetInfo_NPeersCountsConnectedPeers(t *testing.T) { ctx := t.Context() network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{}) hub := network.MakeNode(t, p2p.TestNodeOptions{}) a := network.MakeNode(t, p2p.TestNodeOptions{SelfAddress: true}) - // b declares no address, so hub has no URL to list for it. b := network.MakeNode(t, p2p.TestNodeOptions{}) + require.NoError(t, a.Connect(ctx, hub)) require.NoError(t, b.Connect(ctx, hub)) @@ -32,7 +32,7 @@ func TestNetInfo_ReportsConnectedPeers(t *testing.T) { }, res.PeerConnections) } -func TestNetInfo_ExcludesPexAddresses(t *testing.T) { +func TestNetInfo_PeersIncludesPexAddresses(t *testing.T) { ctx := t.Context() network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{}) opts := p2p.TestNodeOptions{PexOnHandshake: true, SelfAddress: true} @@ -43,12 +43,9 @@ func TestNetInfo_ExcludesPexAddresses(t *testing.T) { require.NoError(t, a.Connect(ctx, hub)) require.NoError(t, b.Connect(ctx, hub)) - // b learns both addresses via PEX but holds a single connection. env := &Environment{Router: b.Router} require.Eventually(t, func() bool { res, err := env.NetInfo(ctx) - return err == nil && len(b.KnownAddrs()) == 2 && - res.NPeers == 1 && len(res.Peers) == 1 && len(res.PeerConnections) == 1 && - res.Peers[0].ID == res.PeerConnections[0].ID + return err == nil && res.NPeers == 1 && len(res.PeerConnections) == 1 && len(res.Peers) == 2 }, 10*time.Second, 10*time.Millisecond) }