Rename committee_member_public_keys

Too long, can be committee_public_keys without losing meaning.

Author: Mikhail Zabaluev

chain-impl-mockchain/src/certificate/vote_plan.rs

@@ -48,7 +48,7 @@ pub struct VotePlan {
     /// vote payload type
     payload_type: vote::PayloadType,
     /// encrypting votes public keys
-    committee_member_public_keys: Vec<chain_vote::MemberPublicKey>,
+    committee_public_keys: Vec<chain_vote::MemberPublicKey>,
 }
 
 #[derive(Debug, Clone)]
@@ -190,15 +190,15 @@ impl VotePlan {
         committee_end: BlockDate,
         proposals: Proposals,
         payload_type: vote::PayloadType,
-        committee_member_public_keys: Vec<chain_vote::MemberPublicKey>,
+        committee_public_keys: Vec<chain_vote::MemberPublicKey>,
     ) -> Self {
         Self {
             vote_start,
             vote_end,
             committee_end,
             proposals,
             payload_type,
-            committee_member_public_keys,
+            committee_public_keys,
         }
     }
 
@@ -244,8 +244,8 @@ impl VotePlan {
         self.payload_type
     }
 
-    pub fn committee_member_public_keys(&self) -> &[chain_vote::MemberPublicKey] {
-        &self.committee_member_public_keys
+    pub fn committee_public_keys(&self) -> &[chain_vote::MemberPublicKey] {
+        &self.committee_public_keys
     }
 
     #[inline]
@@ -289,8 +289,8 @@ impl VotePlan {
 
     pub fn serialize_in(&self, bb: ByteBuilder<Self>) -> ByteBuilder<Self> {
         let mut member_keys_buf: ByteBuilder<u8> = ByteBuilder::new();
-        member_keys_buf = member_keys_buf.u64(self.committee_member_public_keys.len() as u64);
-        for key in &self.committee_member_public_keys {
+        member_keys_buf = member_keys_buf.u64(self.committee_public_keys.len() as u64);
+        for key in &self.committee_public_keys {
             let buf = key.to_bytes();
             member_keys_buf = member_keys_buf.u64(buf.len() as u64).bytes(&buf);
         }
@@ -444,12 +444,12 @@ impl Readable for VotePlan {
         }
 
         let member_keys_len = buf.get_u64()?;
-        let mut committee_member_public_keys = Vec::new();
+        let mut committee_public_keys = Vec::new();
         for _ in 0..member_keys_len {
             let key_len = buf.get_u64()?;
             let key_buf = buf.get_slice(key_len as usize)?;
             // Unwrap should be ok here, since we did serialize it ourselves
-            committee_member_public_keys.push(MemberPublicKey::from_bytes(key_buf).unwrap());
+            committee_public_keys.push(MemberPublicKey::from_bytes(key_buf).unwrap());
         }
 
         Ok(Self {
@@ -458,7 +458,7 @@ impl Readable for VotePlan {
             committee_end,
             proposals,
             payload_type,
-            committee_member_public_keys,
+            committee_public_keys,
         })
     }
 }

chain-impl-mockchain/src/ledger/recovery.rs

@@ -936,7 +936,7 @@ fn unpack_payload_type<R: std::io::BufRead>(
         .map_err(|error| std::io::Error::new(std::io::ErrorKind::Other, error))
 }
 
-fn pack_committee_member_public_keys<W: std::io::Write>(
+fn pack_committee_public_keys<W: std::io::Write>(
     keys: &[chain_vote::MemberPublicKey],
     codec: &mut Codec<W>,
 ) -> Result<(), std::io::Error> {
@@ -949,7 +949,7 @@ fn pack_committee_member_public_keys<W: std::io::Write>(
     Ok(())
 }
 
-fn unpack_committee_member_public_keys<R: std::io::BufRead>(
+fn unpack_committee_public_keys<R: std::io::BufRead>(
     codec: &mut Codec<R>,
 ) -> Result<Vec<chain_vote::MemberPublicKey>, std::io::Error> {
     let size = codec.get_u64()?;
@@ -972,7 +972,7 @@ fn pack_vote_plan<W: std::io::Write>(
     pack_block_date(vote_plan.committee_end(), codec)?;
     pack_payload_type(vote_plan.payload_type(), codec)?;
     pack_vote_proposals(vote_plan.proposals(), codec)?;
-    pack_committee_member_public_keys(vote_plan.committee_member_public_keys(), codec)?;
+    pack_committee_public_keys(vote_plan.committee_public_keys(), codec)?;
     Ok(())
 }
 
@@ -982,7 +982,7 @@ fn unpack_vote_plan<R: std::io::BufRead>(codec: &mut Codec<R>) -> Result<VotePla
     let committee_end = unpack_block_date(codec)?;
     let payload_type = unpack_payload_type(codec)?;
     let proposals = unpack_proposals(codec)?;
-    let keys = unpack_committee_member_public_keys(codec)?;
+    let keys = unpack_committee_public_keys(codec)?;
     Ok(VotePlan::new(
         vote_start,
         vote_end,

chain-impl-mockchain/src/vote/manager.rs

@@ -528,7 +528,7 @@ impl VotePlanManager {
                 proof,
             } => {
                 let pk = chain_vote::EncryptingVoteKey::from_participants(
-                    self.plan.committee_member_public_keys(),
+                    self.plan.committee_public_keys(),
                 );
                 if !chain_vote::verify_vote(&pk, encrypted_vote, proof) {
                     Err(VoteError::VoteVerificationError)