make clippy happy

keyfork-derive-key/src/cli.rs

@@ -1,6 +1,6 @@
 use crate::client::Client;
 use clap::Parser;
-use keyfork_derive_util::{request::*, DerivationPath};
+use keyfork_derive_util::{request::{DerivationAlgorithm, DerivationRequest, DerivationResponse}, DerivationPath};
 
 #[derive(Parser, Clone, Debug)]
 pub struct Command {

keyfork-derive-key/src/client.rs

@@ -1,6 +1,6 @@
 use crate::Result;
-use keyfork_derive_util::request::*;
-use keyfork_frame::*;
+use keyfork_derive_util::request::{DerivationRequest, DerivationResponse};
+use keyfork_frame::{try_decode_from, try_encode_to};
 use std::os::unix::net::UnixStream;
 
 #[derive(Debug)]

keyfork-derive-key/src/main.rs

@@ -3,6 +3,7 @@ use clap::Parser;
 #[cfg(test)]
 mod tests;
 
+#[allow(clippy::wildcard_imports)]
 use keyfork_derive_key::*;
 
 fn main() -> Result<()> {

keyfork-derive-key/src/socket.rs

@@ -1,6 +1,7 @@
 use super::Error;
 use std::{collections::HashMap, os::unix::net::UnixStream, path::PathBuf};
 
+#[allow(clippy::module_name_repetitions)]
 pub fn get_socket() -> Result<UnixStream, Error> {
     let socket_vars = std::env::vars()
         .filter(|(key, _)| ["XDG_RUNTIME_DIR", "KEYFORKD_SOCKET_PATH"].contains(&key.as_str()))

keyfork-derive-util/src/public_key.rs

@@ -35,7 +35,7 @@ pub trait PublicKey: Sized {
         let hash = Sha256::new().chain_update(self.to_bytes()).finalize();
         let hash = Ripemd160::new().chain_update(hash).finalize();
         // Note: Safety assured by type returned from Ripemd160
-        hash[..4].try_into().unwrap()
+        hash[..4].try_into().expect("Ripemd160 returned too little data")
     }
 }
 
@@ -73,8 +73,9 @@ impl PublicKey for k256::PublicKey {
     */
 
     fn to_bytes(&self) -> PublicKeyBytes {
-        // Note: Safety assured by type returned from EncodedPoint
-        self.to_encoded_point(true).as_bytes().try_into().unwrap()
+        let mut result = [0u8; 33];
+        result[..].copy_from_slice(self.to_encoded_point(true).as_bytes());
+        result
     }
 
     fn derive_child(&self, other: PrivateKeyBytes) -> Result<Self, Self::Err> {

keyfork-entropy/src/lib.rs

@@ -37,7 +37,7 @@ fn ensure_offline() {
             .expect("Unable to decode UTF-8 filepath")
             .split('/')
             .last()
-            .unwrap()
+            .expect("No data in file path")
             == "lo"
         {
             continue;

keyfork-mnemonic-from-seed/src/main.rs

@@ -1,3 +1,4 @@
+#[allow(clippy::wildcard_imports)]
 use keyfork_mnemonic_from_seed::*;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {

keyfork-slip10-test-data/src/lib.rs

@@ -25,6 +25,7 @@ const ED25519_512: &str = "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b
                            9f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542";
 
 // Note: This should never error.
+#[allow(clippy::too_many_lines)]
 pub fn test_data() -> Result<HashMap<String, Vec<TestData>>, Box<dyn std::error::Error>> {
     // Format:
     let mut map = HashMap::new();

keyfork/src/main.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::module_name_repetitions)]
+
 use clap::Parser;
 
 mod cli;
@@ -5,5 +7,5 @@ mod cli;
 fn main() {
     let opts = cli::Keyfork::parse();
 
-    opts.command.handle(&opts).unwrap();
+    opts.command.handle(&opts).expect("Unable to handle command");
 }

keyforkd/src/error.rs

@@ -1,7 +1,7 @@
 use thiserror::Error;
 
 #[derive(Debug, Clone, Error)]
-pub enum KeyforkdError {
+pub enum Keyforkd {
     #[error("Neither KEYFORKD_SOCKET_PATH nor XDG_RUNTIME_DIR were set, nowhere to mount socket")]
     NoSocketPath,
 }

keyforkd/src/lib.rs

@@ -13,7 +13,7 @@ pub mod error;
 pub mod middleware;
 pub mod server;
 pub mod service;
-pub use error::KeyforkdError;
+pub use error::Keyforkd as KeyforkdError;
 pub use server::UnixServer;
 pub use service::Keyforkd;
 

keyforkd/src/middleware.rs

@@ -19,6 +19,12 @@ impl<'a, Request> BincodeLayer<'a, Request> {
     }
 }
 
+impl<'a, Request> Default for BincodeLayer<'a, Request> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<'a, S: 'a, Request> Layer<S> for BincodeLayer<'a, Request> {
     type Service = BincodeService<S, Request>;
 
@@ -137,7 +143,7 @@ mod tests {
     async fn can_serde_responses() {
         let content = serialize(&Test::new()).unwrap();
         let mut service = ServiceBuilder::new()
-            .layer(BincodeLayer::<Test>::new())
+            .layer(BincodeLayer::<Test>::default())
             .service(App);
         let result = service
             .ready()