diff --git a/src/network.rs b/src/network.rs
index 941e95c..c988ff1 100644
--- a/src/network.rs
+++ b/src/network.rs
@@ -2,8 +2,7 @@ use std::collections::HashMap;
 
 use anyhow::Result;
 use rand::{thread_rng, RngCore};
-use serde::ser::SerializeStruct;
-use serde::{Deserialize, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use sp_client::bitcoin::consensus::serialize;
 use sp_client::bitcoin::hex::DisplayHex;
@@ -11,8 +10,8 @@ use sp_client::bitcoin::{OutPoint, Transaction};
 use tsify::Tsify;
 
 use crate::error::AnkError;
-use crate::pcd::{Member, RoleDefinition};
-use crate::process::Process;
+use crate::pcd::RoleDefinition;
+use crate::serialization::{OutPointMemberMap, OutPointProcessMap};
 use crate::signature::Proof;
 
 #[derive(Debug, Serialize, Deserialize, Tsify)]
@@ -169,42 +168,16 @@ impl NewTxMessage {
     }
 }
 
-#[derive(Debug, PartialEq, Deserialize, Tsify)]
+#[derive(Debug, Serialize, Deserialize, Tsify)]
 #[tsify(into_wasm_abi, from_wasm_abi)]
 pub struct HandshakeMessage {
     pub sp_address: String,
-    pub peers_list: HashMap<Member, OutPoint>,
-    pub processes_list: HashMap<OutPoint, Process>,
-}
-
-impl Serialize for HandshakeMessage {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut state = serializer.serialize_struct("HandshakeMessage", 3)?;
-
-        state.serialize_field("sp_address", &self.sp_address)?;
-
-        let peers_list: HashMap<String, &OutPoint> = self
-            .peers_list
-            .iter()
-            .map(|(member, outpoint)| {
-                let member_str = serde_json::to_string(member).unwrap(); 
-                (member_str, outpoint)
-            })
-            .collect();
-        state.serialize_field("peers_list", &peers_list)?;
-
-        // Serialize `processes_list` normally
-        state.serialize_field("processes_list", &self.processes_list)?;
-
-        state.end()
-    }
+    pub peers_list: OutPointMemberMap,
+    pub processes_list: OutPointProcessMap,
 }
 
 impl HandshakeMessage {
-    pub fn new(sp_address: String, peers_list: HashMap<Member, OutPoint>, processes_list: HashMap<OutPoint, Process>) -> Self {
+    pub fn new(sp_address: String, peers_list: OutPointMemberMap, processes_list: OutPointProcessMap) -> Self {
         Self {
             sp_address,
             peers_list,
diff --git a/src/serialization.rs b/src/serialization.rs
index 2eb0688..11cdcb6 100644
--- a/src/serialization.rs
+++ b/src/serialization.rs
@@ -3,10 +3,10 @@ use sp_client::bitcoin::OutPoint;
 use std::collections::HashMap;
 use crate::{pcd::Member, process::Process};
 
-#[derive(Serialize, Deserialize)]
-pub struct MemberOutPointMap(#[serde(with = "members_map")] pub HashMap<Member, OutPoint>);
+#[derive(Debug, Serialize, Deserialize)]
+pub struct OutPointMemberMap(#[serde(with = "members_map")] pub HashMap<OutPoint, Member>);
 
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct OutPointProcessMap(#[serde(with = "outpoint_map")] pub HashMap<OutPoint, Process>);
 
 pub mod members_map {
@@ -16,41 +16,28 @@ pub mod members_map {
     use sp_client::bitcoin::OutPoint;
 
     pub fn serialize<S>(
-        map: &HashMap<Member, OutPoint>,
+        map: &HashMap<OutPoint, Member>,
         serializer: S,
     ) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        let map: HashMap<String, OutPoint> = map
+        let map: HashMap<OutPoint, Member> = map
             .iter()
-            .map(|(k, v)| (k.to_string(), *v))
+            .map(|(k, v)| (*k, v.to_owned()))
             .collect();
         map.serialize(serializer)
     }
 
     pub fn deserialize<'de, D>(
         deserializer: D,
-    ) -> Result<HashMap<Member, OutPoint>, D::Error>
+    ) -> Result<HashMap<OutPoint, Member>, D::Error>
     where
         D: Deserializer<'de>,
     {
-        let map: HashMap<String, OutPoint> = HashMap::deserialize(deserializer)?;
+        let map: HashMap<OutPoint, Member> = HashMap::deserialize(deserializer)?;
 
-        let result: Result<HashMap<Member, OutPoint>, D::Error> = map
-            .into_iter()
-            .map(|(k, v)| {
-                let member = k
-                    .split(',')
-                    .map(|s| s.try_into())
-                    .collect::<Result<Vec<_>, _>>()
-                    .map_err(serde::de::Error::custom)?; 
-                let member = Member::new(member).map_err(serde::de::Error::custom)?;
-                Ok((member, v))
-            })
-            .collect(); 
-
-        result
+        Ok(map)
     }
 }