refactor RPC peer identity to pubkey

Replace RPC peer_id usage with pubkey, remove GetPeerPubkey bridge, and drop redundant peer_id fields from pending/open-record data structures.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: quake

crates/fiber-lib/src/fiber/channel.rs

@@ -78,7 +78,7 @@ use ractor::{
 };
 use secp256k1::{XOnlyPublicKey, SECP256K1};
 use serde::{Deserialize, Serialize};
-use serde_with::{serde_as, DisplayFromStr};
+use serde_with::serde_as;
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::iter;
 #[cfg(test)]
@@ -7980,9 +7980,8 @@ pub struct ChannelOpenRecord {
     /// channels, the temp ID is replaced by the computed new ID when `accept_channel` is
     /// called.
     pub channel_id: Hash256,
-    /// The remote peer involved in this channel-opening attempt.
-    #[serde_as(as = "DisplayFromStr")]
-    pub peer_id: PeerId,
+    /// The remote peer public key.
+    pub pubkey: Pubkey,
     /// Whether the local node is the accepting side (received the `OpenChannel` request).
     pub is_acceptor: bool,
     /// Current status of the opening process.
@@ -8001,11 +8000,11 @@ pub struct ChannelOpenRecord {
 
 impl ChannelOpenRecord {
     /// Create a new outbound record in the `WaitingForPeer` state.
-    pub fn new(channel_id: Hash256, peer_id: PeerId, funding_amount: u128) -> Self {
+    pub fn new(channel_id: Hash256, pubkey: Pubkey, funding_amount: u128) -> Self {
         let now = now_timestamp_as_millis_u64();
         Self {
             channel_id,
-            peer_id,
+            pubkey,
             is_acceptor: false,
             status: ChannelOpeningStatus::WaitingForPeer,
             funding_amount,
@@ -8017,8 +8016,8 @@ impl ChannelOpenRecord {
 
     /// Create a new inbound record in the `WaitingForPeer` state.
     /// Used when a remote peer's `OpenChannel` request is queued for local acceptance.
-    pub fn new_inbound(channel_id: Hash256, peer_id: PeerId, remote_funding_amount: u128) -> Self {
-        let mut record = Self::new(channel_id, peer_id, remote_funding_amount);
+    pub fn new_inbound(channel_id: Hash256, pubkey: Pubkey, remote_funding_amount: u128) -> Self {
+        let mut record = Self::new(channel_id, pubkey, remote_funding_amount);
         record.is_acceptor = true;
         record
     }

crates/fiber-lib/src/fiber/network.rs

@@ -209,8 +209,8 @@ pub struct AcceptChannelResponse {
 pub struct PendingAcceptChannel {
     /// The temporary channel ID assigned by the initiator.
     pub channel_id: Hash256,
-    /// The peer ID of the channel initiator.
-    pub peer_id: PeerId,
+    /// The public key of the channel initiator.
+    pub pubkey: Pubkey,
     /// The amount of CKB or UDT the initiator is contributing to the channel.
     pub funding_amount: u128,
     /// UDT type script, if this is a UDT channel.
@@ -2020,16 +2020,15 @@ where
                     .collect::<Vec<_>>();
                 let _ = rpc.send(Ok(peers));
             }
-
             NetworkActorCommand::GetPendingAcceptChannels(rpc) => {
                 let pending = state
                     .to_be_accepted_channels
                     .map
                     .iter()
                     .map(
-                        |(channel_id, (peer_id, open_channel))| PendingAcceptChannel {
+                        |(channel_id, (pubkey, open_channel))| PendingAcceptChannel {
                             channel_id: *channel_id,
-                            peer_id: peer_id.clone(),
+                            pubkey: *pubkey,
                             funding_amount: open_channel.funding_amount,
                             udt_type_script: open_channel.funding_udt_type_script.clone(),
                             created_at: state
@@ -3376,7 +3375,7 @@ where
         self.on_channel_created(temp_channel_id, &peer_id, channel.clone());
 
         // Record the channel opening attempt so it can be queried via RPC.
-        let record = ChannelOpenRecord::new(temp_channel_id, peer_id, funding_amount);
+        let record = ChannelOpenRecord::new(temp_channel_id, remote_pubkey, funding_amount);
         self.store.insert_channel_open_record(record);
 
         Ok((channel, temp_channel_id))
@@ -3398,20 +3397,13 @@ where
             tlc_expiry_delta,
         } = accept_channel;
 
-        let (peer_id, open_channel) = self
+        let (remote_pubkey, open_channel) = self
             .to_be_accepted_channels
             .remove(&temp_channel_id)
-            .ok_or(ProcessingChannelError::InvalidParameter(format!(
-                "No channel with temp id {:?} found",
-                &temp_channel_id
-            )))?;
-
-        let remote_pubkey =
-            self.get_peer_pubkey(&peer_id)
-                .ok_or(ProcessingChannelError::InvalidParameter(format!(
-                    "Peer {:?} pubkey not found",
-                    &peer_id
-                )))?;
+            .ok_or(ProcessingChannelError::InvalidParameter(
+            format!("No channel with temp id {:?} found", &temp_channel_id),
+        ))?;
+        let peer_id = remote_pubkey.tentacle_peer_id();
 
         let shutdown_script =
             shutdown_script.unwrap_or_else(|| self.default_shutdown_script.clone());
@@ -3955,7 +3947,7 @@ where
             .to_be_accepted_channels
             .map
             .iter()
-            .filter(|(_, (peer_id, _))| peer_id == id)
+            .filter(|(_, (pubkey, _))| pubkey.tentacle_peer_id() == *id)
             .map(|(channel_id, _)| *channel_id)
             .collect();
         for channel_id in failed_channels {
@@ -4200,6 +4192,15 @@ where
     ) -> ProcessingChannelResult {
         let id = open_channel.channel_id;
         let remote_funding_amount = open_channel.funding_amount;
+        let remote_pubkey = self
+            .peer_session_map
+            .get(&peer_id)
+            .map(|peer| peer.pubkey)
+            .or_else(|| self.get_peer_pubkey(&peer_id))
+            .ok_or(ProcessingChannelError::InvalidParameter(format!(
+                "Peer {:?} pubkey not found",
+                &peer_id
+            )))?;
         let result = check_open_channel_parameters(
             &open_channel.funding_udt_type_script,
             &open_channel.shutdown_script,
@@ -4211,15 +4212,15 @@ where
         )
         .and_then(|_| {
             self.to_be_accepted_channels
-                .try_insert(id, peer_id.clone(), open_channel)
+                .try_insert(id, remote_pubkey, open_channel)
         });
 
         match result {
             Ok(_) => {
                 // Create a persistent record so the accepting side can see this pending channel
                 // via list_channels(only_pending=true) and across node restarts.
                 let record =
-                    ChannelOpenRecord::new_inbound(id, peer_id.clone(), remote_funding_amount);
+                    ChannelOpenRecord::new_inbound(id, remote_pubkey, remote_funding_amount);
                 self.store.insert_channel_open_record(record);
 
                 // Notify outside observers.
@@ -5036,7 +5037,7 @@ pub(crate) fn find_type(addr: &Multiaddr) -> TransportType {
 struct ToBeAcceptedChannels {
     total_number_limit: usize,
     total_bytes_limit: usize,
-    map: HashMap<Hash256, (PeerId, OpenChannel)>,
+    map: HashMap<Hash256, (Pubkey, OpenChannel)>,
 }
 
 impl Default for ToBeAcceptedChannels {
@@ -5067,21 +5068,21 @@ impl ToBeAcceptedChannels {
         }
     }
 
-    fn remove(&mut self, id: &Hash256) -> Option<(PeerId, OpenChannel)> {
+    fn remove(&mut self, id: &Hash256) -> Option<(Pubkey, OpenChannel)> {
         self.map.remove(id)
     }
 
     // insert and apply throttle control
     fn try_insert(
         &mut self,
         id: Hash256,
-        peer_id: PeerId,
+        pubkey: Pubkey,
         open_channel: OpenChannel,
     ) -> ProcessingChannelResult {
         if let Some(existing_value) = self.map.get(&id) {
             let err_message = format!(
                 "A channel from {:?} of id {:?} is already awaiting to be accepted",
-                &peer_id, &id,
+                &pubkey, &id,
             );
             warn!("{}: {:?}", err_message, existing_value);
             return Err(ProcessingChannelError::RepeatedProcessing(err_message));
@@ -5092,7 +5093,7 @@ impl ToBeAcceptedChannels {
         let (total_number, total_bytes) = self
             .map
             .values()
-            .filter(|(saved_peer_id, _)| *saved_peer_id == peer_id)
+            .filter(|(saved_pubkey, _)| *saved_pubkey == pubkey)
             .fold(
                 (1, open_channel.mem_size()),
                 |(count, size), (_, saved_open_channel)| {
@@ -5113,9 +5114,9 @@ impl ToBeAcceptedChannels {
 
         debug!(
             "Channel from {:?} of id {:?} is now awaiting to be accepted: {:?}",
-            &peer_id, &id, &open_channel
+            &pubkey, &id, &open_channel
         );
-        self.map.insert(id, (peer_id, open_channel));
+        self.map.insert(id, (pubkey, open_channel));
         Ok(())
     }
 }

crates/fiber-lib/src/fiber/tests/rpc.rs

@@ -66,7 +66,7 @@ async fn test_rpc_basic() {
         .send_rpc_request(
             "list_channels",
             ListChannelsParams {
-                peer_id: None,
+                pubkey: None,
                 include_closed: None,
                 only_pending: None,
             },
@@ -214,13 +214,13 @@ async fn test_rpc_list_peers() {
     let list_peers: ListPeersResult = node_0.send_rpc_request("list_peers", ()).await.unwrap();
     assert_eq!(list_peers.peers.len(), 1);
     assert_eq!(list_peers.peers[0].pubkey, node_1.pubkey);
-    let node_1_peer_id = list_peers.peers[0].peer_id.clone();
+    let node_1_pubkey = list_peers.peers[0].pubkey;
 
     let _res: () = node_0
         .send_rpc_request(
             "disconnect_peer",
             crate::rpc::peer::DisconnectPeerParams {
-                peer_id: node_1_peer_id,
+                pubkey: node_1_pubkey,
             },
         )
         .await
@@ -254,8 +254,6 @@ async fn test_rpc_list_peers() {
     dbg!("list_peers: {:?}", &list_peers);
     assert!(list_peers.peers.iter().any(|p| p.pubkey == node_1.pubkey));
     assert!(list_peers.peers.iter().any(|p| p.pubkey == node_3.pubkey));
-    assert!(list_peers.peers.iter().any(|p| p.peer_id == node_1.peer_id));
-    assert!(list_peers.peers.iter().any(|p| p.peer_id == node_3.peer_id));
 }
 
 #[tokio::test]
@@ -342,7 +340,7 @@ async fn test_rpc_shutdown_channels() {
         .send_rpc_request(
             "list_channels",
             ListChannelsParams {
-                peer_id: None,
+                pubkey: None,
                 include_closed: None,
                 only_pending: None,
             },
@@ -371,7 +369,7 @@ async fn test_rpc_shutdown_channels() {
         .send_rpc_request(
             "list_channels",
             ListChannelsParams {
-                peer_id: None,
+                pubkey: None,
                 include_closed: Some(true),
                 only_pending: None,
             },
@@ -413,7 +411,7 @@ async fn test_rpc_shutdown_channels() {
         .send_rpc_request(
             "list_channels",
             ListChannelsParams {
-                peer_id: None,
+                pubkey: None,
                 include_closed: Some(true),
                 only_pending: None,
             },
@@ -604,7 +602,7 @@ async fn test_rpc_basic_with_auth() {
         .send_rpc_request(
             "list_channels",
             ListChannelsParams {
-                peer_id: None,
+                pubkey: None,
                 include_closed: None,
                 only_pending: None,
             },

crates/fiber-lib/src/rpc/README.md

@@ -202,9 +202,8 @@ Attempts to open a channel with a peer.
 
 ##### Params
 
-* `peer_id` - <em>`PeerId`</em>, The peer ID to open a channel with (base58 string, derived from the peer's `Pubkey`).
+* `pubkey` - <em>[Pubkey](#type-pubkey)</em>, The public key of the peer to open a channel with.
  The peer must be connected through the [connect_peer](#peer-connect_peer) rpc first.
- You can obtain a peer's `peer_id` from the `list_peers` RPC.
 * `funding_amount` - <em>`u128`</em>, The amount of CKB or UDT to fund the channel with.
 * `public` - <em>`Option<bool>`</em>, Whether this is a public channel (will be broadcasted to network, and can be used to forward TLCs), an optional parameter, default value is true.
 * `one_way` - <em>`Option<bool>`</em>, Whether this is a one-way channel (will not be broadcasted to network, and can only be used to send payment one way), an optional parameter, default value is false.
@@ -298,7 +297,7 @@ Lists all channels.
 
 ##### Params
 
-* `peer_id` - <em>`Option<PeerId>`</em>, The peer ID to list channels for (base58 string, derived from the peer's `Pubkey`).
+* `pubkey` - <em>Option<[Pubkey](#type-pubkey)></em>, The public key to list channels for.
  An optional parameter, if not provided, all channels will be listed.
 * `include_closed` - <em>`Option<bool>`</em>, Whether to include closed channels in the list, an optional parameter, default value is false
 * `only_pending` - <em>`Option<bool>`</em>, When set to true, only return channels that are still being opened (non-final states:
@@ -887,7 +886,7 @@ Disconnect from a peer.
 
 ##### Params
 
-* `peer_id` - <em>`PeerId`</em>, The peer ID of the peer to disconnect (base58 string, derived from the peer's `Pubkey`).
+* `pubkey` - <em>[Pubkey](#type-pubkey)</em>, The public key of the peer to disconnect.
 
 ##### Returns
 
@@ -1144,7 +1143,7 @@ The channel data structure
 * `is_one_way` - <em>`bool`</em>, Is this channel one-way?
  Combines with is_acceptor to determine if the channel able to send payment to the counterparty or not.
 * `channel_outpoint` - <em>`Option<OutPoint>`</em>, The outpoint of the channel
-* `peer_id` - <em>`PeerId`</em>, The peer ID of the channel counterparty (base58 string, derived from the peer's `Pubkey`).
+* `pubkey` - <em>[Pubkey](#type-pubkey)</em>, The public key of the channel counterparty.
 * `funding_udt_type_script` - <em>`Option<Script>`</em>, The UDT type script of the channel
 * `state` - <em>[ChannelState](#type-channelstate)</em>, The state of the channel
 * `local_balance` - <em>`u128`</em>, The local balance of the channel
@@ -1430,8 +1429,6 @@ The information about a peer connected to the node.
 #### Fields
 
 * `pubkey` - <em>[Pubkey](#type-pubkey)</em>, The identity public key of the peer (also known as `node_id`).
-* `peer_id` - <em>`PeerId`</em>, The peer ID of the peer (base58 string, derived by hashing the `pubkey` above).
- This is used for P2P transport connections, e.g. when calling `open_channel` or `disconnect_peer`.
 * `address` - <em>`MultiAddr`</em>, The multi-address associated with the connecting peer.
  Note: this is only the address which used for connecting to the peer, not all addresses of the peer.
  The `graph_nodes` in Graph rpc module will return all addresses of the peer.