Cumulo Live Peers: from static peer lists to real-time peer lists

Cumulo Live Peers

When you run a Celestia node and connectivity starts failing, a static peer list is often not enough.

What you need in that moment is simple: peers that are actually reachable from the outside right now, not peers that were visible from one node a few days ago.

That is why we built Cumulo Live Peers.

It is a live peer checker for Celestia mainnet and Mocha testnet, updated every 30 minutes and available through both a public dashboard and API.

The idea is straightforward: keep checking which peers are really reachable, filter out the unstable ones, and give node operators a list they can actually use.

How it works

Every cycle, Cumulo Live Peers builds a candidate pool from several sources:

  • Our own Celestia nodes

  • RPC endpoints from validators in the ecosystem

  • Addrbooks and peer lists collected from validator resources

  • Peers contributed directly by operators

Then we test each candidate with a direct TCP check against its P2P port.

If a peer is not reachable from the outside, it does not make it into the published list.

We also do not publish peers just because they appeared once. To be included, a peer needs to show consistent stability across roughly the last 5 hours of observations. If a peer disappears or becomes unreachable, it is automatically removed after a few cycles.

Not just “more peers”

The goal is not to publish the biggest possible list.

The goal is to publish a useful one.

Peers are scored based on:

  • Recent stability

  • Outbound activity

  • How many independent sources confirmed the same peer

  • Geographic diversity

This helps avoid lists full of random peers that may not help much in practice, especially when an operator is trying to recover connectivity quickly.

Ready to use

You can use the live peer lists here:

Mainnet:
https://cumulo.pro/services/celestia/peers

Mocha testnet:
https://cumulo.pro/services/celestia_mocha/peers

Full technical documentation:
https://github.com/Cumulo-pro/Cumulo-Front-Chain/blob/main/check_peers/PEERS_SYSTEM.md

The result is an always-updated list of the most stable and well-connected peers in the network, ready to apply with a single command.

Why we built this

At Cumulo, we run validator infrastructure across Celestia and other modular networks, and peer connectivity is one of those operational problems that looks simple until it is not.

Most operators have had that moment where a node is stuck, peers are not behaving as expected, and the usual static lists are not helping much.

Cumulo Live Peers is our attempt to make that part of node operations a little more practical: live checks, public data, reproducible logic and a list that keeps updating without anyone having to maintain it manually.


Validator resource lists

To make the external sources more useful, we also maintain public validator resource lists for Celestia mainnet and Mocha testnet.

These include RPCs, addrbooks and contributed peers.

The more validators contribute their resources, the better the scoring becomes for everyone, because the system can compare more independent sources and build a more representative view of the network.

If you are a Celestia validator and want to add your resources, you can open a PR here:

Mainnet validators:
https://github.com/Cumulo-pro/Cumulo-Front-Chain/blob/main/Celestia/data/validators.json

Testnet validators:
https://github.com/Cumulo-pro/Cumulo-Front-Chain/blob/main/Celestia/data/validators_testnet.json

We hope this is useful for Celestia validators, node operators and teams running infrastructure.

Feedback, suggestions and validator contributions are very welcome.

3 Likes

Update: peers are now verified with a real P2P handshake

A quick follow-up to this post. The TCP check we described above had a limit we wanted to fix: an open port only shows that something is listening, not that the node behind it will actually talk to you. So Cumulo Live Peers now verifies every candidate with a real P2P handshake instead of a plain TCP check.

It is already live on Celestia mainnet and Mocha-5. Same URLs, same API, same 30 minute cycle.

Why we changed it

When we measured it, we found that a large share of the peers passing the TCP check were not useful in practice: some accepted the connection and never answered the handshake, and others completed it and closed the connection right away because they had no free inbound slots. For a node trying to recover connectivity, that is exactly what we do not want in the list.

What changed

Once per cycle, the collector now behaves like a real node up to the point where peers are exchanged: SecretConnection handshake, then the NodeInfo exchange. That lets it check things a port scan cannot:

  • The node ID proven in the handshake matches the published one.
  • The peer reports the right chain-id. Peers on another network (for example a testnet RPC listed in a mainnet file) are detected and quarantined instead of being listed.
  • Whether the peer keeps the connection or closes it because it has no free inbound slots.

The stability rule follows the same idea as before: a peer is listed only if its latest handshake succeeded and it passed at least 7 of its last 10 conclusive checks (about 5 hours). The list is not padded with peers that fail, so it can be shorter than 20. If the probe cannot run in a cycle, or the list would have too few peers, the TCP-based list is published instead, so the service is never left empty.

New data in the dashboard and the API

Each peer now shows “P2P: Verified” instead of “TCP” in the dashboard, and peers.json includes extra fields: p2p_status, handshake_ms, moniker, cometbft_version and p2p_checked_at. The peers.txt and the one-line apply command work exactly as before.

What you may see in your node logs

The probe uses its own dedicated node key (never a validator or node key) and identifies itself with the moniker cumulo-peers-probe (peers.cumulo.me). It opens one connection per peer and cycle, holds it for a few seconds and closes it. No retries, no gossip, nothing beyond the handshake.

If you want to be listed:

  • Keep free inbound slots.
  • Keep your node ID stable.
  • Set a real moniker instead of the default.

Mocha-5 validator resources

If you contribute resources for the testnet, the source file for Mocha-5 is now validators_mocha-5.json. The testnet file linked in the original post belongs to the previous network.

Documentation

The technical documentation has been updated, including a new configuration section that explains how the probe is enabled and tuned: PEERS_SYSTEM.md.

If you find a reachable node that does not show up in the list, or a peer in the list that does not work for you, please tell us here. That is the most useful feedback we can get.

1 Like