converts msg to [u8] slice

crates/chia-bls/src/cached_bls.rs

@@ -46,16 +46,16 @@ impl BLSCache {
         Self { cache }
     }
 
-    pub fn get_pairings<P: Borrow<[[u8; 48]]>, M: Borrow<[Vec<u8>]>>(
+    pub fn get_pairings<P: Borrow<[[u8; 48]]>, M: AsRef<[u8]>>(
         &mut self,
         pks: &P,
-        msgs: &M,
+        msgs: &[M],
         force_cache: bool,
     ) -> Vec<GTElement> {
         let mut pairings: Vec<Option<GTElement>> = vec![];
         let mut missing_count: usize = 0;
 
-        for (pk, msg) in pks.borrow().iter().zip(msgs.borrow().iter()) {
+        for (pk, msg) in pks.borrow().iter().zip(msgs.iter()) {
             let mut hasher = Sha256::new();
             hasher.update(pk);
             hasher.update(msg); // pk + msg
@@ -90,7 +90,7 @@ impl BLSCache {
                 ret.push(pairing.clone());
             } else {
                 let mut aug_msg = pks.borrow()[i].to_vec();
-                aug_msg.extend_from_slice(&msgs.borrow()[i]); // pk + msg
+                aug_msg.extend_from_slice(msgs[i].as_ref()); // pk + msg
                 let aug_hash: Signature = hash_to_g2(&aug_msg);
 
                 let pk_parsed: &mut PublicKey = pk_bytes_to_g1
@@ -112,16 +112,16 @@ impl BLSCache {
     pub fn aggregate_verify(
         &mut self,
         pks: &Vec<[u8; 48]>,
-        msgs: &Vec<Vec<u8>>,
+        msgs: &Vec<&[u8]>,
         sig: &Signature,
         force_cache: bool,
     ) -> bool {
         let mut pairings: Vec<GTElement> = self.get_pairings(pks, msgs, force_cache);
         if pairings.is_empty() {
-            let mut data = Vec::<(PublicKey, Vec<u8>)>::new();
+            let mut data = Vec::<(PublicKey, &[u8])>::new();
             for (pk, msg) in pks.iter().zip(msgs.iter()) {
                 let pk = PublicKey::from_bytes_unchecked(pk).unwrap();
-                data.push((pk.clone(), msg.clone()));
+                data.push((pk.clone(), msg));
             }
             return agg_ver(sig, data);
         }
@@ -167,9 +167,9 @@ impl BLSCache {
             .iter()
             .map(|item| item.extract::<[u8; 48]>())
             .collect::<PyResult<_>>()?;
-        let msgs_r: Vec<Vec<u8>> = msgs
+        let msgs_r: Vec<&[u8]> = msgs
             .iter()
-            .map(|item| item.extract::<Vec<u8>>())
+            .map(|item| item.extract::<&[u8]>())
             .collect::<PyResult<_>>()?;
         let force_cache_bool = force_cache.extract::<bool>()?;
         Ok(self.aggregate_verify(&pks_r, &msgs_r, sig, force_cache_bool))
@@ -213,10 +213,10 @@ pub mod tests {
         let byte_array: [u8; 32] = [0; 32];
         let sk: SecretKey = SecretKey::from_seed(&byte_array);
         let pk: PublicKey = sk.public_key();
-        let msg: Vec<u8> = vec![106; 32];
+        let msg: &[u8] = &[106; 32];
         let sig: Signature = sign(&sk, &msg);
         let pk_list: Vec<[u8; 48]> = [pk.to_bytes()].to_vec();
-        let msg_list: Vec<Vec<u8>> = [msg].to_vec();
+        let msg_list: Vec<&[u8]> = [msg].to_vec();
         assert!(bls_cache.aggregate_verify(&pk_list, &msg_list, &sig, true));
         assert_eq!(bls_cache.cache.len(), 1);
         // try again with (pk, msg) cached
@@ -231,26 +231,26 @@ pub mod tests {
         let byte_array: [u8; 32] = [0; 32];
         let sk: SecretKey = SecretKey::from_seed(&byte_array);
         let pk: PublicKey = sk.public_key();
-        let msg: Vec<u8> = vec![106; 32];
+        let msg: &[u8] = &[106; 32];
         let sig: Signature = sign(&sk, &msg);
         let mut pk_list: Vec<[u8; 48]> = [pk.to_bytes()].to_vec();
-        let mut msg_list: Vec<Vec<u8>> = [msg].to_vec();
+        let mut msg_list: Vec<&[u8]> = [msg].to_vec();
         // add first to cache
         // try one cached, one not cached
         assert!(bls_cache.aggregate_verify(&pk_list, &msg_list, &sig, false));
         assert_eq!(bls_cache.cache.len(), 1);
         let byte_array: [u8; 32] = [1; 32];
         let sk: SecretKey = SecretKey::from_seed(&byte_array);
         let pk: PublicKey = sk.public_key();
-        let msg: Vec<u8> = vec![107; 32];
+        let msg: &[u8] = &[107; 32];
         let sig = aggregate([sig, sign(&sk, &msg)]);
         pk_list.push(pk.to_bytes());
         msg_list.push(msg);
         assert!(bls_cache.aggregate_verify(&pk_list, &msg_list, &sig, false));
         assert_eq!(bls_cache.cache.len(), 2);
         // try reusing a pubkey
         let pk: PublicKey = sk.public_key();
-        let msg: Vec<u8> = vec![108; 32];
+        let msg: &[u8] = &[108; 32];
         let sig = aggregate([sig, sign(&sk, &msg)]);
         pk_list.push(pk.to_bytes());
         msg_list.push(msg);
@@ -272,10 +272,10 @@ pub mod tests {
             let byte_array: [u8; 32] = [i as u8; 32];
             let sk: SecretKey = SecretKey::from_seed(&byte_array);
             let pk: PublicKey = sk.public_key();
-            let msg: Vec<u8> = vec![106; 32];
+            let msg: &[u8] = &[106; 32];
             let sig: Signature = sign(&sk, &msg);
             let pk_list: Vec<[u8; 48]> = vec![pk.to_bytes()];
-            let msg_list: Vec<Vec<u8>> = vec![msg];
+            let msg_list: Vec<&[u8]> = vec![msg];
             assert!(bls_cache.aggregate_verify(&pk_list, &msg_list, &sig, true));
         }
         assert_eq!(bls_cache.cache.len(), 3);