Update secp256k1 to edition 2018 and fix imports

Author: elichai

Cargo.toml

@@ -10,7 +10,7 @@ documentation = "https://docs.rs/secp256k1/"
 description = "Rust wrapper library for Pieter Wuille's `libsecp256k1`. Implements ECDSA and BIP 340 signatures for the SECG elliptic curve group secp256k1 and related utilities."
 keywords = [ "crypto", "ECDSA", "secp256k1", "libsecp256k1", "bitcoin" ]
 readme = "README.md"
-autoexamples = false # Remove when edition 2018 https://github.com/rust-lang/cargo/issues/5330
+edition = "2018"
 
 # Should make docs.rs show all functions, even those behind non-default features
 [package.metadata.docs.rs]

clippy.toml

@@ -1 +1 @@
-msrv = "1.29"
+msrv = "1.41.1"

src/context.rs

@@ -1,9 +1,9 @@
 use core::marker::PhantomData;
 use core::mem::ManuallyDrop;
-use ffi::{self, CPtr, types::AlignedType};
-use ffi::types::{c_uint, c_void};
-use Error;
-use Secp256k1;
+
+use crate::{Error, Secp256k1};
+use crate::ffi::{self, CPtr, types::AlignedType};
+use crate::ffi::types::{c_uint, c_void};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
@@ -13,12 +13,11 @@ pub use self::alloc_only::*;
 #[cfg_attr(docsrs, doc(cfg(all(feature = "global-context", feature = "std"))))]
 /// Module implementing a singleton pattern for a global `Secp256k1` context.
 pub mod global {
-    #[cfg(feature = "rand-std")]
-    use rand;
 
     use std::ops::Deref;
     use std::sync::Once;
-    use {Secp256k1, All};
+
+    use crate::{All, Secp256k1};
 
     /// Proxy struct for global `SECP256K1` context.
     #[derive(Debug, Copy, Clone)]
@@ -107,10 +106,16 @@ mod private {
 #[cfg(any(feature = "std", feature = "alloc"))]
 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
 mod alloc_only {
-    #[cfg(feature = "std")]
-    use std::alloc;
     #[cfg(not(feature = "std"))]
     use alloc::alloc;
+    #[cfg(feature = "std")]
+    use std::alloc;
+
+    use core::marker::PhantomData;
+
+    use super::private;
+    use crate::ffi::{self, types::{c_uint, c_void}};
+    use crate::{Secp256k1, Signing, Verification, Context, AlignedType};
 
     #[cfg(feature = "rand-std")]
     use rand;
@@ -119,8 +124,7 @@ mod alloc_only {
     impl private::Sealed for All {}
     impl private::Sealed for VerifyOnly {}
 
-    use super::*;
-    const ALIGN_TO: usize = ::core::mem::align_of::<AlignedType>();
+    const ALIGN_TO: usize = core::mem::align_of::<AlignedType>();
 
     /// Represents the set of capabilities needed for signing.
     #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]

src/ecdh.rs

@@ -15,14 +15,11 @@
 //! Support for shared secret computations.
 //!
 
-use core::{ptr, str};
-use core::borrow::Borrow;
+use core::{borrow::Borrow, ptr, str};
 
-use {Error, from_hex};
-use key::{SecretKey, PublicKey};
-use ffi::{self, CPtr};
 use secp256k1_sys::types::{c_int, c_uchar, c_void};
-use constants;
+
+use crate::{constants, Error, ffi::{self, CPtr}, key::{PublicKey, SecretKey}};
 
 // The logic for displaying shared secrets relies on this (see `secret.rs`).
 const SHARED_SECRET_SIZE: usize = constants::SECRET_KEY_SIZE;
@@ -97,7 +94,7 @@ impl str::FromStr for SharedSecret {
     type Err = Error;
     fn from_str(s: &str) -> Result<SharedSecret, Error> {
         let mut res = [0u8; SHARED_SECRET_SIZE];
-        match from_hex(s, &mut res) {
+        match crate::from_hex(s, &mut res) {
             Ok(SHARED_SECRET_SIZE) => Ok(SharedSecret::from_bytes(res)),
             _ => Err(Error::InvalidSharedSecret)
         }
@@ -177,7 +174,7 @@ impl ::serde::Serialize for SharedSecret {
     fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         if s.is_human_readable() {
             let mut buf = [0u8; SHARED_SECRET_SIZE * 2];
-            s.serialize_str(::to_hex(&self.0, &mut buf).expect("fixed-size hex serialization"))
+            s.serialize_str(crate::to_hex(&self.0, &mut buf).expect("fixed-size hex serialization"))
         } else {
             s.serialize_bytes(&self.as_ref()[..])
         }
@@ -204,13 +201,13 @@ impl<'de> ::serde::Deserialize<'de> for SharedSecret {
 #[cfg(test)]
 #[allow(unused_imports)]
 mod tests {
-    use super::*;
     use rand::thread_rng;
-    use super::super::Secp256k1;
-
     #[cfg(target_arch = "wasm32")]
     use wasm_bindgen_test::wasm_bindgen_test as test;
 
+    use crate::Secp256k1;
+    use super::SharedSecret;
+
     #[test]
     #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn ecdh() {
@@ -230,7 +227,7 @@ mod tests {
         let x = [5u8; 32];
         let y = [7u8; 32];
         let mut output = [0u8; 64];
-        let res = unsafe { super::c_callback(output.as_mut_ptr(), x.as_ptr(), y.as_ptr(), ptr::null_mut()) };
+        let res = unsafe { super::c_callback(output.as_mut_ptr(), x.as_ptr(), y.as_ptr(), core::ptr::null_mut()) };
         assert_eq!(res, 1);
         let mut new_x = [0u8; 32];
         let mut new_y = [0u8; 32];
@@ -244,7 +241,8 @@ mod tests {
     #[cfg(not(fuzzing))]
     #[cfg(all(feature="rand-std", feature = "std", feature = "bitcoin_hashes"))]
     fn bitcoin_hashes_and_sys_generate_same_secret() {
-        use hashes::{sha256, Hash, HashEngine};
+        use bitcoin_hashes::{sha256, Hash, HashEngine};
+        use crate::ecdh::shared_secret_point;
 
         let s = Secp256k1::signing_only();
         let (sk1, _) = s.generate_keypair(&mut thread_rng());
@@ -292,11 +290,13 @@ mod tests {
 
 #[cfg(all(test, feature = "unstable"))]
 mod benches {
-    use rand::thread_rng;
     use test::{Bencher, black_box};
 
+    use rand::thread_rng;
+
+    use crate::Secp256k1;
+
     use super::SharedSecret;
-    use super::super::Secp256k1;
 
     #[bench]
     pub fn bench_ecdh(bh: &mut Bencher) {

src/ecdsa/mod.rs

@@ -2,8 +2,8 @@
 
 use core::{fmt, str, ops, ptr, mem};
 
-use {Signing, Verification, Message, PublicKey, Secp256k1, SecretKey, from_hex, Error, ffi};
-use ffi::CPtr;
+use crate::{Signing, Verification, Message, PublicKey, Secp256k1, SecretKey, from_hex, Error, ffi};
+use crate::ffi::CPtr;
 
 #[cfg(feature = "recovery")]
 mod recovery;
@@ -13,7 +13,7 @@ mod recovery;
 pub use self::recovery::{RecoveryId, RecoverableSignature};
 
 #[cfg(feature = "global-context")]
-use SECP256K1;
+use crate::SECP256K1;
 
 /// An ECDSA signature
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -304,8 +304,8 @@ impl From<ffi::Signature> for Signature {
 
 #[cfg(feature = "serde")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
-impl ::serde::Serialize for Signature {
-    fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+impl serde::Serialize for Signature {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         if s.is_human_readable() {
             s.collect_str(self)
         } else {
@@ -316,14 +316,14 @@ impl ::serde::Serialize for Signature {
 
 #[cfg(feature = "serde")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
-impl<'de> ::serde::Deserialize<'de> for Signature {
-    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+impl<'de> serde::Deserialize<'de> for Signature {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
         if d.is_human_readable() {
-            d.deserialize_str(::serde_util::FromStrVisitor::new(
+            d.deserialize_str(crate::serde_util::FromStrVisitor::new(
                 "a hex string representing a DER encoded Signature"
             ))
         } else {
-            d.deserialize_bytes(::serde_util::BytesVisitor::new(
+            d.deserialize_bytes(crate::serde_util::BytesVisitor::new(
                 "raw byte stream, that represents a DER encoded Signature",
                 Signature::from_der
             ))

src/ecdsa/recovery.rs

@@ -18,12 +18,10 @@
 //!
 
 use core::ptr;
-use key;
+use crate::{key, Secp256k1, Message, Error, Verification, Signing, ecdsa::Signature};
 use super::ffi as super_ffi;
 use self::super_ffi::CPtr;
-use ffi::recovery as ffi;
-use super::*;
-use {Verification, Secp256k1, Signing, Message};
+use crate::ffi::recovery as ffi;
 
 /// A tag used for recovering the public key from a compact signature.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -127,7 +125,7 @@ impl RecoverableSignature {
     #[cfg(feature = "global-context")]
     #[cfg_attr(docsrs, doc(cfg(feature = "global-context")))]
     pub fn recover(&self, msg: &Message) -> Result<key::PublicKey, Error> {
-        SECP256K1.recover_ecdsa(msg, self)
+        crate::SECP256K1.recover_ecdsa(msg, self)
     }
 }
 
@@ -235,9 +233,10 @@ impl<C: Verification> Secp256k1<C> {
 #[cfg(test)]
 #[allow(unused_imports)]
 mod tests {
-    use super::*;
     use rand::{RngCore, thread_rng};
-    use key::SecretKey;
+
+    use crate::{Error, SecretKey, Secp256k1, Message};
+    use super::{RecoveryId, RecoverableSignature};
 
     #[cfg(target_arch = "wasm32")]
     use wasm_bindgen_test::wasm_bindgen_test as test;