test: add secp256k1 v0.30.0 patch testing (#2234)

Author: leruaa

patch-testing/secp256k1/build.rs

@@ -1,3 +1,12 @@
+use sp1_build::BuildArgs;
+
 fn main() {
-    sp1_build::build_program("./program");
+    sp1_build::build_program_with_args(
+        "./program",
+        BuildArgs { features: vec!["v0-29-1".to_string()], ..Default::default() },
+    );
+    sp1_build::build_program_with_args(
+        "./program",
+        BuildArgs { features: vec!["v0-30-0".to_string()], ..Default::default() },
+    );
 }

patch-testing/secp256k1/program/Cargo.toml

@@ -7,15 +7,41 @@ edition = "2021"
 [[bin]]
 name = "secp256k1_verify"
 path = "bin/verify.rs"
+required-features = ["v0-29-1"]
 
 [[bin]]
 name = "secp256k1_recover"
 path = "bin/recover.rs"
+required-features = ["v0-29-1"]
+
+
+[[bin]]
+name = "secp256k1_verify_v0_30_0"
+path = "bin/verify.rs"
+required-features = ["v0-30-0"]
+
+[[bin]]
+name = "secp256k1_recover_v0_30_0"
+path = "bin/recover.rs"
+required-features = ["v0-30-0"]
 
 [dependencies]
 sp1-zkvm = { path = "../../../crates/zkvm/entrypoint" }
 serde = { version = "1.0.215", features = ["derive"] }
-secp256k1 = { git = "https://github.com/sp1-patches/rust-secp256k1", tag = "patch-0.29.1-sp1-4.1.0", features = ["recovery", "global-context", "rand", "serde"] }
+secp256k1-v0-29-1 = { git = "https://github.com/sp1-patches/rust-secp256k1", package = "secp256k1", tag = "patch-0.29.1-sp1-4.1.0", features = [
+    "recovery",
+    "global-context",
+    "serde",
+], optional = true }
+secp256k1-v0-30-0 = { git = "https://github.com/sp1-patches/rust-secp256k1", package = "secp256k1", tag = "patch-0.30.0-sp1-4.1.0", features = [
+    "recovery",
+    "global-context",
+    "serde",
+], optional = true }
+
+[features]
+v0-29-1 = ["dep:secp256k1-v0-29-1"]
+v0-30-0 = ["dep:secp256k1-v0-30-0"]
 
 [patch.crates-io]
 sp1-lib = { path = "../../../crates/zkvm/lib" }

patch-testing/secp256k1/program/bin/recover.rs

@@ -1,8 +1,15 @@
 #![no_main]
 sp1_zkvm::entrypoint!(main);
 
+#[cfg(feature = "v0-29-1")]
+extern crate secp256k1_v0_29_1 as secp256k1;
+
+#[cfg(feature = "v0-30-0")]
+extern crate secp256k1_v0_30_0 as secp256k1;
+
 use secp256k1::{
-    ecdsa::{RecoverableSignature, RecoveryId}, PublicKey, Message, Secp256k1
+    ecdsa::{RecoverableSignature, RecoveryId},
+    Message, PublicKey, Secp256k1,
 };
 
 pub fn main() {
@@ -18,13 +25,22 @@ fn inner_recover() -> Option<PublicKey> {
     let recid: i32 = sp1_zkvm::io::read();
     let msg = sp1_zkvm::io::read_vec();
     let sig: [u8; 64] = sp1_zkvm::io::read_vec().try_into().unwrap();
-    
-    let recid= RecoveryId::from_i32(recid).unwrap();
+
+    #[cfg(feature = "v0-29-1")]
+    let recid = RecoveryId::from_i32(recid).unwrap();
+
+    #[cfg(feature = "v0-30-0")]
+    let recid = RecoveryId::try_from(recid).unwrap();
+
     let message = Message::from_digest_slice(&msg).unwrap();
-    let sig = RecoverableSignature::from_compact(&sig, recid).unwrap(); 
-    
+    let sig = RecoverableSignature::from_compact(&sig, recid).unwrap();
+
     let secp = Secp256k1::new();
+    #[cfg(feature = "v0-29-1")]
     let recovered = secp.recover_ecdsa(&message, &sig);
-    
+
+    #[cfg(feature = "v0-30-0")]
+    let recovered = secp.recover_ecdsa(message, &sig);
+
     recovered.ok()
 }

patch-testing/secp256k1/program/bin/verify.rs

@@ -1,10 +1,13 @@
 #![no_main]
 sp1_zkvm::entrypoint!(main);
 
-use secp256k1::{
-    ecdsa::Signature,
-    Message, PublicKey,
-};
+#[cfg(feature = "v0-29-1")]
+extern crate secp256k1_v0_29_1 as secp256k1;
+
+#[cfg(feature = "v0-30-0")]
+extern crate secp256k1_v0_30_0 as secp256k1;
+
+use secp256k1::{ecdsa::Signature, Message, PublicKey};
 
 pub fn main() {
     let times = sp1_zkvm::io::read::<u8>();
@@ -25,5 +28,11 @@ fn inner_verify() -> bool {
 
     let secp = secp256k1::Secp256k1::new();
 
-    secp.verify_ecdsa(&message, &signature, &pubkey).is_ok()
+    #[cfg(feature = "v0-29-1")]
+    let ok = secp.verify_ecdsa(&message, &signature, &pubkey).is_ok();
+
+    #[cfg(feature = "v0-30-0")]
+    let ok = secp.verify_ecdsa(message, &signature, &pubkey).is_ok();
+
+    ok
 }

patch-testing/secp256k1/src/lib.rs

@@ -1,82 +1,107 @@
 #[cfg(test)]
-use secp256k1::{Message, PublicKey, Secp256k1};
+mod tests {
+    use secp256k1::{Message, PublicKey, Secp256k1};
+
+    #[sp1_test::sp1_test("secp256k1_recover", syscalls = [SECP256K1_DOUBLE, SECP256K1_ADD], prove)]
+    fn test_recover_rand_lte_100(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
+        recover_rand_lte_100(stdin)
+    }
 
-#[sp1_test::sp1_test("secp256k1_recover", syscalls = [SECP256K1_DOUBLE, SECP256K1_ADD])]
-fn test_recover_rand_lte_100(
-    stdin: &mut sp1_sdk::SP1Stdin,
-) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
-    let times = 100_u8;
+    #[sp1_test::sp1_test("secp256k1_recover_v0_30_0", syscalls = [SECP256K1_DOUBLE, SECP256K1_ADD], prove)]
+    fn test_recover_v0_30_0_rand_lte_100(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
+        recover_rand_lte_100(stdin)
+    }
 
-    stdin.write(&times);
+    fn recover_rand_lte_100(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
+        let times = 100_u8;
 
-    let secp = Secp256k1::new();
+        stdin.write(&times);
 
-    let mut pubkeys = Vec::with_capacity(times.into());
-    for _ in 0..times {
-        let mut rng = rand::thread_rng();
-        let (secret, public) = secp.generate_keypair(&mut rng);
+        let secp = Secp256k1::new();
 
-        pubkeys.push(public);
+        let mut pubkeys = Vec::with_capacity(times.into());
+        for _ in 0..times {
+            let mut rng = rand::thread_rng();
+            let (secret, public) = secp.generate_keypair(&mut rng);
 
-        let msg = rand::random::<[u8; 32]>();
-        let msg = Message::from_digest_slice(&msg).unwrap();
+            pubkeys.push(public);
 
-        let signature = secp.sign_ecdsa_recoverable(&msg, &secret);
+            let msg = rand::random::<[u8; 32]>();
+            let msg = Message::from_digest_slice(&msg).unwrap();
 
-        // Verify that the unpatched version of this function recovers as expected.
-        assert_eq!(secp.recover_ecdsa(&msg, &signature).unwrap(), public);
+            let signature = secp.sign_ecdsa_recoverable(&msg, &secret);
 
-        let (recid, sig) = signature.serialize_compact();
+            // Verify that the unpatched version of this function recovers as expected.
+            assert_eq!(secp.recover_ecdsa(&msg, &signature).unwrap(), public);
 
-        let recid = recid.to_i32();
+            let (recid, sig) = signature.serialize_compact();
 
-        stdin.write(&recid);
-        stdin.write(msg.as_ref());
-        stdin.write_slice(sig.as_slice());
-    }
+            let recid = recid.to_i32();
 
-    move |mut public| {
-        println!("checking publioc values");
-        for key in pubkeys {
-            assert_eq!(public.read::<Option<PublicKey>>(), Some(key));
+            stdin.write(&recid);
+            stdin.write(msg.as_ref());
+            stdin.write_slice(sig.as_slice());
+        }
+
+        move |mut public| {
+            println!("checking public values");
+            for key in pubkeys {
+                assert_eq!(public.read::<Option<PublicKey>>(), Some(key));
+            }
         }
     }
-}
 
-#[sp1_test::sp1_test("secp256k1_verify", syscalls = [SECP256K1_DOUBLE, SECP256K1_ADD])]
-fn test_verify_rand_lte_100(
-    stdin: &mut sp1_sdk::SP1Stdin,
-) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
-    let times = 100_u8;
-    stdin.write(&times);
+    #[sp1_test::sp1_test("secp256k1_verify", syscalls = [SECP256K1_DOUBLE, SECP256K1_ADD], prove)]
+    fn test_verify_rand_lte_100(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
+        verify_rand_lte_100(stdin)
+    }
+
+    #[sp1_test::sp1_test("secp256k1_verify_v0_30_0", syscalls = [SECP256K1_DOUBLE, SECP256K1_ADD], prove)]
+    fn test_verify_v0_30_0_rand_lte_100(
+        stdin: &mut sp1_sdk::SP1Stdin,
+    ) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
+        verify_rand_lte_100(stdin)
+    }
 
-    let secp = Secp256k1::new();
+    fn verify_rand_lte_100(stdin: &mut sp1_sdk::SP1Stdin) -> impl FnOnce(sp1_sdk::SP1PublicValues) {
+        let times = 100_u8;
+        stdin.write(&times);
 
-    for _ in 0..times {
-        let mut rng = rand::thread_rng();
-        let (secret, public) = secp.generate_keypair(&mut rng);
+        let secp = Secp256k1::new();
 
-        let msg = rand::random::<[u8; 32]>();
-        let msg = Message::from_digest_slice(&msg).unwrap();
+        for _ in 0..times {
+            let mut rng = rand::thread_rng();
+            let (secret, public) = secp.generate_keypair(&mut rng);
 
-        let signature = secp.sign_ecdsa(&msg, &secret);
+            let msg = rand::random::<[u8; 32]>();
+            let msg = Message::from_digest_slice(&msg).unwrap();
 
-        // verify the unpatched version of the function verifies as expected
-        assert!(secp.verify_ecdsa(&msg, &signature, &public).is_ok());
+            let signature = secp.sign_ecdsa(&msg, &secret);
 
-        let msg = msg.as_ref().to_vec();
-        let signature = signature.serialize_der().to_vec();
+            // verify the unpatched version of the function verifies as expected
+            assert!(secp.verify_ecdsa(&msg, &signature, &public).is_ok());
 
-        stdin.write_vec(msg);
-        stdin.write_vec(signature);
-        stdin.write(&public);
-    }
+            let msg = msg.as_ref().to_vec();
+            let signature = signature.serialize_der().to_vec();
 
-    move |mut public| {
-        for _ in 0..times {
-            assert!(public.read::<bool>());
+            stdin.write_vec(msg);
+            stdin.write_vec(signature);
+            stdin.write(&public);
+        }
+
+        move |mut public| {
+            for _ in 0..times {
+                assert!(public.read::<bool>());
+            }
         }
     }
 }
-
 // add cases for fail verify, although its not patched