Update Member

src/pcd.rs

@@ -1,5 +1,6 @@
 use anyhow::{Error, Result};
 use rs_merkle::{algorithms::Sha256, MerkleTree};
+use serde::ser::SerializeStruct;
 use std::collections::{HashMap, HashSet};
 use std::hash::{Hash as StdHash, Hasher};
 
@@ -23,12 +24,29 @@ use crate::{
     signature::{AnkHash, AnkValidationNoHash, AnkValidationYesHash, Proof},
 };
 
-#[derive(Debug, Default, Clone, Serialize, Deserialize, Tsify)]
+#[derive(Debug, Default, Clone, Deserialize, Tsify)]
 #[tsify(into_wasm_abi, from_wasm_abi)]
 pub struct Member {
     sp_addresses: Vec<String>,
 }
 
+impl Serialize for Member {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        // Deduplicate and sort sp_addresses
+        let set: HashSet<_> = self.sp_addresses.iter().collect();
+        let mut unique_items: Vec<_> = set.into_iter().collect();
+        unique_items.sort_unstable();
+
+        // Serialize as an object with the sp_addresses key
+        let mut state = serializer.serialize_struct("Member", 1)?;
+        state.serialize_field("sp_addresses", &unique_items)?;
+        state.end()
+    }
+}
+
 impl PartialEq for Member {
     fn eq(&self, other: &Self) -> bool {
         let self_set: HashSet<_> = self.sp_addresses.iter().collect();
@@ -57,14 +75,9 @@ impl Member {
             return Err(Error::msg("empty address set"));
         }
 
-        let mut seen = HashSet::new();
+        let unique_addresses: HashSet<_> = sp_addresses.into_iter().collect();
-        for s in sp_addresses.iter() {
-            if !seen.insert(s.clone()) {
-                return Err(Error::msg("Duplicate addresses found"));
-            }
-        }
 
-        let res: Vec<String> = sp_addresses
+        let res: Vec<String> = unique_addresses
             .iter()
             .map(|a| Into::<String>::into(*a))
             .collect();
@@ -172,7 +185,7 @@ pub trait Pcd<'a>: Serialize + Deserialize<'a> {
 
     /// We run this on the result of `hash_all_fields`
     fn create_merkle_tree(&self) -> Result<MerkleTree<Sha256>> {
-        let map = self.to_value_object()?;
+        let map = self.to_sorted_key_values()?;
         let leaves: Result<Vec<[u8; 32]>> = map
             .iter()
             .map(|(_, value)| {