recovery: rewrite API to not use context objects

This API is basically unused except for some niche or legacy
applications, so I feel comfortable breaking it pretty dramatically.

Move all the Secp256k1 functions onto RecoverableSignature and use
self/Self as appropriate.

Leave the stupid ecdsa_recoverable names even though they are even more
redundant, because this module is basically in maintenance mode. We only
do these changes since we'll be forced to once we drop the Secp256k1
object.

Author: chain-forgexcr45

Cargo.toml

@@ -57,7 +57,7 @@ unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(secp256k1_fu
 
 [[example]]
 name = "sign_verify_recovery"
-required-features = ["recovery", "std"]
+required-features = ["recovery"]
 
 [[example]]
 name = "sign_verify"

examples/sign_verify_recovery.rs

@@ -1,33 +1,25 @@
 extern crate secp256k1;
 
-use secp256k1::{ecdsa, Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification};
+use secp256k1::{ecdsa, Error, Message, PublicKey, SecretKey};
 
-fn recover<C: Verification>(
-    secp: &Secp256k1<C>,
-    msg_digest: [u8; 32],
-    sig: [u8; 64],
-    recovery_id: u8,
-) -> Result<PublicKey, Error> {
-    let msg = Message::from_digest(msg_digest);
+fn recover(msg_digest: [u8; 32], sig: [u8; 64], recovery_id: u8) -> Result<PublicKey, Error> {
     let id = ecdsa::RecoveryId::try_from(i32::from(recovery_id))?;
     let sig = ecdsa::RecoverableSignature::from_compact(&sig, id)?;
+    let msg = Message::from_digest(msg_digest);
 
-    secp.recover_ecdsa(msg, &sig)
+    sig.recover_ecdsa(msg)
 }
 
-fn sign_recovery<C: Signing>(
-    secp: &Secp256k1<C>,
+fn sign_recovery(
     msg_digest: [u8; 32],
     seckey: [u8; 32],
 ) -> Result<ecdsa::RecoverableSignature, Error> {
     let msg = Message::from_digest(msg_digest);
     let seckey = SecretKey::from_byte_array(seckey)?;
-    Ok(secp.sign_ecdsa_recoverable(msg, &seckey))
+    Ok(ecdsa::RecoverableSignature::sign_ecdsa_recoverable(msg, &seckey))
 }
 
 fn main() {
-    let secp = Secp256k1::new();
-
     let seckey = [
         59, 148, 11, 85, 134, 130, 61, 253, 2, 174, 59, 70, 27, 180, 51, 107, 94, 203, 174, 253,
         102, 39, 170, 146, 46, 252, 4, 143, 236, 12, 136, 28,
@@ -39,9 +31,9 @@ fn main() {
     .unwrap();
     let msg_digest = *b"this must be secure hash output.";
 
-    let signature = sign_recovery(&secp, msg_digest, seckey).unwrap();
+    let signature = sign_recovery(msg_digest, seckey).unwrap();
 
     let (recovery_id, serialize_sig) = signature.serialize_compact();
 
-    assert_eq!(recover(&secp, msg_digest, serialize_sig, recovery_id.to_u8()), Ok(pubkey));
+    assert_eq!(recover(msg_digest, serialize_sig, recovery_id.to_u8()), Ok(pubkey));
 }

no_std_test/src/main.rs

@@ -51,26 +51,18 @@ use core::panic::PanicInfo;
 
 use secp256k1::ecdh::{self, SharedSecret};
 use secp256k1::ffi::types::AlignedType;
-use secp256k1::rand::{self, RngCore};
+use secp256k1::rand::RngCore;
 use secp256k1::serde::Serialize;
 use secp256k1::*;
-
-use serde_cbor::de;
 use serde_cbor::ser::SliceWrite;
-use serde_cbor::Serializer;
+use serde_cbor::{de, Serializer};
 
-fn abort() -> ! {
-    unsafe { libc::abort() }
-}
+fn abort() -> ! { unsafe { libc::abort() } }
 
 struct FakeRng;
 impl RngCore for FakeRng {
-    fn next_u32(&mut self) -> u32 {
-        57
-    }
-    fn next_u64(&mut self) -> u64 {
-        57
-    }
+    fn next_u32(&mut self) -> u32 { 57 }
+    fn next_u64(&mut self) -> u64 { 57 }
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         for i in dest {
             *i = 57;
@@ -93,9 +85,9 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
     let sig = secp.sign_ecdsa(message, &secret_key);
     assert!(secp.verify_ecdsa(&sig, message, &public_key).is_ok());
 
-    let rec_sig = secp.sign_ecdsa_recoverable(message, &secret_key);
+    let rec_sig = ecdsa::RecoverableSignature::sign_ecdsa_recoverable(message, &secret_key);
     assert!(secp.verify_ecdsa(&rec_sig.to_standard(), message, &public_key).is_ok());
-    assert_eq!(public_key, secp.recover_ecdsa(message, &rec_sig).unwrap());
+    assert_eq!(public_key, rec_sig.recover_ecdsa(message).unwrap());
     let (rec_id, data) = rec_sig.serialize_compact();
     let new_rec_sig = ecdsa::RecoverableSignature::from_compact(&data, rec_id).unwrap();
     assert_eq!(rec_sig, new_rec_sig);
@@ -133,12 +125,7 @@ struct Print {
 }
 
 impl Print {
-    pub fn new() -> Self {
-        Self {
-            loc: 0,
-            buf: [0u8; 512],
-        }
-    }
+    pub fn new() -> Self { Self { loc: 0, buf: [0u8; 512] } }
 
     pub fn print(&self) {
         unsafe {