Run the formatter

Author: tcharding

examples/sign_verify.rs

@@ -17,22 +17,15 @@ extern crate secp256k1;
 
 use secp256k1::{ecdsa, Error, Message, PublicKey, SecretKey};
 
-fn verify(
-    sig: [u8; 64],
-    msg_digest: [u8; 32],
-    pubkey: [u8; 33],
-) -> Result<bool, Error> {
+fn verify(sig: [u8; 64], msg_digest: [u8; 32], pubkey: [u8; 33]) -> Result<bool, Error> {
     let msg = Message::from_digest(msg_digest);
     let sig = ecdsa::Signature::from_compact(&sig)?;
     let pubkey = PublicKey::from_slice(&pubkey)?;
 
     Ok(ecdsa::verify(&sig, msg, &pubkey).is_ok())
 }
 
-fn sign(
-    msg_digest: [u8; 32],
-    seckey: [u8; 32],
-) -> Result<ecdsa::Signature, Error> {
+fn sign(msg_digest: [u8; 32], seckey: [u8; 32]) -> Result<ecdsa::Signature, Error> {
     let msg = Message::from_digest(msg_digest);
     let seckey = SecretKey::from_secret_bytes(seckey)?;
     Ok(ecdsa::sign(msg, &seckey))

secp256k1-sys/src/lib.rs

@@ -1,5 +1,3 @@
-
-
 //! # secp256k1-sys FFI bindings
 //! Direct bindings to the underlying C library functions. These should
 //! not be needed for most users.

src/ecdsa/mod.rs

@@ -13,9 +13,7 @@ use core::{fmt, ptr, str};
 pub use self::recovery::{RecoverableSignature, RecoveryId};
 pub use self::serialized_signature::SerializedSignature;
 use crate::ffi::CPtr;
-use crate::{
-    ecdsa, ffi, from_hex, Error, Message, PublicKey, Secp256k1, SecretKey,
-};
+use crate::{ecdsa, ffi, from_hex, Error, Message, PublicKey, Secp256k1, SecretKey};
 
 /// An ECDSA signature
 #[derive(Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
@@ -253,19 +251,21 @@ fn sign_ecdsa_with_noncedata_pointer(
         // We can assume the return value because it's not possible to construct
         // an invalid signature from a valid `Message` and `SecretKey`
         let res = crate::with_global_context(
-            |secp: &Secp256k1<crate::AllPreallocated>| ffi::secp256k1_ecdsa_sign(
-                secp.ctx.as_ptr(),
-                &mut ret,
-                msg.as_c_ptr(),
-                sk.as_c_ptr(),
-                ffi::secp256k1_nonce_function_rfc6979,
-                noncedata_ptr
-            ),
+            |secp: &Secp256k1<crate::AllPreallocated>| {
+                ffi::secp256k1_ecdsa_sign(
+                    secp.ctx.as_ptr(),
+                    &mut ret,
+                    msg.as_c_ptr(),
+                    sk.as_c_ptr(),
+                    ffi::secp256k1_nonce_function_rfc6979,
+                    noncedata_ptr,
+                )
+            },
             Some(&sk.to_secret_bytes()),
         );
 
         assert_eq!(res, 1);
-        
+
         Signature::from(ret)
     }
 }
@@ -304,14 +304,16 @@ fn sign_grind_with_check(
             // We can assume the return value because it's not possible to construct
             // an invalid signature from a valid `Message` and `SecretKey`
             let res = crate::with_global_context(
-                |secp: &Secp256k1<crate::AllPreallocated>| ffi::secp256k1_ecdsa_sign(
-                    secp.ctx.as_ptr(),
-                    &mut ret,
-                    msg.as_c_ptr(),
-                    sk.as_c_ptr(),
-                    ffi::secp256k1_nonce_function_rfc6979,
-                    entropy_p
-                ),
+                |secp: &Secp256k1<crate::AllPreallocated>| {
+                    ffi::secp256k1_ecdsa_sign(
+                        secp.ctx.as_ptr(),
+                        &mut ret,
+                        msg.as_c_ptr(),
+                        sk.as_c_ptr(),
+                        ffi::secp256k1_nonce_function_rfc6979,
+                        entropy_p,
+                    )
+                },
                 Some(&sk.to_secret_bytes()),
             );
             assert_eq!(res, 1);
@@ -337,11 +339,7 @@ fn sign_grind_with_check(
 /// of signing operation performed by this function is exponential in the
 /// number of bytes grinded.
 /// Requires a signing capable context.
-pub fn sign_grind_r(
-    msg: impl Into<Message>,
-    sk: &SecretKey,
-    bytes_to_grind: usize,
-) -> Signature {
+pub fn sign_grind_r(msg: impl Into<Message>, sk: &SecretKey, bytes_to_grind: usize) -> Signature {
     let len_check = |s: &ffi::Signature| der_length_check(s, 71 - bytes_to_grind);
     sign_grind_with_check(msg, sk, len_check)
 }
@@ -377,21 +375,19 @@ pub fn sign_low_r(msg: impl Into<Message>, sk: &SecretKey) -> Signature {
 /// # }
 /// ```
 #[inline]
-pub fn verify(
-    sig: &Signature,
-    msg: impl Into<Message>,
-    pk: &PublicKey,
-) -> Result<(), Error> {
+pub fn verify(sig: &Signature, msg: impl Into<Message>, pk: &PublicKey) -> Result<(), Error> {
     let msg = msg.into();
     unsafe {
         let res = crate::with_global_context(
-            |secp: &Secp256k1<crate::AllPreallocated>| ffi::secp256k1_ecdsa_verify(
-                secp.ctx.as_ptr(),
-                sig.as_c_ptr(),
-                msg.as_c_ptr(),
-                pk.as_c_ptr(),
-            ),
-            None,               // FIXME: What goes here?
+            |secp: &Secp256k1<crate::AllPreallocated>| {
+                ffi::secp256k1_ecdsa_verify(
+                    secp.ctx.as_ptr(),
+                    sig.as_c_ptr(),
+                    msg.as_c_ptr(),
+                    pk.as_c_ptr(),
+                )
+            },
+            None, // FIXME: What goes here?
         );
         if res == 0 {
             Err(Error::IncorrectSignature)

src/ellswift.rs

@@ -114,21 +114,20 @@ impl ElligatorSwift {
     ///     let es = ElligatorSwift::from_seckey(sk, None);
     /// # }
     /// ```
-    pub fn from_seckey(
-        sk: SecretKey,
-        aux_rand: Option<[u8; 32]>,
-    ) -> ElligatorSwift {
+    pub fn from_seckey(sk: SecretKey, aux_rand: Option<[u8; 32]>) -> ElligatorSwift {
         let mut es_out = [0u8; constants::ELLSWIFT_ENCODING_SIZE];
         let aux_rand_ptr = aux_rand.as_c_ptr();
         unsafe {
             let ret = crate::with_global_context(
-                |secp: &Secp256k1<crate::AllPreallocated>| ffi::secp256k1_ellswift_create(
-                    secp.ctx().as_ptr(),
-                    es_out.as_mut_c_ptr(),
-                    sk.as_c_ptr(),
-                    aux_rand_ptr,
-                ),
-                Some(&sk.to_secret_bytes()),     
+                |secp: &Secp256k1<crate::AllPreallocated>| {
+                    ffi::secp256k1_ellswift_create(
+                        secp.ctx().as_ptr(),
+                        es_out.as_mut_c_ptr(),
+                        sk.as_c_ptr(),
+                        aux_rand_ptr,
+                    )
+                },
+                Some(&sk.to_secret_bytes()),
             );
             debug_assert_eq!(ret, 1);
         }
@@ -386,11 +385,9 @@ mod tests {
         // Test that we can round trip an ElligatorSwift created from a secret key
         let rand32 = [1u8; 32];
         let priv32 = [1u8; 32];
-        let ell =
-            ElligatorSwift::from_seckey(SecretKey::from_secret_bytes(rand32).unwrap(), None);
+        let ell = ElligatorSwift::from_seckey(SecretKey::from_secret_bytes(rand32).unwrap(), None);
         let pk = PublicKey::from_ellswift(ell);
-        let expected =
-            PublicKey::from_secret_key(&SecretKey::from_secret_bytes(priv32).unwrap());
+        let expected = PublicKey::from_secret_key(&SecretKey::from_secret_bytes(priv32).unwrap());
 
         assert_eq!(pk, expected);
     }