Consolidate imports

src/accountant.rs

@@ -3,13 +3,15 @@
 //! transfer funds to other users.
 
 use log::{hash, Entry, Sha256Hash};
-use event::{Event, PublicKey, Signature};
+use event::{get_pubkey, sign_transaction_data, Event, PublicKey, Signature};
 use genesis::Genesis;
 use historian::Historian;
 use ring::signature::Ed25519KeyPair;
 use std::sync::mpsc::SendError;
 use std::collections::HashMap;
 use std::result;
+use std::thread::sleep;
+use std::time::Duration;
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum AccountingError {
@@ -107,7 +109,6 @@ impl Accountant {
         keypair: &Ed25519KeyPair,
         to: PublicKey,
     ) -> Result<Signature> {
-        use event::{get_pubkey, sign_transaction_data};
         let from = get_pubkey(keypair);
         let sig = sign_transaction_data(&n, keypair, &to);
         let event = Event::Transaction {
@@ -124,8 +125,6 @@ impl Accountant {
     }
 
     pub fn wait_on_signature(self: &mut Self, wait_sig: &Signature) {
-        use std::thread::sleep;
-        use std::time::Duration;
         let mut entries = self.sync();
         let mut found = false;
         while !found {
@@ -147,6 +146,8 @@ mod tests {
     use event::{generate_keypair, get_pubkey};
     use logger::ExitReason;
     use genesis::Creator;
+    use std::thread::sleep;
+    use std::time::Duration;
 
     #[test]
     fn test_accountant() {
@@ -169,8 +170,6 @@ mod tests {
 
     #[test]
     fn test_invalid_transfer() {
-        use std::thread::sleep;
-        use std::time::Duration;
         let bob = Creator::new(1_000);
         let bob_pubkey = bob.pubkey;
         let alice = Genesis::new(11_000, vec![bob]);

src/accountant_skel.rs

@@ -1,6 +1,8 @@
 use std::io;
 use accountant::Accountant;
 use event::{Event, PublicKey, Signature};
+use std::net::UdpSocket;
+use bincode::{deserialize, serialize};
 
 pub struct AccountantSkel {
     pub obj: Accountant,
@@ -60,8 +62,6 @@ impl AccountantSkel {
 
     /// UDP Server that forwards messages to Accountant methods.
     pub fn serve(self: &mut Self, addr: &str) -> io::Result<()> {
-        use std::net::UdpSocket;
-        use bincode::{deserialize, serialize};
         let socket = UdpSocket::bind(addr)?;
         let mut buf = vec![0u8; 1024];
         loop {

src/accountant_stub.rs

@@ -5,7 +5,7 @@
 use std::net::UdpSocket;
 use std::io;
 use bincode::{deserialize, serialize};
-use event::{PublicKey, Signature};
+use event::{get_pubkey, sign_transaction_data, PublicKey, Signature};
 use ring::signature::Ed25519KeyPair;
 use accountant_skel::{Request, Response};
 
@@ -40,7 +40,6 @@ impl AccountantStub {
         keypair: &Ed25519KeyPair,
         to: PublicKey,
     ) -> io::Result<Signature> {
-        use event::{get_pubkey, sign_transaction_data};
         let from = get_pubkey(keypair);
         let sig = sign_transaction_data(&n, keypair, &to);
         self.transfer_signed(from, to, n, sig).map(|_| sig)

src/bin/client-demo.rs

@@ -1,19 +1,18 @@
 //extern crate serde_json;
 extern crate silk;
 
+use silk::accountant_stub::AccountantStub;
+use silk::accountant_skel::AccountantSkel;
+use silk::accountant::Accountant;
+use silk::event::{generate_keypair, get_pubkey, sign_transaction_data, verify_event, Event};
+use silk::genesis::Genesis;
+use std::time::Instant;
+use std::net::UdpSocket;
+use std::thread::{sleep, spawn};
+use std::time::Duration;
 //use std::io::stdin;
 
 fn main() {
-    use silk::accountant_stub::AccountantStub;
-    use silk::accountant_skel::AccountantSkel;
-    use silk::accountant::Accountant;
-    use silk::event::{generate_keypair, get_pubkey, sign_transaction_data};
-    use silk::genesis::Genesis;
-    use std::time::Instant;
-    use std::net::UdpSocket;
-    use std::thread::{sleep, spawn};
-    use std::time::Duration;
-
     let addr = "127.0.0.1:8000";
     let send_addr = "127.0.0.1:8001";
 
@@ -53,7 +52,6 @@ fn main() {
     );
 
     println!("Verify signatures...");
-    use silk::event::{verify_event, Event};
     let now = Instant::now();
     for &(k, s) in &sigs {
         let e = Event::Transaction {

src/event.rs

@@ -16,7 +16,10 @@
 use generic_array::GenericArray;
 use generic_array::typenum::{U32, U64};
 use ring::signature::Ed25519KeyPair;
+use ring::{rand, signature};
+use untrusted;
 use serde::Serialize;
+use bincode::serialize;
 
 pub type PublicKey = GenericArray<u8, U32>;
 pub type Signature = GenericArray<u8, U64>;
@@ -50,8 +53,6 @@ impl<T> Event<T> {
 
 /// Return a new ED25519 keypair
 pub fn generate_keypair() -> Ed25519KeyPair {
-    use ring::{rand, signature};
-    use untrusted;
     let rng = rand::SystemRandom::new();
     let pkcs8_bytes = signature::Ed25519KeyPair::generate_pkcs8(&rng).unwrap();
     signature::Ed25519KeyPair::from_pkcs8(untrusted::Input::from(&pkcs8_bytes)).unwrap()
@@ -64,7 +65,6 @@ pub fn get_pubkey(keypair: &Ed25519KeyPair) -> PublicKey {
 
 /// Return a signature for the given data using the private key from the given keypair.
 fn sign_serialized<T: Serialize>(data: &T, keypair: &Ed25519KeyPair) -> Signature {
-    use bincode::serialize;
     let serialized = serialize(data).unwrap();
     GenericArray::clone_from_slice(keypair.sign(&serialized).as_ref())
 }
@@ -86,8 +86,6 @@ pub fn sign_claim_data<T: Serialize>(data: &T, keypair: &Ed25519KeyPair) -> Sign
 
 /// Verify a signed message with the given public key.
 pub fn verify_signature(peer_public_key_bytes: &[u8], msg_bytes: &[u8], sig_bytes: &[u8]) -> bool {
-    use untrusted;
-    use ring::signature;
     let peer_public_key = untrusted::Input::from(peer_public_key_bytes);
     let msg = untrusted::Input::from(msg_bytes);
     let sig = untrusted::Input::from(sig_bytes);
@@ -102,7 +100,6 @@ pub fn get_signature<T>(event: &Event<T>) -> Option<Signature> {
 }
 
 pub fn verify_event<T: Serialize>(event: &Event<T>) -> bool {
-    use bincode::serialize;
     if let Event::Transaction {
         from,
         to,

src/historian.rs

@@ -3,13 +3,14 @@
 
 use std::thread::JoinHandle;
 use std::collections::HashSet;
-use std::sync::mpsc::{Receiver, SyncSender};
+use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::time::Instant;
 use log::{hash, Entry, Sha256Hash};
 use logger::{verify_event_and_reserve_signature, ExitReason, Logger};
 use event::{Event, Signature};
 use serde::Serialize;
 use std::fmt::Debug;
+use std::thread;
 
 pub struct Historian<T> {
     pub sender: SyncSender<Event<T>>,
@@ -20,7 +21,6 @@ pub struct Historian<T> {
 
 impl<T: 'static + Serialize + Clone + Debug + Send> Historian<T> {
     pub fn new(start_hash: &Sha256Hash, ms_per_tick: Option<u64>) -> Self {
-        use std::sync::mpsc::sync_channel;
         let (sender, event_receiver) = sync_channel(1000);
         let (entry_sender, receiver) = sync_channel(1000);
         let thread_hdl =
@@ -46,7 +46,6 @@ impl<T: 'static + Serialize + Clone + Debug + Send> Historian<T> {
         receiver: Receiver<Event<T>>,
         sender: SyncSender<Entry<T>>,
     ) -> JoinHandle<(Entry<T>, ExitReason)> {
-        use std::thread;
         thread::spawn(move || {
             let mut logger = Logger::new(receiver, sender, start_hash);
             let now = Instant::now();

src/log.rs

@@ -17,6 +17,9 @@ use generic_array::GenericArray;
 use generic_array::typenum::U32;
 use serde::Serialize;
 use event::*;
+use sha2::{Digest, Sha256};
+use rayon::prelude::*;
+use std::iter;
 
 pub type Sha256Hash = GenericArray<u8, U32>;
 
@@ -41,7 +44,6 @@ impl<T> Entry<T> {
 
 /// Return a Sha256 hash for the given data.
 pub fn hash(val: &[u8]) -> Sha256Hash {
-    use sha2::{Digest, Sha256};
     let mut hasher = Sha256::default();
     hasher.input(val);
     hasher.result()
@@ -114,7 +116,6 @@ pub fn verify_entry<T: Serialize>(entry: &Entry<T>, start_hash: &Sha256Hash) ->
 
 /// Verifies the hashes and counts of a slice of events are all consistent.
 pub fn verify_slice(events: &[Entry<Sha256Hash>], start_hash: &Sha256Hash) -> bool {
-    use rayon::prelude::*;
     let genesis = [Entry::new_tick(Default::default(), start_hash)];
     let event_pairs = genesis.par_iter().chain(events).zip(events);
     event_pairs.all(|(x0, x1)| verify_entry(&x1, &x0.end_hash))
@@ -122,7 +123,6 @@ pub fn verify_slice(events: &[Entry<Sha256Hash>], start_hash: &Sha256Hash) -> bo
 
 /// Verifies the hashes and counts of a slice of events are all consistent.
 pub fn verify_slice_u64(events: &[Entry<u64>], start_hash: &Sha256Hash) -> bool {
-    use rayon::prelude::*;
     let genesis = [Entry::new_tick(Default::default(), start_hash)];
     let event_pairs = genesis.par_iter().chain(events).zip(events);
     event_pairs.all(|(x0, x1)| verify_entry(&x1, &x0.end_hash))
@@ -153,7 +153,6 @@ pub fn create_ticks(
     num_hashes: u64,
     len: usize,
 ) -> Vec<Entry<Sha256Hash>> {
-    use std::iter;
     let mut end_hash = *start_hash;
     iter::repeat(Event::Tick)
         .take(len)

src/logger.rs

@@ -6,7 +6,7 @@
 //! The resulting stream of entries represents ordered events in time.
 
 use std::collections::HashSet;
-use std::sync::mpsc::{Receiver, SyncSender};
+use std::sync::mpsc::{Receiver, SyncSender, TryRecvError};
 use std::time::{Duration, Instant};
 use log::{hash_event, Entry, Sha256Hash};
 use event::{get_signature, verify_event, Event, Signature};
@@ -77,7 +77,6 @@ impl<T: Serialize + Clone + Debug> Logger<T> {
         epoch: Instant,
         ms_per_tick: Option<u64>,
     ) -> Result<(), (Entry<T>, ExitReason)> {
-        use std::sync::mpsc::TryRecvError;
         loop {
             if let Some(ms) = ms_per_tick {
                 if epoch.elapsed() > Duration::from_millis((self.num_ticks + 1) * ms) {