MAINT: Rustfmt enigma-principal/enclave and removed unnecessary dependencies

elichai · elichai · commit 75ce7f9d1de9 · 2019-04-03T11:51:30.000+03:00
diff --git a/enigma-principal/enclave/Cargo.toml b/enigma-principal/enclave/Cargo.toml
@@ -7,34 +7,17 @@ authors = ["Enigma <support@enigma.co>"]
 name = "enigma_principal_enclave"
 crate-type = ["staticlib"]
 
-[features]
-default = []
-
 [dependencies]
 enigma-tools-t = { path = "../../enigma-tools-t" }
 enigma-tools-m = { path = "../../enigma-tools-m", default-features = false, features = ["sgx"] }
 enigma-types = { path = "../../enigma-types", default-features = false, features = ["sgx"] }
 enigma-crypto = { path = "../../enigma-crypto", default-features = false, features = ["sgx", "asymmetric"] }
 
 lazy_static = {version = "=1.2.0", features = ["spin_no_std"] }
-serde = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-serde_derive = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-serde_json = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
 ethabi = { git = "https://github.com/enigmampc/ethabi.git", rev = "sgx-v6.1.0", default-features = false}
 ethereum-types = { git = "https://github.com/enigmampc/primitives.git", rev = "sgx-v0.4.0", default-features = false}
-rustc-hex = { git = "https://github.com/enigmampc/rustc-hex.git", rev = "sgx-2.0.1-v1.0.4"}
-etcommon-hexutil = { version = "0.2", default-features = false }
-libsecp256k1 = "0.2.1"
-etcommon-bigint = { version = "0.2", default-features = false, features = ["rlp"] }
-etcommon-rlp = {version = "0.2", default-features = false}
 
 sgx_types = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
 sgx_tstd = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
 sgx_trts = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-sgx_tse = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-sgx_tdh = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-sgx_tservice = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-sgx_alloc = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-sgx_tseal = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
-sgx_rand = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
 sgx_tunittest = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.4" }
diff --git a/enigma-principal/enclave/src/epoch_keeper_t/epoch_t.rs b/enigma-principal/enclave/src/epoch_keeper_t/epoch_t.rs
@@ -1,11 +1,13 @@
-use ethabi::{Bytes, encode, Token};
-use ethereum_types::{H160, U256};
-use enigma_types::ContractAddress;
-use enigma_tools_t::common::errors_t::{EnclaveError::{self, SystemError}, EnclaveSystemError};
 use enigma_tools_m::keeper_types::{InputWorkerParams, RawEncodable};
+use enigma_tools_t::common::errors_t::{
+    EnclaveError::{self, SystemError},
+    EnclaveSystemError,
+};
+use enigma_types::ContractAddress;
+use ethabi::{encode, Bytes, Token};
+use ethereum_types::{H160, U256};
 use std::string::ToString;
 
-
 pub type EpochNonce = [u8; 32];
 
 #[derive(Debug, Clone)]
@@ -17,8 +19,9 @@ pub struct Epoch {
 
 impl Epoch {
     pub fn get_selected_worker(&self, sc_addr: ContractAddress) -> Result<H160, EnclaveError> {
-        self.worker_params.get_selected_worker(sc_addr, self.seed)
-            .ok_or(SystemError(EnclaveSystemError::WorkerAuthError { err: "Worker selection returns nothing.".to_string() }))
+        self.worker_params
+            .get_selected_worker(sc_addr, self.seed)
+            .ok_or_else(|| SystemError(EnclaveSystemError::WorkerAuthError { err: "Worker selection returns nothing.".to_string() }))
     }
 }
 
diff --git a/enigma-principal/enclave/src/epoch_keeper_t/mod.rs b/enigma-principal/enclave/src/epoch_keeper_t/mod.rs
@@ -1,34 +1,33 @@
-use ethabi::Token;
-use ethereum_types::{H256, H160, U256};
-use sgx_trts::trts::rsgx_read_rand;
-use sgx_types::*;
-use std::collections::HashMap;
-use std::path;
-use std::str;
-use std::string::ToString;
-use std::sync::SgxMutex;
-use std::sync::SgxMutexGuard;
-
-use enigma_crypto::hash::Keccak256;
-use enigma_tools_t::common::errors_t::{EnclaveError, EnclaveError::*, EnclaveSystemError::*};
-use enigma_tools_m::utils::EthereumAddress;
-use enigma_tools_t::common::ToHex;
-use enigma_tools_t::common::utils_t::LockExpectMutex;
-use enigma_tools_t::document_storage_t::{is_document, load_sealed_document, save_sealed_document, SEAL_LOG_SIZE, SealedDocumentStorage};
+use crate::SIGNING_KEY;
+use enigma_tools_m::keeper_types::{decode, InputWorkerParams, RawEncodable};
+use enigma_tools_t::{
+    common::{
+        errors_t::{
+            EnclaveError::{self, *},
+            EnclaveSystemError::*,
+        },
+        utils_t::LockExpectMutex,
+        ToHex,
+    },
+    document_storage_t::{is_document, load_sealed_document, save_sealed_document, SealedDocumentStorage, SEAL_LOG_SIZE},
+};
 use enigma_types::ContractAddress;
 use epoch_keeper_t::epoch_t::{Epoch, EpochNonce};
-use enigma_tools_m::keeper_types::{decode, InputWorkerParams, RawEncodable};
+use ethereum_types::{H160, U256};
 use ocalls_t;
-
-use crate::SIGNING_KEY;
+use sgx_trts::trts::rsgx_read_rand;
+use sgx_types::*;
+use std::{collections::HashMap, path, str, string::ToString, sync::SgxMutex};
 
 pub mod epoch_t;
 
 const INIT_NONCE: uint32_t = 0;
 const EPOCH_DIR: &str = "epoch";
 
 // The epoch seed contains the seeds + a nonce that must match the Ethereum tx
-lazy_static! { pub static ref EPOCH: SgxMutex< HashMap<U256, Epoch >> = SgxMutex::new(HashMap::new()); }
+lazy_static! {
+    pub static ref EPOCH: SgxMutex<HashMap<U256, Epoch>> = SgxMutex::new(HashMap::new());
+}
 
 /// The epoch root path is guaranteed to exist of the enclave was initialized
 fn get_epoch_root_path() -> path::PathBuf {
@@ -37,44 +36,40 @@ fn get_epoch_root_path() -> path::PathBuf {
     path_buf
 }
 
-fn get_epoch_nonce_path() -> path::PathBuf {
-    get_epoch_root_path().join("nonce.sealed")
-}
+fn get_epoch_nonce_path() -> path::PathBuf { get_epoch_root_path().join("nonce.sealed") }
 
 fn get_epoch(epoch_map: &HashMap<U256, Epoch>, block_number: Option<U256>) -> Result<Option<Epoch>, EnclaveError> {
     println!("Getting epoch for block number: {:?}", block_number);
     if block_number.is_some() {
-        return Err(SystemError(WorkerAuthError { err: "Epoch lookup by block number not implemented.".to_string() }));
-    }
-    if epoch_map.is_empty() {
+        Err(SystemError(WorkerAuthError { err: "Epoch lookup by block number not implemented.".to_string() }))
+    } else if epoch_map.is_empty() {
         println!("Epoch not found");
         let nonce_path = get_epoch_nonce_path();
         if is_document(&nonce_path) {
             println!("Unsealing epoch nonce");
             let mut sealed_log_out = [0u8; SEAL_LOG_SIZE];
             load_sealed_document(&nonce_path, &mut sealed_log_out)?;
             let doc = SealedDocumentStorage::<EpochNonce>::unseal(&mut sealed_log_out)?;
-            match doc {
-                Some(doc) => {
-                    let nonce = Some(doc.data);
-                    println!("found epoch marker: {:?}", nonce);
-                    //TODO: unseal the epoch
-                }
-                None => ()
+            if let Some(doc) = doc {
+                let nonce = Some(doc.data);
+                println!("found epoch marker: {:?}", nonce);
+                // TODO: unseal the epoch
             }
         }
-        return Ok(None);
+        Ok(None)
+    } else {
+        // The epoch map cannot be empty here
+        let nonce = epoch_map.keys().max().unwrap();
+        let epoch: Epoch = epoch_map.get(nonce).unwrap().clone();
+        Ok(Some(epoch))
     }
-    // The epoch map cannot be empty here
-    let nonce = epoch_map.keys().max().unwrap().clone();
-    let epoch: Epoch = epoch_map.get(&nonce).unwrap().clone();
-    Ok(Some(epoch))
 }
 
 /// Creates new epoch both in the cache and as sealed documents
-fn new_epoch(nonce_map: &mut HashMap<U256, Epoch>, worker_params: &InputWorkerParams, nonce: U256, seed: U256) -> Result<Epoch, EnclaveError> {
+fn new_epoch(nonce_map: &mut HashMap<U256, Epoch>, worker_params:
+            &InputWorkerParams, nonce: U256, seed: U256) -> Result<Epoch, EnclaveError> {
     let mut marker_doc: SealedDocumentStorage<EpochNonce> = SealedDocumentStorage {
-        version: 0x1234, //TODO: what's this?
+        version: 0x1234, // TODO: what's this?
         data: [0; 32],
     };
     marker_doc.data = nonce.into();
@@ -85,12 +80,8 @@ fn new_epoch(nonce_map: &mut HashMap<U256, Epoch>, worker_params: &InputWorkerPa
     save_sealed_document(&marker_path, &sealed_log_in)?;
     println!("Sealed the epoch marker: {:?}", marker_path);
 
-    let epoch = Epoch {
-        nonce,
-        seed,
-        worker_params: worker_params.clone(),
-    };
-    //TODO: seal the epoch
+    let epoch = Epoch { nonce, seed, worker_params: worker_params.clone() };
+    // TODO: seal the epoch
     println!("Storing epoch: {:?}", epoch);
     match nonce_map.insert(nonce, epoch.clone()) {
         Some(prev) => println!("New epoch stored successfully, previous epoch: {:?}", prev),
@@ -106,8 +97,7 @@ pub(crate) fn ecall_set_worker_params_internal(worker_params_rlp: &[u8], rand_ou
     println!("Successfully decoded RLP worker parameters");
     let mut guard = EPOCH.lock_expect("Epoch");
 
-    let nonce: U256 = get_epoch(&*guard, None)?
-        .map_or_else(|| INIT_NONCE.into(), |_| guard.keys().max().unwrap() + 1);
+    let nonce: U256 = get_epoch(&*guard, None)?.map_or_else(|| INIT_NONCE.into(), |_| guard.keys().max().unwrap() + 1);
 
     println!("Generated a nonce by incrementing the previous by 1 {:?}", nonce);
     *nonce_out = EpochNonce::from(nonce);
@@ -129,7 +119,9 @@ pub(crate) fn ecall_get_epoch_worker_internal(sc_addr: ContractAddress, block_nu
     let epoch = match get_epoch(&guard, block_number)? {
         Some(epoch) => epoch,
         None => {
-            return Err(SystemError(WorkerAuthError { err: format!("No epoch found for block number (None == latest): {:?}", block_number) }));
+            return Err(SystemError(WorkerAuthError {
+                err: format!("No epoch found for block number (None == latest): {:?}", block_number),
+            }));
         }
     };
     println!("Running worker selection using Epoch: {:?}", epoch);
@@ -138,22 +130,17 @@ pub(crate) fn ecall_get_epoch_worker_internal(sc_addr: ContractAddress, block_nu
 }
 
 pub mod tests {
-    use ethereum_types::{H160, U256};
-
     use super::*;
+    use ethereum_types::{H160, U256};
 
-    //noinspection RsTypeCheck
+    // noinspection RsTypeCheck
     pub fn test_get_epoch_worker_internal() {
         let worker_params = InputWorkerParams {
             block_number: U256::from(1),
             workers: vec![H160::from(0), H160::from(1), H160::from(2), H160::from(3)],
             stakes: vec![U256::from(1), U256::from(1), U256::from(1), U256::from(1)],
         };
-        let epoch = Epoch {
-            nonce: U256::from(0),
-            seed: U256::from(1),
-            worker_params,
-        };
+        let epoch = Epoch { nonce: U256::from(0), seed: U256::from(1), worker_params };
         println!("The epoch: {:?}", epoch);
         let sc_addr = ContractAddress::from([1u8; 32]);
         let worker = epoch.get_selected_worker(sc_addr).unwrap();
diff --git a/enigma-principal/enclave/src/keys_keeper_t/mod.rs b/enigma-principal/enclave/src/keys_keeper_t/mod.rs
@@ -1,26 +1,30 @@
-use ethabi::{decode, ParamType};
-use sgx_trts::trts::rsgx_read_rand;
-use std::{collections::HashMap, sync::SgxMutex, sync::SgxMutexGuard, vec::Vec};
-use std::path;
-use std::string::ToString;
-
-use enigma_crypto::asymmetric::KeyPair;
-use enigma_crypto::Encryption;
-use enigma_crypto::hash::Keccak256;
-use enigma_tools_t::common::ToHex;
-use enigma_tools_m::utils::EthereumAddress;
-use enigma_tools_t::common::errors_t::{EnclaveError, EnclaveError::*, EnclaveSystemError::*};
-use enigma_tools_t::common::utils_t::LockExpectMutex;
-use enigma_tools_t::document_storage_t::{is_document, load_sealed_document, save_sealed_document, SEAL_LOG_SIZE, SealedDocumentStorage};
-use enigma_tools_m::primitives::km_primitives::{PrincipalMessage, PrincipalMessageType};
+use crate::SIGNING_KEY;
+use enigma_crypto::{asymmetric::KeyPair, Encryption};
+use enigma_tools_m::{
+    primitives::km_primitives::{PrincipalMessage, PrincipalMessageType},
+    utils::EthereumAddress,
+};
+use enigma_tools_t::{
+    common::{
+        errors_t::{
+            EnclaveError::{self, *},
+            EnclaveSystemError::*,
+        },
+        utils_t::LockExpectMutex,
+        ToHex,
+    },
+    document_storage_t::{is_document, load_sealed_document, save_sealed_document, SealedDocumentStorage, SEAL_LOG_SIZE},
+};
 use enigma_types::{ContractAddress, Hash256, StateKey};
 use ocalls_t;
-
-use crate::SIGNING_KEY;
+use sgx_trts::trts::rsgx_read_rand;
+use std::{collections::HashMap, path, sync::SgxMutex, vec::Vec};
 
 const STATE_KEYS_DIR: &str = "state-keys";
 
-lazy_static! { pub static ref STATE_KEY_STORE: SgxMutex< HashMap<ContractAddress, StateKey> > = SgxMutex::new(HashMap::new()); }
+lazy_static! {
+    pub static ref STATE_KEY_STORE: SgxMutex<HashMap<ContractAddress, StateKey>> = SgxMutex::new(HashMap::new());
+}
 
 /// The state keys root path is guaranteed to exist of the enclave was initialized
 fn get_state_keys_root_path() -> path::PathBuf {
@@ -35,7 +39,8 @@ fn get_document_path(sc_addr: &ContractAddress) -> path::PathBuf {
 
 /// Read state keys from the cache and sealed documents.
 /// Adds keys to the cache after unsealing.
-fn get_state_keys(keys_map: &mut HashMap<ContractAddress, StateKey>, sc_addrs: &[ContractAddress]) -> Result<Vec<Option<StateKey>>, EnclaveError> {
+fn get_state_keys(keys_map: &mut HashMap<ContractAddress, StateKey>,
+                  sc_addrs: &[ContractAddress]) -> Result<Vec<Option<StateKey>>, EnclaveError> {
     let mut results: Vec<Option<StateKey>> = Vec::new();
     for &addr in sc_addrs {
         let key = match keys_map.get(&addr) {
@@ -69,11 +74,12 @@ fn get_state_keys(keys_map: &mut HashMap<ContractAddress, StateKey>, sc_addrs: &
 }
 
 /// Creates new state keys both in the cache and as sealed documents
-fn new_state_keys(keys_map: &mut HashMap<ContractAddress, StateKey>, sc_addrs: &Vec<ContractAddress>) -> Result<Vec<StateKey>, EnclaveError> {
+fn new_state_keys(keys_map: &mut HashMap<ContractAddress, StateKey>,
+                  sc_addrs: &[ContractAddress]) -> Result<Vec<StateKey>, EnclaveError> {
     let mut results: Vec<StateKey> = Vec::new();
     for &addr in sc_addrs {
         let mut doc: SealedDocumentStorage<StateKey> = SealedDocumentStorage {
-            version: 0x1234, //TODO: what's this?
+            version: 0x1234, // TODO: what's this?
             data: [0; 32],
         };
         // Generate a new key randomly
@@ -109,7 +115,7 @@ fn build_get_state_keys_response(sc_addrs: Vec<ContractAddress>) -> Result<Vec<(
         }
     }
     new_state_keys(&mut guard, &new_addrs)?; // If the vector is empty this won't do anything.
-    //Now we have keys for all addresses in cache
+                                             // Now we have keys for all addresses in cache
     for addr in sc_addrs {
         match guard.get(&addr) {
             Some(&key) => response_data.push((addr, key)),
@@ -123,7 +129,9 @@ fn build_get_state_keys_response(sc_addrs: Vec<ContractAddress>) -> Result<Vec<(
 
 /// Get encrypted state keys
 
-pub(crate) fn ecall_get_enc_state_keys_internal(msg_bytes: &[u8], addrs_bytes: Vec<ContractAddress>, sig: [u8; 65], sig_out: &mut [u8; 65]) -> Result<Vec<u8>, EnclaveError> {
+pub(crate) fn ecall_get_enc_state_keys_internal(
+    msg_bytes: &[u8], addrs_bytes: Vec<ContractAddress>, sig: [u8; 65], sig_out: &mut [u8; 65],
+) -> Result<Vec<u8>, EnclaveError> {
     let msg = PrincipalMessage::from_message(msg_bytes)?;
     let user_pubkey = msg.get_pubkey();
     let msg_id = msg.get_id();
@@ -157,11 +165,10 @@ pub(crate) fn ecall_get_enc_state_keys_internal(msg_bytes: &[u8], addrs_bytes: V
 }
 
 pub mod tests {
-    use enigma_tools_t::common::FromHex;
-
     use super::*;
+    use enigma_tools_t::common::FromHex;
 
-    //noinspection RsTypeCheck
+    // noinspection RsTypeCheck
     pub fn test_state_keys_storage() {
         let data = vec![
             "9F86D081884C7D659A2FEAA0C55AD015A3BF4F1B2B0B822CD15D6C15B0F00A08".from_hex().unwrap(),
@@ -176,7 +183,8 @@ pub mod tests {
         let mut guard = STATE_KEY_STORE.lock_expect("State Key Store");
         let new_keys = new_state_keys(&mut guard, &sc_addrs).expect("Unable to store state keys");
 
-        let cached_keys = get_state_keys(&mut guard, &sc_addrs).expect("Unable to get state keys from cache")
+        let cached_keys = get_state_keys(&mut guard, &sc_addrs)
+            .expect("Unable to get state keys from cache")
             .iter()
             .map(|k| k.unwrap())
             .collect::<Vec<StateKey>>();
@@ -185,7 +193,8 @@ pub mod tests {
         // Clearing the cache to test retrieval of sealed keys form disk
         guard.clear();
 
-        let stored_keys = get_state_keys(&mut guard, &sc_addrs).expect("Unable to get state keys from sealed files")
+        let stored_keys = get_state_keys(&mut guard, &sc_addrs)
+            .expect("Unable to get state keys from sealed files")
             .iter()
             .map(|k| k.unwrap())
             .collect::<Vec<StateKey>>();
diff --git a/enigma-principal/enclave/src/lib.rs b/enigma-principal/enclave/src/lib.rs
