rustfmt

Author: jgraef

accounts/tree-primitives/src/accounts_tree_node.rs

@@ -317,10 +317,10 @@ mod tests {
 
     use super::*;
     use nimiq_account::{BasicAccount, HashedTimeLockedContract, VestingContract};
+    use nimiq_hash::HashOutput;
     use nimiq_keys::Address;
     use nimiq_primitives::coin::Coin;
     use nimiq_transaction::account::htlc_contract::{AnyHash, HashAlgorithm};
-    use nimiq_hash::HashOutput;
 
     const EMPTY_ROOT: &str = "000000";
     const ROOT: &str = "0000100130038679a597d998138965b1793503993691e50d3910347f2e6274327e0806c72d01311f5fec71d6df5709e7adb711835a80da5cca8ce27896a3e4a241977f62c142eb0132ef92a236c7622e6790bf8cfd13084488aa13d46109ecbbcca4579a4de8da2bdf01330ca9352121ed6a6ab793e124fb6453d96886cfdb9b8a399176ebc791313fd93001342161b614ecf10695066f82254149101292df15a8c7592ae3b44a2839247eeb1a01353604eb34e8720018f389a124eb7c05997b02c345a3f35ae06138584bb849d1b90136cfdf697dced7f0c07a09fdf2a7ba11641575205080cd9179f182a96ea01a69ca0137aea67da2ffc348458e4d8444477be2d6720da53c18414e0f6aed72ba4b5fd8b801383a6fc24a01fb88dc151dcc4d861e61e6951312c07be024d4df52ef5821dd77110139113ecaa04dfeeccef55576e7edc42a882cf9abb166509aca9598eb1b07b32f9a0161043cf8dd6f459a1edfdd1c7c25bd94263e0d00e650912967bb54ff899aa101bf01621cf41c547dba18db0b92b09a59d73c64e1be0f026ffcc7f56aad1f91938f07bd0163f4f3a285954a201a850e4331c7eeace387a83556dbac3c8ada406630b231110e0164297b13179a75cb0dd2288297d167c59cfd9fd29e20a0a20ad9a3c7e8f97ce308016596ee021457f86b14100eebe16efbe1c207f5914f59582cf7f64c986a3dca53040166ba6e9a80a103cac67f82938f6d6a63f1c87b9f4d1e06161ee63943461199b46e";

beserial/src/lib.rs

@@ -12,10 +12,10 @@ pub use crate::types::uvar;
 
 #[cfg(feature = "bitvec")]
 mod bitvec;
-#[cfg(feature = "net")]
-mod net;
 #[cfg(feature = "libp2p")]
 mod libp2p;
+#[cfg(feature = "net")]
+mod net;
 mod types;
 
 // Base traits
@@ -88,10 +88,8 @@ impl From<SerializingError> for std::io::Error {
     }
 }
 
-
 // Implementation for u8 and u16/32/64/128 (big endian)
 
-
 impl Deserialize for u8 {
     fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
         Ok(reader.read_u8()?)
@@ -164,7 +162,6 @@ primitive_serialize!(i128, 16, read_i128, write_i128);
 primitive_serialize!(f32, 4, read_f32, write_f32);
 primitive_serialize!(f64, 8, read_f64, write_f64);
 
-
 // Unit
 
 impl Deserialize for () {
@@ -541,8 +538,7 @@ impl<T: Serialize> SerializeWithLength for [T] {
     fn serialize<S: Serialize + num::FromPrimitive, W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
         let mut size = 0;
 
-        let n = S::from_usize(self.len())
-            .ok_or(SerializingError::Overflow)?;
+        let n = S::from_usize(self.len()).ok_or(SerializingError::Overflow)?;
         size += Serialize::serialize(&n, writer)?;
 
         for elem in self {

beserial/src/libp2p.rs

@@ -2,14 +2,10 @@
 
 use std::convert::TryFrom;
 
-use libp2p::{
-    identity::PublicKey,
-    Multiaddr, PeerId,
-};
-use byteorder::{WriteBytesExt, ReadBytesExt};
-
-use crate::{Serialize, Deserialize, SerializeWithLength, DeserializeWithLength, SerializingError, uvar};
+use byteorder::{ReadBytesExt, WriteBytesExt};
+use libp2p::{identity::PublicKey, Multiaddr, PeerId};
 
+use crate::{uvar, Deserialize, DeserializeWithLength, Serialize, SerializeWithLength, SerializingError};
 
 impl Serialize for Multiaddr {
     fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
@@ -26,19 +22,17 @@ impl Serialize for Multiaddr {
 impl Deserialize for Multiaddr {
     fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
         let buf: Vec<u8> = DeserializeWithLength::deserialize::<u8, R>(reader)?;
-        Multiaddr::try_from(buf)
-            .map_err(|_| SerializingError::InvalidValue)
+        Multiaddr::try_from(buf).map_err(|_| SerializingError::InvalidValue)
     }
 }
 
-
 impl Serialize for PublicKey {
     fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
         match self {
             PublicKey::Ed25519(pk) => {
                 writer.write_all(&pk.encode())?;
                 Ok(32) // `PublicKey::encode` always returns a `[u8; 32]`.
-            },
+            }
             _ => panic!("Only ed25519 keys are currently supported for serialization."),
         }
     }
@@ -52,13 +46,11 @@ impl Deserialize for PublicKey {
     fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
         let mut buf = [0u8; 32];
         reader.read_exact(&mut buf)?;
-        let pk = libp2p::identity::ed25519::PublicKey::decode(&buf)
-            .map_err(|_| SerializingError::InvalidValue)?;
+        let pk = libp2p::identity::ed25519::PublicKey::decode(&buf).map_err(|_| SerializingError::InvalidValue)?;
         Ok(PublicKey::Ed25519(pk))
     }
 }
 
-
 impl Serialize for PeerId {
     fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
         SerializeWithLength::serialize::<u8, W>(self.as_bytes(), writer)
@@ -71,7 +63,6 @@ impl Serialize for PeerId {
 
 impl Deserialize for PeerId {
     fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
-        PeerId::from_bytes(DeserializeWithLength::deserialize::<u8, R>(reader)?)
-            .map_err(|_| SerializingError::InvalidValue)
+        PeerId::from_bytes(DeserializeWithLength::deserialize::<u8, R>(reader)?).map_err(|_| SerializingError::InvalidValue)
     }
 }

messages/src/lib.rs

@@ -35,7 +35,7 @@ use block_albatross::{
 use handel::update::LevelUpdateMessage;
 use hash::Blake2bHash;
 use keys::{Address, KeyPair, PublicKey, Signature};
-use macros::{create_typed_array, add_hex_io_fns_typed_arr};
+use macros::{add_hex_io_fns_typed_arr, create_typed_array};
 use network_interface::message::Message as MessageInterface;
 use peer_address::address::{PeerAddress, PeerId};
 use peer_address::protocol::ProtocolFlags;

mnemonic/src/lib.rs

@@ -10,7 +10,7 @@ use bitvec::prelude::{AsBits, BitSlice, BitVec, Msb0};
 use unicode_normalization::UnicodeNormalization;
 
 use hash::pbkdf2::{compute_pbkdf2_sha512, Pbkdf2Error};
-use hash::{Hasher, Sha256Hasher, HashOutput};
+use hash::{HashOutput, Hasher, Sha256Hasher};
 use macros::{add_hex_io_fns_typed_arr, create_typed_array};
 use utils::crc::Crc8Computer;
 

network-albatross/src/network.rs

@@ -2,26 +2,24 @@ use std::cmp;
 use std::sync::{Arc, Weak};
 use std::time::Duration;
 
+use async_trait::async_trait;
 use atomic::Atomic;
 use atomic::Ordering;
+use futures_03::Stream;
 use parking_lot::RwLock;
 use parking_lot::RwLockReadGuard;
 use rand::rngs::OsRng;
 use rand::Rng;
-use tokio_02::sync::broadcast;
-use async_trait::async_trait;
-use futures_03::Stream;
 use thiserror::Error;
+use tokio_02::sync::broadcast;
 
-use beserial::{Serialize, Deserialize};
+use beserial::{Deserialize, Serialize};
 use blockchain_albatross::Blockchain;
 use genesis::NetworkId;
 use macros::upgrade_weak;
 use network_interface::{
     network::Topic,
-    prelude::{
-        Network as NetworkInterface, NetworkEvent as NetworkEventI, Peer as PeerInterface,
-    }
+    prelude::{Network as NetworkInterface, NetworkEvent as NetworkEventI, Peer as PeerInterface},
 };
 use utils::mutable_once::MutableOnce;
 use utils::observer::Notifier;
@@ -40,11 +38,8 @@ use crate::peer_channel::PeerChannel;
 use crate::peer_scorer::PeerScorer;
 use crate::Peer;
 
-
 #[derive(Debug, Error)]
-pub enum NetworkError {
-
-}
+pub enum NetworkError {}
 
 #[derive(Debug, Ord, PartialOrd, PartialEq, Eq, Hash)]
 enum NetworkTimer {
@@ -435,31 +430,31 @@ impl NetworkInterface for Network {
     }
 
     async fn subscribe<T>(_topic: &T) -> Box<dyn Stream<Item = (T::Item, Self::PeerType)> + Send>
-        where
-            T: Topic + Sync,
+    where
+        T: Topic + Sync,
     {
         unimplemented!()
     }
 
     async fn publish<T>(_topic: &T, _item: <T as Topic>::Item)
-        where
-            T: Topic + Sync,
+    where
+        T: Topic + Sync,
     {
         unimplemented!()
     }
 
     async fn dht_get<K, V>(&self, _k: &K) -> Result<V, Self::Error>
-        where
-            K: AsRef<[u8]> + Send + Sync,
-            V: Deserialize + Send + Sync,
+    where
+        K: AsRef<[u8]> + Send + Sync,
+        V: Deserialize + Send + Sync,
     {
         unimplemented!()
     }
 
     async fn dht_put<K, V>(&self, _k: &K, _v: &V) -> Result<(), Self::Error>
-        where
-            K: AsRef<[u8]> + Send + Sync,
-            V: Serialize + Send + Sync,
+    where
+        K: AsRef<[u8]> + Send + Sync,
+        V: Serialize + Send + Sync,
     {
         unimplemented!()
     }

network-albatross/src/peer.rs

@@ -8,14 +8,14 @@ use async_trait::async_trait;
 use futures_03::Stream;
 
 use hash::Blake2bHash;
-use network_interface::prelude::{CloseReason, Message, Peer as PeerInterface, SendError};
 use network_interface::peer::RequestResponse;
+use network_interface::prelude::{CloseReason, Message, Peer as PeerInterface, SendError};
 use peer_address::address::NetAddress;
 use peer_address::address::PeerAddress;
 
 use crate::connection::close_type::CloseType;
-use crate::peer_channel::PeerChannel;
 use crate::network::NetworkError;
+use crate::peer_channel::PeerChannel;
 
 #[derive(Clone, Debug)]
 pub struct Peer {

network-albatross/src/peer_channel/channel.rs

@@ -22,7 +22,7 @@ use parking_lot::RwLock;
 use beserial::Deserialize;
 use network_interface::message::{peek_type, Message};
 use network_interface::peer::dispatch::{unbounded_dispatch, DispatchError};
-use network_interface::peer::{CloseReason, Peer as PeerInterface, SendError as SendErrorI, RequestResponse};
+use network_interface::peer::{CloseReason, Peer as PeerInterface, RequestResponse, SendError as SendErrorI};
 use network_messages::MessageNotifier;
 use peer_address::address::PeerAddress;
 use utils::observer::Notifier;
@@ -31,10 +31,10 @@ use crate::connection::close_type::CloseType;
 use crate::connection::network_connection::AddressInfo;
 use crate::connection::network_connection::ClosedFlag;
 use crate::connection::network_connection::NetworkConnection;
+use crate::network::NetworkError;
 #[cfg(feature = "metrics")]
 use crate::network_metrics::MessageMetrics;
 use crate::websocket::Message as WebSocketMessage;
-use crate::network::NetworkError;
 
 use super::sink::PeerSink;
 use super::stream::PeerStreamEvent;

network-interface/src/lib.rs

@@ -1,8 +1,8 @@
 pub mod message;
 pub mod network;
 pub mod peer;
-pub mod request_response;
 pub mod peer_map;
+pub mod request_response;
 
 pub mod prelude {
     pub use crate::message::*;

network-interface/src/message/mod.rs

@@ -112,10 +112,7 @@ pub fn peek_length(buffer: &[u8]) -> Result<usize, SerializingError> {
     Ok(n as usize)
 }
 
-pub async fn read_message<R: AsyncRead + Unpin>(
-    mut reader: R,
-) -> Result<Vec<u8>, SerializingError> {
-
+pub async fn read_message<R: AsyncRead + Unpin>(mut reader: R) -> Result<Vec<u8>, SerializingError> {
     log::trace!("read_message: reading magic and first byte of type...");
     // Read message magic and first type byte.
     let mut msg = vec![0; 5];