feat(rpc): getpeerinfo + getconnectioncount surface real registry data

Wire RPC context to the shared p2p peer registry and return registry-backed network peer data.

Op: extend

Author: metaphorics

Cargo.lock

@@ -130,6 +130,7 @@ pub fn run(mut config: Config) -> Result<()> {
         state.transactions(),
         state.network(),
         state.mining_template_id(),
+        state.peers(),
     );
     let rpc_handler = Arc::new(bitcoin_rs_rpc::Handler::new(Arc::new(rpc_context)));
     let rpc_server = bitcoin_rs_rpc::RpcServer::bind(

crates/node/src/run.rs

@@ -26,6 +26,7 @@ fn rpc_context_shares_arc_identity_with_node_state() -> Result<()> {
     let transactions = state.transactions();
     let network = state.network();
     let mining_template_id = state.mining_template_id();
+    let peers = state.peers();
 
     let ctx = Context::from_handles(
         Arc::clone(&chain_tip),
@@ -34,6 +35,7 @@ fn rpc_context_shares_arc_identity_with_node_state() -> Result<()> {
         Arc::clone(&transactions),
         Arc::clone(&network),
         Arc::clone(&mining_template_id),
+        Arc::clone(&peers),
     );
 
     assert!(
@@ -60,6 +62,7 @@ fn rpc_context_shares_arc_identity_with_node_state() -> Result<()> {
         Arc::ptr_eq(&ctx.mining_template_id, &mining_template_id),
         "mining_template_id must share identity"
     );
+    assert!(Arc::ptr_eq(&ctx.peers, &peers), "peers must share identity");
 
     Ok(())
 }

crates/node/tests/rpc_wiring.rs

@@ -13,9 +13,9 @@ workspace = true
 
 [features]
 default = []
-rocksdb = ["bitcoin-rs-storage/rocksdb"]
-fjall = ["bitcoin-rs-storage/fjall"]
-redb = ["bitcoin-rs-storage/redb"]
+rocksdb = ["bitcoin-rs-storage/rocksdb", "bitcoin-rs-p2p/rocksdb"]
+fjall = ["bitcoin-rs-storage/fjall", "bitcoin-rs-p2p/fjall"]
+redb = ["bitcoin-rs-storage/redb", "bitcoin-rs-p2p/redb"]
 mdbx = ["bitcoin-rs-storage/mdbx"]
 
 [dependencies]
@@ -24,6 +24,7 @@ bitcoin-rs-consensus.workspace = true
 bitcoin-rs-chain.workspace = true
 bitcoin-rs-index.workspace = true
 bitcoin-rs-mempool.workspace = true
+bitcoin-rs-p2p.workspace = true
 bitcoin-rs-utxo.workspace = true
 bitcoin-rs-filters.workspace = true
 bitcoin-rs-coinstats.workspace = true

crates/rpc/Cargo.toml

@@ -84,6 +84,8 @@ pub struct Context {
     pub transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
     /// Network counters and peers.
     pub network: Arc<RwLock<NetworkState>>,
+    /// Shared registry of currently-handshook peers.
+    pub peers: Arc<RwLock<Vec<bitcoin_rs_p2p::PeerInfo>>>,
     /// Current getblocktemplate long-poll id.
     pub mining_template_id: Arc<ArcSwap<CompactString>>,
     /// Receiver notified when mining template inputs change.
@@ -114,6 +116,7 @@ impl Context {
             blocks: Arc::new(RwLock::new(Vec::new())),
             transactions: Arc::new(RwLock::new(HashMap::new())),
             network: Arc::new(RwLock::new(NetworkState::default())),
+            peers: Arc::new(RwLock::new(Vec::new())),
             mining_template_id: Arc::new(ArcSwap::from_pointee(CompactString::new("0"))),
             mining_notifications,
             mining_sender,
@@ -134,6 +137,7 @@ impl Context {
         transactions: Arc<RwLock<HashMap<Txid, Transaction>>>,
         network: Arc<RwLock<NetworkState>>,
         mining_template_id: Arc<ArcSwap<CompactString>>,
+        peers: Arc<RwLock<Vec<bitcoin_rs_p2p::PeerInfo>>>,
     ) -> Self {
         let (mining_sender, mining_notifications) = unbounded();
         Self {
@@ -142,6 +146,7 @@ impl Context {
             blocks,
             transactions,
             network,
+            peers,
             mining_template_id,
             mining_notifications,
             mining_sender,
@@ -228,6 +233,7 @@ mod tests {
             Arc::new(RwLock::new(HashMap::new())),
             Arc::new(RwLock::new(NetworkState::default())),
             Arc::new(ArcSwap::from_pointee(CompactString::new("0"))),
+            Arc::new(RwLock::new(Vec::new())),
         );
         assert!(
             Arc::ptr_eq(&ctx.chain_tip, &chain_tip),

crates/rpc/src/context.rs

@@ -32,9 +32,44 @@ pub(crate) fn getnetworkinfo(_ctx: &Arc<Context>, params: &Value) -> Result<Valu
     }))
 }
 
-pub(crate) fn getpeerinfo(_ctx: &Arc<Context>, params: &Value) -> Result<Value, RpcError> {
+pub(crate) fn getpeerinfo(ctx: &Arc<Context>, params: &Value) -> Result<Value, RpcError> {
     ensure_no_params(params)?;
-    Ok(json!([]))
+    let peers = ctx.peers.read();
+    let mut array = Vec::with_capacity(peers.len());
+    for (id, peer) in peers.iter().enumerate() {
+        array.push(json!({
+            "id": id,
+            "addr": peer.addr.to_string(),
+            "addrbind": peer.addr.to_string(),
+            "services": format!("{:016x}", peer.services),
+            "servicesnames": Vec::<String>::new(),
+            "relaytxes": true,
+            "lastsend": 0,
+            "lastrecv": 0,
+            "bytessent": 0,
+            "bytesrecv": 0,
+            "conntime": peer.conn_time,
+            "timeoffset": 0,
+            "pingtime": 0.0,
+            "minping": 0.0,
+            "version": peer.version,
+            "subver": peer.user_agent.clone(),
+            "inbound": peer.inbound,
+            "startingheight": peer.start_height,
+            "presynced_headers": -1,
+            "synced_headers": -1,
+            "synced_blocks": -1,
+            "inflight": Vec::<u32>::new(),
+            "addr_processed": 0,
+            "addr_rate_limited": 0,
+            "permissions": Vec::<String>::new(),
+            "minfeefilter": 0.0,
+            "bytessent_per_msg": serde_json::Map::<String, serde_json::Value>::new(),
+            "bytesrecv_per_msg": serde_json::Map::<String, serde_json::Value>::new(),
+            "connection_type": if peer.inbound { "inbound" } else { "outbound" },
+        }));
+    }
+    Ok(json!(array))
 }
 
 pub(crate) fn addnode(_ctx: &Arc<Context>, params: &Value) -> Result<Value, RpcError> {
@@ -50,7 +85,8 @@ pub(crate) fn disconnectnode(_ctx: &Arc<Context>, params: &Value) -> Result<Valu
 
 pub(crate) fn getconnectioncount(ctx: &Arc<Context>, params: &Value) -> Result<Value, RpcError> {
     ensure_no_params(params)?;
-    Ok(json!(ctx.network.read().connection_count))
+    let count = ctx.peers.read().len();
+    Ok(json!(count))
 }
 
 pub(crate) fn getnettotals(ctx: &Arc<Context>, params: &Value) -> Result<Value, RpcError> {

crates/rpc/src/handlers/network.rs

@@ -2,14 +2,21 @@
 extern crate alloc;
 
 use alloc::sync::Arc;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 
+use arc_swap::{ArcSwap, ArcSwapOption};
 use bitcoin::consensus::encode::serialize_hex;
 use bitcoin::hashes::Hash as _;
 use bitcoin::{Amount, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut, Txid, Witness};
 use bitcoin_rs_chain::{ChainWork, NodeId, TipSnapshot};
 use bitcoin_rs_mempool::MempoolEntry;
+use bitcoin_rs_mempool::{Mempool, MempoolLimits};
+use bitcoin_rs_p2p::PeerInfo;
 use bitcoin_rs_primitives::Hash256;
-use bitcoin_rs_rpc::{BlockRecord, Context, Handler, RpcError};
+use bitcoin_rs_rpc::{BlockRecord, Context, Handler, NetworkState, RpcError};
+use compact_str::CompactString;
+use hashbrown::HashMap;
+use parking_lot::RwLock;
 use sonic_rs::{JsonContainerTrait as _, JsonValueTrait as _, json};
 
 #[test]
@@ -102,6 +109,32 @@ fn all_required_handlers_return_core_shapes() -> Result<(), Box<dyn std::error::
     Ok(())
 }
 
+#[test]
+fn network_peer_methods_read_shared_peer_registry() -> Result<(), Box<dyn std::error::Error>> {
+    let peers = Arc::new(RwLock::new(vec![PeerInfo {
+        addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8333),
+        version: 70_016,
+        services: 0,
+        user_agent: "/test/".into(),
+        start_height: 0,
+        conn_time: 0,
+        inbound: true,
+    }]));
+    let handler = Handler::new(context_with_peers(peers));
+
+    let count = handler.dispatch("getconnectioncount", &json!([]))?;
+    assert_eq!(count.as_u64(), Some(1));
+
+    let peer_info = handler.dispatch("getpeerinfo", &json!([]))?;
+    let peer_info = peer_info
+        .as_array()
+        .ok_or("getpeerinfo must return array")?;
+    let peer = peer_info.get(0).ok_or("getpeerinfo must return one peer")?;
+    assert_eq!(peer_info.len(), 1);
+    assert_eq!(peer.get("version").as_u64(), Some(70_016));
+    Ok(())
+}
+
 #[test]
 fn signing_methods_are_disabled() -> Result<(), Box<dyn std::error::Error>> {
     let handler = Handler::new(Arc::new(Context::new()));
@@ -148,6 +181,18 @@ impl Fixture {
     }
 }
 
+fn context_with_peers(peers: Arc<RwLock<Vec<PeerInfo>>>) -> Arc<Context> {
+    Arc::new(Context::from_handles(
+        Arc::new(ArcSwapOption::empty()),
+        Arc::new(RwLock::new(Mempool::new(MempoolLimits::default()))),
+        Arc::new(RwLock::new(Vec::new())),
+        Arc::new(RwLock::new(HashMap::new())),
+        Arc::new(RwLock::new(NetworkState::default())),
+        Arc::new(ArcSwap::from_pointee(CompactString::new("0"))),
+        peers,
+    ))
+}
+
 fn tx(label: u8, script_pubkey: ScriptBuf) -> Transaction {
     Transaction {
         version: bitcoin::transaction::Version::TWO,