Fix lint errors in crypto crate

diff --git a/crypto/src/ecdsa.rs b/crypto/src/ecdsa.rs
index f7859a6b..c5c90969 100644
--- a/crypto/src/ecdsa.rs
+++ b/crypto/src/ecdsa.rs
@@ -44,9 +44,14 @@ impl Signature {
     }
 
     /// Deserializes from slice following the standardness rules for [`EcdsaSighashType`].
+    ///
+    /// # Errors
+    ///
+    /// * [`DecodeError::EmptySignature`] if the slice is empty.
+    /// * [`DecodeError::Secp256k1`] if the slice cannot be decoded to an ECDSA signature.
     pub fn from_slice(sl: &[u8]) -> Result<Self, DecodeError> {
         let (sighash_type, sig) = sl.split_last().ok_or(DecodeError::EmptySignature)?;
-        let sighash_type = EcdsaSighashType::from_standard(*sighash_type as u32)?;
+        let sighash_type = EcdsaSighashType::from_standard(u32::from(*sighash_type))?;
         let signature =
             secp256k1::ecdsa::Signature::from_der(sig).map_err(DecodeError::Secp256k1)?;
         Ok(Self { signature, sighash_type })
@@ -77,6 +82,10 @@ impl Signature {
     }
 
     /// Serializes an ECDSA signature (inner secp256k1 signature in DER format) to a `writer`.
+    ///
+    /// # Errors
+    ///
+    /// If the signature bytes cannot be written to the provided `writer`.
     #[inline]
     pub fn serialize_to_writer<W: Write + ?Sized>(&self, writer: &mut W) -> Result<(), io::Error> {
         let sig = self.serialize();
@@ -115,7 +124,7 @@ pub struct SerializedSignature {
 }
 
 impl SerializedSignature {
-    /// Constructs a new SerializedSignature from a Signature.
+    /// Constructs a new `SerializedSignature` from a Signature.
     ///
     /// In other words this serializes a `Signature` into a `SerializedSignature`.
     #[inline]
@@ -124,6 +133,12 @@ impl SerializedSignature {
     /// Converts the serialized signature into the [`Signature`] struct.
     ///
     /// In other words this deserializes the `SerializedSignature`.
+    ///
+    /// # Errors
+    ///
+    /// See [`from_slice`]
+    ///
+    /// [`from_slice`]: Signature::from_slice
     #[inline]
     pub fn to_signature(self) -> Result<Signature, DecodeError> { Signature::from_slice(&self) }
 
@@ -138,6 +153,10 @@ impl SerializedSignature {
     pub fn iter(&self) -> core::slice::Iter<'_, u8> { self.into_iter() }
 
     /// Writes this serialized signature to a `writer`.
+    ///
+    /// # Errors
+    ///
+    /// If the signature bytes cannot be written to the provided `writer`.
     #[inline]
     pub fn write_to<W: Write + ?Sized>(&self, writer: &mut W) -> Result<(), io::Error> {
         writer.write_all(self)
@@ -338,9 +357,9 @@ impl<'a> Arbitrary<'a> for Signature {
         // The valid range of r and s should be between 0 and n-1 where
         // n = 0xFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364141
         let high_min = 0x0u128;
-        let high_max = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEu128;
+        let high_max = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFEu128;
         let low_min = 0x0u128;
-        let low_max = 0xBAAEDCE6AF48A03BBFD25E8CD0364140u128;
+        let low_max = 0xBAAE_DCE6_AF48_A03B_BFD2_5E8C_D036_4140u128;
 
         // Equally weight the chances of getting a minimum value for a signature, maximum value for
         // a signature, and an arbitrary valid signature
@@ -385,7 +404,7 @@ mod tests {
         let mut buf = vec![];
         sig.serialize_to_writer(&mut buf).expect("write failed");
 
-        assert_eq!(sig.to_vec(), buf)
+        assert_eq!(sig.to_vec(), buf);
     }
 
     #[test]