update to lastest tdn version

Cargo.toml

@@ -36,8 +36,8 @@ sysinfo = "0.21"
 serde = { version = "1", features = ["derive"] }
 tokio = { version = "1", features = ["full"] }
 web3 = { version = "0.17", default-features = false, features = ["http-tls", "signing"] }
-tdn = { version = "0.5", default-features = false, features = ["full"] }
-tdn_did = { version = "0.5" }
+tdn = { version = "0.6", default-features = false, features = ["full"] }
+tdn_did = { version = "0.6" }
 tdn_storage = { git = "https://github.com/cypherlink/tdn_storage", branch="main" }
 group-chat_types = { git = "https://github.com/cympletech/esse_types", branch="main" }
 domain_types = { git = "https://github.com/cympletech/esse_types", branch="main" }

lib/pages/setting/network.dart

@@ -21,6 +21,8 @@ class _NetworkDetailState extends State<NetworkDetail> {
   List<String> networkDht = [];
   List<List<String>> networkStable = [];
 
+  String _selectedTrans = "quic";
+
   changeWs() async {
     Global.changeWs(wsController.text);
     await rpc.init(wsController.text);
@@ -34,7 +36,7 @@ class _NetworkDetailState extends State<NetworkDetail> {
   }
 
   addBootstrap() {
-    rpc.send('add-bootstrap', [addController.text]);
+    rpc.send('add-bootstrap', [addController.text, _selectedTrans]);
     setState(() {});
   }
 
@@ -66,6 +68,25 @@ class _NetworkDetailState extends State<NetworkDetail> {
     }
   }
 
+  Widget _trans(String value, color) {
+    return Row(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        Radio(
+          value: value,
+          groupValue: _selectedTrans,
+          onChanged: (String? n) => setState(() {
+              if (n != null) {
+                _selectedTrans = n;
+              }
+        })),
+        _selectedTrans == value
+        ? Text(value.toUpperCase(), style: TextStyle(color: color.primary))
+        : Text(value.toUpperCase()),
+      ]
+    );
+  }
+
   @override
   initState() {
     loadNetworkStable();
@@ -139,6 +160,13 @@ class _NetworkDetailState extends State<NetworkDetail> {
                 child: Column(
                   children: [
                     _settingHead(lang.networkAdd),
+                    Row(
+                      mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+                      children: [
+                        _trans("quic", color), _trans("tcp", color),
+                      ]
+                    ),
+                    const SizedBox(height: 5.0),
                     SocketInputText(controller: addController, action: addBootstrap, state: true),
                     const SizedBox(height: 15.0),
                   ]

src/apps/chat/layer.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::{EventId, GroupId},
     message::{RecvType, SendType},
-    primitive::{DeliveryType, HandleResult, PeerAddr, Result},
+    primitive::{DeliveryType, HandleResult, Peer, PeerId, Result},
     rpc::RpcError,
 };
 use tdn_did::{user::User, Proof};
@@ -67,7 +67,7 @@ pub(crate) async fn handle(
         RecvType::Connect(addr, data) | RecvType::ResultConnect(addr, data) => {
             // ESSE chat layer connect date structure.
             if handle_connect(&mgid, &fgid, &addr, data, &mut layer, &mut results)? {
-                let proof = layer.group.read().await.prove_addr(&mgid, &addr)?;
+                let proof = layer.group.read().await.prove_addr(&mgid, &addr.id)?;
                 let data = bincode::serialize(&proof).unwrap_or(vec![]);
                 let msg = SendType::Result(0, addr, true, false, data);
                 results.layers.push((mgid, fgid, msg));
@@ -86,7 +86,7 @@ pub(crate) async fn handle(
             } else {
                 let db = chat_db(&layer.base, &mgid)?;
                 if let Some(friend) = Friend::get_it(&db, &fgid)? {
-                    if friend.contains_addr(&addr) {
+                    if friend.contains_addr(&addr.id) {
                         results.rpcs.push(rpc::friend_close(mgid, friend.id));
                         friend.close(&db)?;
                     }
@@ -134,7 +134,7 @@ pub(crate) async fn handle(
 fn handle_connect(
     mgid: &GroupId,
     fgid: &GroupId,
-    addr: &PeerAddr,
+    addr: &Peer,
     data: Vec<u8>,
     layer: &mut Layer,
     results: &mut HandleResult,
@@ -143,17 +143,17 @@ fn handle_connect(
     let proof: Proof = bincode::deserialize(&data)?;
 
     // 1. check verify.
-    proof.verify(fgid, addr, &layer.addr)?;
+    proof.verify(fgid, &addr.id, &layer.addr)?;
 
     // 2. check friendship.
-    let friend = update_friend(&layer.base, mgid, fgid, addr)?;
+    let friend = update_friend(&layer.base, mgid, fgid, &addr.id)?;
     if friend.is_none() {
         return Ok(false);
     }
     let fid = friend.unwrap().id; // safe.
 
     // 3. get session.
-    let session_some = connect_session(&layer.base, mgid, &SessionType::Chat, &fid, addr)?;
+    let session_some = connect_session(&layer.base, mgid, &SessionType::Chat, &fid, &addr.id)?;
     if session_some.is_none() {
         return Ok(false);
     }
@@ -162,10 +162,10 @@ fn handle_connect(
     // 4. active this session.
     layer
         .running_mut(mgid)?
-        .check_add_online(*fgid, Online::Direct(*addr), sid, fid)?;
+        .check_add_online(*fgid, Online::Direct(addr.id), sid, fid)?;
 
     // 5. session online to UI.
-    results.rpcs.push(session_connect(*mgid, &sid, addr));
+    results.rpcs.push(session_connect(*mgid, &sid, &addr.id));
     Ok(true)
 }
 
@@ -174,7 +174,7 @@ impl LayerEvent {
         fgid: GroupId,
         mgid: GroupId,
         layer: &mut Layer,
-        addr: PeerAddr,
+        addr: PeerId,
         bytes: Vec<u8>,
     ) -> Result<HandleResult> {
         let event: LayerEvent = bincode::deserialize(&bytes)?;
@@ -464,7 +464,7 @@ fn update_friend(
     base: &PathBuf,
     mgid: &GroupId,
     fgid: &GroupId,
-    addr: &PeerAddr,
+    addr: &PeerId,
 ) -> Result<Option<Friend>> {
     let db = chat_db(base, mgid)?;
     if let Some(friend) = Friend::get(&db, fgid)? {
@@ -489,7 +489,7 @@ pub(super) fn req_message(layer: &mut Layer, me: User, request: Request) -> Send
 pub(super) fn reject_message(
     layer: &mut Layer,
     tid: i64,
-    addr: PeerAddr,
+    addr: PeerId,
     me_id: GroupId,
 ) -> SendType {
     let data = bincode::serialize(&LayerEvent::Reject).unwrap_or(vec![]);
@@ -502,7 +502,7 @@ pub(crate) fn event_message(
     layer: &mut Layer,
     tid: i64,
     me_id: GroupId,
-    addr: PeerAddr,
+    addr: PeerId,
     event: &LayerEvent,
 ) -> SendType {
     let data = bincode::serialize(event).unwrap_or(vec![]);
@@ -511,12 +511,12 @@ pub(crate) fn event_message(
     SendType::Event(uid, addr, data)
 }
 
-pub(crate) fn chat_conn(proof: Proof, addr: PeerAddr) -> SendType {
+pub(crate) fn chat_conn(proof: Proof, addr: Peer) -> SendType {
     let data = bincode::serialize(&proof).unwrap_or(vec![]);
-    SendType::Connect(0, addr, None, None, data)
+    SendType::Connect(0, addr, data)
 }
 
-pub(super) fn agree_message(proof: Proof, me: User, addr: PeerAddr) -> Result<SendType> {
+pub(super) fn agree_message(proof: Proof, me: User, addr: PeerId) -> Result<SendType> {
     let data = bincode::serialize(&LayerEvent::Agree(me, proof)).unwrap_or(vec![]);
     Ok(SendType::Event(0, addr, data))
 }

src/apps/chat/models.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tdn::types::{
     group::{EventId, GroupId},
-    primitive::{PeerAddr, Result},
+    primitive::{PeerId, Result},
     rpc::{json, RpcParam},
 };
 use tdn_storage::local::{DStorage, DsValue};
@@ -17,7 +17,7 @@ use crate::storage::{
 pub(crate) struct Friend {
     pub id: i64,
     pub gid: GroupId,
-    pub addr: PeerAddr,
+    pub addr: PeerId,
     pub name: String,
     pub remark: String,
     pub is_closed: bool,
@@ -29,7 +29,7 @@ pub(crate) struct Friend {
 pub(crate) struct Request {
     pub id: i64,
     pub gid: GroupId,
-    pub addr: PeerAddr,
+    pub addr: PeerId,
     pub name: String,
     pub remark: String,
     pub is_me: bool,
@@ -43,11 +43,11 @@ pub(crate) struct Request {
 /// message type use in network.
 #[derive(Serialize, Deserialize, Clone)]
 pub(crate) enum NetworkMessage {
-    String(String),                              // content
-    Image(Vec<u8>),                              // image bytes.
-    File(String, Vec<u8>),                       // filename, file bytes.
-    Contact(String, GroupId, PeerAddr, Vec<u8>), // name, gid, addr, avatar bytes.
-    Record(Vec<u8>, u32),                        // record audio bytes.
+    String(String),                            // content
+    Image(Vec<u8>),                            // image bytes.
+    File(String, Vec<u8>),                     // filename, file bytes.
+    Contact(String, GroupId, PeerId, Vec<u8>), // name, gid, addr, avatar bytes.
+    Record(Vec<u8>, u32),                      // record audio bytes.
     Emoji,
     Phone,
     Video,
@@ -146,7 +146,7 @@ impl NetworkMessage {
                 }
                 let cname = v[0].to_owned();
                 let cgid = GroupId::from_hex(v[1])?;
-                let caddr = PeerAddr::from_hex(v[2])?;
+                let caddr = PeerId::from_hex(v[2])?;
                 let avatar_bytes = read_avatar_sync(base, gid, &cgid)?;
                 Ok(NetworkMessage::Contact(cname, cgid, caddr, avatar_bytes))
             }
@@ -225,7 +225,7 @@ pub(crate) struct Message {
 }
 
 impl Friend {
-    pub fn new(gid: GroupId, addr: PeerAddr, name: String, remark: String) -> Friend {
+    pub fn new(gid: GroupId, addr: PeerId, name: String, remark: String) -> Friend {
         let start = SystemTime::now();
         let datetime = start
             .duration_since(UNIX_EPOCH)
@@ -244,7 +244,7 @@ impl Friend {
         }
     }
 
-    pub fn contains_addr(&self, addr: &PeerAddr) -> bool {
+    pub fn contains_addr(&self, addr: &PeerId) -> bool {
         &self.addr == addr
     }
 
@@ -262,7 +262,7 @@ impl Friend {
             is_closed: v.pop().unwrap().as_bool(),
             remark: v.pop().unwrap().as_string(),
             name: v.pop().unwrap().as_string(),
-            addr: PeerAddr::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerAddr::default()),
+            addr: PeerId::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerId::default()),
             gid: GroupId::from_hex(v.pop().unwrap().as_str()).unwrap_or(GroupId::default()),
             id: v.pop().unwrap().as_i64(),
         }
@@ -400,7 +400,7 @@ impl Friend {
         db.update(&sql)
     }
 
-    pub fn addr_update(db: &DStorage, id: i64, addr: &PeerAddr) -> Result<usize> {
+    pub fn addr_update(db: &DStorage, id: i64, addr: &PeerId) -> Result<usize> {
         let sql = format!(
             "UPDATE friends SET addr='{}' WHERE id = {}",
             addr.to_hex(),
@@ -453,7 +453,7 @@ impl Friend {
 impl Request {
     pub fn new(
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         name: String,
         remark: String,
         is_me: bool,
@@ -501,7 +501,7 @@ impl Request {
             is_me: v.pop().unwrap().as_bool(),
             remark: v.pop().unwrap().as_string(),
             name: v.pop().unwrap().as_string(),
-            addr: PeerAddr::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerAddr::default()),
+            addr: PeerId::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerId::default()),
             gid: GroupId::from_hex(v.pop().unwrap().as_str()).unwrap_or(GroupId::default()),
             id: v.pop().unwrap().as_i64(),
         }

src/apps/chat/rpc.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
     message::SendType,
-    primitive::{HandleResult, PeerAddr},
+    primitive::{HandleResult, PeerId},
     rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
 };
 use tdn_did::user::User;
@@ -163,7 +163,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             drop(layer_lock);
 
             if let Some(faddr) = online {
-                let mut addrs: HashMap<PeerAddr, GroupId> = HashMap::new();
+                let mut addrs: HashMap<PeerId, GroupId> = HashMap::new();
                 addrs.insert(faddr, friend.gid);
                 let sender = state.group.read().await.sender();
                 tokio::spawn(sleep_waiting_close_stable(sender, HashMap::new(), addrs));
@@ -203,7 +203,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             drop(layer_lock);
 
             if let Some(faddr) = online {
-                let mut addrs: HashMap<PeerAddr, GroupId> = HashMap::new();
+                let mut addrs: HashMap<PeerId, GroupId> = HashMap::new();
                 addrs.insert(faddr, friend.gid);
                 let sender = state.group.read().await.sender();
                 tokio::spawn(sleep_waiting_close_stable(sender, HashMap::new(), addrs));
@@ -241,7 +241,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         "chat-request-create",
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
             let remote_gid = GroupId::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
-            let remote_addr = PeerAddr::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
+            let remote_addr = PeerId::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
             let remote_name = params[2].as_str().ok_or(RpcError::ParseError)?.to_string();
             let remark = params[3].as_str().ok_or(RpcError::ParseError)?.to_string();
 

src/apps/device/models.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use std::time::{SystemTime, UNIX_EPOCH};
-use tdn::types::primitive::{PeerAddr, Result};
+use tdn::types::primitive::{Peer, PeerId, Result};
 use tdn::types::rpc::{json, RpcParam};
 use tdn_storage::local::{DStorage, DsValue};
 
@@ -8,13 +8,13 @@ pub(crate) struct Device {
     pub id: i64,
     pub name: String,
     pub info: String,
-    pub addr: PeerAddr,
+    pub addr: PeerId,
     pub lasttime: i64,
     pub online: bool,
 }
 
 impl Device {
-    pub fn new(name: String, info: String, addr: PeerAddr) -> Self {
+    pub fn new(name: String, info: String, addr: PeerId) -> Self {
         let start = SystemTime::now();
         let lasttime = start
             .duration_since(UNIX_EPOCH)
@@ -35,7 +35,7 @@ impl Device {
     fn from_values(mut v: Vec<DsValue>) -> Device {
         Device {
             lasttime: v.pop().unwrap().as_i64(),
-            addr: PeerAddr::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerAddr::default()),
+            addr: PeerId::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerId::default()),
             info: v.pop().unwrap().as_string(),
             name: v.pop().unwrap().as_string(),
             id: v.pop().unwrap().as_i64(),
@@ -67,15 +67,15 @@ impl Device {
         Ok(devices)
     }
 
-    pub fn distributes(db: &DStorage) -> Result<HashMap<PeerAddr, (i64, bool)>> {
+    pub fn distributes(db: &DStorage) -> Result<HashMap<PeerId, (Peer, i64, bool)>> {
         let matrix = db.query("SELECT id, addr FROM devices where is_deleted = false")?;
         let mut devices = HashMap::new();
         for mut values in matrix {
             if values.len() == 2 {
-                let addr = PeerAddr::from_hex(values.pop().unwrap().as_str())
-                    .unwrap_or(PeerAddr::default());
+                let addr =
+                    PeerId::from_hex(values.pop().unwrap().as_str()).unwrap_or(PeerId::default());
                 let id = values.pop().unwrap().as_i64();
-                devices.insert(addr, (id, false));
+                devices.insert(addr, (Peer::peer(addr), id, false));
             }
         }
         Ok(devices)

src/apps/device/rpc.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
-    primitive::{HandleResult, PeerAddr},
+    primitive::{HandleResult, Peer, PeerId},
     rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
 };
 
@@ -81,7 +81,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
     handler.add_method(
         "device-status",
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
-            let addr = PeerAddr::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
+            let addr = PeerId::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
 
             let group_lock = state.group.read().await;
             if &addr == group_lock.addr() {
@@ -107,9 +107,13 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
     handler.add_method(
         "device-create",
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
-            let addr = PeerAddr::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
+            let addr = PeerId::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
 
-            let msg = state.group.read().await.create_message(&gid, addr)?;
+            let msg = state
+                .group
+                .read()
+                .await
+                .create_message(&gid, Peer::peer(addr))?;
             Ok(HandleResult::group(gid, msg))
         },
     );
@@ -117,9 +121,13 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
     handler.add_method(
         "device-connect",
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
-            let addr = PeerAddr::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
+            let addr = PeerId::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
 
-            let msg = state.group.read().await.connect_message(&gid, addr)?;
+            let msg = state
+                .group
+                .read()
+                .await
+                .connect_message(&gid, Peer::peer(addr))?;
             Ok(HandleResult::group(gid, msg))
         },
     );

src/apps/domain/mod.rs

@@ -6,7 +6,7 @@ use domain_types::{LayerPeerEvent, PeerEvent};
 use tdn::types::{
     group::GroupId,
     message::SendType,
-    primitive::{HandleResult, PeerAddr, Result},
+    primitive::{HandleResult, PeerId, Result},
 };
 use tdn_did::Proof;
 
@@ -14,7 +14,7 @@ use tdn_did::Proof;
 #[inline]
 pub(crate) fn add_layer(
     results: &mut HandleResult,
-    addr: PeerAddr,
+    addr: PeerId,
     event: PeerEvent,
     ogid: GroupId,
 ) -> Result<()> {

src/apps/domain/models.rs

@@ -1,5 +1,5 @@
 use tdn::types::{
-    primitive::{PeerAddr, Result},
+    primitive::{PeerId, Result},
     rpc::{json, RpcParam},
 };
 use tdn_storage::local::{DStorage, DsValue};
@@ -11,7 +11,7 @@ pub(crate) struct Provider {
     /// name.
     name: String,
     /// address.
-    pub addr: PeerAddr,
+    pub addr: PeerId,
     /// is add ok.
     is_ok: bool,
     /// is default.
@@ -23,7 +23,7 @@ pub(crate) struct Provider {
 }
 
 impl Provider {
-    pub fn prepare(addr: PeerAddr) -> Self {
+    pub fn prepare(addr: PeerId) -> Self {
         Self {
             id: 0,
             name: addr.to_hex(),
@@ -53,7 +53,7 @@ impl Provider {
             is_proxy: v.pop().unwrap().as_bool(),
             is_default: v.pop().unwrap().as_bool(),
             is_ok: v.pop().unwrap().as_bool(),
-            addr: PeerAddr::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
+            addr: PeerId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             name: v.pop().unwrap().as_string(),
             id: v.pop().unwrap().as_i64(),
         }
@@ -96,7 +96,7 @@ impl Provider {
     }
 
     /// insert a new provider.
-    pub fn get_by_addr(db: &DStorage, addr: &PeerAddr) -> Result<Self> {
+    pub fn get_by_addr(db: &DStorage, addr: &PeerId) -> Result<Self> {
         let sql = format!(
             "SELECT id, name, addr, is_ok, is_default, is_proxy, is_actived FROM providers WHERE addr = '{}'",
             addr.to_hex()

src/apps/domain/rpc.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
-    primitive::{HandleResult, PeerAddr},
+    primitive::{HandleResult, PeerId},
     rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
 };
 
@@ -40,7 +40,7 @@ pub(crate) fn search_result(
     mgid: GroupId,
     name: &str,
     gid: &GroupId,
-    addr: &PeerAddr,
+    addr: &PeerId,
     bio: &str,
     avatar: &Vec<u8>,
 ) -> RpcParam {
@@ -87,7 +87,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
     handler.add_method(
         "domain-provider-add",
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
-            let provider = PeerAddr::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
+            let provider = PeerId::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
 
             let mut results = HandleResult::new();
             let db = domain_db(state.layer.read().await.base(), &gid)?;
@@ -137,7 +137,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         "domain-register",
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
             let provider = params[0].as_i64().ok_or(RpcError::ParseError)?;
-            let addr = PeerAddr::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
+            let addr = PeerId::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
             let name = params[2].as_str().ok_or(RpcError::ParseError)?.to_string();
             let bio = params[3].as_str().ok_or(RpcError::ParseError)?.to_string();
 
@@ -160,7 +160,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         "domain-active",
         |gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
             let name = params[0].as_str().ok_or(RpcError::ParseError)?.to_owned();
-            let provider = PeerAddr::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
+            let provider = PeerId::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
             let active = params[2].as_bool().ok_or(RpcError::ParseError)?;
 
             let mut results = HandleResult::new();
@@ -179,7 +179,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         "domain-remove",
         |gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
             let name = params[0].as_str().ok_or(RpcError::ParseError)?.to_owned();
-            let provider = PeerAddr::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
+            let provider = PeerId::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
 
             let mut results = HandleResult::new();
             let event = PeerEvent::Delete(name);
@@ -192,7 +192,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
     handler.add_method(
         "domain-search",
         |gid: GroupId, params: Vec<RpcParam>, _state: Arc<RpcState>| async move {
-            let addr = PeerAddr::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
+            let addr = PeerId::from_hex(params[0].as_str().ok_or(RpcError::ParseError)?)?;
             let name = params[1].as_str().ok_or(RpcError::ParseError)?.to_owned();
 
             let mut results = HandleResult::new();

src/apps/group_chat/layer.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
     message::{RecvType, SendType},
-    primitive::{HandleResult, PeerAddr, Result},
+    primitive::{HandleResult, Peer, PeerId, Result},
 };
 use tokio::sync::RwLock;
 
@@ -63,21 +63,23 @@ pub(crate) async fn handle(
                     if let Ok((mid, _)) = Member::get_id(&db, &id, &fgid) {
                         let res = LayerResult(gcd, height);
                         let data = bincode::serialize(&res).unwrap_or(vec![]);
-                        let s = SendType::Result(0, addr, true, false, data);
+                        let s = SendType::Result(0, addr.clone(), true, false, data);
                         add_server_layer(&mut results, fgid, s);
 
                         layer.write().await.running_mut(&gcd)?.check_add_online(
                             fgid,
-                            Online::Direct(addr),
+                            Online::Direct(addr.id),
                             id,
                             mid,
                         )?;
 
-                        let _ = Member::addr_update(&db, &id, &fgid, &addr);
-                        results.rpcs.push(rpc::member_online(ogid, id, fgid, addr));
+                        let _ = Member::addr_update(&db, &id, &fgid, &addr.id);
+                        results
+                            .rpcs
+                            .push(rpc::member_online(ogid, id, fgid, addr.id));
 
                         let new_data =
-                            bincode::serialize(&LayerEvent::MemberOnline(gcd, fgid, addr))?;
+                            bincode::serialize(&LayerEvent::MemberOnline(gcd, fgid, addr.id))?;
 
                         for (mid, maddr) in layer.read().await.running(&gcd)?.onlines() {
                             let s = SendType::Event(0, *maddr, new_data.clone());
@@ -101,7 +103,7 @@ pub(crate) async fn handle(
             // only cleint handle it. IMPORTANT !!! tgid IS ogid.
             if !is_server && is_ok {
                 let mut layer_lock = layer.write().await;
-                handle_connect(tgid, addr, data, &mut layer_lock, &mut results)?;
+                handle_connect(tgid, &addr, data, &mut layer_lock, &mut results)?;
             } else {
                 let msg = SendType::Result(0, addr, false, false, vec![]);
                 add_layer(&mut results, tgid, msg);
@@ -110,12 +112,12 @@ pub(crate) async fn handle(
         RecvType::ResultConnect(addr, data) => {
             // only cleint handle it. IMPORTANT !!! tgid IS ogid.
             if is_server {
-                let msg = SendType::Result(0, addr, false, false, vec![]);
+                let msg = SendType::Result(0, addr.clone(), false, false, vec![]);
                 add_layer(&mut results, tgid, msg);
             }
 
             let mut layer_lock = layer.write().await;
-            if handle_connect(tgid, addr, data, &mut layer_lock, &mut results)? {
+            if handle_connect(tgid, &addr, data, &mut layer_lock, &mut results)? {
                 let msg = SendType::Result(0, addr, true, false, vec![]);
                 add_layer(&mut results, tgid, msg);
             }
@@ -140,7 +142,7 @@ pub(crate) async fn handle(
 
 fn handle_connect(
     ogid: GroupId,
-    addr: PeerAddr,
+    addr: &Peer,
     data: Vec<u8>,
     layer: &mut Layer,
     results: &mut HandleResult,
@@ -152,13 +154,18 @@ fn handle_connect(
     let db = group_chat_db(layer.base(), &ogid)?;
     if let Some(group) = GroupChat::get(&db, &gcd)? {
         // 1.0 check address.
-        if group.g_addr != addr {
+        if group.g_addr != addr.id {
             return Ok(false);
         }
 
         // 1.1 get session.
-        let session_some =
-            connect_session(layer.base(), &ogid, &SessionType::Group, &group.id, &addr)?;
+        let session_some = connect_session(
+            layer.base(),
+            &ogid,
+            &SessionType::Group,
+            &group.id,
+            &addr.id,
+        )?;
         if session_some.is_none() {
             return Ok(false);
         }
@@ -167,18 +174,18 @@ fn handle_connect(
         // 1.2 online this group.
         layer
             .running_mut(&ogid)?
-            .check_add_online(gcd, Online::Direct(addr), sid, group.id)?;
+            .check_add_online(gcd, Online::Direct(addr.id), sid, group.id)?;
 
         // 1.3 online to UI.
-        results.rpcs.push(session_connect(ogid, &sid, &addr));
+        results.rpcs.push(session_connect(ogid, &sid, &addr.id));
 
         println!("will sync remote: {}, my: {}", height, group.height);
         // 1.4 sync group height.
         if group.height < height {
-            add_layer(results, ogid, sync(gcd, addr, group.height));
+            add_layer(results, ogid, sync(gcd, addr.id, group.height));
         } else {
             // sync online members.
-            add_layer(results, ogid, sync_online(gcd, addr));
+            add_layer(results, ogid, sync_online(gcd, addr.id));
         }
         Ok(true)
     } else {
@@ -198,7 +205,7 @@ async fn handle_event(
     fgid: GroupId, // server use fgid is remote account.
     tgid: GroupId, // client user tgid is my account.
     is_server: bool,
-    addr: PeerAddr,
+    addr: PeerId,
     event: LayerEvent,
     layer: &Arc<RwLock<Layer>>,
     results: &mut HandleResult,
@@ -349,7 +356,7 @@ async fn handle_event(
                 .read()
                 .await
                 .prove_addr(&ogid, &addr)?;
-            add_layer(results, ogid, group_chat_conn(proof, addr, gcd));
+            add_layer(results, ogid, group_chat_conn(proof, Peer::peer(addr), gcd));
         }
         LayerEvent::Reject(gcd, efficacy) => {
             // only client handle it.
@@ -672,19 +679,19 @@ async fn broadcast(
     Ok(())
 }
 
-pub(crate) fn group_chat_conn(proof: Proof, addr: PeerAddr, gid: GroupId) -> SendType {
+pub(crate) fn group_chat_conn(proof: Proof, addr: Peer, gid: GroupId) -> SendType {
     let data =
         bincode::serialize(&LayerConnect(gid, ConnectProof::Common(proof))).unwrap_or(vec![]);
-    SendType::Connect(0, addr, None, None, data)
+    SendType::Connect(0, addr, data)
 }
 
-fn sync(gcd: GroupId, addr: PeerAddr, height: i64) -> SendType {
+fn sync(gcd: GroupId, addr: PeerId, height: i64) -> SendType {
     println!("Send sync request...");
     let data = bincode::serialize(&LayerEvent::SyncReq(gcd, height + 1)).unwrap_or(vec![]);
     SendType::Event(0, addr, data)
 }
 
-fn sync_online(gcd: GroupId, addr: PeerAddr) -> SendType {
+fn sync_online(gcd: GroupId, addr: PeerId) -> SendType {
     let data = bincode::serialize(&LayerEvent::MemberOnlineSync(gcd)).unwrap_or(vec![]);
     SendType::Event(0, addr, data)
 }
@@ -694,7 +701,7 @@ async fn agree(
     ogid: &GroupId,
     gcd: &GroupId,
     group: GroupChat,
-    addr: PeerAddr,
+    addr: PeerId,
 ) -> SendType {
     let gavatar = read_avatar(base, ogid, gcd).await.unwrap_or(vec![]);
     let group_info = group.to_group_info("".to_owned(), gavatar, vec![]);
@@ -703,7 +710,7 @@ async fn agree(
     SendType::Event(0, addr, d)
 }
 
-fn reject(gcd: GroupId, addr: PeerAddr, lost: bool) -> SendType {
+fn reject(gcd: GroupId, addr: PeerId, lost: bool) -> SendType {
     let d = bincode::serialize(&LayerEvent::Reject(gcd, lost)).unwrap_or(vec![]);
     SendType::Event(0, addr, d)
 }
@@ -713,7 +720,7 @@ fn handle_sync(
     ogid: GroupId,
     id: i64,
     gcd: GroupId,
-    addr: PeerAddr,
+    addr: PeerId,
     height: i64,
     mut from: i64,
     to: i64,

src/apps/group_chat/models/group.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tdn::types::{
     group::GroupId,
-    primitive::{PeerAddr, Result},
+    primitive::{PeerId, Result},
     rpc::{json, RpcParam},
 };
 use tdn_storage::local::{DStorage, DsValue};
@@ -28,7 +28,7 @@ pub(crate) struct GroupChat {
     /// group chat type.
     pub g_type: GroupType,
     /// group chat server addresse.
-    pub g_addr: PeerAddr,
+    pub g_addr: PeerId,
     /// group chat name.
     pub g_name: String,
     /// group chat simple intro.
@@ -51,7 +51,7 @@ impl GroupChat {
     pub fn new(
         owner: GroupId,
         g_type: GroupType,
-        g_addr: PeerAddr,
+        g_addr: PeerId,
         g_name: String,
         g_bio: String,
         is_need_agree: bool,
@@ -91,7 +91,7 @@ impl GroupChat {
         height: i64,
         owner: GroupId,
         g_type: GroupType,
-        g_addr: PeerAddr,
+        g_addr: PeerId,
         g_name: String,
         g_bio: String,
         is_need_agree: bool,
@@ -126,7 +126,7 @@ impl GroupChat {
         key: GroupChatKey,
         info: GroupInfo,
         height: i64,
-        addr: PeerAddr,
+        addr: PeerId,
         base: &PathBuf,
         mgid: &GroupId,
         is_remote: bool,
@@ -220,7 +220,7 @@ impl GroupChat {
             is_ok: v.pop().unwrap().as_bool(),
             g_bio: v.pop().unwrap().as_string(),
             g_name: v.pop().unwrap().as_string(),
-            g_addr: PeerAddr::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
+            g_addr: PeerId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             g_type: GroupType::from_u32(v.pop().unwrap().as_i64() as u32),
             g_id: GroupId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             owner: GroupId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),

src/apps/group_chat/models/member.rs

@@ -1,7 +1,7 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 use tdn::types::{
     group::GroupId,
-    primitive::{PeerAddr, Result},
+    primitive::{PeerId, Result},
     rpc::{json, RpcParam},
 };
 use tdn_storage::local::{DStorage, DsValue};
@@ -15,7 +15,7 @@ pub(crate) struct Member {
     /// member's Did(GroupId)
     pub m_id: GroupId,
     /// member's addresse.
-    pub m_addr: PeerAddr,
+    pub m_addr: PeerId,
     /// member's name.
     pub m_name: String,
     /// is group chat manager.
@@ -30,7 +30,7 @@ impl Member {
     pub fn new_notime(
         fid: i64,
         m_id: GroupId,
-        m_addr: PeerAddr,
+        m_addr: PeerId,
         m_name: String,
         is_manager: bool,
     ) -> Self {
@@ -55,7 +55,7 @@ impl Member {
     pub fn new(
         fid: i64,
         m_id: GroupId,
-        m_addr: PeerAddr,
+        m_addr: PeerId,
         m_name: String,
         is_manager: bool,
         datetime: i64,
@@ -90,7 +90,7 @@ impl Member {
             is_block: v.pop().unwrap().as_bool(),
             is_manager: v.pop().unwrap().as_bool(),
             m_name: v.pop().unwrap().as_string(),
-            m_addr: PeerAddr::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
+            m_addr: PeerId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             m_id: GroupId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             fid: v.pop().unwrap().as_i64(),
             id: v.pop().unwrap().as_i64(),
@@ -182,7 +182,7 @@ impl Member {
         }
     }
 
-    pub fn addr_update(db: &DStorage, fid: &i64, mid: &GroupId, addr: &PeerAddr) -> Result<usize> {
+    pub fn addr_update(db: &DStorage, fid: &i64, mid: &GroupId, addr: &PeerId) -> Result<usize> {
         let sql = format!(
             "UPDATE members SET addr='{}' WHERE fid = {} AND mid = '{}'",
             addr.to_hex(),
@@ -192,7 +192,7 @@ impl Member {
         db.update(&sql)
     }
 
-    pub fn update(db: &DStorage, id: &i64, addr: &PeerAddr, name: &str) -> Result<usize> {
+    pub fn update(db: &DStorage, id: &i64, addr: &PeerId, name: &str) -> Result<usize> {
         let sql = format!(
             "UPDATE members SET addr='{}', name='{}' WHERE id = {}",
             addr.to_hex(),

src/apps/group_chat/models/provider.rs

@@ -1,5 +1,5 @@
 use tdn::types::{
-    primitive::{PeerAddr, Result},
+    primitive::{PeerId, Result},
     rpc::{json, RpcParam},
 };
 use tdn_storage::local::{DStorage, DsValue};
@@ -10,7 +10,7 @@ use group_chat_types::GroupType;
 pub(crate) struct Provider {
     pub id: i64,
     name: String,
-    addr: PeerAddr,
+    addr: PeerId,
     kinds: Vec<GroupType>,
     remain: i64,
     is_ok: bool,
@@ -40,7 +40,7 @@ fn kinds_print(kinds: &Vec<GroupType>) -> i64 {
 }
 
 impl Provider {
-    pub fn new(addr: PeerAddr) -> Self {
+    pub fn new(addr: PeerId) -> Self {
         Self {
             addr,
             name: String::new(),
@@ -68,7 +68,7 @@ impl Provider {
             is_ok: v.pop().unwrap().as_bool(),
             remain: v.pop().unwrap().as_i64(),
             kinds: parse_kinds(v.pop().unwrap().as_i64()),
-            addr: PeerAddr::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
+            addr: PeerId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             name: v.pop().unwrap().as_string(),
             id: v.pop().unwrap().as_i64(),
         }
@@ -83,7 +83,7 @@ impl Provider {
         Ok(providers)
     }
 
-    pub fn get_by_addr(db: &DStorage, addr: &PeerAddr) -> Result<Self> {
+    pub fn get_by_addr(db: &DStorage, addr: &PeerId) -> Result<Self> {
         let sql = format!(
             "SELECT id, name, addr, kinds, remain, is_ok FROM providers WHERE addr = '{}'",
             addr.to_hex()

src/apps/group_chat/models/request.rs

@@ -1,7 +1,7 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 use tdn::types::{
     group::GroupId,
-    primitive::{PeerAddr, Result},
+    primitive::{PeerId, Result},
     rpc::{json, RpcParam},
 };
 use tdn_storage::local::{DStorage, DsValue};
@@ -15,7 +15,7 @@ pub(crate) struct Request {
     fid: i64,
     pub rid: i64,
     pub gid: GroupId,
-    pub addr: PeerAddr,
+    pub addr: PeerId,
     pub name: String,
     key: GroupChatKey,
     remark: String,
@@ -29,7 +29,7 @@ impl Request {
         fid: i64,
         rid: i64,
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         name: String,
         remark: String,
         datetime: i64,
@@ -52,7 +52,7 @@ impl Request {
     pub fn new_by_server(
         fid: i64,
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         name: String,
         remark: String,
     ) -> Self {
@@ -79,7 +79,7 @@ impl Request {
 
     pub fn new_by_me(
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         name: String,
         remark: String,
         key: GroupChatKey,
@@ -128,7 +128,7 @@ impl Request {
             is_ok: v.pop().unwrap().as_bool(),
             remark: v.pop().unwrap().as_string(),
             name: v.pop().unwrap().as_string(),
-            addr: PeerAddr::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
+            addr: PeerId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             gid: GroupId::from_hex(v.pop().unwrap().as_string()).unwrap_or(Default::default()),
             rid: v.pop().unwrap().as_i64(),
             fid: v.pop().unwrap().as_i64(),

src/apps/group_chat/rpc.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
     message::{NetworkType, SendType},
-    primitive::{HandleResult, PeerAddr},
+    primitive::{HandleResult, PeerId},
     rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
 };
 use tdn_did::Proof;
@@ -82,7 +82,7 @@ pub(crate) fn member_info(
     mgid: GroupId,
     id: i64,
     mid: i64,
-    addr: PeerAddr,
+    addr: PeerId,
     name: String,
 ) -> RpcParam {
     rpc_response(
@@ -94,7 +94,7 @@ pub(crate) fn member_info(
 }
 
 #[inline]
-pub(crate) fn member_online(mgid: GroupId, gid: i64, mid: GroupId, maddr: PeerAddr) -> RpcParam {
+pub(crate) fn member_online(mgid: GroupId, gid: i64, mid: GroupId, maddr: PeerId) -> RpcParam {
     rpc_response(
         0,
         "group-chat-member-online",
@@ -202,7 +202,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         "group-chat-provider-check",
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
             let id = params[0].as_i64().ok_or(RpcError::ParseError)?;
-            let addr = PeerAddr::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
+            let addr = PeerId::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
 
             if id == 0 {
                 // insert into database.
@@ -249,7 +249,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let db = group_chat_db(&base, &gid)?;
             let addr = match glocation {
                 GroupLocation::Remote => {
-                    PeerAddr::from_hex(params[3].as_str().ok_or(RpcError::ParseError)?)?
+                    PeerId::from_hex(params[3].as_str().ok_or(RpcError::ParseError)?)?
                 }
                 GroupLocation::Local => state.layer.read().await.addr.clone(),
             };
@@ -364,7 +364,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
         |gid: GroupId, params: Vec<RpcParam>, state: Arc<RpcState>| async move {
             let gtype = GroupType::from_u32(params[0].as_i64().ok_or(RpcError::ParseError)? as u32);
             let gcd = GroupId::from_hex(params[1].as_str().ok_or(RpcError::ParseError)?)?;
-            let gaddr = PeerAddr::from_hex(params[2].as_str().ok_or(RpcError::ParseError)?)?;
+            let gaddr = PeerId::from_hex(params[2].as_str().ok_or(RpcError::ParseError)?)?;
             let gname = params[3].as_str().ok_or(RpcError::ParseError)?.to_owned();
             let gremark = params[4].as_str().ok_or(RpcError::ParseError)?;
             let gproof = params[5].as_str().ok_or(RpcError::ParseError)?;

src/event.rs

@@ -6,7 +6,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use tdn::types::{
     group::{EventId, GroupId},
     message::{SendMessage, SendType},
-    primitive::{HandleResult, PeerAddr, Result},
+    primitive::{HandleResult, PeerId, Result},
 };
 use tdn_did::user::User;
 use tdn_storage::local::DStorage;
@@ -44,7 +44,7 @@ pub(crate) enum InnerEvent {
     SessionRequestDelete(GroupId),
     /// Session's friend update by friend.
     /// params: f_gid, addr, name, avatar. (TODO addrs as list to store. keep others device)
-    SessionFriendInfo(GroupId, PeerAddr, String, Vec<u8>),
+    SessionFriendInfo(GroupId, PeerId, String, Vec<u8>),
     /// Session's friend update by me.
     /// params: f_gid, remark
     SessionFriendUpdate(GroupId, String),
@@ -60,13 +60,13 @@ pub(crate) enum InnerEvent {
     SessionMessageDelete(EventId),
     /// create a file.
     /// params: file_id, file_parent_id, file_directory, file_name, file_desc, device_addr.
-    FileCreate(FileDid, FileDid, RootDirectory, String, String, PeerAddr),
+    FileCreate(FileDid, FileDid, RootDirectory, String, String, PeerId),
     /// update file info. file_id, file_name, file_desc.
     FileUpdate(FileDid, String, String),
     /// update file's parent id (move file to other directory).
     FileParent(FileDid, FileDid),
     /// backup file in new device.
-    FileBackup(FileDid, PeerAddr),
+    FileBackup(FileDid, PeerId),
     /// delete a file.
     FileDelete(FileDid),
 }
@@ -90,7 +90,7 @@ pub(crate) enum SyncEvent {
     Request(
         EventId,
         GroupId,
-        PeerAddr,
+        PeerId,
         String,
         Vec<u8>,
         String,
@@ -104,7 +104,7 @@ pub(crate) enum SyncEvent {
     Friend(
         EventId,
         GroupId,
-        PeerAddr,
+        PeerId,
         String,
         Vec<u8>,
         String,
@@ -153,7 +153,7 @@ impl InnerEvent {
 
     pub fn merge_event(
         db: &DStorage,
-        addr: &PeerAddr,
+        addr: &PeerId,
         results: &mut HandleResult,
         our_height: u64,
         our_event: EventId,
@@ -211,7 +211,7 @@ impl InnerEvent {
         self,
         group: &mut Group,
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         eheight: u64,
         eid: EventId,
         pre_event: EventId,
@@ -390,7 +390,7 @@ impl InnerEvent {
                     tokio::spawn(async move {
                         let online = layer_lock.write().await.remove_online(&ggid, &f.gid);
                         if let Some(faddr) = online {
-                            let mut addrs: HashMap<PeerAddr, GroupId> = HashMap::new();
+                            let mut addrs: HashMap<PeerId, GroupId> = HashMap::new();
                             addrs.insert(faddr, f.gid);
                             tokio::spawn(rpc::sleep_waiting_close_stable(
                                 sender,
@@ -418,7 +418,7 @@ impl InnerEvent {
                     tokio::spawn(async move {
                         let online = layer_lock.write().await.remove_online(&ggid, &f.gid);
                         if let Some(faddr) = online {
-                            let mut addrs: HashMap<PeerAddr, GroupId> = HashMap::new();
+                            let mut addrs: HashMap<PeerId, GroupId> = HashMap::new();
                             addrs.insert(faddr, f.gid);
                             tokio::spawn(rpc::sleep_waiting_close_stable(
                                 sender,
@@ -473,7 +473,7 @@ impl StatusEvent {
         self,
         group: &mut Group,
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         _results: &mut HandleResult,
         layer: &Arc<RwLock<Layer>>,
         _uid: u64,
@@ -669,7 +669,7 @@ impl SyncEvent {
         group: &mut Group,
         layer: &Arc<RwLock<Layer>>,
         results: &mut HandleResult,
-        addr: PeerAddr,
+        addr: PeerId,
     ) -> Result<()> {
         if events.len() as u64 != to + 1 - from {
             return Ok(());
@@ -811,7 +811,7 @@ impl SyncEvent {
                             tokio::spawn(async move {
                                 let online = layer_lock.write().await.remove_online(&ggid, &fgid);
                                 if let Some(faddr) = online {
-                                    let mut addrs: HashMap<PeerAddr, GroupId> = HashMap::new();
+                                    let mut addrs: HashMap<PeerId, GroupId> = HashMap::new();
                                     addrs.insert(faddr, fgid);
                                     tokio::spawn(rpc::sleep_waiting_close_stable(
                                         sender,

src/group.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::{EventId, GroupId},
     message::{RecvType, SendMessage, SendType},
-    primitive::{HandleResult, PeerAddr, Result},
+    primitive::{HandleResult, Peer, PeerId, Result},
 };
 use tdn_did::{user::User, Proof};
 use tokio::sync::{mpsc::Sender, RwLock};
@@ -33,7 +33,7 @@ pub(crate) struct Group {
     /// TDN network sender.
     sender: Sender<SendMessage>,
     /// current address.
-    addr: PeerAddr,
+    addr: PeerId,
     /// all accounts.
     accounts: HashMap<GroupId, Account>,
     /// distributed devices.
@@ -44,7 +44,7 @@ pub(crate) struct Group {
 #[derive(Serialize, Deserialize)]
 enum GroupConnect {
     /// Params: User, consensus height, event_id, remote_name, remote_info, other_devices addr.
-    Create(Proof, User, u64, EventId, String, String, Vec<PeerAddr>),
+    Create(Proof, User, u64, EventId, String, String, Vec<PeerId>),
     /// connected.
     Connect(u64, EventId),
 }
@@ -57,9 +57,9 @@ pub(crate) enum GroupEvent {
     /// Sync infomations.
     Status(StatusEvent),
     /// device's info update.
-    DeviceUpdate(PeerAddr, String),
+    DeviceUpdate(PeerId, String),
     /// device deleted.
-    DeviceDelete(PeerAddr),
+    DeviceDelete(PeerId),
     /// offline.
     DeviceOffline,
     /// Device status request.
@@ -97,8 +97,8 @@ impl Group {
             RecvType::Leave(addr) => {
                 for (_, account) in &mut self.runnings {
                     if let Some(device) = account.distributes.get_mut(&addr) {
-                        device.1 = false;
-                        results.rpcs.push(device_rpc::device_offline(gid, device.0));
+                        device.2 = false;
+                        results.rpcs.push(device_rpc::device_offline(gid, device.1));
                     }
                 }
             }
@@ -128,11 +128,12 @@ impl Group {
         &mut self,
         results: &mut HandleResult,
         gid: &GroupId,
-        addr: PeerAddr,
+        addr: Peer,
         data: Vec<u8>,
         is_connect: bool,
     ) -> Result<()> {
         let connect = bincode::deserialize(&data)?;
+        let peer_id = addr.id;
 
         let (remote_height, remote_event, others) = match connect {
             GroupConnect::Create(
@@ -145,12 +146,14 @@ impl Group {
                 others,
             ) => {
                 // check remote addr is receive addr.
-                if remote.addr != addr {
+                if remote.addr != peer_id {
                     return Err(anyhow!("Address is invalid."));
                 }
-                proof.verify(gid, &addr, &self.addr)?;
+                proof.verify(gid, &peer_id, &self.addr)?;
                 if is_connect {
-                    results.groups.push((*gid, self.agree_message(gid, addr)?));
+                    results
+                        .groups
+                        .push((*gid, self.agree_message(gid, addr.clone())?));
                 }
 
                 // first init sync.
@@ -174,21 +177,23 @@ impl Group {
                 let running = self.runnings.get_mut(gid).unwrap(); // safe unwrap. checked.
                 let mut new_addrs = vec![];
                 for a in others {
-                    if a != addr && a != self.addr && !running.distributes.contains_key(&a) {
+                    if a != peer_id && a != self.addr && !running.distributes.contains_key(&a) {
                         new_addrs.push(a);
                     }
                 }
 
-                if let Some(v) = running.distributes.get_mut(&addr) {
-                    v.1 = true;
-                    results.rpcs.push(device_rpc::device_online(*gid, v.0));
+                if let Some(v) = running.distributes.get_mut(&peer_id) {
+                    v.2 = true;
+                    results.rpcs.push(device_rpc::device_online(*gid, v.1));
                     (remote_height, remote_event, new_addrs)
                 } else {
-                    let mut device = Device::new(device_name, device_info, addr);
+                    let mut device = Device::new(device_name, device_info, peer_id);
                     let db = consensus_db(&self.base, gid)?;
                     device.insert(&db)?;
                     db.close()?;
-                    running.distributes.insert(addr, (device.id, true));
+                    running
+                        .distributes
+                        .insert(peer_id, (addr.clone(), device.id, true));
                     results.rpcs.push(device_rpc::device_create(*gid, &device));
                     results
                         .rpcs
@@ -202,7 +207,7 @@ impl Group {
                     .get(gid)
                     .unwrap() // safe, checked
                     .distributes
-                    .contains_key(&addr)
+                    .contains_key(&peer_id)
                 {
                     if is_connect {
                         results.groups.push((*gid, self.connect_result(gid, addr)?));
@@ -215,7 +220,7 @@ impl Group {
                 }
 
                 let v = self.running_mut(gid)?;
-                let did = v.add_online(&addr)?;
+                let did = v.add_online(&peer_id)?;
                 results.rpcs.push(device_rpc::device_online(*gid, did));
                 (remote_height, remote_event, vec![])
             }
@@ -225,12 +230,14 @@ impl Group {
         if account.height != remote_height || account.event != remote_event {
             results
                 .groups
-                .push((*gid, self.sync_message(gid, addr, 1, account.height)?));
+                .push((*gid, self.sync_message(gid, peer_id, 1, account.height)?));
         }
 
         // connect to others.
         for addr in others {
-            results.groups.push((*gid, self.create_message(gid, addr)?));
+            results
+                .groups
+                .push((*gid, self.create_message(gid, Peer::peer(addr))?));
         }
 
         Ok(())
@@ -241,7 +248,7 @@ impl Group {
     pub async fn init(
         secret: [u8; 32],
         sender: Sender<SendMessage>,
-        addr: PeerAddr,
+        addr: PeerId,
         accounts: HashMap<GroupId, Account>,
         base: PathBuf,
     ) -> Result<Group> {
@@ -255,7 +262,7 @@ impl Group {
         })
     }
 
-    pub fn addr(&self) -> &PeerAddr {
+    pub fn addr(&self) -> &PeerId {
         &self.addr
     }
 
@@ -311,7 +318,7 @@ impl Group {
         }
     }
 
-    pub fn prove_addr(&self, mgid: &GroupId, raddr: &PeerAddr) -> Result<Proof> {
+    pub fn prove_addr(&self, mgid: &GroupId, raddr: &PeerId) -> Result<Proof> {
         let running = self.running(mgid)?;
         Ok(Proof::prove(&running.keypair, &self.addr, raddr))
     }
@@ -327,9 +334,9 @@ impl Group {
     pub fn distribute_conns(&self, gid: &GroupId) -> Vec<SendType> {
         let mut vecs = vec![];
         if let Some(running) = &self.runnings.get(gid) {
-            for (addr, _) in &running.distributes {
+            for (addr, (peer, _, _)) in &running.distributes {
                 if addr != &self.addr {
-                    if let Ok(s) = self.connect_message(gid, *addr) {
+                    if let Ok(s) = self.connect_message(gid, peer.clone()) {
                         vecs.push(s);
                     }
                 }
@@ -342,9 +349,9 @@ impl Group {
         let mut conns = HashMap::new();
         for (mgid, running) in &self.runnings {
             let mut vecs = vec![];
-            for (addr, _) in &running.distributes {
+            for (addr, (peer, _, _)) in &running.distributes {
                 if addr != &self.addr {
-                    if let Ok(s) = self.connect_message(mgid, *addr) {
+                    if let Ok(s) = self.connect_message(mgid, peer.clone()) {
                         vecs.push(s);
                     }
                 }
@@ -356,7 +363,7 @@ impl Group {
 
     pub fn online_devices(&self, gid: &GroupId, mut devices: Vec<Device>) -> Vec<Device> {
         if let Some(running) = self.runnings.get(gid) {
-            for (addr, (_id, online)) in &running.distributes {
+            for (addr, (_peer, _id, online)) in &running.distributes {
                 if *online {
                     for device in devices.iter_mut() {
                         if device.addr == *addr {
@@ -370,10 +377,10 @@ impl Group {
         devices
     }
 
-    pub fn remove_all_running(&mut self) -> HashMap<PeerAddr, ()> {
-        let mut addrs: HashMap<PeerAddr, ()> = HashMap::new();
+    pub fn remove_all_running(&mut self) -> HashMap<PeerId, ()> {
+        let mut addrs: HashMap<PeerId, ()> = HashMap::new();
         for (_, running) in self.runnings.drain() {
-            for (addr, (_id, online)) in running.distributes {
+            for (addr, (_peer, _id, online)) in running.distributes {
                 if addr != self.addr && online {
                     addrs.insert(addr, ());
                 }
@@ -382,11 +389,11 @@ impl Group {
         addrs
     }
 
-    pub fn remove_running(&mut self, gid: &GroupId) -> HashMap<PeerAddr, ()> {
+    pub fn remove_running(&mut self, gid: &GroupId) -> HashMap<PeerId, ()> {
         // check close the stable connection.
-        let mut addrs: HashMap<PeerAddr, ()> = HashMap::new();
+        let mut addrs: HashMap<PeerId, ()> = HashMap::new();
         if let Some(running) = self.runnings.remove(gid) {
-            for (addr, (_id, online)) in running.distributes {
+            for (addr, (_peer, _id, online)) in running.distributes {
                 if addr != self.addr && online {
                     addrs.insert(addr, ());
                 }
@@ -394,7 +401,7 @@ impl Group {
 
             // check if other stable connection.
             for other_running in self.runnings.values() {
-                for (addr, (_id, online)) in &other_running.distributes {
+                for (addr, (_peer, _id, online)) in &other_running.distributes {
                     if *online && addrs.contains_key(addr) {
                         addrs.remove(addr);
                     }
@@ -514,19 +521,17 @@ impl Group {
         }
     }
 
-    pub fn create_message(&self, gid: &GroupId, addr: PeerAddr) -> Result<SendType> {
+    pub fn create_message(&self, gid: &GroupId, addr: Peer) -> Result<SendType> {
         let user = self.clone_user(gid)?;
         let account = self.account(gid)?;
         let height = account.height;
         let event = account.event;
-        let proof = self.prove_addr(gid, &addr)?;
+        let proof = self.prove_addr(gid, &addr.id)?;
         let running = self.running(gid)?;
 
         Ok(SendType::Connect(
             0,
             addr,
-            None,
-            None,
             bincode::serialize(&GroupConnect::Create(
                 proof,
                 user,
@@ -540,15 +545,15 @@ impl Group {
         ))
     }
 
-    pub fn connect_message(&self, gid: &GroupId, addr: PeerAddr) -> Result<SendType> {
+    pub fn connect_message(&self, gid: &GroupId, addr: Peer) -> Result<SendType> {
         let account = self.account(gid)?;
         let height = account.height;
         let event = account.event;
         let data = bincode::serialize(&GroupConnect::Connect(height, event)).unwrap_or(vec![]);
-        Ok(SendType::Connect(0, addr, None, None, data))
+        Ok(SendType::Connect(0, addr, data))
     }
 
-    pub fn connect_result(&self, gid: &GroupId, addr: PeerAddr) -> Result<SendType> {
+    pub fn connect_result(&self, gid: &GroupId, addr: Peer) -> Result<SendType> {
         let account = self.account(gid)?;
         let height = account.height;
         let event = account.event;
@@ -556,12 +561,12 @@ impl Group {
         Ok(SendType::Result(0, addr, true, false, data))
     }
 
-    pub fn agree_message(&self, gid: &GroupId, addr: PeerAddr) -> Result<SendType> {
+    pub fn agree_message(&self, gid: &GroupId, addr: Peer) -> Result<SendType> {
         let account = self.account(gid)?;
         let height = account.height;
         let event = account.event;
         let me = self.clone_user(gid)?;
-        let proof = self.prove_addr(gid, &addr)?;
+        let proof = self.prove_addr(gid, &addr.id)?;
         let running = self.running(gid)?;
 
         Ok(SendType::Result(
@@ -597,7 +602,7 @@ impl Group {
     pub fn sync_message(
         &self,
         gid: &GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         from: u64,
         to: u64,
     ) -> Result<SendType> {
@@ -616,7 +621,7 @@ impl Group {
         Ok(SendType::Event(0, addr, data))
     }
 
-    pub fn event_message(&self, addr: PeerAddr, event: &GroupEvent) -> Result<SendType> {
+    pub fn event_message(&self, addr: PeerId, event: &GroupEvent) -> Result<SendType> {
         let data = bincode::serialize(event).unwrap_or(vec![]);
         Ok(SendType::Event(0, addr, data))
     }
@@ -647,7 +652,7 @@ impl Group {
         let e = GroupEvent::Event(eheight, eid, pre_event, event);
         let data = bincode::serialize(&e).unwrap_or(vec![]);
         let running = self.running(gid)?;
-        for (addr, (_id, online)) in &running.distributes {
+        for (addr, (_peer, _id, online)) in &running.distributes {
             if *online {
                 let msg = SendType::Event(0, *addr, data.clone());
                 results.groups.push((*gid, msg))
@@ -664,7 +669,7 @@ impl Group {
     ) -> Result<()> {
         let running = self.running(gid)?;
         let data = bincode::serialize(&GroupEvent::Status(event)).unwrap_or(vec![]);
-        for (addr, (_id, online)) in &running.distributes {
+        for (addr, (_peer, _id, online)) in &running.distributes {
             if *online {
                 let msg = SendType::Event(0, *addr, data.clone());
                 results.groups.push((*gid, msg))
@@ -679,7 +684,7 @@ impl GroupEvent {
         group: &mut Group,
         event: GroupEvent,
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         layer: &Arc<RwLock<Layer>>,
         uid: u64,
     ) -> Result<HandleResult> {

src/group/consensus.rs

@@ -6,7 +6,7 @@ struct RunningAccount {
     /// device's info.
     device_info: String,
     /// distribute connected devices.
-    distributes: HashMap<PeerAddr, (i64, bool)>,
+    distributes: HashMap<PeerId, (i64, bool)>,
     /// uptime
     uptime: u32,
     /// pool to store consensus event.
@@ -14,7 +14,7 @@ struct RunningAccount {
     /// voting block.
     vote_block: BlockId,
     /// voting confirm.
-    vote_confirm: Vec<PeerAddr>,
+    vote_confirm: Vec<PeerId>,
     /// next block miner.
     next_miner: PeerAdr,
 }
@@ -37,7 +37,7 @@ pub(crate) enum ConsensusEvent {
     /// Consensus: confirm block.
     MineConfirm(u64),
     /// miner lost, need new.
-    MinerNew(PeerAddr),
+    MinerNew(PeerId),
     /// confirm miner is lost.
     MinerNewConfirm(bool),
     /// Consensus: Miner lost, re-vote.

src/group/running.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tdn::types::{
     group::GroupId,
-    primitive::{PeerAddr, Result},
+    primitive::{Peer, PeerId, Result},
 };
 
 use tdn_did::Keypair;
@@ -19,7 +19,7 @@ pub(crate) struct RunningAccount {
     /// device's info.
     pub device_info: String,
     /// distribute connected devices.
-    pub distributes: HashMap<PeerAddr, (i64, bool)>,
+    pub distributes: HashMap<PeerId, (Peer, i64, bool)>,
     /// uptime
     pub uptime: u32,
 }
@@ -47,19 +47,19 @@ impl RunningAccount {
         })
     }
 
-    pub fn add_online(&mut self, addr: &PeerAddr) -> Result<i64> {
+    pub fn add_online(&mut self, addr: &PeerId) -> Result<i64> {
         if let Some(v) = self.distributes.get_mut(addr) {
-            v.1 = true;
-            Ok(v.0)
+            v.2 = true;
+            Ok(v.1)
         } else {
             Err(anyhow!("device missing"))
         }
     }
 
-    pub fn offline(&mut self, addr: &PeerAddr) -> Result<i64> {
+    pub fn offline(&mut self, addr: &PeerId) -> Result<i64> {
         if let Some(v) = self.distributes.get_mut(addr) {
-            v.1 = false;
-            Ok(v.0)
+            v.2 = false;
+            Ok(v.1)
         } else {
             Err(anyhow!("device missing"))
         }

src/layer.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
     message::SendType,
-    primitive::{PeerAddr, Result},
+    primitive::{Peer, PeerId, Result},
 };
 use tokio::sync::RwLock;
 
@@ -36,13 +36,13 @@ pub(crate) struct Layer {
     /// storage base path.
     pub base: PathBuf,
     /// self peer addr.
-    pub addr: PeerAddr,
+    pub addr: PeerId,
     /// group info.
     pub group: Arc<RwLock<Group>>,
 }
 
 impl Layer {
-    pub async fn init(base: PathBuf, addr: PeerAddr, group: Arc<RwLock<Group>>) -> Result<Layer> {
+    pub async fn init(base: PathBuf, addr: PeerId, group: Arc<RwLock<Group>>) -> Result<Layer> {
         Ok(Layer {
             base,
             group,
@@ -79,9 +79,9 @@ impl Layer {
         Ok(())
     }
 
-    pub fn remove_running(&mut self, gid: &GroupId) -> HashMap<PeerAddr, GroupId> {
+    pub fn remove_running(&mut self, gid: &GroupId) -> HashMap<PeerId, GroupId> {
         // check close the stable connection.
-        let mut addrs: HashMap<PeerAddr, GroupId> = HashMap::new();
+        let mut addrs: HashMap<PeerId, GroupId> = HashMap::new();
         if let Some(running) = self.runnings.remove(gid) {
             for (addr, fgid) in running.remove_onlines() {
                 addrs.insert(addr, fgid);
@@ -103,8 +103,8 @@ impl Layer {
         addrs
     }
 
-    pub fn remove_all_running(&mut self) -> HashMap<PeerAddr, GroupId> {
-        let mut addrs: HashMap<PeerAddr, GroupId> = HashMap::new();
+    pub fn remove_all_running(&mut self) -> HashMap<PeerId, GroupId> {
+        let mut addrs: HashMap<PeerId, GroupId> = HashMap::new();
         for (_, running) in self.runnings.drain() {
             for (addr, fgid) in running.remove_onlines() {
                 addrs.insert(addr, fgid);
@@ -118,7 +118,7 @@ impl Layer {
         self.running(mgid)?.get_online_id(fgid)
     }
 
-    pub fn remove_online(&mut self, gid: &GroupId, fgid: &GroupId) -> Option<PeerAddr> {
+    pub fn remove_online(&mut self, gid: &GroupId, fgid: &GroupId) -> Option<PeerId> {
         self.running_mut(gid).ok()?.remove_online(fgid)
     }
 
@@ -136,11 +136,11 @@ impl Layer {
                 match s.s_type {
                     SessionType::Chat => {
                         let proof = group_lock.prove_addr(mgid, &s.addr)?;
-                        vecs.push((s.gid, chat_conn(proof, s.addr)));
+                        vecs.push((s.gid, chat_conn(proof, Peer::peer(s.addr))));
                     }
                     SessionType::Group => {
                         let proof = group_lock.prove_addr(mgid, &s.addr)?;
-                        vecs.push((GROUP_ID, group_chat_conn(proof, s.addr, s.gid)));
+                        vecs.push((GROUP_ID, group_chat_conn(proof, Peer::peer(s.addr), s.gid)));
                     }
                     _ => {}
                 }
@@ -152,7 +152,7 @@ impl Layer {
         Ok(conns)
     }
 
-    pub fn is_online(&self, faddr: &PeerAddr) -> bool {
+    pub fn is_online(&self, faddr: &PeerId) -> bool {
         for (_, running) in &self.runnings {
             running.check_addr_online(faddr);
         }
@@ -164,13 +164,13 @@ impl Layer {
 #[derive(Eq, PartialEq)]
 pub(crate) enum Online {
     /// connected to this device.
-    Direct(PeerAddr),
+    Direct(PeerId),
     /// connected to other device.
-    _Relay(PeerAddr),
+    _Relay(PeerId),
 }
 
 impl Online {
-    fn addr(&self) -> &PeerAddr {
+    fn addr(&self) -> &PeerId {
         match self {
             Online::Direct(ref addr) | Online::_Relay(ref addr) => addr,
         }
@@ -243,7 +243,7 @@ impl RunningLayer {
         self.consensus
     }
 
-    pub fn active(&mut self, gid: &GroupId, is_me: bool) -> Option<PeerAddr> {
+    pub fn active(&mut self, gid: &GroupId, is_me: bool) -> Option<PeerId> {
         if let Some(online) = self.sessions.get_mut(gid) {
             if is_me {
                 online.suspend_me = false;
@@ -291,14 +291,14 @@ impl RunningLayer {
     }
 
     /// get online peer's addr.
-    pub fn online(&self, gid: &GroupId) -> Result<PeerAddr> {
+    pub fn online(&self, gid: &GroupId) -> Result<PeerId> {
         self.sessions
             .get(gid)
             .map(|online| *online.online.addr())
             .ok_or(anyhow!("remote not online"))
     }
 
-    pub fn online_direct(&self, gid: &GroupId) -> Result<PeerAddr> {
+    pub fn online_direct(&self, gid: &GroupId) -> Result<PeerId> {
         if let Some(online) = self.sessions.get(gid) {
             match online.online {
                 Online::Direct(addr) => return Ok(addr),
@@ -309,7 +309,7 @@ impl RunningLayer {
     }
 
     /// get all online peer.
-    pub fn onlines(&self) -> Vec<(&GroupId, &PeerAddr)> {
+    pub fn onlines(&self) -> Vec<(&GroupId, &PeerId)> {
         self.sessions
             .iter()
             .map(|(fgid, online)| (fgid, online.online.addr()))
@@ -341,7 +341,7 @@ impl RunningLayer {
     }
 
     /// check offline, and return is direct.
-    pub fn check_offline(&mut self, gid: &GroupId, addr: &PeerAddr) -> bool {
+    pub fn check_offline(&mut self, gid: &GroupId, addr: &PeerId) -> bool {
         if let Some(online) = self.sessions.remove(gid) {
             if online.online.addr() != addr {
                 return false;
@@ -357,14 +357,14 @@ impl RunningLayer {
         false
     }
 
-    pub fn remove_online(&mut self, gid: &GroupId) -> Option<PeerAddr> {
+    pub fn remove_online(&mut self, gid: &GroupId) -> Option<PeerId> {
         self.sessions
             .remove(gid)
             .map(|online| *online.online.addr())
     }
 
     /// remove all onlines peer.
-    pub fn remove_onlines(self) -> Vec<(PeerAddr, GroupId)> {
+    pub fn remove_onlines(self) -> Vec<(PeerId, GroupId)> {
         let mut peers = vec![];
         for (fgid, online) in self.sessions {
             match online.online {
@@ -376,7 +376,7 @@ impl RunningLayer {
     }
 
     /// check if addr is online.
-    pub fn check_addr_online(&self, addr: &PeerAddr) -> bool {
+    pub fn check_addr_online(&self, addr: &PeerId) -> bool {
         for (_, online) in &self.sessions {
             if online.online.addr() == addr {
                 return true;
@@ -386,7 +386,7 @@ impl RunningLayer {
     }
 
     /// peer leave, remove online peer.
-    pub fn peer_leave(&mut self, addr: &PeerAddr) -> Vec<i64> {
+    pub fn peer_leave(&mut self, addr: &PeerId) -> Vec<i64> {
         let mut peers = vec![];
         let mut deletes = vec![];
         for (fgid, online) in &self.sessions {
@@ -403,7 +403,7 @@ impl RunningLayer {
     }
 
     /// list all onlines groups.
-    pub fn close_suspend(&mut self, self_addr: &PeerAddr) -> Vec<(GroupId, PeerAddr, i64)> {
+    pub fn close_suspend(&mut self, self_addr: &PeerId) -> Vec<(GroupId, PeerId, i64)> {
         let mut needed = vec![];
         for (fgid, online) in &mut self.sessions {
             // when online is self. skip.

src/primitives.rs

@@ -1,11 +1,14 @@
-use std::net::SocketAddr;
+use tdn::prelude::Peer;
 
 #[inline]
-pub(crate) fn network_seeds() -> Vec<SocketAddr> {
+pub(crate) fn network_seeds() -> Vec<Peer> {
     #[rustfmt::skip]
-    let seeds: Vec<&str> = vec![
-        "1.15.156.199:7364",
+    let seeds: Vec<(&str, &str)> = vec![
+        ("1.15.156.199:7364", "quic"),
     ];
 
-    seeds.iter().map(|v| v.parse().unwrap()).collect()
+    seeds
+        .iter()
+        .map(|(v, t)| Peer::socket_transport(v.parse().unwrap(), t))
+        .collect()
 }

src/rpc.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
     message::{NetworkType, SendMessage, SendType, StateRequest, StateResponse},
-    primitive::{HandleResult, PeerAddr, Result},
+    primitive::{HandleResult, Peer, PeerId, Result},
     rpc::{json, rpc_response, RpcError, RpcHandler, RpcParam},
 };
 use tdn_did::{generate_mnemonic, Count};
@@ -23,7 +23,7 @@ use crate::session::{connect_session, Session, SessionType};
 use crate::storage::{group_chat_db, session_db};
 
 pub(crate) fn init_rpc(
-    addr: PeerAddr,
+    addr: PeerId,
     group: Arc<RwLock<Group>>,
     layer: Arc<RwLock<Layer>>,
 ) -> RpcHandler<RpcState> {
@@ -38,7 +38,7 @@ pub(crate) struct RpcState {
 }
 
 #[inline]
-pub(crate) fn network_stable(peers: Vec<(PeerAddr, bool)>) -> RpcParam {
+pub(crate) fn network_stable(peers: Vec<(PeerId, bool)>) -> RpcParam {
     let s_peers: Vec<Vec<String>> = peers
         .iter()
         .map(|(p, is_d)| {
@@ -54,7 +54,7 @@ pub(crate) fn network_stable(peers: Vec<(PeerAddr, bool)>) -> RpcParam {
 }
 
 #[inline]
-pub(crate) fn network_dht(peers: Vec<PeerAddr>) -> RpcParam {
+pub(crate) fn network_dht(peers: Vec<PeerId>) -> RpcParam {
     let s_peers: Vec<String> = peers.iter().map(|p| p.to_hex()).collect();
     rpc_response(0, "network-dht", json!(s_peers), GroupId::default())
 }
@@ -89,7 +89,7 @@ pub(crate) fn session_last(
 pub(crate) fn _session_update(
     mgid: GroupId,
     id: &i64,
-    addr: &PeerAddr,
+    addr: &PeerId,
     name: &str,
     is_top: bool,
 ) -> RpcParam {
@@ -102,7 +102,7 @@ pub(crate) fn _session_update(
 }
 
 #[inline]
-pub(crate) fn session_connect(mgid: GroupId, id: &i64, addr: &PeerAddr) -> RpcParam {
+pub(crate) fn session_connect(mgid: GroupId, id: &i64, addr: &PeerId) -> RpcParam {
     rpc_response(0, "session-connect", json!([id, addr.to_hex()]), mgid)
 }
 
@@ -138,8 +138,8 @@ fn session_list(sessions: Vec<Session>) -> RpcParam {
 #[inline]
 pub(crate) async fn sleep_waiting_close_stable(
     sender: Sender<SendMessage>,
-    groups: HashMap<PeerAddr, ()>,
-    layers: HashMap<PeerAddr, GroupId>,
+    groups: HashMap<PeerId, ()>,
+    layers: HashMap<PeerId, GroupId>,
 ) -> std::result::Result<(), SendError<SendMessage>> {
     tokio::time::sleep(std::time::Duration::from_secs(10)).await;
     for (addr, _) in groups {
@@ -200,7 +200,7 @@ pub(crate) async fn inner_rpc(uid: u64, method: &str, sender: &Sender<SendMessag
 }
 
 fn new_rpc_handler(
-    addr: PeerAddr,
+    addr: PeerId,
     group: Arc<RwLock<Group>>,
     layer: Arc<RwLock<Layer>>,
 ) -> RpcHandler<RpcState> {
@@ -218,8 +218,12 @@ fn new_rpc_handler(
         "add-bootstrap",
         |_gid, params: Vec<RpcParam>, _| async move {
             let socket = params[0].as_str().ok_or(RpcError::ParseError)?;
+            let transport = params[1].as_str().ok_or(RpcError::ParseError)?;
+
             if let Ok(addr) = socket.parse::<SocketAddr>() {
-                Ok(HandleResult::network(NetworkType::Connect(addr)))
+                Ok(HandleResult::network(NetworkType::Connect(
+                    Peer::socket_transport(addr, transport),
+                )))
             } else {
                 Err(RpcError::InvalidRequest)
             }
@@ -293,8 +297,7 @@ fn new_rpc_handler(
             let name = params[3].as_str().ok_or(RpcError::ParseError)?;
             let lock = params[4].as_str().ok_or(RpcError::ParseError)?;
 
-            let some_addr =
-                PeerAddr::from_hex(params[5].as_str().ok_or(RpcError::ParseError)?).ok();
+            let some_addr = PeerId::from_hex(params[5].as_str().ok_or(RpcError::ParseError)?).ok();
 
             let (id, gid) = state
                 .group
@@ -312,7 +315,7 @@ fn new_rpc_handler(
             if let Some(addr) = some_addr {
                 let group_lock = state.group.read().await;
                 let sender = group_lock.sender();
-                let msg = group_lock.create_message(&gid, addr)?;
+                let msg = group_lock.create_message(&gid, Peer::peer(addr))?;
                 drop(group_lock);
                 tokio::spawn(async move {
                     tokio::time::sleep(std::time::Duration::from_secs(2)).await;
@@ -561,11 +564,17 @@ fn new_rpc_handler(
             match s.s_type {
                 SessionType::Chat => {
                     let proof = group_lock.prove_addr(&gid, &s.addr)?;
-                    results.layers.push((gid, s.gid, chat_conn(proof, s.addr)));
+                    results
+                        .layers
+                        .push((gid, s.gid, chat_conn(proof, Peer::peer(s.addr))));
                 }
                 SessionType::Group => {
                     let proof = group_lock.prove_addr(&gid, &s.addr)?;
-                    add_layer(&mut results, gid, group_chat_conn(proof, s.addr, s.gid));
+                    add_layer(
+                        &mut results,
+                        gid,
+                        group_chat_conn(proof, Peer::peer(s.addr), s.gid),
+                    );
                 }
                 _ => {}
             }

src/server.rs

@@ -47,7 +47,11 @@ pub async fn start(db_path: String) -> Result<()> {
 
     info!("Config RPC HTTP : {:?}", config.rpc_addr);
     info!("Config RPC WS   : {:?}", config.rpc_ws);
-    info!("Config P2P      : {:?}", config.p2p_addr);
+    info!(
+        "Config P2P      : {} {:?}",
+        config.p2p_peer.transport.to_str(),
+        config.p2p_peer.socket
+    );
 
     let rand_secret = config.secret.clone();
 
@@ -155,7 +159,7 @@ async fn sleep_waiting_reboot(
 }
 
 async fn session_remain(
-    self_addr: PeerAddr,
+    self_addr: PeerId,
     layer: Arc<RwLock<Layer>>,
     sender: Sender<SendMessage>,
 ) -> Result<()> {

src/session.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 use tdn::types::{
     group::GroupId,
-    primitive::{PeerAddr, Result},
+    primitive::{PeerId, Result},
     rpc::{json, RpcParam},
 };
 use tdn_storage::local::{DStorage, DsValue};
@@ -40,7 +40,7 @@ pub(crate) struct Session {
     pub id: i64,
     fid: i64,
     pub gid: GroupId,
-    pub addr: PeerAddr,
+    pub addr: PeerId,
     pub s_type: SessionType,
     name: String,
     is_top: bool,
@@ -54,7 +54,7 @@ impl Session {
     pub fn new(
         fid: i64,
         gid: GroupId,
-        addr: PeerAddr,
+        addr: PeerId,
         s_type: SessionType,
         name: String,
         datetime: i64,
@@ -99,7 +99,7 @@ impl Session {
             is_top: v.pop().unwrap().as_bool(),
             name: v.pop().unwrap().as_string(),
             s_type: SessionType::from_int(v.pop().unwrap().as_i64()),
-            addr: PeerAddr::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerAddr::default()),
+            addr: PeerId::from_hex(v.pop().unwrap().as_str()).unwrap_or(PeerId::default()),
             gid: GroupId::from_hex(v.pop().unwrap().as_str()).unwrap_or(GroupId::default()),
             fid: v.pop().unwrap().as_i64(),
             id: v.pop().unwrap().as_i64(),
@@ -241,7 +241,7 @@ pub(crate) fn connect_session(
     mgid: &GroupId,
     s_type: &SessionType,
     fid: &i64,
-    addr: &PeerAddr,
+    addr: &PeerId,
 ) -> Result<Option<Session>> {
     let db = session_db(base, mgid)?;