all crates: `cargo fmt`

crates/daemon/keyforkd-client/src/tests.rs

@@ -9,58 +9,58 @@ use std::{os::unix::net::UnixStream, str::FromStr};
 fn secp256k1_test_suite() {
     use k256::SecretKey;
 
-    let tests = test_data()
+    let tests = test_data().unwrap().remove("secp256k1").unwrap();
-        .unwrap()
-        .remove("secp256k1")
-        .unwrap();
 
     for seed_test in tests {
         let seed = seed_test.seed;
-        run_test(&seed, move |socket_path| -> Result<(), Box<dyn std::error::Error + Send>> {
+        run_test(
-            for test in seed_test.tests {
+            &seed,
-                let socket = UnixStream::connect(socket_path).unwrap();
+            move |socket_path| -> Result<(), Box<dyn std::error::Error + Send>> {
-                let mut client = Client::new(socket);
+                for test in seed_test.tests {
-                let chain = DerivationPath::from_str(test.chain).unwrap();
-                let chain_len = chain.len();
-                if chain_len < 2 {
-                    continue;
-                }
-                if chain.iter().take(2).any(|index| !index.is_hardened()) {
-                    continue;
-                }
-                // Consistency check: ensure the server and the client can each derive the same
-                // key using an XPrv, for all but the last XPrv, which is verified after this
-                for i in 2..chain_len {
-                    // FIXME: Keyfork will only allow one request per session
                     let socket = UnixStream::connect(socket_path).unwrap();
                     let mut client = Client::new(socket);
-                    let path = DerivationPath::from_str(test.chain).unwrap();
+                    let chain = DerivationPath::from_str(test.chain).unwrap();
-                    let left_path = path.inner()[..i]
+                    let chain_len = chain.len();
-                        .iter()
+                    if chain_len < 2 {
-                        .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone()));
+                        continue;
-                    let right_path = path.inner()[i..]
+                    }
-                        .iter()
+                    if chain.iter().take(2).any(|index| !index.is_hardened()) {
-                        .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone()));
+                        continue;
-                    let xprv = dbg!(client.request_xprv::<SecretKey>(&left_path)).unwrap();
+                    }
-                    let derived_xprv = xprv.derive_path(&right_path).unwrap();
+                    // Consistency check: ensure the server and the client can each derive the same
-                    let socket = UnixStream::connect(socket_path).unwrap();
+                    // key using an XPrv, for all but the last XPrv, which is verified after this
-                    let mut client = Client::new(socket);
+                    for i in 2..chain_len {
-                    let keyforkd_xprv = client.request_xprv::<SecretKey>(&path).unwrap();
+                        // FIXME: Keyfork will only allow one request per session
-                    assert_eq!(
+                        let socket = UnixStream::connect(socket_path).unwrap();
-                        derived_xprv, keyforkd_xprv,
+                        let mut client = Client::new(socket);
-                        "{left_path} + {right_path} != {path}"
+                        let path = DerivationPath::from_str(test.chain).unwrap();
+                        let left_path = path.inner()[..i]
+                            .iter()
+                            .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone()));
+                        let right_path = path.inner()[i..]
+                            .iter()
+                            .fold(DerivationPath::default(), |p, i| p.chain_push(i.clone()));
+                        let xprv = dbg!(client.request_xprv::<SecretKey>(&left_path)).unwrap();
+                        let derived_xprv = xprv.derive_path(&right_path).unwrap();
+                        let socket = UnixStream::connect(socket_path).unwrap();
+                        let mut client = Client::new(socket);
+                        let keyforkd_xprv = client.request_xprv::<SecretKey>(&path).unwrap();
+                        assert_eq!(
+                            derived_xprv, keyforkd_xprv,
+                            "{left_path} + {right_path} != {path}"
+                        );
+                    }
+                    let req = DerivationRequest::new(
+                        DerivationAlgorithm::Secp256k1,
+                        &DerivationPath::from_str(test.chain).unwrap(),
                     );
+                    let response =
+                        DerivationResponse::try_from(client.request(&req.into()).unwrap()).unwrap();
+                    assert_eq!(&response.data, test.private_key.as_slice());
                 }
-                let req = DerivationRequest::new(
+                Ok(())
-                    DerivationAlgorithm::Secp256k1,
+            },
-                    &DerivationPath::from_str(test.chain).unwrap(),
+        )
-                );
-                let response =
-                    DerivationResponse::try_from(client.request(&req.into()).unwrap()).unwrap();
-                assert_eq!(&response.data, test.private_key.as_slice());
-            }
-            Ok(())
-        })
         .unwrap();
     }
 }

crates/daemon/keyforkd/src/middleware.rs

@@ -162,6 +162,9 @@ mod tests {
             .call(content.clone())
             .await
             .unwrap();
-        assert_eq!(result, serialize(&Result::<Test, Infallible>::Ok(test)).unwrap());
+        assert_eq!(
+            result,
+            serialize(&Result::<Test, Infallible>::Ok(test)).unwrap()
+        );
     }
 }

crates/daemon/keyforkd/src/service.rs

@@ -39,7 +39,10 @@ impl Keyforkd {
     /// Create a new instance of Keyfork from a given seed.
     pub fn new(seed: Vec<u8>) -> Self {
         if seed.len() < 16 {
-            warn!("Entropy size is lower than 128 bits: {} bits.", seed.len() * 8);
+            warn!(
+                "Entropy size is lower than 128 bits: {} bits.",
+                seed.len() * 8
+            );
         }
         Self {
             seed: Arc::new(seed),
@@ -77,11 +80,11 @@ impl Service<Request> for Keyforkd {
                     .iter()
                     .take(2)
                     .enumerate()
-                    .find(|(_, index)| {
+                    .find(|(_, index)| !index.is_hardened())
-                        !index.is_hardened()
-                    })
                 {
-                    return Err(DerivationError::InvalidDerivationPath(i, unhardened_index.inner()).into())
+                    return Err(
+                        DerivationError::InvalidDerivationPath(i, unhardened_index.inner()).into(),
+                    );
                 }
 
                 #[cfg(feature = "tracing")]
@@ -111,10 +114,7 @@ mod tests {
 
     #[tokio::test]
     async fn properly_derives_secp256k1() {
-        let tests = test_data()
+        let tests = test_data().unwrap().remove("secp256k1").unwrap();
-            .unwrap()
-            .remove("secp256k1")
-            .unwrap();
 
         for per_seed in tests {
             let seed = &per_seed.seed;

crates/daemon/keyforkd/src/test_util.rs

@@ -90,7 +90,10 @@ where
                 let service = ServiceBuilder::new()
                     .layer(middleware::BincodeLayer::new())
                     .service(Keyforkd::new(seed.to_vec()));
-                server.run(service).await.expect(bug!("Unable to start service"));
+                server
+                    .run(service)
+                    .await
+                    .expect(bug!("Unable to start service"));
             }
         });
 

crates/derive/keyfork-derive-key/src/main.rs

@@ -46,7 +46,10 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
     let mut client = Client::discover_socket()?;
     let request = DerivationRequest::new(algo, &path);
     let response = client.request(&request.into())?;
-    println!("{}", smex::encode(DerivationResponse::try_from(response)?.data));
+    println!(
+        "{}",
+        smex::encode(DerivationResponse::try_from(response)?.data)
+    );
     Ok(())
 }
 

crates/derive/keyfork-derive-openpgp/src/main.rs

@@ -2,8 +2,8 @@
 
 use std::{env, process::ExitCode, str::FromStr};
 
-use keyfork_derive_util::DerivationPath;
 use keyfork_derive_path_data::paths;
+use keyfork_derive_util::DerivationPath;
 use keyforkd_client::Client;
 
 use ed25519_dalek::SigningKey;
@@ -82,7 +82,10 @@ fn validate(
     let index = paths::OPENPGP.inner().first().unwrap();
 
     let path = DerivationPath::from_str(path)?;
-    assert!(path.len() >= 2, "Expected path of at least m/{index}/account_id'");
+    assert!(
+        path.len() >= 2,
+        "Expected path of at least m/{index}/account_id'"
+    );
 
     let given_index = path.iter().next().expect("checked .len() above");
     assert_eq!(

crates/derive/keyfork-derive-util/src/extended_key/private_key.rs

@@ -189,7 +189,10 @@ where
             }
         }
 
-        assert!(has_any_nonzero, bug!("hmac function returned all-zero master key"));
+        assert!(
+            has_any_nonzero,
+            bug!("hmac function returned all-zero master key")
+        );
 
         Self::from_parts(
             private_key
@@ -223,13 +226,11 @@ where
     /// ```
     pub fn from_parts(key: &[u8; 32], depth: u8, chain_code: [u8; 32]) -> Result<Self> {
         match K::from_bytes(key) {
-            Ok(key) => {
+            Ok(key) => Ok(Self {
-                Ok(Self {
+                private_key: key,
-                    private_key: key,
+                depth,
-                    depth,
+                chain_code,
-                    chain_code,
+            }),
-                })
-            }
             Err(_) => Err(Error::InvalidKey),
         }
     }

crates/derive/keyfork-derive-util/src/lib.rs

@@ -17,7 +17,10 @@ pub mod public_key;
 mod tests;
 
 #[doc(inline)]
-pub use crate::extended_key::{private_key::{ExtendedPrivateKey, Error as XPrvError, VariableLengthSeed}, public_key::{ExtendedPublicKey, Error as XPubError}};
+pub use crate::extended_key::{
+    private_key::{Error as XPrvError, ExtendedPrivateKey, VariableLengthSeed},
+    public_key::{Error as XPubError, ExtendedPublicKey},
+};
 
 pub use crate::{
     index::{DerivationIndex, Error as IndexError},

crates/derive/keyfork-derive-util/src/public_key.rs

@@ -110,7 +110,7 @@ impl PublicKey for k256::PublicKey {
 
     fn derive_child(&self, other: PrivateKeyBytes) -> Result<Self, Self::Err> {
         use k256::elliptic_curve::ScalarPrimitive;
-        use k256::{Secp256k1, Scalar};
+        use k256::{Scalar, Secp256k1};
 
         // Construct a scalar from bytes
         let scalar = ScalarPrimitive::<Secp256k1>::from_bytes(&other.into());

crates/derive/keyfork-derive-util/src/tests.rs

@@ -13,10 +13,7 @@ use keyfork_slip10_test_data::{test_data, Test};
 fn secp256k1() {
     use k256::SecretKey;
 
-    let tests = test_data()
+    let tests = test_data().unwrap().remove("secp256k1").unwrap();
-        .unwrap()
-        .remove("secp256k1")
-        .unwrap();
 
     for per_seed in tests {
         let seed = &per_seed.seed;

crates/keyfork-shard/src/bin/keyfork-shard-combine-openpgp.rs

@@ -35,7 +35,11 @@ fn run() -> Result<()> {
     let openpgp = OpenPGP;
     let prompt_handler = default_handler()?;
 
-    let bytes = openpgp.decrypt_all_shards_to_secret(key_discovery.as_deref(), messages_file, prompt_handler)?;
+    let bytes = openpgp.decrypt_all_shards_to_secret(
+        key_discovery.as_deref(),
+        messages_file,
+        prompt_handler,
+    )?;
     print!("{}", smex::encode(bytes));
 
     Ok(())

crates/keyfork-shard/src/bin/keyfork-shard-decrypt-openpgp.rs

@@ -8,7 +8,7 @@ use std::{
 };
 
 use keyfork_prompt::default_handler;
-use keyfork_shard::{Format, openpgp::OpenPGP};
+use keyfork_shard::{openpgp::OpenPGP, Format};
 
 type Result<T, E = Box<dyn std::error::Error>> = std::result::Result<T, E>;
 
@@ -35,7 +35,11 @@ fn run() -> Result<()> {
     let openpgp = OpenPGP;
     let prompt_handler = default_handler()?;
 
-    openpgp.decrypt_one_shard_for_transport(key_discovery.as_deref(), messages_file, prompt_handler)?;
+    openpgp.decrypt_one_shard_for_transport(
+        key_discovery.as_deref(),
+        messages_file,
+        prompt_handler,
+    )?;
 
     Ok(())
 }

crates/keyfork-shard/src/bin/keyfork-shard-remote.rs

@@ -1,9 +1,6 @@
 //! Combine OpenPGP shards using remote transport and output the hex-encoded secret.
 
-use std::{
+use std::{env, process::ExitCode};
-    env,
-    process::ExitCode,
-};
 
 use keyfork_shard::remote_decrypt;
 

crates/keyfork-shard/src/bin/keyfork-shard-split-openpgp.rs

@@ -2,7 +2,7 @@
 
 use std::{env, path::PathBuf, process::ExitCode, str::FromStr};
 
-use keyfork_shard::{Format, openpgp::OpenPGP};
+use keyfork_shard::{openpgp::OpenPGP, Format};
 
 #[derive(Clone, Debug)]
 enum Error {
@@ -52,7 +52,13 @@ fn run() -> Result<()> {
 
     let openpgp = OpenPGP;
 
-    openpgp.shard_and_encrypt(threshold, max, &input, key_discovery.as_path(), std::io::stdout())?;
+    openpgp.shard_and_encrypt(
+        threshold,
+        max,
+        &input,
+        key_discovery.as_path(),
+        std::io::stdout(),
+    )?;
     Ok(())
 }
 

crates/keyfork-shard/src/openpgp.rs

@@ -6,11 +6,12 @@ use std::{
     collections::HashMap,
     io::{Read, Write},
     path::Path,
+    rc::Rc,
     str::FromStr,
     sync::Mutex,
-    rc::Rc,
 };
 
+use blahaj::Share;
 use keyfork_bug::bug;
 use keyfork_derive_openpgp::{
     derive_util::{DerivationPath, VariableLengthSeed},
@@ -25,7 +26,7 @@ use openpgp::{
         stream::{DecryptionHelper, DecryptorBuilder, VerificationHelper},
         Parse,
     },
-    policy::{NullPolicy, StandardPolicy, Policy},
+    policy::{NullPolicy, Policy, StandardPolicy},
     serialize::{
         stream::{ArbitraryWriter, Encryptor2, LiteralWriter, Message, Recipient, Signer},
         Marshal,
@@ -34,7 +35,6 @@ use openpgp::{
     KeyID, PacketPile,
 };
 pub use sequoia_openpgp as openpgp;
-use blahaj::Share;
 
 mod keyring;
 use keyring::Keyring;
@@ -238,7 +238,7 @@ impl OpenPGP {
             let policy = StandardPolicy::new();
             let valid_cert = cert.with_policy(&policy, None).map_err(Error::Sequoia)?;
             if get_encryption_keys(&valid_cert).next().is_none() {
-                return Err(Error::NoValidKeys(valid_cert.keyid()))
+                return Err(Error::NoValidKeys(valid_cert.keyid()));
             }
         }
         Ok(certs.into_values().collect())

crates/keyfork/src/clap_ext.rs

@@ -43,7 +43,7 @@ impl FromStr for Options {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if s.is_empty() {
-            return Ok(Default::default())
+            return Ok(Default::default());
         }
         let values = s
             .split(',')

crates/keyfork/src/cli/derive.rs

@@ -1,4 +1,4 @@
-use super::{Keyfork, create};
+use super::{create, Keyfork};
 use clap::{Args, Parser, Subcommand, ValueEnum};
 use std::{fmt::Display, io::Write, path::PathBuf};
 
@@ -141,10 +141,9 @@ impl Display for Slug {
         #[allow(clippy::redundant_at_rest_pattern)]
         match (self.0.inner() & (0b1 << 31)).to_be_bytes().as_slice() {
             [0, 0, 0, 0] => Ok(()),
-            [0, 0, 0, bytes @ ..] | [0, 0, bytes @ ..] | [0, bytes @ ..] | [bytes @ ..] => f
+            [0, 0, 0, bytes @ ..] | [0, 0, bytes @ ..] | [0, bytes @ ..] | [bytes @ ..] => {
-                .write_str(
+                f.write_str(std::str::from_utf8(bytes).expect("slug constructed from non-utf8"))
-                    std::str::from_utf8(bytes).expect("slug constructed from non-utf8"),
+            }
-                ),
         }
     }
 }

crates/keyfork/src/cli/mnemonic.rs

@@ -1,8 +1,7 @@
 use super::{
     create,
     derive::{self, Deriver},
-    provision,
+    provision, Keyfork,
-    Keyfork,
 };
 use crate::{clap_ext::*, config, openpgp_card::factory_reset_current_card};
 use card_backend_pcsc::PcscBackend;
@@ -20,7 +19,7 @@ use keyfork_derive_openpgp::{
     openpgp::{
         self,
         armor::{Kind, Writer},
-        packet::{UserID, signature::SignatureBuilder},
+        packet::{signature::SignatureBuilder, UserID},
         policy::StandardPolicy,
         serialize::{
             stream::{Encryptor2, LiteralWriter, Message, Recipient},
@@ -544,7 +543,9 @@ fn derive_key(seed: [u8; 64], index: u8) -> Result<openpgp::Cert, Box<dyn std::e
     ];
 
     let subkey = DerivationIndex::new(u32::from(index), true)?;
-    let path = keyfork_derive_path_data::paths::OPENPGP_SHARD.clone().chain_push(subkey);
+    let path = keyfork_derive_path_data::paths::OPENPGP_SHARD
+        .clone()
+        .chain_push(subkey);
     let xprv = XPrv::new(seed)
         .expect("could not construct master key from seed")
         .derive_path(&path)?;

crates/keyfork/src/cli/mod.rs

@@ -7,7 +7,7 @@ mod recover;
 mod shard;
 
 pub fn create(path: &std::path::Path) -> std::io::Result<std::fs::File> {
-    eprintln!("Writing derived key to: {path}", path=path.display());
+    eprintln!("Writing derived key to: {path}", path = path.display());
     std::fs::File::create(path)
 }
 
@@ -96,12 +96,7 @@ impl KeyforkCommands {
             KeyforkCommands::Completion { shell } => {
                 let mut command = Keyfork::command();
                 let command_name = command.get_name().to_string();
-                clap_complete::generate(
+                clap_complete::generate(*shell, &mut command, command_name, &mut std::io::stdout());
-                    *shell,
-                    &mut command,
-                    command_name,
-                    &mut std::io::stdout(),
-                );
             }
         }
         Ok(())

crates/keyfork/src/cli/provision/mod.rs

@@ -94,7 +94,10 @@ impl Provisioner {
 
 impl ValueEnum for Provisioner {
     fn value_variants<'a>() -> &'a [Self] {
-        &[Self::OpenPGPCard(openpgp::OpenPGPCard), Self::Shard(openpgp::Shard)]
+        &[
+            Self::OpenPGPCard(openpgp::OpenPGPCard),
+            Self::Shard(openpgp::Shard),
+        ]
     }
 
     fn to_possible_value(&self) -> Option<PossibleValue> {

crates/keyfork/src/cli/recover.rs

@@ -1,10 +1,10 @@
 use super::Keyfork;
 use clap::{Parser, Subcommand};
-use std::path::PathBuf;
 use nix::{
     sys::wait::waitpid,
     unistd::{fork, ForkResult},
 };
+use std::path::PathBuf;
 
 use keyfork_mnemonic::{English, Mnemonic};
 use keyfork_prompt::{
@@ -86,7 +86,7 @@ pub struct Recover {
     command: RecoverSubcommands,
 
     /// Daemonize the server once started, restoring control back to the shell.
-    #[arg(long, global=true)]
+    #[arg(long, global = true)]
     daemon: bool,
 }
 
@@ -102,12 +102,12 @@ impl Recover {
                     // wait for the child to die, so we don't exit prematurely
                     waitpid(Some(child), None)?;
                     return Ok(());
-                },
+                }
                 ForkResult::Child => {
                     if let ForkResult::Parent { .. } = unsafe { fork() }? {
                         return Ok(());
                     }
-                },
+                }
             }
         }
         tokio::runtime::Builder::new_multi_thread()

crates/keyfork/src/cli/shard.rs

@@ -109,14 +109,15 @@ impl ShardExec for OpenPGP {
         output: &mut impl Write,
     ) -> Result<(), Box<dyn std::error::Error>> {
         use keyfork_derive_openpgp::openpgp::{
+            armor::{Kind, Writer},
             serialize::Marshal,
-            armor::{Writer, Kind},
         };
 
         let openpgp = keyfork_shard::openpgp::OpenPGP;
         let prompt = default_handler()?;
 
-        let (threshold, certs) = openpgp.decrypt_metadata_from_file(key_discovery, input, prompt)?;
+        let (threshold, certs) =
+            openpgp.decrypt_metadata_from_file(key_discovery, input, prompt)?;
         let mut writer = Writer::new(output_pubkeys, Kind::PublicKey)?;
         for cert in certs {
             cert.serialize(&mut writer)?;
@@ -187,7 +188,7 @@ pub enum ShardSubcommands {
 
         /// The path to discover private keys from.
         key_discovery: Option<PathBuf>,
-    }
+    },
 }
 
 impl ShardSubcommands {
@@ -256,7 +257,11 @@ impl ShardSubcommands {
                     None => panic!("{COULD_NOT_DETERMINE_FORMAT}"),
                 }
             }
-            ShardSubcommands::Metadata { shardfile, output_pubkeys, key_discovery } => {
+            ShardSubcommands::Metadata {
+                shardfile,
+                output_pubkeys,
+                key_discovery,
+            } => {
                 let shard_content = std::fs::read_to_string(shardfile)?;
                 if shard_content.contains("BEGIN PGP MESSAGE") {
                     let _ = format.insert(Format::OpenPGP(OpenPGP));

crates/keyfork/src/main.rs

@@ -1,5 +1,4 @@
 #![doc = include_str!("../README.md")]
-
 #![allow(clippy::module_name_repetitions)]
 
 use std::process::ExitCode;
@@ -8,9 +7,9 @@ use clap::Parser;
 
 use keyfork_bin::{Bin, ClosureBin};
 
+pub mod clap_ext;
 mod cli;
 mod config;
-pub mod clap_ext;
 mod openpgp_card;
 
 fn main() -> ExitCode {

crates/qrcode/keyfork-qrcode/src/lib.rs

@@ -171,7 +171,6 @@ fn dbg_elapsed(count: u64, instant: Instant) {
     let framerate = count as f64 / elapsed as f64;
     eprintln!("framerate: {count}/{elapsed} = {framerate}");
     std::thread::sleep(std::time::Duration::from_secs(5));
-
 }
 
 #[derive(Debug)]

crates/qrcode/keyfork-zbar-sys/build.rs

@@ -45,7 +45,7 @@ fn main() -> Result<()> {
     if let Err(e) = generate_bindings_file() {
         eprintln!("Building zbar-sys failed: {e}");
         eprintln!("Ensure zbar headers, libclang, and pkg-config are installed");
-        return Err(e)
+        return Err(e);
     }
 
     Ok(())

crates/qrcode/keyfork-zbar/src/image.rs

@@ -43,12 +43,7 @@ impl Image {
     /// Accepts raw data in the configured format. See: [`Image::set_format`]
     fn set_data(&mut self, data: Vec<u8>) {
         unsafe {
-            sys::zbar_image_set_data(
+            sys::zbar_image_set_data(self.inner, data.as_ptr().cast(), data.len() as u64, None)
-                self.inner,
-                data.as_ptr().cast(),
-                data.len() as u64,
-                None,
-            )
         }
         // keep data in self to avoid use after free when data goes out of scope
         let _ = self.inner_data.insert(data);

crates/qrcode/keyfork-zbar/src/image_scanner.rs

@@ -58,10 +58,7 @@ impl ImageScanner {
     /// Link: [`sys::zbar_scan_image`]
     ///
     /// TODO: return an iterator over scanned values
-    pub fn scan_image(
+    pub fn scan_image(&mut self, image: &Image) -> Vec<Symbol> {
-        &mut self,
-        image: &Image,
-    ) -> Vec<Symbol> {
         unsafe { sys::zbar_scan_image(self.inner, image.inner) };
         let mut result = vec![];
         let mut symbol = unsafe { sys::zbar_image_first_symbol(image.inner) };

crates/qrcode/keyfork-zbar/src/lib.rs

@@ -11,6 +11,6 @@ pub use sys::zbar_config_e as Config;
 pub use sys::zbar_modifier_e as Modifier;
 pub use sys::zbar_orientation_e as Orientation;
 
-pub mod image_scanner;
 pub mod image;
+pub mod image_scanner;
 pub mod symbol;

crates/util/keyfork-bin/src/lib.rs

@@ -68,7 +68,7 @@ pub trait Bin {
     #[allow(clippy::missing_errors_doc)]
     fn validate_args(&self, args: impl Iterator<Item = String>) -> ProcessResult<Self::Args>;
 
-    /// Run the binary 
+    /// Run the binary
     #[allow(clippy::missing_errors_doc)]
     fn run(&self, args: Self::Args) -> ProcessResult;
 
@@ -102,10 +102,13 @@ pub trait Bin {
 
 /// A Bin that doesn't take any arguments.
 pub struct ClosureBin<F: Fn() -> ProcessResult> {
-    closure: F
+    closure: F,
 }
 
-impl<F> ClosureBin<F> where F: Fn() -> ProcessResult {
+impl<F> ClosureBin<F>
+where
+    F: Fn() -> ProcessResult,
+{
     /// Create a new Bin from a closure.
     ///
     /// # Examples
@@ -120,13 +123,14 @@ impl<F> ClosureBin<F> where F: Fn() -> ProcessResult {
     /// bin.main();
     /// ```
     pub fn new(closure: F) -> Self {
-        Self {
+        Self { closure }
-            closure
-        }
     }
 }
 
-impl<F> Bin for ClosureBin<F> where F: Fn() -> ProcessResult {
+impl<F> Bin for ClosureBin<F>
+where
+    F: Fn() -> ProcessResult,
+{
     type Args = ();
 
     fn validate_args(&self, _args: impl Iterator<Item = String>) -> ProcessResult<Self::Args> {

crates/util/keyfork-mnemonic/src/bin/keyfork-mnemonic-from-seed.rs

@@ -8,7 +8,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     input.read_line(&mut line)?;
     let decoded = smex::decode(line.trim())?;
 
-    let mnemonic = Mnemonic::from_raw_bytes(&decoded) ;
+    let mnemonic = Mnemonic::from_raw_bytes(&decoded);
 
     println!("{mnemonic}");
 

crates/util/keyfork-mnemonic/src/lib.rs

@@ -114,7 +114,9 @@ impl Wordlist for English {
             let mut words = wordlist_file.lines().skip(1).map(|x| x.trim().to_string());
             English {
                 words: std::array::from_fn(|_| {
-                    words.next().expect(bug!("wordlist {} should have 2048 words"))
+                    words
+                        .next()
+                        .expect(bug!("wordlist {} should have 2048 words"))
                 }),
             }
         })
@@ -283,7 +285,7 @@ where
             return Err(MnemonicGenerationError::InvalidByteLength(bit_count));
         }
 
-        Ok( Self::from_raw_bytes(bytes) )
+        Ok(Self::from_raw_bytes(bytes))
     }
 
     /// Generate a [`Mnemonic`] from the provided data and [`Wordlist`]. The data may be of a size

crates/util/keyfork-prompt/src/terminal.rs

@@ -148,7 +148,9 @@ where
                 .queue(cursor::MoveTo(0, 0))
                 .expect(bug!("can't move to origin"));
         }
-        self.write.flush().expect(bug!("can't execute terminal reset commands"));
+        self.write
+            .flush()
+            .expect(bug!("can't execute terminal reset commands"));
     }
 }
 
@@ -349,12 +351,14 @@ where
                     KeyCode::Left | KeyCode::Up => {
                         active_choice = active_choice.saturating_sub(1);
                     }
-                    KeyCode::Right | KeyCode::Down => match choices.len().saturating_sub(active_choice) {
+                    KeyCode::Right | KeyCode::Down => {
-                        0 | 1 => {}
+                        match choices.len().saturating_sub(active_choice) {
-                        _ => {
+                            0 | 1 => {}
-                            active_choice += 1;
+                            _ => {
+                                active_choice += 1;
+                            }
                         }
-                    },
+                    }
                     KeyCode::Enter => {
                         return Ok(active_choice);
                     }

crates/util/keyfork-prompt/src/validators.rs

@@ -87,9 +87,7 @@ impl Validator for SecurePinValidator {
                 if !range.contains(&ch) {
                     return Err(Box::new(PinError::InvalidCharacters(ch, index)));
                 }
-                if [-1, 1].contains(&(ch as i32 - last_char))
+                if [-1, 1].contains(&(ch as i32 - last_char)) && !ignore_sequential_characters {
-                    && !ignore_sequential_characters
-                {
                     score += 1;
                 }
                 last_char = ch as i32;
@@ -102,7 +100,7 @@ impl Validator for SecurePinValidator {
                 score += s.chars().count() - chars.len();
             }
             if score * 2 > s.chars().count() {
-                return Err(Box::new(PinError::InsecurePIN))
+                return Err(Box::new(PinError::InsecurePIN));
             }
             Ok(s)
         })