bump dependencies

Author: OBorce

Cargo.lock

@@ -52,7 +52,7 @@ pub fn web_server<
     socket: TcpListener,
     state: ApiServerWebServerState<Arc<T>, Arc<R>>,
     enable_post_endpoints: bool,
-) -> axum::serve::Serve<Router, Router> {
+) -> axum::serve::Serve<TcpListener, Router, Router> {
     let cors_layer = CorsLayer::new()
         .allow_methods(AllowMethods::list([Method::GET, Method::POST]))
         .allow_headers(Any)

Cargo.toml

@@ -27,7 +27,7 @@ num.workspace = true
 parity-scale-codec.workspace = true
 ripemd.workspace = true
 schnorrkel.workspace = true
-secp256k1 = { workspace = true, default-features = false, features = ["rand-std", "std", "rand"] }
+secp256k1 = { workspace = true, default-features = false, features = ["std", "rand"] }
 serde = { workspace = true, features = ["derive"] }
 sha-1.workspace = true
 sha2.workspace = true

api-server/web-server/src/api/mod.rs

@@ -57,7 +57,7 @@ fn to_key_and_chain_code(
     mac: Hmac<Sha512>,
 ) -> Result<(secp256k1::SecretKey, ChainCode), DerivationError> {
     util::to_key_and_chain_code(mac, |secret_key_bytes| {
-        secp256k1::SecretKey::from_slice(secret_key_bytes)
+        secp256k1::SecretKey::from_byte_array(&secret_key_bytes)
             .map_err(|_| DerivationError::KeyDerivationError)
     })
 }

crypto/Cargo.toml

@@ -44,7 +44,7 @@ impl Encode for Secp256k1PrivateKey {
 impl Decode for Secp256k1PrivateKey {
     fn decode<I: serialization::Input>(input: &mut I) -> Result<Self, serialization::Error> {
         let mut v = <[u8; secp256k1::constants::SECRET_KEY_SIZE]>::decode(input)?;
-        let result = secp256k1::SecretKey::from_slice(&v)
+        let result = secp256k1::SecretKey::from_byte_array(&v)
             .map(|r| Secp256k1PrivateKey { data: r })
             .map_err(|_| serialization::Error::from("Private Key deserialization failed"));
         v.zeroize();
@@ -73,9 +73,11 @@ impl Secp256k1PrivateKey {
     }
 
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, Secp256k1KeyError> {
-        secp256k1::SecretKey::from_slice(bytes)
-            .map(|r| Secp256k1PrivateKey { data: r })
-            .map_err(|_| Secp256k1KeyError::InvalidData)
+        secp256k1::SecretKey::from_byte_array(
+            &bytes.try_into().map_err(|_| Secp256k1KeyError::InvalidData)?,
+        )
+        .map(|r| Secp256k1PrivateKey { data: r })
+        .map_err(|_| Secp256k1KeyError::InvalidData)
     }
 
     pub fn as_native(&self) -> &secp256k1::SecretKey {
@@ -94,15 +96,14 @@ impl Secp256k1PrivateKey {
         let secp = secp256k1::Secp256k1::new();
         // Hash the message
         let e = Blake2b32Stream::new().write(msg).finalize();
-        let msg_hash =
-            secp256k1::Message::from_digest_slice(e.as_slice()).expect("Blake2b32 is 32 bytes");
+        let msg_hash = secp256k1::Message::from_digest(e.into());
         // Sign the hash
         // TODO(SECURITY) erase keypair after signing
         let keypair = self.data.keypair(&secp);
 
         let aux_data = aux_data_provider.get_secp256k1_schnorr_aux_data();
 
-        secp.sign_schnorr_with_aux_rand(&msg_hash, &keypair, &aux_data)
+        secp.sign_schnorr_with_aux_rand(msg_hash.as_ref(), &keypair, &aux_data)
     }
 }
 
@@ -168,8 +169,7 @@ impl Secp256k1PublicKey {
     ) -> bool {
         // Hash the message
         let e = Blake2b32Stream::new().write(msg).finalize();
-        let msg_hashed =
-            secp256k1::Message::from_digest_slice(e.as_slice()).expect("Blake2b32 is 32 bytes");
+        let msg_hashed = secp256k1::Message::from_digest(e.into());
         // Verify the signature
         self.verify_message_hashed(signature, &msg_hashed)
     }
@@ -182,7 +182,7 @@ impl Secp256k1PublicKey {
         let secp = secp256k1::Secp256k1::new();
         secp.verify_schnorr(
             signature,
-            msg_hashed,
+            msg_hashed.as_ref(),
             &self.pubkey_data.x_only_public_key().0,
         )
         .is_ok()
@@ -377,7 +377,7 @@ mod test {
         assert!(pk.verify_message(&sig1, &msg));
         assert!(pk.verify_message(&sig2, &msg));
         assert_eq!(sig1, sig2);
-        assert_eq!(sig1.serialize(), sig2.serialize());
+        assert_eq!(sig1.to_byte_array(), sig2.to_byte_array());
     }
 
     #[rstest]

crypto/src/key/secp256k1/extended_keys.rs

@@ -65,8 +65,7 @@ impl Decode for Signature {
         match sig_kind {
             SignatureKind::Secp256k1Schnorr => {
                 let data = <[u8; secp256k1::constants::SCHNORR_SIGNATURE_SIZE]>::decode(input)?;
-                let sig = secp256k1::schnorr::Signature::from_slice(&data)
-                    .map_err(|_| serialization::Error::from("Signature deserialization failed"))?;
+                let sig = secp256k1::schnorr::Signature::from_byte_array(data);
                 Ok(Signature::Secp256k1Schnorr(sig))
             }
         }
@@ -85,8 +84,11 @@ impl Signature {
     ) -> Result<Self, SignatureError> {
         match kind {
             SignatureKind::Secp256k1Schnorr => {
-                let decoded_sig = secp256k1::schnorr::Signature::from_slice(data.as_ref())
-                    .map_err(|_| SignatureError::SignatureConstructionError)?;
+                let decoded_sig = secp256k1::schnorr::Signature::from_byte_array(
+                    data.as_ref()
+                        .try_into()
+                        .map_err(|_| SignatureError::SignatureConstructionError)?,
+                );
                 Ok(Self::Secp256k1Schnorr(decoded_sig))
             }
         }

crypto/src/key/secp256k1/mod.rs

@@ -15,6 +15,7 @@
 
 use generic_array::{sequence::Split, typenum::U32, GenericArray};
 use hmac::{Hmac, Mac};
+use secp256k1::constants;
 use sha2::Sha512;
 use zeroize::Zeroize;
 
@@ -31,7 +32,7 @@ pub fn new_hmac_sha_512(key: &[u8]) -> Hmac<Sha512> {
 
 pub fn to_key_and_chain_code<SecretKey>(
     mac: Hmac<Sha512>,
-    to_key: impl FnOnce(&[u8]) -> Result<SecretKey, DerivationError>,
+    to_key: impl FnOnce([u8; constants::SECRET_KEY_SIZE]) -> Result<SecretKey, DerivationError>,
 ) -> Result<(SecretKey, ChainCode), DerivationError> {
     // Finalize the hmac
     let mut result = mac.finalize().into_bytes();
@@ -44,7 +45,7 @@ pub fn to_key_and_chain_code<SecretKey>(
     result.zeroize();
 
     // Create the secret key key
-    let secret_key = to_key(secret_key_bytes.as_slice())?;
+    let secret_key = to_key(secret_key_bytes.into())?;
     secret_key_bytes.zeroize();
 
     // Chain code

crypto/src/key/signature/mod.rs

@@ -328,7 +328,7 @@ fn to_key_and_chain_code(
     key_kind: VRFKeyKind,
 ) -> Result<(VRFPrivateKey, ChainCode), DerivationError> {
     util::to_key_and_chain_code(mac, |secret_key_bytes| {
-        VRFPrivateKey::new_using_random_bytes(secret_key_bytes, key_kind)
+        VRFPrivateKey::new_using_random_bytes(&secret_key_bytes, key_kind)
             .map(|(prv, _pub)| prv)
             .map_err(|_| DerivationError::KeyDerivationError)
     })

crypto/src/util/mod.rs

@@ -19,7 +19,7 @@ use std::{
 };
 
 use clap::Parser;
-use hickory_client::rr::Name;
+use hickory_client::proto::rr::Name;
 use utils_networking::IpOrSocketAddress;
 
 use common::primitives::per_thousand::PerThousand;