diff --git a/examples/sign_verify_recovery.rs b/examples/sign_verify_recovery.rs
index f1d22d4c7..627bbdc13 100644
--- a/examples/sign_verify_recovery.rs
+++ b/examples/sign_verify_recovery.rs
@@ -11,14 +11,14 @@ fn recover<C: Verification>(secp: &Secp256k1<C>,msg: &[u8],sig: [u8; 64],recover
     let id = ecdsa::RecoveryId::from_i32(recovery_id as i32)?;
     let sig = ecdsa::RecoverableSignature::from_compact(&sig, id)?;
 
-    secp.recover(&msg, &sig)
+    secp.recover_ecdsa(&msg, &sig)
 }
 
 fn sign_recovery<C: Signing>(secp: &Secp256k1<C>, msg: &[u8], seckey: [u8; 32]) -> Result<ecdsa::RecoverableSignature, Error> {
     let msg = sha256::Hash::hash(msg);
     let msg = Message::from_slice(&msg)?;
     let seckey = SecretKey::from_slice(&seckey)?;
-    Ok(secp.sign_recoverable(&msg, &seckey))
+    Ok(secp.sign_ecdsa_recoverable(&msg, &seckey))
 }
 
 fn main() {
diff --git a/no_std_test/src/main.rs b/no_std_test/src/main.rs
index f6ecd9517..d245ce9dd 100644
--- a/no_std_test/src/main.rs
+++ b/no_std_test/src/main.rs
@@ -106,14 +106,14 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
     let public_key = PublicKey::from_secret_key(&secp, &secret_key);
     let message = Message::from_slice(&[0xab; 32]).expect("32 bytes");
 
-    let sig = secp.sign(&message, &secret_key);
-    assert!(secp.verify(&message, &sig, &public_key).is_ok());
+    let sig = secp.sign_ecdsa(&message, &secret_key);
+    assert!(secp.verify_ecdsa(&message, &sig, &public_key).is_ok());
 
-    let rec_sig = secp.sign_recoverable(&message, &secret_key);
-    assert!(secp.verify(&message, &rec_sig.to_standard(), &public_key).is_ok());
-    assert_eq!(public_key, secp.recover(&message, &rec_sig).unwrap());
+    let rec_sig = secp.sign_ecdsa_recoverable(&message, &secret_key);
+    assert!(secp.verify_ecdsa(&message, &rec_sig.to_standard(), &public_key).is_ok());
+    assert_eq!(public_key, secp.recover_ecdsa(&message, &rec_sig).unwrap());
     let (rec_id, data) = rec_sig.serialize_compact();
-    let new_rec_sig = recovery::RecoverableSignature::from_compact(&data, rec_id).unwrap();
+    let new_rec_sig = ecdsa::RecoverableSignature::from_compact(&data, rec_id).unwrap();
     assert_eq!(rec_sig, new_rec_sig);
 
     let mut cbor_ser = [0u8; 100];
@@ -121,7 +121,7 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
     let mut ser = Serializer::new(writer);
     sig.serialize(&mut ser).unwrap();
     let size = ser.into_inner().bytes_written();
-    let new_sig: Signature = de::from_mut_slice(&mut cbor_ser[..size]).unwrap();
+    let new_sig: ecdsa::Signature = de::from_mut_slice(&mut cbor_ser[..size]).unwrap();
     assert_eq!(sig, new_sig);
 
     let _ = SharedSecret::new(&public_key, &secret_key);
diff --git a/src/ecdsa/recovery.rs b/src/ecdsa/recovery.rs
index 5901615b1..eb32284b8 100644
--- a/src/ecdsa/recovery.rs
+++ b/src/ecdsa/recovery.rs
@@ -146,9 +146,14 @@ impl From<ffi::RecoverableSignature> for RecoverableSignature {
 impl<C: Signing> Secp256k1<C> {
     /// Constructs a signature for `msg` using the secret key `sk` and RFC6979 nonce
     /// Requires a signing-capable context.
-    pub fn sign_recoverable(&self, msg: &Message, sk: &key::SecretKey)
-                            -> RecoverableSignature {
+    #[deprecated(since = "0.21.0", note = "Use sign_ecdsa_recoverable instead.")]
+    pub fn sign_recoverable(&self, msg: &Message, sk: &key::SecretKey) -> RecoverableSignature {
+        self.sign_ecdsa_recoverable(msg, sk)
+    }
 
+    /// Constructs a signature for `msg` using the secret key `sk` and RFC6979 nonce
+    /// Requires a signing-capable context.
+    pub fn sign_ecdsa_recoverable(&self, msg: &Message, sk: &key::SecretKey) -> RecoverableSignature {
         let mut ret = ffi::RecoverableSignature::new();
         unsafe {
             // We can assume the return value because it's not possible to construct
@@ -173,7 +178,14 @@ impl<C: Signing> Secp256k1<C> {
 impl<C: Verification> Secp256k1<C> {
     /// Determines the public key for which `sig` is a valid signature for
     /// `msg`. Requires a verify-capable context.
-    pub fn recover(&self, msg: &Message, sig: &RecoverableSignature)
+    #[deprecated(since = "0.21.0", note = "Use recover_ecdsa instead.")]
+    pub fn recover(&self, msg: &Message, sig: &RecoverableSignature) -> Result<key::PublicKey, Error> {
+        self.recover_ecdsa(msg, sig)
+    }
+
+    /// Determines the public key for which `sig` is a valid signature for
+    /// `msg`. Requires a verify-capable context.
+    pub fn recover_ecdsa(&self, msg: &Message, sig: &RecoverableSignature)
                    -> Result<key::PublicKey, Error> {
 
         unsafe {