Add musig combine

Author: jonasnick

build.rs

@@ -55,7 +55,8 @@ fn main() {
                .define("USE_ENDOMORPHISM", Some("1"))
                .define("ENABLE_MODULE_ECDH", Some("1"))
                .define("ENABLE_MODULE_RECOVERY", Some("1"))
-               .define("ENABLE_MODULE_SCHNORRSIG", Some("1"));
+               .define("ENABLE_MODULE_SCHNORRSIG", Some("1"))
+               .define("ENABLE_MODULE_MUSIG", Some("1"));
 
     if let Ok(target_endian) = env::var("CARGO_CFG_TARGET_ENDIAN") {
         if target_endian == "big" {

src/ffi.rs

@@ -82,4 +82,13 @@ extern "C" {
         pk: *const *const PublicKey,
         n_sigs: usize,
     ) -> c_int;
+
+    pub fn secp256k1_musig_pubkey_combine(
+        cx: *const Context,
+        scratch: *mut ScratchSpace,
+        combined_pk: *mut PublicKey,
+        pk_hash32: *mut c_uchar,
+        pubkeys: *const PublicKey,
+        n_pubkeys: usize,
+    ) -> c_int;
 }

src/lib.rs

@@ -39,6 +39,7 @@ pub extern crate secp256k1;
 mod macros;
 pub mod ffi;
 pub mod schnorrsig;
+pub mod musig;
 mod test_utils;
 
 /// TODO: Scratch space doc

src/musig.rs

@@ -0,0 +1,71 @@
+// secp256k1-zkp bindings
+// Written in 2019 by
+//   Jonas Nick
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to
+// the public domain worldwide. This software is distributed without
+// any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software.
+// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+//
+
+//! # MuSig
+//! Support for bip-schnorr compliant multisignatures in the plain-pubkey model
+//!
+
+use std::{ptr, mem};
+
+use secp256k1::{self, Secp256k1, Verification};
+use secp256k1::key::PublicKey;
+
+use ffi;
+
+pub trait Verify {
+    fn combine(&self, pks: &[PublicKey]) -> PublicKey;
+}
+
+impl<C: Verification> Verify for Secp256k1<C> {
+    // TODO: doc want to combine a collection of keys
+    fn combine(&self, pks: &[PublicKey]) -> PublicKey {
+        let mut pkptrs = Vec::with_capacity(pks.len());
+        for pk in pks {
+            pkptrs.push(pk.as_ptr());
+        }
+        unsafe {
+            let mut pk: PublicKey = mem::uninitialized();
+            // TODO
+            // scratch space is NULL so only error can be
+            // due to keys adding up to infinity
+            assert_eq!(ffi::secp256k1_musig_pubkey_combine(*self.ctx(),
+                                                           ptr::null_mut(),
+                                                           pk.as_mut_ptr(),
+                                                           ptr::null_mut(),
+                                                           pks[0].as_ptr(),
+                                                           pks.len()), 1);
+            pk
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use rand::thread_rng;
+    use secp256k1::{Secp256k1};
+    use super::Verify;
+    use test_utils::GenerateKeypair;
+
+    #[test]
+    fn combine() {
+        let s = Secp256k1::new();
+        let mut pks = vec![];
+        for _ in 0..10 {
+            let (_, pk) = s.generate_keypair(&mut thread_rng());
+            pks.push(pk);
+        }
+        let combined = s.combine(&pks);
+        println!("{}", combined);
+    }
+}
+