diff --git a/src/experimental/bit.rs b/src/experimental/bit.rs
index 7f196ed..eb31fe5 100644
--- a/src/experimental/bit.rs
+++ b/src/experimental/bit.rs
@@ -205,9 +205,9 @@ where
     type M = Message;
     type PKG = PublicKey<E>;
 
-    type PKnM = ::core::iter::Once<(Message, PublicKey<E>)>;
-
-    fn messages_and_publickeys(self) -> Self::PKnM {
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<Item = (Message, PublicKey<E>)> + ExactSizeIterator {
         let mut publickey = E::PublicKeyGroup::zero();
         for i in 0..8 * self.signers.borrow().len() {
             if self.signers.borrow()[i / 8] & (1 << (i % 8)) != 0 {
@@ -380,9 +380,9 @@ where
     type M = Message;
     type PKG = PublicKey<E>;
 
-    type PKnM = ::core::iter::Once<(Message, PublicKey<E>)>;
-
-    fn messages_and_publickeys(self) -> Self::PKnM {
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<Item = (Message, PublicKey<E>)> + ExactSizeIterator {
         let mut publickey = E::PublicKeyGroup::zero();
         for signers in self.signers.iter().rev().map(|signers| signers.borrow()) {
             publickey.double_in_place();
@@ -659,8 +659,7 @@ mod tests {
         }
         assert!(bitsig1.merge(&bitsig2).is_err());
 
-        let mut multimsg =
-            crate::pop_aggregator::SignatureAggregatorAssumingPoP::<ZBLS>::new();
+        let mut multimsg = crate::pop_aggregator::SignatureAggregatorAssumingPoP::<ZBLS>::new();
         multimsg.aggregate(&bitsig1);
         multimsg.aggregate(&bitsig2);
         assert!(multimsg.verify()); // verifiers::verify_with_distinct_messages(&dms,true)
diff --git a/src/experimental/delinear.rs b/src/experimental/delinear.rs
index ca14ec0..b69ed27 100644
--- a/src/experimental/delinear.rs
+++ b/src/experimental/delinear.rs
@@ -63,9 +63,10 @@ impl<'a, E: EngineBLS> Signed for &'a Delinearized<E> {
 
     type M = &'a Message;
     type PKG = &'a PublicKey<Self::E>;
-    type PKnM = ::std::collections::hash_map::Iter<'a, Message, PublicKey<E>>;
 
-    fn messages_and_publickeys(self) -> Self::PKnM {
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<Item = (&'a Message, &'a PublicKey<E>)> + ExactSizeIterator {
         self.messages_n_publickeys.iter()
     }
 
diff --git a/src/experimental/distinct.rs b/src/experimental/distinct.rs
index 3e7c653..4a6cc52 100644
--- a/src/experimental/distinct.rs
+++ b/src/experimental/distinct.rs
@@ -81,9 +81,10 @@ impl<'a, E: EngineBLS> Signed for &'a DistinctMessages<E> {
 
     type M = &'a Message;
     type PKG = &'a PublicKey<Self::E>;
-    type PKnM = ::std::collections::hash_map::Iter<'a, Message, PublicKey<E>>;
 
-    fn messages_and_publickeys(self) -> Self::PKnM {
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<Item = (&'a Message, &'a PublicKey<E>)> + ExactSizeIterator {
         self.messages_n_publickeys.iter()
     }
 
diff --git a/src/lib.rs b/src/lib.rs
index 03c95ab..6fb2c8c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -91,7 +91,6 @@
 #[cfg(doctest)]
 pub struct ReadmeDoctests;
 
-
 extern crate ark_serialize;
 extern crate ark_serialize_derive;
 
@@ -161,7 +160,9 @@ impl<E: EngineBLS> GeneralizedBLSPublicKey<E> for PublicKey<E> {
     }
 }
 
-impl<E: EngineBLS> GeneralizedBLSPublicKey<E> for (PublicKey<E>, nugget::PublicKeyInSignatureGroup<E>) {
+impl<E: EngineBLS> GeneralizedBLSPublicKey<E>
+    for (PublicKey<E>, nugget::PublicKeyInSignatureGroup<E>)
+{
     fn public_key(&self) -> PublicKey<E> {
         self.0
     }
@@ -295,29 +296,20 @@ impl<'a> From<&'a [u8]> for Message {
 /// We shall make `messages_and_publickeys` take `&sefl` and
 /// remove these limitations in the future once ATCs stabalize,
 /// thus removing `PKG`.  See [Rust RFC 1598](https://github.com/rust-lang/rfcs/blob/master/text/1598-generic_associated_types.md)
-/// We shall eventually remove MnPK entirely whenever `-> impl Trait`
-/// in traits gets stabalized.  See [Rust RFCs 1522, 1951, and 2071](https://github.com/rust-lang/rust/issues/34511
 pub trait Signed: Sized {
     type E: EngineBLS;
 
     /// Return the aggregated signature
     fn signature(&self) -> Signature<Self::E>;
 
-    type M: Borrow<Message>; // = Message;
-    type PKG: GeneralizedBLSPublicKey<Self::E>; // = PublicKey<Self::E>;
-
-    /// Iterator over, messages and public key reference pairs.
-    type PKnM: Iterator<Item = (Self::M, Self::PKG)> + ExactSizeIterator;
-    // type PKnM<'a>: Iterator<Item = (
-    //    &'a <<Self as Signed<'a>>::E as EngineBLS>::PublicKeyGroup,
-    //    &'a Self::M,
-    // )> + DoubleEndedIterator + ExactSizeIterator + 'a;
+    type M: Borrow<Message>;
+    type PKG: GeneralizedBLSPublicKey<Self::E>;
 
     /// Returns an iterator over messages and public key reference for
     /// pairings, often only partially aggregated.
-    fn messages_and_publickeys(self) -> Self::PKnM;
-    // fn messages_and_publickeys<'a>(&'s self) -> PKnM<'a>
-    // -> impl Iterator<Item = (&'a Self::M, &'a Self::E::PublicKeyGroup)> + 'a;
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<Item = (Self::M, Self::PKG)> + ExactSizeIterator;
 
     /// Appropriate BLS signature verification for the `Self` type.
     ///
diff --git a/src/nugget.rs b/src/nugget.rs
index 734f36f..73b9ac4 100644
--- a/src/nugget.rs
+++ b/src/nugget.rs
@@ -21,9 +21,9 @@ use digest::FixedOutputReset;
 use sha2::Sha256;
 
 use crate::broken_derives;
+use crate::chaum_pedersen_signature::DLEQProof;
 use crate::chaum_pedersen_signature::{ChaumPedersenSigner, ChaumPedersenVerifier};
 use crate::dual_scalar_mul::DualScalarMultiplication;
-use crate::chaum_pedersen_signature::DLEQProof;
 use crate::serialize::SerializableToBytes;
 use crate::single::{Keypair, KeypairVT, PublicKey, SecretKey, SecretKeyVT, Signature};
 use crate::{EngineBLS, Message, Signed};
@@ -34,8 +34,6 @@ use crate::{EngineBLS, Message, Signed};
 pub struct PublicKeyInSignatureGroup<E: EngineBLS>(pub E::SignatureGroup);
 broken_derives!(PublicKeyInSignatureGroup); // Actually the derive works for this one, not sure why.
 
-//TODO: Make a type for a sister group. This makes sense because SisterGroup it doesn't mean on itself
-// SisterGroup<E: EngineBLS> = CurveGroup + PrimeGroup<ScalarField = E::Scalar> + SerializableToBytes
 /// Wrapper for a point in the third curve sister group which is supposed to
 /// have the same logarithm as the public key in the public key group
 #[derive(Debug, Clone, Copy, PartialEq, Eq, CanonicalDeserialize)]
@@ -238,10 +236,10 @@ where
     type M = Message;
     type PKG = PublicKey<E>;
 
-    type PKnM = ::core::iter::Once<(Message, PublicKey<E>)>;
-
-    fn messages_and_publickeys(self) -> Self::PKnM {
-        once((self.message.clone(), self.publickey.into_bls_public_key())) // TODO:  Avoid clone
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<Item = (Message, PublicKey<E>)> + ExactSizeIterator {
+        once((self.message.clone(), self.publickey.into_bls_public_key()))
     }
 
     fn signature(&self) -> Signature<E> {
diff --git a/src/pop_aggregator.rs b/src/pop_aggregator.rs
index fda966f..2c8f6a7 100644
--- a/src/pop_aggregator.rs
+++ b/src/pop_aggregator.rs
@@ -112,7 +112,11 @@ impl<E: EngineBLS> SignatureAggregatorAssumingPoP<E> {
     /// distinct message ends up paired with a single aggregated key.
     /// If the public key carries an auxiliary key in the signature group,
     /// it is automatically aggregated as well.
-    pub fn add_message_n_publickey(&mut self, message: &Message, publickey: &impl GeneralizedBLSPublicKey<E>) {
+    pub fn add_message_n_publickey(
+        &mut self,
+        message: &Message,
+        publickey: &impl GeneralizedBLSPublicKey<E>,
+    ) {
         let pk = publickey.public_key();
         let aux = publickey.public_key_in_signature_group();
         self.messages_n_publickeys
@@ -146,9 +150,7 @@ impl<E: EngineBLS> SignatureAggregatorAssumingPoP<E> {
                 existing_aux.0 += &aux.0;
                 Ok(())
             }
-            Some(_) => {
-                Err("message already exists with a different public key")
-            }
+            Some(_) => Err("message already exists with a different public key"),
             None => {
                 self.messages_n_publickeys
                     .insert(message.clone(), (*publickey, *aux));
@@ -187,9 +189,15 @@ impl<'a, E: EngineBLS> Signed for &'a SignatureAggregatorAssumingPoP<E> {
 
     type M = &'a Message;
     type PKG = &'a (PublicKey<E>, PublicKeyInSignatureGroup<E>);
-    type PKnM = alloc::collections::btree_map::Iter<'a, Message, (PublicKey<E>, PublicKeyInSignatureGroup<E>)>;
 
-    fn messages_and_publickeys(self) -> Self::PKnM {
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<
+        Item = (
+            &'a Message,
+            &'a (PublicKey<E>, PublicKeyInSignatureGroup<E>),
+        ),
+    > + ExactSizeIterator {
         self.messages_n_publickeys.iter()
     }
 
@@ -216,8 +224,8 @@ mod tests {
     use crate::Message;
     use crate::TinyBLS;
     use crate::UsualBLS;
-    use rand::SeedableRng;
     use rand::rngs::StdRng;
+    use rand::SeedableRng;
     use sha2::Sha256;
 
     use ark_bls12_377::Bls12_377;
@@ -229,8 +237,9 @@ mod tests {
     fn verify_aggregate_single_message_single_signer() {
         let good = Message::new(b"ctx", b"test message");
 
-        let mut keypair =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([0u8; 32]));
+        let mut keypair = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([0u8; 32]),
+        );
         let good_sig0 = keypair.sign(&good);
         assert!(good_sig0.verify(&good, &keypair.public));
     }
@@ -239,17 +248,18 @@ mod tests {
     fn verify_aggregate_single_message_multi_signers() {
         let good = Message::new(b"ctx", b"test message");
 
-        let mut keypair0 =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([0u8; 32]));
+        let mut keypair0 = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([0u8; 32]),
+        );
         let good_sig0 = keypair0.sign(&good);
 
-        let mut keypair1 =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([1u8; 32]));
+        let mut keypair1 = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([1u8; 32]),
+        );
         let good_sig1 = keypair1.sign(&good);
 
-        let mut aggregated_sigs = SignatureAggregatorAssumingPoP::<
-            UsualBLS<Bls12_381, ark_bls12_381::Config>,
-        >::new();
+        let mut aggregated_sigs =
+            SignatureAggregatorAssumingPoP::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::new();
         aggregated_sigs.add_signature(&good_sig0);
         aggregated_sigs.add_signature(&good_sig1);
 
@@ -267,15 +277,15 @@ mod tests {
         let good0 = Message::new(b"ctx", b"Tab over Space");
         let good1 = Message::new(b"ctx", b"Space over Tab");
 
-        let mut keypair =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([0u8; 32]));
+        let mut keypair = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([0u8; 32]),
+        );
 
         let good_sig0 = keypair.sign(&good0);
         let good_sig1 = keypair.sign(&good1);
 
-        let mut aggregated_sigs = SignatureAggregatorAssumingPoP::<
-            UsualBLS<Bls12_381, ark_bls12_381::Config>,
-        >::new();
+        let mut aggregated_sigs =
+            SignatureAggregatorAssumingPoP::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::new();
         aggregated_sigs.add_signature(&good_sig0);
         aggregated_sigs.add_signature(&good_sig1);
 
@@ -293,17 +303,18 @@ mod tests {
         let good0 = Message::new(b"ctx", b"in the beginning");
         let good1 = Message::new(b"ctx", b"there was a flying spaghetti monster");
 
-        let mut keypair0 =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([0u8; 32]));
+        let mut keypair0 = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([0u8; 32]),
+        );
         let good_sig0 = keypair0.sign(&good0);
 
-        let mut keypair1 =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([1u8; 32]));
+        let mut keypair1 = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([1u8; 32]),
+        );
         let good_sig1 = keypair1.sign(&good1);
 
-        let mut aggregated_sigs = SignatureAggregatorAssumingPoP::<
-            UsualBLS<Bls12_381, ark_bls12_381::Config>,
-        >::new();
+        let mut aggregated_sigs =
+            SignatureAggregatorAssumingPoP::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::new();
         aggregated_sigs.add_signature(&good_sig0);
         aggregated_sigs.add_signature(&good_sig1);
 
@@ -320,13 +331,13 @@ mod tests {
     fn verify_aggregate_single_message_repetative_signers() {
         let good = Message::new(b"ctx", b"test message");
 
-        let mut keypair =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([0u8; 32]));
+        let mut keypair = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([0u8; 32]),
+        );
         let good_sig = keypair.sign(&good);
 
-        let mut aggregated_sigs = SignatureAggregatorAssumingPoP::<
-            UsualBLS<Bls12_381, ark_bls12_381::Config>,
-        >::new();
+        let mut aggregated_sigs =
+            SignatureAggregatorAssumingPoP::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::new();
         aggregated_sigs.add_signature(&good_sig);
         aggregated_sigs.add_signature(&good_sig);
 
@@ -344,17 +355,18 @@ mod tests {
         let good0 = Message::new(b"ctx", b"Space over Tab");
         let bad1 = Message::new(b"ctx", b"Tab over Space");
 
-        let mut keypair0 =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([0u8; 32]));
+        let mut keypair0 = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([0u8; 32]),
+        );
         let good_sig0 = keypair0.sign(&good0);
 
-        let mut keypair1 =
-            Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(StdRng::from_seed([1u8; 32]));
+        let mut keypair1 = Keypair::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::generate(
+            StdRng::from_seed([1u8; 32]),
+        );
         let bad_sig1 = keypair1.sign(&bad1);
 
-        let mut aggregated_sigs = SignatureAggregatorAssumingPoP::<
-            UsualBLS<Bls12_381, ark_bls12_381::Config>,
-        >::new();
+        let mut aggregated_sigs =
+            SignatureAggregatorAssumingPoP::<UsualBLS<Bls12_381, ark_bls12_381::Config>>::new();
         aggregated_sigs.add_signature(&good_sig0);
         aggregated_sigs.add_signature(&bad_sig1);
 
@@ -372,7 +384,11 @@ mod tests {
         let message = Message::new(b"ctx", b"test message");
         let mut keypairs: Vec<_> = (0..3)
             .into_iter()
-            .map(|i| Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed([i; 32])))
+            .map(|i| {
+                Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed(
+                    [i; 32],
+                ))
+            })
             .collect();
         let pub_keys_in_sig_grp: Vec<PublicKeyInSignatureGroup<TinyBLS377>> = keypairs
             .iter()
@@ -406,7 +422,12 @@ mod tests {
             verifier_aggregator.add_message_n_publickey(msg, pk);
         }
 
-        let aggregated_pk = (&prover_aggregator).messages_and_publickeys().next().unwrap().1.0;
+        let aggregated_pk = (&prover_aggregator)
+            .messages_and_publickeys()
+            .next()
+            .unwrap()
+            .1
+             .0;
         for aux in &pub_keys_in_sig_grp {
             verifier_aggregator
                 .aggregate_aux_publickey_for_message_n_publickey(&message, &aggregated_pk, aux)
@@ -425,13 +446,25 @@ mod tests {
             bad_verifier.add_message_n_publickey(msg, pk);
         }
         bad_verifier
-            .aggregate_aux_publickey_for_message_n_publickey(&message, &aggregated_pk, &pub_keys_in_sig_grp[1])
+            .aggregate_aux_publickey_for_message_n_publickey(
+                &message,
+                &aggregated_pk,
+                &pub_keys_in_sig_grp[1],
+            )
             .unwrap();
         bad_verifier
-            .aggregate_aux_publickey_for_message_n_publickey(&message, &aggregated_pk, &pub_keys_in_sig_grp[1])
+            .aggregate_aux_publickey_for_message_n_publickey(
+                &message,
+                &aggregated_pk,
+                &pub_keys_in_sig_grp[1],
+            )
             .unwrap();
         bad_verifier
-            .aggregate_aux_publickey_for_message_n_publickey(&message, &aggregated_pk, &pub_keys_in_sig_grp[2])
+            .aggregate_aux_publickey_for_message_n_publickey(
+                &message,
+                &aggregated_pk,
+                &pub_keys_in_sig_grp[2],
+            )
             .unwrap();
 
         assert!(
@@ -463,7 +496,11 @@ mod tests {
             .map(|i| Message::new(b"ctx", &[b'm', b'0' + i as u8]))
             .collect();
         let mut keypairs: Vec<_> = (0..3)
-            .map(|i| Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed([i; 32])))
+            .map(|i| {
+                Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed(
+                    [i; 32],
+                ))
+            })
             .collect();
         let pub_keys_in_sig_grp: Vec<PublicKeyInSignatureGroup<TinyBLS377>> = keypairs
             .iter()
@@ -478,7 +515,11 @@ mod tests {
         // Prover: each signer signs their own distinct message.
         let mut prover_aggregator = SignatureAggregatorAssumingPoP::<TinyBLS377>::new();
 
-        for ((k, m), aux) in keypairs.iter_mut().zip(messages.iter()).zip(pub_keys_in_sig_grp.iter()) {
+        for ((k, m), aux) in keypairs
+            .iter_mut()
+            .zip(messages.iter())
+            .zip(pub_keys_in_sig_grp.iter())
+        {
             prover_aggregator.add_signature(&k.sign(m));
             prover_aggregator.add_message_n_publickey(m, &(k.public, *aux));
         }
@@ -543,7 +584,11 @@ mod tests {
             .map(|i| Message::new(b"ctx", &[b'm', b'0' + i as u8]))
             .collect();
         let mut keypairs: Vec<_> = (0..3)
-            .map(|i| Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed([i; 32])))
+            .map(|i| {
+                Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed(
+                    [i; 32],
+                ))
+            })
             .collect();
         let pub_keys_in_sig_grp: Vec<PublicKeyInSignatureGroup<TinyBLS377>> = keypairs
             .iter()
@@ -557,7 +602,11 @@ mod tests {
 
         // Prover: signs real messages honestly.
         let mut prover_aggregator = SignatureAggregatorAssumingPoP::<TinyBLS377>::new();
-        for ((i, k), aux) in keypairs.iter_mut().enumerate().zip(pub_keys_in_sig_grp.iter()) {
+        for ((i, k), aux) in keypairs
+            .iter_mut()
+            .enumerate()
+            .zip(pub_keys_in_sig_grp.iter())
+        {
             prover_aggregator.add_signature(&k.sign(&real_messages[i]));
             prover_aggregator.add_message_n_publickey(&real_messages[i], &(k.public, *aux));
         }
@@ -579,7 +628,11 @@ mod tests {
         for (i, (_msg, pk)) in prover_entries.iter().enumerate() {
             let wrong_message = &real_messages[(i + 1) % real_messages.len()];
             verifier_aggregator
-                .aggregate_aux_publickey_for_message_n_publickey(wrong_message, pk, &pub_keys_in_sig_grp[i])
+                .aggregate_aux_publickey_for_message_n_publickey(
+                    wrong_message,
+                    pk,
+                    &pub_keys_in_sig_grp[i],
+                )
                 .expect("public key should match");
         }
 
@@ -609,20 +662,25 @@ mod tests {
             .map(|i| Message::new(b"ctx", &[b'm', b'0' + i as u8]))
             .collect();
         let mut keypairs: Vec<_> = (0..3)
-            .map(|i| Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed([i; 32])))
+            .map(|i| {
+                Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed(
+                    [i; 32],
+                ))
+            })
             .collect();
         // The verifier's list: every signer's public key together with
         // its auxiliary key in the signature group.
-        let signer_list: Vec<(PublicKey<TinyBLS377>, PublicKeyInSignatureGroup<TinyBLS377>)> = keypairs
-            .iter()
-            .map(|k| {
-                let aux = nugget::NuggetBLS::<
-                    TinyBLS<Bls12_377, ark_bls12_377::Config>,
-                    <TinyBLS<Bls12_377, ark_bls12_377::Config> as EngineBLS>::SignatureGroup,
-                >::into_public_key_in_signature_group(k);
-                (k.public, aux)
-            })
-            .collect();
+        let signer_list: Vec<(PublicKey<TinyBLS377>, PublicKeyInSignatureGroup<TinyBLS377>)> =
+            keypairs
+                .iter()
+                .map(|k| {
+                    let aux = nugget::NuggetBLS::<
+                        TinyBLS<Bls12_377, ark_bls12_377::Config>,
+                        <TinyBLS<Bls12_377, ark_bls12_377::Config> as EngineBLS>::SignatureGroup,
+                    >::into_public_key_in_signature_group(k);
+                    (k.public, aux)
+                })
+                .collect();
 
         // Per-message participation bitfield: bit i set iff signer i
         // participated. m0 ← {0,1} = 0b011 ; m1 ← {1,2} = 0b110.
@@ -740,18 +798,23 @@ mod tests {
             .map(|i| Message::new(b"ctx", &[b'm', b'0' + i as u8]))
             .collect();
         let mut keypairs: Vec<_> = (0..2)
-            .map(|i| Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed([i; 32])))
-            .collect();
-        let signer_list: Vec<(PublicKey<TinyBLS377>, PublicKeyInSignatureGroup<TinyBLS377>)> = keypairs
-            .iter()
-            .map(|k| {
-                let aux = nugget::NuggetBLS::<
-                    TinyBLS<Bls12_377, ark_bls12_377::Config>,
-                    <TinyBLS<Bls12_377, ark_bls12_377::Config> as EngineBLS>::SignatureGroup,
-                >::into_public_key_in_signature_group(k);
-                (k.public, aux)
+            .map(|i| {
+                Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed(
+                    [i; 32],
+                ))
             })
             .collect();
+        let signer_list: Vec<(PublicKey<TinyBLS377>, PublicKeyInSignatureGroup<TinyBLS377>)> =
+            keypairs
+                .iter()
+                .map(|k| {
+                    let aux = nugget::NuggetBLS::<
+                        TinyBLS<Bls12_377, ark_bls12_377::Config>,
+                        <TinyBLS<Bls12_377, ark_bls12_377::Config> as EngineBLS>::SignatureGroup,
+                    >::into_public_key_in_signature_group(k);
+                    (k.public, aux)
+                })
+                .collect();
 
         // Same signers participate in every message.
         let bitfields: [u8; 2] = [0b11, 0b11];
@@ -891,7 +954,11 @@ mod tests {
     fn aux_key_verifier_rejects_aggregator_without_aux_keys() {
         let message = Message::new(b"ctx", b"test message");
         let mut keypairs: Vec<_> = (0..3)
-            .map(|i| Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed([i; 32])))
+            .map(|i| {
+                Keypair::<TinyBLS<Bls12_377, ark_bls12_377::Config>>::generate(StdRng::from_seed(
+                    [i; 32],
+                ))
+            })
             .collect();
 
         let mut aggregator = SignatureAggregatorAssumingPoP::<TinyBLS377>::new();
diff --git a/src/single.rs b/src/single.rs
index 86e2d1b..9e74970 100644
--- a/src/single.rs
+++ b/src/single.rs
@@ -19,9 +19,8 @@
 //! improved performance enough then we instead suggest tweaking
 //! `CurveGroup::add_mixed` to test for normalized points.
 //!
-//! TODO: Add serde support for serialization throughout.  See
-//!  https://github.com/ebfull/pairing/pull/87#issuecomment-402397091
-//!  https://github.com/poanetwork/hbbft/blob/38178af1244ddeca27f9d23750ca755af6e886ee/src/crypto/serde_impl.rs#L95
+//! Serialization for Public Keys and Signatures is provided via
+//! [`SerializableToBytes`](crate::serialize::SerializableToBytes)
 
 use alloc::{vec, vec::Vec};
 
@@ -152,9 +151,6 @@ impl<E: EngineBLS> SecretKeyVT<E> {
 /// methods of `SecretKeyVT`, so roughly
 /// `SecretKeyVT::from_repr(SecretKeyVT::read(reader) ?) ?.into_split(thread_rng())`.
 ///
-/// TODO: Provide sensible `to_bytes` and `from_bytes` methods
-/// for `ZBLS` and `TinyBLS<..>`.
-///
 /// TODO: Is Pippenger’s algorithm, or another fast MSM algorithm,
 /// secure when used with key splitting?
 
@@ -162,9 +158,12 @@ impl<E: EngineBLS> SecretKeyVT<E> {
 /// key splitting.
 #[derive(ZeroizeOnDrop)]
 pub struct SecretKey<E: EngineBLS> {
-    #[zeroize] key: [E::Scalar; 2],
-    #[zeroize] old_unsigned: E::SignatureGroup,
-    #[zeroize] old_signed: E::SignatureGroup,
+    #[zeroize]
+    key: [E::Scalar; 2],
+    #[zeroize]
+    old_unsigned: E::SignatureGroup,
+    #[zeroize]
+    old_signed: E::SignatureGroup,
 }
 
 impl<E: EngineBLS> Clone for SecretKey<E> {
@@ -393,7 +392,6 @@ where
     E: EngineBLS,
 {
     fn check(&self) -> Result<(), SerializationError> {
-        //TODO probabaly turn into vartime and check that because vartime impl valid
         match (self.key[0].check(), self.key[1].check()) {
             (Ok(()), Ok(())) => Ok(()),
             _ => Err(SerializationError::InvalidData),
@@ -462,7 +460,6 @@ impl<E: EngineBLS> SerializableToBytes for SecretKey<E> {
 /// Detached BLS Signature
 #[derive(Debug, CanonicalSerialize, CanonicalDeserialize)]
 pub struct Signature<E: EngineBLS>(pub E::SignatureGroup);
-// TODO: Serialization
 
 broken_derives!(Signature); // Actually the derive works for this one, not sure why.
 
@@ -472,7 +469,7 @@ impl<E: EngineBLS> Signature<E> {
     /// Verify a single BLS signature
     pub fn verify(&self, message: &Message, publickey: &PublicKey<E>) -> bool {
         let pk_affine: <E as EngineBLS>::PublicKeyGroupAffine = publickey.0.into();
-        //This is redundant if we have verified public key's PoP which reject out of subgroup keys 
+        //This is redundant if we have verified public key's PoP which reject out of subgroup keys
         if !E::verify_public_key_in_public_key_subgroup(&pk_affine) {
             return false;
         }
@@ -490,7 +487,6 @@ impl<E: EngineBLS> Signature<E> {
 /// BLS Public Key
 #[derive(Debug, CanonicalSerialize, CanonicalDeserialize)]
 pub struct PublicKey<E: EngineBLS>(pub E::PublicKeyGroup);
-// TODO: Serialization
 
 // impl<E: EngineBLS> PublicKey<E> where E: DeserializePublicKey {
 //     pub fn i_have_checked_this_proof_of_possession(self) -> PublicKey<PoP<E>> {
@@ -499,7 +495,6 @@ pub struct PublicKey<E: EngineBLS>(pub E::PublicKeyGroup);
 // }
 
 broken_derives!(PublicKey);
-//serialization!(PublicKey,PublicKeyGroup,EngineBLS,EngineBLS);
 
 impl<E: EngineBLS> PublicKey<E> {
     //const DESCRIPTION : &'static str = "A BLS signature";
@@ -529,7 +524,6 @@ impl<E: EngineBLS> Clone for KeypairVT<E> {
     }
 }
 
-// TODO: Serialization
 impl<E: EngineBLS> KeypairVT<E> {
     /// Generate a `Keypair`
     pub fn generate<R: Rng>(rng: R) -> Self {
@@ -584,7 +578,6 @@ impl<E: EngineBLS> Clone for Keypair<E> {
     }
 }
 
-// TODO: Serialization
 impl<E: EngineBLS> Keypair<E> {
     /// Generate a `Keypair`
     pub fn generate<R: Rng>(rng: R) -> Self {
@@ -644,7 +637,6 @@ pub struct SignedMessage<E: EngineBLS> {
     pub publickey: PublicKey<E>,
     pub signature: Signature<E>,
 }
-// TODO: Serialization
 
 // borrow_wrapper!(Signature,SignatureGroup,signature);
 // borrow_wrapper!(PublicKey,PublicKeyGroup,publickey);
@@ -662,13 +654,13 @@ impl<E: EngineBLS> Eq for SignedMessage<E> {}
 impl<'a, E: EngineBLS> Signed for &'a SignedMessage<E> {
     type E = E;
 
-    type M = Message;
+    type M = &'a Message;
     type PKG = PublicKey<E>;
 
-    type PKnM = ::core::iter::Once<(Message, PublicKey<E>)>;
-
-    fn messages_and_publickeys(self) -> Self::PKnM {
-        once((self.message.clone(), self.publickey)) // TODO:  Avoid clone
+    fn messages_and_publickeys(
+        self,
+    ) -> impl Iterator<Item = (&'a Message, PublicKey<E>)> + ExactSizeIterator {
+        once((&self.message, self.publickey))
     }
 
     fn signature(&self) -> Signature<E> {
@@ -990,6 +982,4 @@ mod tests {
             random_seed.as_slice(),
         );
     }
-
-
 }
diff --git a/src/verifiers.rs b/src/verifiers.rs
index df90210..cc95b09 100644
--- a/src/verifiers.rs
+++ b/src/verifiers.rs
@@ -8,7 +8,7 @@ use core::borrow::Borrow;
 // We use BTreeMap instead of HashMap for no_std compatibility.
 use alloc::collections::BTreeMap;
 use ark_ec::AffineRepr;
-use ark_ff::{field_hashers::{DefaultFieldHasher, HashToField}};
+use ark_ff::field_hashers::{DefaultFieldHasher, HashToField};
 use ark_serialize::CanonicalSerialize;
 use digest::FixedOutputReset;
 
@@ -103,8 +103,6 @@ fn collect_messages_and_publickeys<S: Signed>(
 /// parallel.  This might mean (a) some sort function using
 /// `ops::IndexMut` instead of slices, and (b) wrapper types to make
 /// tuples of slices satisfy `ops::IndexMut`.
-// TODO:  Impl PartialEq, Eq, Hash for pairing::EncodedPoint
-// to avoid  struct H(E::PublicKeyGroup::Affine::Uncompressed);
 fn merge_by_signer<E: EngineBLS>(
     affine_publickeys: Vec<PublicKeyAffine<E>>,
     messages: Vec<SignatureProjective<E>>,
@@ -141,11 +139,7 @@ fn merge_by_signer_with_aux<E: EngineBLS>(
         SignatureProjective<E>,
     );
     let mut map: BTreeMap<Vec<u8>, PkAuxMsg<E>> = BTreeMap::new();
-    for ((pk, aux), m) in affine_publickeys
-        .into_iter()
-        .zip(aux_keys)
-        .zip(messages)
-    {
+    for ((pk, aux), m) in affine_publickeys.into_iter().zip(aux_keys).zip(messages) {
         let aux_affine = aux.into_affine();
         let mut pk_bytes = vec![0; pk.uncompressed_size()];
         pk.serialize_uncompressed(&mut pk_bytes[..]).unwrap();
@@ -186,7 +180,6 @@ fn normalize_publickeys<E: EngineBLS>(
     }
 }
 
-
 /// Batch-normalize message points together with the aggregate signature,
 /// returning the affine messages and the affine signature separately.
 // TODO: Assess if we could cache normalized message hashes anyplace
@@ -241,8 +234,7 @@ pub fn verify_unoptimized<S: Signed>(s: S) -> bool {
 pub fn verify_simple<S: Signed>(s: S) -> bool {
     let (signature, publickeys, messages) = collect_messages_and_publickeys(s);
     let affine_pks = PublicKeyProjective::<S::E>::normalize_batch(&publickeys);
-    let (affine_msgs, affine_sig) =
-        normalize_messages_and_signature::<S::E>(messages, signature);
+    let (affine_msgs, affine_sig) = normalize_messages_and_signature::<S::E>(messages, signature);
     verify_normalized::<S::E>(&affine_pks, &affine_msgs, affine_sig)
 }
 
@@ -343,15 +335,13 @@ pub fn verify_using_aggregated_auxiliary_public_keys<
 
     // Merge message points that share the same signer.
     // Returns None if same public key appears with conflicting aux keys.
-    let (merged_pks, merged_aux, mut merged_msgs) = match
-        merge_by_signer_with_aux::<S::E>(affine_publickeys, aux_keys, messages)
-    {
-        Some(v) => v,
-        None => return false,
-    };
+    let (merged_pks, merged_aux, mut merged_msgs) =
+        match merge_by_signer_with_aux::<S::E>(affine_publickeys, aux_keys, messages) {
+            Some(v) => v,
+            None => return false,
+        };
 
-    let hasher =
-        <DefaultFieldHasher<H> as HashToField<<S::E as EngineBLS>::Scalar>>::new(&[]);
+    let hasher = <DefaultFieldHasher<H> as HashToField<<S::E as EngineBLS>::Scalar>>::new(&[]);
 
     // Build the transcript once:
     //   asig || (msg_1 || apk1_1 || apk2_1) || ... || (msg_n || apk1_n || apk2_n)
@@ -364,8 +354,7 @@ pub fn verify_using_aggregated_auxiliary_public_keys<
 
     let entry_size = 2 * <S::E as EngineBLS>::SIGNATURE_SERIALIZED_SIZE
         + <S::E as EngineBLS>::PUBLICKEY_SERIALIZED_SIZE;
-    let transcript_size =
-        <S::E as EngineBLS>::SIGNATURE_SERIALIZED_SIZE + n * entry_size;
+    let transcript_size = <S::E as EngineBLS>::SIGNATURE_SERIALIZED_SIZE + n * entry_size;
     // Reserve a little extra for the per-entry index suffix used by t_i (i >= 2).
     let mut seed = Vec::with_capacity(transcript_size + core::mem::size_of::<u64>());
     seed.extend_from_slice(&signature_as_bytes);
@@ -700,12 +689,14 @@ mod tests {
     fn verify_prepared_accepts_cofactor_components() {
         let bad = signed_with_g1_cofactor_pk();
         let prepared_pk = <EB as EngineBLS>::prepare_public_key(bad.publickey.0);
-        let prepared_msg = <EB as EngineBLS>::prepare_signature(
-            bad.message.hash_to_signature_curve::<EB>(),
-        );
+        let prepared_msg =
+            <EB as EngineBLS>::prepare_signature(bad.message.hash_to_signature_curve::<EB>());
         let prepared_sig = <EB as EngineBLS>::prepare_signature(bad.signature.0);
         let pairs = [(prepared_pk, prepared_msg)];
-        assert!(<EB as EngineBLS>::verify_prepared(prepared_sig, pairs.iter()));
+        assert!(<EB as EngineBLS>::verify_prepared(
+            prepared_sig,
+            pairs.iter()
+        ));
     }
 
     #[test]