Run cargo fmt

Run the command `cargo +nightly fmt` to fix formatting issues.

The formatter got confused in one place, adding an incorrect
indentation, this was manually fixed.

Author: tcharding

examples/sign_verify.rs

@@ -2,9 +2,14 @@ extern crate bitcoin_hashes;
 extern crate secp256k1;
 
 use bitcoin_hashes::{sha256, Hash};
-use secp256k1::{Error, Message, PublicKey, Secp256k1, SecretKey, ecdsa, Signing, Verification};
-
-fn verify<C: Verification>(secp: &Secp256k1<C>, msg: &[u8], sig: [u8; 64], pubkey: [u8; 33]) -> Result<bool, Error> {
+use secp256k1::{ecdsa, Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification};
+
+fn verify<C: Verification>(
+    secp: &Secp256k1<C>,
+    msg: &[u8],
+    sig: [u8; 64],
+    pubkey: [u8; 33],
+) -> Result<bool, Error> {
     let msg = sha256::Hash::hash(msg);
     let msg = Message::from_slice(&msg)?;
     let sig = ecdsa::Signature::from_compact(&sig)?;
@@ -13,7 +18,11 @@ fn verify<C: Verification>(secp: &Secp256k1<C>, msg: &[u8], sig: [u8; 64], pubke
     Ok(secp.verify_ecdsa(&msg, &sig, &pubkey).is_ok())
 }
 
-fn sign<C: Signing>(secp: &Secp256k1<C>, msg: &[u8], seckey: [u8; 32]) -> Result<ecdsa::Signature, Error> {
+fn sign<C: Signing>(
+    secp: &Secp256k1<C>,
+    msg: &[u8],
+    seckey: [u8; 32],
+) -> Result<ecdsa::Signature, Error> {
     let msg = sha256::Hash::hash(msg);
     let msg = Message::from_slice(&msg)?;
     let seckey = SecretKey::from_slice(&seckey)?;
@@ -23,8 +32,14 @@ fn sign<C: Signing>(secp: &Secp256k1<C>, msg: &[u8], seckey: [u8; 32]) -> Result
 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];
-    let pubkey = [2, 29, 21, 35, 7, 198, 183, 43, 14, 208, 65, 139, 14, 112, 205, 128, 231, 245, 41, 91, 141, 134, 245, 114, 45, 63, 82, 19, 251, 210, 57, 79, 54];
+    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,
+    ];
+    let pubkey = [
+        2, 29, 21, 35, 7, 198, 183, 43, 14, 208, 65, 139, 14, 112, 205, 128, 231, 245, 41, 91, 141,
+        134, 245, 114, 45, 63, 82, 19, 251, 210, 57, 79, 54,
+    ];
     let msg = b"This is some message";
 
     let signature = sign(&secp, msg, seckey).unwrap();

examples/sign_verify_recovery.rs

@@ -1,11 +1,15 @@
-
 extern crate bitcoin_hashes;
 extern crate secp256k1;
 
 use bitcoin_hashes::{sha256, Hash};
-use secp256k1::{Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification, ecdsa};
-
-fn recover<C: Verification>(secp: &Secp256k1<C>,msg: &[u8],sig: [u8; 64],recovery_id: u8) -> Result<PublicKey, Error> {
+use secp256k1::{ecdsa, Error, Message, PublicKey, Secp256k1, SecretKey, Signing, Verification};
+
+fn recover<C: Verification>(
+    secp: &Secp256k1<C>,
+    msg: &[u8],
+    sig: [u8; 64],
+    recovery_id: u8,
+) -> Result<PublicKey, Error> {
     let msg = sha256::Hash::hash(msg);
     let msg = Message::from_slice(&msg)?;
     let id = ecdsa::RecoveryId::from_i32(recovery_id as i32)?;
@@ -14,7 +18,11 @@ fn recover<C: Verification>(secp: &Secp256k1<C>,msg: &[u8],sig: [u8; 64],recover
     secp.recover_ecdsa(&msg, &sig)
 }
 
-fn sign_recovery<C: Signing>(secp: &Secp256k1<C>, msg: &[u8], seckey: [u8; 32]) -> Result<ecdsa::RecoverableSignature, Error> {
+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)?;
@@ -25,22 +33,19 @@ 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,
+        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,
     ];
     let pubkey = PublicKey::from_slice(&[
-        2,
-        29, 21, 35, 7, 198, 183, 43, 14, 208, 65, 139, 14, 112, 205, 128, 231,
-        245, 41, 91, 141, 134, 245, 114, 45, 63, 82, 19, 251, 210, 57, 79, 54,
-    ]).unwrap();
+        2, 29, 21, 35, 7, 198, 183, 43, 14, 208, 65, 139, 14, 112, 205, 128, 231, 245, 41, 91, 141,
+        134, 245, 114, 45, 63, 82, 19, 251, 210, 57, 79, 54,
+    ])
+    .unwrap();
     let msg = b"This is some message";
 
     let signature = sign_recovery(&secp, msg, seckey).unwrap();
 
     let (recovery_id, serialize_sig) = signature.serialize_compact();
 
-    assert_eq!(
-        recover(&secp, msg, serialize_sig, recovery_id.to_i32() as u8),
-        Ok(pubkey)
-    );
+    assert_eq!(recover(&secp, msg, serialize_sig, recovery_id.to_i32() as u8), Ok(pubkey));
 }

src/context.rs

@@ -1,13 +1,12 @@
 use core::marker::PhantomData;
 use core::mem::ManuallyDrop;
 
-use crate::{Error, Secp256k1};
-use crate::ffi::{self, CPtr, types::AlignedType};
-use crate::ffi::types::{c_uint, c_void};
-
 #[cfg(feature = "alloc")]
 #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
 pub use self::alloc_only::*;
+use crate::ffi::types::{c_uint, c_void, AlignedType};
+use crate::ffi::{self, CPtr};
+use crate::{Error, Secp256k1};
 
 #[cfg(all(feature = "global-context", feature = "std"))]
 #[cfg_attr(docsrs, doc(cfg(all(feature = "global-context", feature = "std"))))]
@@ -41,13 +40,17 @@ pub mod global {
     impl Deref for GlobalContext {
         type Target = Secp256k1<All>;
 
-        #[allow(unused_mut)]    // Unused when `rand-std` is not enabled.
+        #[allow(unused_mut)] // Unused when `rand-std` is not enabled.
         fn deref(&self) -> &Self::Target {
             static ONCE: Once = Once::new();
             static mut CONTEXT: Option<Secp256k1<All>> = None;
             ONCE.call_once(|| unsafe {
                 let mut ctx = Secp256k1::new();
-                #[cfg(all(not(target_arch = "wasm32"), feature = "rand-std", not(feature = "global-context-less-secure")))]
+                #[cfg(all(
+                    not(target_arch = "wasm32"),
+                    feature = "rand-std",
+                    not(feature = "global-context-less-secure")
+                ))]
                 {
                     ctx.randomize(&mut rand::thread_rng());
                 }
@@ -58,10 +61,9 @@ pub mod global {
     }
 }
 
-
 /// A trait for all kinds of contexts that lets you define the exact flags and a function to
 /// deallocate memory. It isn't possible to implement this for types outside this crate.
-pub unsafe trait Context : private::Sealed {
+pub unsafe trait Context: private::Sealed {
     /// Flags for the ffi.
     const FLAGS: c_uint;
     /// A constant description of the context.
@@ -106,13 +108,13 @@ mod private {
 #[cfg(feature = "alloc")]
 #[cfg_attr(docsrs, doc(cfg(any(feature = "alloc"))))]
 mod alloc_only {
-    use crate::alloc::alloc;
-
     use core::marker::PhantomData;
 
     use super::private;
-    use crate::ffi::{self, types::{c_uint, c_void}};
-    use crate::{Secp256k1, Signing, Verification, Context, AlignedType};
+    use crate::alloc::alloc;
+    use crate::ffi::types::{c_uint, c_void};
+    use crate::ffi::{self};
+    use crate::{AlignedType, Context, Secp256k1, Signing, Verification};
 
     impl private::Sealed for SignOnly {}
     impl private::Sealed for All {}
@@ -195,16 +197,22 @@ mod alloc_only {
 
             let size = unsafe { ffi::secp256k1_context_preallocated_size(C::FLAGS) };
             let layout = alloc::Layout::from_size_align(size, ALIGN_TO).unwrap();
-            let ptr = unsafe {alloc::alloc(layout)};
+            let ptr = unsafe { alloc::alloc(layout) };
 
             #[allow(unused_mut)] // ctx is not mutated under some feature combinations.
             let mut ctx = Secp256k1 {
-                ctx: unsafe { ffi::secp256k1_context_preallocated_create(ptr as *mut c_void, C::FLAGS) },
+                ctx: unsafe {
+                    ffi::secp256k1_context_preallocated_create(ptr as *mut c_void, C::FLAGS)
+                },
                 phantom: PhantomData,
                 size,
             };
 
-            #[cfg(all(not(target_arch = "wasm32"), feature = "rand-std", not(feature = "global-context-less-secure")))]
+            #[cfg(all(
+                not(target_arch = "wasm32"),
+                feature = "rand-std",
+                not(feature = "global-context-less-secure")
+            ))]
             {
                 ctx.randomize(&mut rand::thread_rng());
             }
@@ -220,9 +228,7 @@ mod alloc_only {
         /// If `rand-std` feature is enabled, context will have been randomized using `thread_rng`.
         /// If `rand-std` feature is not enabled please consider randomizing the context (see docs
         /// for `Secp256k1::gen_new()`).
-        pub fn new() -> Secp256k1<All> {
-            Secp256k1::gen_new()
-        }
+        pub fn new() -> Secp256k1<All> { Secp256k1::gen_new() }
     }
 
     impl Secp256k1<SignOnly> {
@@ -231,9 +237,7 @@ mod alloc_only {
         /// If `rand-std` feature is enabled, context will have been randomized using `thread_rng`.
         /// If `rand-std` feature is not enabled please consider randomizing the context (see docs
         /// for `Secp256k1::gen_new()`).
-        pub fn signing_only() -> Secp256k1<SignOnly> {
-            Secp256k1::gen_new()
-        }
+        pub fn signing_only() -> Secp256k1<SignOnly> { Secp256k1::gen_new() }
     }
 
     impl Secp256k1<VerifyOnly> {
@@ -242,24 +246,22 @@ mod alloc_only {
         /// If `rand-std` feature is enabled, context will have been randomized using `thread_rng`.
         /// If `rand-std` feature is not enabled please consider randomizing the context (see docs
         /// for `Secp256k1::gen_new()`).
-        pub fn verification_only() -> Secp256k1<VerifyOnly> {
-            Secp256k1::gen_new()
-        }
+        pub fn verification_only() -> Secp256k1<VerifyOnly> { Secp256k1::gen_new() }
     }
 
     impl Default for Secp256k1<All> {
-        fn default() -> Self {
-            Self::new()
-        }
+        fn default() -> Self { Self::new() }
     }
 
     impl<C: Context> Clone for Secp256k1<C> {
         fn clone(&self) -> Secp256k1<C> {
-            let size = unsafe {ffi::secp256k1_context_preallocated_clone_size(self.ctx as _)};
+            let size = unsafe { ffi::secp256k1_context_preallocated_clone_size(self.ctx as _) };
             let layout = alloc::Layout::from_size_align(size, ALIGN_TO).unwrap();
-            let ptr = unsafe {alloc::alloc(layout)};
+            let ptr = unsafe { alloc::alloc(layout) };
             Secp256k1 {
-                ctx: unsafe { ffi::secp256k1_context_preallocated_clone(self.ctx, ptr as *mut c_void) },
+                ctx: unsafe {
+                    ffi::secp256k1_context_preallocated_clone(self.ctx, ptr as *mut c_void)
+                },
                 phantom: PhantomData,
                 size,
             }
@@ -313,7 +315,8 @@ impl<'buf, C: Context + 'buf> Secp256k1<C> {
             ctx: unsafe {
                 ffi::secp256k1_context_preallocated_create(
                     buf.as_mut_c_ptr() as *mut c_void,
-                    C::FLAGS)
+                    C::FLAGS,
+                )
             },
             phantom: PhantomData,
             size: 0, // We don't care about the size because it's the caller responsibility to deallocate.
@@ -323,13 +326,13 @@ impl<'buf, C: Context + 'buf> Secp256k1<C> {
 
 impl<'buf> Secp256k1<AllPreallocated<'buf>> {
     /// Creates a new Secp256k1 context with all capabilities
-    pub fn preallocated_new(buf: &'buf mut [AlignedType]) -> Result<Secp256k1<AllPreallocated<'buf>>, Error> {
+    pub fn preallocated_new(
+        buf: &'buf mut [AlignedType],
+    ) -> Result<Secp256k1<AllPreallocated<'buf>>, Error> {
         Secp256k1::preallocated_gen_new(buf)
     }
     /// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for a context.
-    pub fn preallocate_size() -> usize {
-        Self::preallocate_size_gen()
-    }
+    pub fn preallocate_size() -> usize { Self::preallocate_size_gen() }
 
     /// Create a context from a raw context.
     ///
@@ -342,7 +345,9 @@ impl<'buf> Secp256k1<AllPreallocated<'buf>> {
     /// * The user must handle the freeing of the context(using the correct functions) by himself.
     /// * Violating these may lead to Undefined Behavior.
     ///
-    pub unsafe fn from_raw_all(raw_ctx: *mut ffi::Context) -> ManuallyDrop<Secp256k1<AllPreallocated<'buf>>> {
+    pub unsafe fn from_raw_all(
+        raw_ctx: *mut ffi::Context,
+    ) -> ManuallyDrop<Secp256k1<AllPreallocated<'buf>>> {
         ManuallyDrop::new(Secp256k1 {
             ctx: raw_ctx,
             phantom: PhantomData,
@@ -353,15 +358,15 @@ impl<'buf> Secp256k1<AllPreallocated<'buf>> {
 
 impl<'buf> Secp256k1<SignOnlyPreallocated<'buf>> {
     /// Creates a new Secp256k1 context that can only be used for signing.
-    pub fn preallocated_signing_only(buf: &'buf mut [AlignedType]) -> Result<Secp256k1<SignOnlyPreallocated<'buf>>, Error> {
+    pub fn preallocated_signing_only(
+        buf: &'buf mut [AlignedType],
+    ) -> Result<Secp256k1<SignOnlyPreallocated<'buf>>, Error> {
         Secp256k1::preallocated_gen_new(buf)
     }
 
     /// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for the context.
     #[inline]
-    pub fn preallocate_signing_size() -> usize {
-        Self::preallocate_size_gen()
-    }
+    pub fn preallocate_signing_size() -> usize { Self::preallocate_size_gen() }
 
     /// Create a context from a raw context.
     ///
@@ -374,7 +379,9 @@ impl<'buf> Secp256k1<SignOnlyPreallocated<'buf>> {
     /// * The user must handle the freeing of the context(using the correct functions) by himself.
     /// * This list *is not* exhaustive, and any violation may lead to Undefined Behavior.
     ///
-    pub unsafe fn from_raw_signing_only(raw_ctx: *mut ffi::Context) -> ManuallyDrop<Secp256k1<SignOnlyPreallocated<'buf>>> {
+    pub unsafe fn from_raw_signing_only(
+        raw_ctx: *mut ffi::Context,
+    ) -> ManuallyDrop<Secp256k1<SignOnlyPreallocated<'buf>>> {
         ManuallyDrop::new(Secp256k1 {
             ctx: raw_ctx,
             phantom: PhantomData,
@@ -385,15 +392,15 @@ impl<'buf> Secp256k1<SignOnlyPreallocated<'buf>> {
 
 impl<'buf> Secp256k1<VerifyOnlyPreallocated<'buf>> {
     /// Creates a new Secp256k1 context that can only be used for verification
-    pub fn preallocated_verification_only(buf: &'buf mut [AlignedType]) -> Result<Secp256k1<VerifyOnlyPreallocated<'buf>>, Error> {
+    pub fn preallocated_verification_only(
+        buf: &'buf mut [AlignedType],
+    ) -> Result<Secp256k1<VerifyOnlyPreallocated<'buf>>, Error> {
         Secp256k1::preallocated_gen_new(buf)
     }
 
     /// Uses the ffi `secp256k1_context_preallocated_size` to check the memory size needed for the context.
     #[inline]
-    pub fn preallocate_verification_size() -> usize {
-        Self::preallocate_size_gen()
-    }
+    pub fn preallocate_verification_size() -> usize { Self::preallocate_size_gen() }
 
     /// Create a context from a raw context.
     ///
@@ -406,7 +413,9 @@ impl<'buf> Secp256k1<VerifyOnlyPreallocated<'buf>> {
     /// * The user must handle the freeing of the context(using the correct functions) by himself.
     /// * This list *is not* exhaustive, and any violation may lead to Undefined Behavior.
     ///
-    pub unsafe fn from_raw_verification_only(raw_ctx: *mut ffi::Context) -> ManuallyDrop<Secp256k1<VerifyOnlyPreallocated<'buf>>> {
+    pub unsafe fn from_raw_verification_only(
+        raw_ctx: *mut ffi::Context,
+    ) -> ManuallyDrop<Secp256k1<VerifyOnlyPreallocated<'buf>>> {
         ManuallyDrop::new(Secp256k1 {
             ctx: raw_ctx,
             phantom: PhantomData,