Implement MuSig2 multisignature scheme

schnorr_fun/src/adaptor/mod.rs

@@ -110,7 +110,7 @@ where
         // key before decrypting it
         r.conditional_negate(needs_negation);
 
-        let c = self.challenge(&R.to_xonly(), X, message);
+        let c = self.challenge(R.to_xonly(), X, message);
         let s_hat = s!(r + c * x).mark::<Public>();
 
         EncryptedSignature {
@@ -216,7 +216,7 @@ where
         // !needs_negation => R_hat = R - Y
         let R_hat = g!(R + { Y.conditional_negate(!needs_negation) });
 
-        let c = self.challenge(&R.to_xonly(), &X.to_xonly(), message);
+        let c = self.challenge(R.to_xonly(), X.to_xonly(), message);
 
         R_hat == g!(s_hat * { self.G() } - c * X)
     }

schnorr_fun/src/keypair.rs

@@ -28,8 +28,8 @@ impl KeyPair {
     }
 
     /// Returns a reference to the public key.
-    pub fn public_key(&self) -> &XOnly {
-        &self.pk
+    pub fn public_key(&self) -> XOnly {
+        self.pk
     }
 
     /// Gets a reference to the key-pair as a tuple
@@ -39,8 +39,8 @@ impl KeyPair {
     /// # use schnorr_fun::{Schnorr, fun::Scalar};
     /// # let keypair = schnorr_fun::test_instance!().new_keypair(Scalar::one());
     /// let (secret_key, public_key) = keypair.as_tuple();
-    pub fn as_tuple(&self) -> (&Scalar, &XOnly) {
-        (&self.sk, &self.pk)
+    pub fn as_tuple(&self) -> (&Scalar, XOnly) {
+        (&self.sk, self.pk)
     }
 
     /// Returns the full `Point<EvenY>` for the public key which is used in [`verify`].

schnorr_fun/src/schnorr.rs

@@ -111,7 +111,7 @@ where
         );
 
         let R = XOnly::from_scalar_mul(&self.G, &mut r);
-        let c = self.challenge(&R, X, message);
+        let c = self.challenge(R, X, message);
         let s = s!(r + c * x).mark::<Public>();
 
         Signature { R, s }
@@ -168,20 +168,15 @@ impl<NG, CH: Digest<OutputSize = U32> + Clone, GT> Schnorr<CH, NG, GT> {
     /// let keypair = schnorr.new_keypair(Scalar::random(&mut rand::thread_rng()));
     /// let mut r = Scalar::random(&mut rand::thread_rng());
     /// let R = XOnly::from_scalar_mul(schnorr.G(), &mut r);
-    /// let challenge = schnorr.challenge(&R, keypair.public_key(), message);
+    /// let challenge = schnorr.challenge(R, keypair.public_key(), message);
     /// let s = s!(r + challenge * { keypair.secret_key() });
     /// let signature = Signature { R, s };
     /// assert!(schnorr.verify(&keypair.verification_key(), message, &signature));
     /// ```
     ///
     /// [BIP-340]: https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki
     /// [`Secrecy`]: secp256kfun::marker::Secrecy
-    pub fn challenge<S: Secrecy>(
-        &self,
-        R: &XOnly,
-        X: &XOnly,
-        m: Message<'_, S>,
-    ) -> Scalar<S, Zero> {
+    pub fn challenge<S: Secrecy>(&self, R: XOnly, X: XOnly, m: Message<'_, S>) -> Scalar<S, Zero> {
         let hash = self.challenge_hash.clone();
         let challenge = Scalar::from_hash(hash.add(R).add(X).add(&m));
 
@@ -228,9 +223,9 @@ impl<NG, CH: Digest<OutputSize = U32> + Clone, GT> Schnorr<CH, NG, GT> {
     ) -> bool {
         let X = public_key;
         let (R, s) = signature.as_tuple();
-        let c = self.challenge(R, &X.to_xonly(), message);
+        let c = self.challenge(R, X.to_xonly(), message);
         let R_implied = g!(s * self.G - c * X).mark::<Normal>();
-        R_implied == *R
+        R_implied == R
     }
 
     /// _Anticipates_ a Schnorr signature given the nonce `R` that will be used ahead of time.
@@ -242,7 +237,7 @@ impl<NG, CH: Digest<OutputSize = U32> + Clone, GT> Schnorr<CH, NG, GT> {
         R: &Point<EvenY, impl Secrecy>,
         m: Message<'_, impl Secrecy>,
     ) -> Point<Jacobian, Public, Zero> {
-        let c = self.challenge(&R.to_xonly(), &X.to_xonly(), m);
+        let c = self.challenge(R.to_xonly(), X.to_xonly(), m);
         g!(R + c * X)
     }
 }

schnorr_fun/src/signature.rs

@@ -47,8 +47,8 @@ impl<S> Signature<S> {
     /// # let signature = schnorr_fun::Signature::random(&mut rand::thread_rng());
     /// let (R, s) = signature.as_tuple();
     /// ```
-    pub fn as_tuple(&self) -> (&XOnly, &Scalar<S, Zero>) {
-        (&self.R, &self.s)
+    pub fn as_tuple(&self) -> (XOnly, &Scalar<S, Zero>) {
+        (self.R, &self.s)
     }
 
     /// Marks the signature with a [`Secrecy`]. If it is marked as `Secret` the

schnorr_fun/tests/bip340.rs

@@ -50,7 +50,7 @@ fn signing_test_vectors() {
         let secret_key = Scalar::<Secret, NonZero>::from_str(line[1]).unwrap();
         let expected_public_key = XOnly::from_str(line[2]).unwrap();
         let keypair = bip340.new_keypair(secret_key);
-        assert_eq!(keypair.public_key(), &expected_public_key);
+        assert_eq!(keypair.public_key(), expected_public_key);
         let message = hex::decode(line[4]).unwrap();
         let signature = bip340.sign(&keypair, Message::<Public>::raw(&message));
         let expected_signature = Signature::<Public>::from_str(line[5]).unwrap();