Fix wrong constant hash to curve function

src/engine.rs

@@ -102,16 +102,9 @@ pub trait EngineBLS {
 
     /// Hash one message to the signature curve.
     fn hash_to_signature_curve<M: Borrow<[u8]>>(message: M) -> Self::SignatureGroup {
-
-    // TODO::arbitrary seed just to make it compile should come from the message
-    let seed = [
-        1, 0, 0, 0, 23, 0, 0, 0, 200, 1, 0, 0, 210, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0,
-    ];
-
-        let mut myrng = rand::rngs::StdRng::from_seed(seed);
+	let mut myrng = rand::rngs::StdRng::from_seed(*array_ref![message.borrow(),0,32]);
         <Self::SignatureGroup as UniformRand>::rand(&mut myrng)
-    }
+    }␎
 
     /// Run the Miller loop from `Engine` but orients its arguments
     /// to be a `SignatureGroup` and `PublicKeyGroup`.

src/single.rs

@@ -547,7 +547,7 @@ impl<E: EngineBLS> Signature<E> {
         //   let message = s[0].into_affine().prepare();
         //   let signature = s[1].into_affine().prepare();
         // TODO: Compare benchmarks on variants
-        E::verify_prepared( signature, once( & (publickey,message)) )
+        E::verify_prepared( signature,  &[(publickey,message)] )
     }
 }
 
@@ -827,7 +827,8 @@ mod tests {
         let good = Message::new(b"ctx",b"test message");
 
         let mut keypair  = Keypair::<ZBLS>::generate(thread_rng());
-        let good_sig = zbls_usual_bytes_test(keypair.sign(good));
+        let good_sig0 = keypair.sign(good);
+        let good_sig = zbls_usual_bytes_test(good_sig0);
         assert!(good_sig.verify_slow());
 
         let keypair_vt = keypair.into_vartime();
@@ -836,18 +837,24 @@ mod tests {
         assert!( good_sig == keypair_vt.sign(good) );
 
         let bad = Message::new(b"ctx",b"wrong message");
-        let bad_sig = zbls_usual_bytes_test(keypair.sign(bad));
+        let bad_sig0 = keypair.sign(bad);
+	let bad_sig = zbls_usual_bytes_test(bad_sig0);
         assert!( bad_sig == keypair.into_vartime().sign(bad) );
+
         assert!( bad_sig.verify() );
 
         let another = Message::new(b"ctx",b"another message");
         let another_sig = keypair.sign(another);
         assert!( another_sig == keypair.into_vartime().sign(another) );
         assert!( another_sig.verify() );
 
+
         assert!(keypair.public.verify(good, &good_sig.signature),
                 "Verification of a valid signature failed!");
-
+
+	assert!(good != bad, "good == bad");
+	assert!(good_sig.signature != bad_sig.signature, "good sig == bad sig");
+
         assert!(!keypair.public.verify(good, &bad_sig.signature),
                 "Verification of a signature on a different message passed!");
         assert!(!keypair.public.verify(bad, &good_sig.signature),