FIX: Fixed PR requests - AtomicU64, TryInto, setWorkerParams, etc.

FIX: Replaced redundant AtomicU64
FIX: Removed duplicate entries
FIX: Remove unnecessary log file
FIX: Removing the priv key print
FIX: Fixed the TryInto implementation
FIX: Removed unnecessary code in the document storage unit test
FIX: Housekeeping to improve the readibility of functions in the keys_keeper module
FIX: Fixed the setWorkerParams message signature
FIX: Housekeeping in the epoch keeper
FIX: Fix rand byte array length and other fixes
DEV: Moved the logging module to enigma_tools_u
FIX: Removed redundant clone of a variable implementing Copy
FIX: Removed the `connect_batch` fn which is no longer used
FIX: Remove unnecessary config
FIX: Removed unnecessary feature
FIX: Housekeeping in the app file
FIX: Removed redundant clone calls
FIX: Improved error handling when fetching the current block number
FIX: Removed explicit CORS domain validation config

Author: fredfortier

.gitignore

@@ -89,6 +89,3 @@ dockerfile-elichai/
 
 /target
 **/*.rs.bk
-
-/target
-**/*.rs.bk

enigma-core/app/Cargo.lock

@@ -23,7 +23,6 @@ lazy_static = "1.2.0"
 lru-cache = "0.1.1"
 log = "0.4.6"
 log-derive = "0.2"
-simplelog = "0.5.3"
 structopt = "0.2"
 
 
@@ -35,4 +34,4 @@ ethabi = "6.1.0"
 cross-test-utils = { path = "cross-test-utils" }
 regex = "1"
 rand = "0.6.5"
-tempfile = "3.0"
+tempfile = "3.0"

enigma-core/app/Cargo.toml

@@ -17,7 +17,7 @@ extern crate tokio_zmq;
 extern crate zmq;
 #[macro_use]
 extern crate failure;
-extern crate enigma_tools_u;
+pub extern crate enigma_tools_u;
 extern crate enigma_crypto;
 extern crate enigma_types;
 extern crate rustc_hex as hex;
@@ -29,7 +29,6 @@ pub extern crate log;
 #[macro_use]
 pub extern crate log_derive;
 pub extern crate structopt;
-pub extern crate simplelog;
 
 pub mod common_u;
 pub mod db;
@@ -38,7 +37,6 @@ pub mod evm_u;
 pub mod km_u;
 pub mod networking;
 pub mod wasm_u;
-pub mod logging;
 pub mod cli;
 
 #[cfg(feature = "cross-test-utils")]

enigma-core/app/src/lib.rs

@@ -11,7 +11,7 @@ use db::DB;
 use cli::Opt;
 use structopt::StructOpt;
 use futures::Future;
-use simplelog::CombinedLogger;
+use enigma_tools_u::common_u::logging::{self, CombinedLogger};
 
 fn main() {
     let opt: Opt = Opt::from_args();
@@ -42,7 +42,7 @@ mod tests {
     use enigma_core_app::sgx_types::*;
     use enigma_core_app::db::DB;
     use self::enigma_types::RawPointer;
-    use enigma_core_app::simplelog::TermLogger;
+    use enigma_tools_u::common_u::logging::TermLogger;
     use enigma_core_app::log::LevelFilter;
     use self::tempfile::TempDir;
 

enigma-core/app/src/logging.rs

@@ -31,7 +31,6 @@ web3 = { git = "https://github.com/tomusdrw/rust-web3.git", default-features = f
 jsonrpc-http-server = "10.0"
 log = "0.4.6"
 log-derive = "0.2"
-simplelog = "0.5.3"
 unicase = "=2.2.0"
 rmp-serde = "0.13.7"
 

enigma-core/app/src/main.rs

@@ -45,18 +45,6 @@ impl TryInto<[u8; 65]> for StringWrapper {
     }
 }
 
-impl Into<Vec<u8>> for StringWrapper {
-    fn into(self) -> Vec<u8> {
-        self.try_into().expect("Unable to cast byte array attribute")
-    }
-}
-
-impl Into<[u8; 65]> for StringWrapper {
-    fn into(self) -> [u8; 65] {
-        self.try_into().expect("Unable to cast fixed 65-bytes array attribute")
-    }
-}
-
 #[derive(Deserialize, Debug, Clone)]
 pub struct StateKeyRequest {
     pub data: StringWrapper,
@@ -129,22 +117,20 @@ impl PrincipalHttpServer {
     /// Example:
     /// curl -X POST --data '{"jsonrpc": "2.0", "method": "get_state_keys", "params": ["84a46461746181a75265717565737493dc0020cca7cc937b64ccb8cccacca5cc8f03721bccb6ccbacccf5c78cccb235fccebcce0cce70b1bcc84cccdcc99541461cca0cc8edc002016367accacccb67a4a017ccc8dcca8ccabcc95682ccccb390863780f7114ccddcca0cca0cce0ccc55644ccc7ccc4dc0020ccb1cce9cc9324505bccd32dcca0cce1ccf85dcccf5e19cca0cc9dccb0481ecc8a15ccf62c41cceb320304cca8cce927a269649c1363ccb3301c101f33cce1cc9a0524a67072656669789e456e69676d61204d657373616765a67075626b6579dc0040cce5ccbe28cc9dcc9a2eccbd08ccc0457a5f16ccdfcc9fccdc256c5d5f6c3514cccdcc95ccb47c11ccc4cccd3e31ccf0cce4ccefccc83ccc80cce8121c3939ccbb2561cc80ccec48ccbecca8ccc569ccd2cca3ccda6bcce415ccfa20cc9bcc98ccda", "43f19586b0a0ae626b9418fe8355888013be1c9b4263a4b3a27953de641991e936ed6c4076a2a383b3b001936bf0eb6e23c78fbec1ee36f19c6a9d24d75e9e081c"]' -H "Content-Type: application/json" http://127.0.0.1:3040/
     ///
-    #[logfn(INFO)]
     pub fn start(&self) {
         let mut io = IoHandler::default();
         let epoch_provider = Arc::clone(&self.epoch_provider);
         io.add_method(METHOD_GET_STATE_KEYS, move |params: Params| {
             let epoch_provider = epoch_provider.clone();
             let request = params.parse::<StateKeyRequest>()?;
-            let eid = epoch_provider.eid.load(Ordering::SeqCst);
-            let body = match Self::get_state_keys_internal(epoch_provider, request, eid) {
+            let eid = epoch_provider.eid.clone();
+            let body = match Self::get_state_keys_internal(epoch_provider, request, *eid) {
                 Ok(body) => body,
                 Err(err) => return Err(ServerError { code: ErrorCode::InternalError, message: format!("Unable to get keys: {:?}", err), data: None }),
             };
             Ok(body)
         });
         let server = ServerBuilder::new(io)
-            .cors(DomainsValidation::AllowOnly(vec![AccessControlAllowOrigin::Null]))
             .start_http(&format!("0.0.0.0:{}", self.port).parse().unwrap())
             .expect("Unable to start RPC server");
         println!("JSON-RPC HTTP server listening on port: {}", self.port);
@@ -181,7 +167,7 @@ mod test {
         let sig = Bytes::from(sig.to_vec());
         let nonce = U256::from(0);
         let epoch_state = EpochState { seed, sig, nonce, confirmed_state };
-        let results = PrincipalHttpServer::find_epoch_contract_addresses(reader, request.sig.try_into(), epoch_state).unwrap();
+        let results = PrincipalHttpServer::find_epoch_contract_addresses(reader, request.sig.try_into().unwrap(), epoch_state).unwrap();
         println!("Found contract addresses: {:?}", results);
         assert_eq!(results, vec![H256([0; 32])])
     }

enigma-principal/app/Cargo.lock

@@ -2,7 +2,6 @@ use std::fs::File;
 use std::io::prelude::*;
 use std::str;
 use std::sync::Arc;
-use std::sync::atomic::AtomicU64;
 use std::thread;
 
 use failure::Error;
@@ -149,20 +148,22 @@ impl Sampler for PrincipalManager {
 
     fn get_contract_address(&self) -> Address { self.contract.address() }
 
-    fn get_account_address(&self) -> Address { self.contract.account.clone() }
+    //noinspection RsBorrowChecker
+    fn get_account_address(&self) -> Address { self.contract.account }
 
     fn get_network_url(&self) -> String { self.config.url.clone() }
 
     fn get_block_number(&self) -> Result<U256, Error> {
-        let block_number = self.get_web3().eth().block_number().wait().unwrap();
+        let block_number = match self.get_web3().eth().block_number().wait() {
+            Ok(block_number) => block_number,
+            Err(err) => bail!("Current block number not available: {:?}", err),
+        };
         Ok(block_number)
     }
 
     fn register<G: Into<U256>>(&self, signing_address: String, gas_limit: G) -> Result<H256, Error> {
         let registration_params = self.report_manager.get_registration_params()?;
-        let report = registration_params.report.clone();
-        let signature = registration_params.signature.clone();
-        let receipt = self.contract.register(signing_address, report, signature, gas_limit, self.config.confirmations as usize)?;
+        let receipt = self.contract.register(signing_address, registration_params.report, registration_params.signature, gas_limit, self.config.confirmations as usize)?;
         Ok(receipt.transaction_hash)
     }
 
@@ -204,7 +205,7 @@ impl Sampler for PrincipalManager {
         // get enigma contract
         let enigma_contract = &self.contract;
         // Start the WorkerParameterized Web3 log filter
-        let eid: Arc<AtomicU64> = Arc::new(AtomicU64::new(self.eid));
+        let eid: Arc<sgx_enclave_id_t> = Arc::new(self.eid);
         let epoch_provider = Arc::new(EpochProvider::new(eid.clone(), self.contract.clone())?);
 
         // Start the JSON-RPC Server
@@ -301,7 +302,7 @@ mod test {
         principal.verify_identity_or_register(gas_limit).unwrap();
 
         let block_number = principal.get_web3().eth().block_number().wait().unwrap();
-        let eid_safe = Arc::new(AtomicU64::new(eid));
+        let eid_safe = Arc::new(eid);
         let epoch_provider = EpochProvider::new(eid_safe, principal.contract.clone()).unwrap();
         epoch_provider.reset_epoch_state().unwrap();
         epoch_provider.set_worker_params(block_number, gas_limit, 0).unwrap();

enigma-principal/app/Cargo.toml

@@ -2,7 +2,6 @@ use std::fs::File;
 use std::io::prelude::*;
 use std::path::Path;
 use std::sync::Arc;
-use std::sync::atomic::AtomicU64;
 
 use failure::Error;
 use sgx_types::sgx_enclave_id_t;
@@ -18,7 +17,6 @@ use esgx::general::{ENCLAVE_DIR, storage_dir};
 #[logfn(INFO)]
 pub fn start(eid: sgx_enclave_id_t) -> Result<(), Error> {
     let opt = cli::options::Opt::from_args();
-    let _config = deploy_scripts::load_config(opt.deploy_config.as_str())?;
     let mut principal_config = PrincipalManager::load_config(opt.principal_config.as_str())?;
     let report_manager = ReportManager::new(principal_config.clone(), eid)?;
     let signing_address = report_manager.get_signing_address()?;
@@ -34,46 +32,8 @@ pub fn start(eid: sgx_enclave_id_t) -> Result<(), Error> {
         file.write_all(prefixed_signing_address.as_bytes())?;
         println!("Wrote signing address: {:?} in file: {:?}", prefixed_signing_address, path);
     } else {
-//        cli::options::print_logo();
-
-        // deploy the contracts Enigma,EnigmaToken (not deployed yet)
         if opt.deploy {
-            println!("[Mode:] deploying to default.");
-            /* step1 : prepeare the contracts (deploy Enigma,EnigmaToken) */
-            // load the config
-            // deploy all contracts. (Enigma & EnigmaToken)
-//            let enigma_contract = Arc::new(EnigmaContract::deploy_contract(Path::new(&config.enigma_token_contract_path),
-//                                                                  Path::new(&config.enigma_contract_path),
-//                                                                  &principal_config.url,
-//                                                                  Some(&config.account_address), // This means that account no. 0 will be used, we should use the one from the JSON or add an `--account` cli option. or
-//                                                                  &sign_key)?);
-//
-//            /* step2 : build the config of the principal node   */
-//            // optional : set time limit for the principal node
-//            let ttl = if opt.time_to_live > 0 { Some(opt.time_to_live) } else { None };
-//
-//            let gas_limit = 5_999_999;
-//            let contract_addr = enigma_contract.address();
-//            principal_config.set_accounts_address(enigma_contract.account.to_hex());
-//            principal_config.set_enigma_contract_address(contract_addr.to_hex());
-//            principal_config.max_epochs = ttl;
-//
-//            println!("Enigma contract deployed: {:?}", enigma_contract.address());
-//            let principal: PrincipalManager = PrincipalManager::new_delegated(principal_config, enigma_contract, eid);
-//            println!("Connected to the Enigma contract with account: {:?}", principal.get_account_address());
-//
-//            /* step3 optional - run miner to simulate blocks */
-//            let join_handle = if opt.mine > 0 {
-//                Some(principal_manager::run_miner(principal.get_account_address(), principal.get_web3(), opt.mine as u64))
-//            } else {
-//                None
-//            };
-//
-//            /* step4 : run the principal manager */
-//            principal.run(gas_limit).unwrap();
-//            if let Some(t) = join_handle { t.join().unwrap(); }
-            panic!("Self-deploy mode not yet implemented. Fix issues with linked libraries in the Enigma contract.");
-            // contracts deployed, just run
+            unimplemented!("Self-deploy mode not yet implemented. Fix issues with linked libraries in the Enigma contract.");
         } else {
             println!("[Mode:] run node NO DEPLOY.");
             /* step1 : build the config of the principal node   */
@@ -112,7 +72,7 @@ pub fn start(eid: sgx_enclave_id_t) -> Result<(), Error> {
                 };
             } else if opt.set_worker_params {
                 let block_number = principal.get_block_number()?;
-                let eid_safe = Arc::new(AtomicU64::new(eid));
+                let eid_safe = Arc::new(eid);
                 let epoch_provider = EpochProvider::new(eid_safe, principal.contract.clone())?;
                 let tx = epoch_provider.set_worker_params(block_number, gas_limit, principal_config.confirmations as usize)?;
                 println!("The setWorkersParams tx: {:?}", tx);

enigma-principal/app/build-principal.log

@@ -22,15 +22,16 @@ use epoch_u::epoch_types::{ConfirmedEpochState, EpochState, WorkersParameterized
 use esgx::epoch_keeper_u::set_worker_params;
 use esgx::general::{ENCLAVE_DIR, storage_dir};
 use keys_u::keeper_types_u::InputWorkerParams;
+use sgx_types::sgx_enclave_id_t;
 
 pub struct EpochProvider {
     pub contract: Arc<EnigmaContract>,
     pub epoch_state: Arc<Mutex<Option<EpochState>>>,
-    pub eid: Arc<AtomicU64>,
+    pub eid: Arc<sgx_enclave_id_t>,
 }
 
 impl EpochProvider {
-    pub fn new(eid: Arc<AtomicU64>, contract: Arc<EnigmaContract>) -> Result<EpochProvider, Error> {
+    pub fn new(eid: Arc<sgx_enclave_id_t>, contract: Arc<EnigmaContract>) -> Result<EpochProvider, Error> {
         let epoch_state_val = Self::read_epoch_state()?;
         // TODO: If the state is not empty, get the active workers and prove them to the enclave
         println!("Initializing EpochProvider with EpochState: {:?}", epoch_state_val);
@@ -179,10 +180,10 @@ impl EpochProvider {
             stakes: result.1,
         };
         println!("The active workers: {:?}", worker_params);
-        let epoch_state = &mut set_worker_params(self.eid.load(Ordering::SeqCst), worker_params.clone())?;
+        let epoch_state = &mut set_worker_params(*self.eid, worker_params.clone())?;
         println!("Waiting for setWorkerParams({:?}, {:?}, {:?})", block_number, epoch_state.seed, epoch_state.sig);
         // TODO: Consider a retry mechanism, either store the EpochSeed or add a getter ecall
-        let receipt = self.contract.set_workers_params(block_number, epoch_state.seed.clone(), epoch_state.sig.clone(), gas_limit, confirmations)?;
+        let receipt = self.contract.set_workers_params(block_number, epoch_state.seed, epoch_state.sig.clone(), gas_limit, confirmations)?;
         self.parse_worker_parameterized(&receipt)?;
         println!("Caching selected workers");
         self.confirm_epoch(epoch_state, worker_params)?;

enigma-principal/app/src/boot_network/keys_provider_http.rs

@@ -54,7 +54,7 @@ pub fn get_enc_state_keys(eid: sgx_enclave_id_t, request: StateKeyRequest, epoch
             msg_bytes.len(),
             addrs_bytes.as_ptr() as *const u8,
             addrs_bytes.len(),
-            &request.sig.into(),
+            &request.sig.try_into()?,
             enc_response_slice.as_mut_ptr() as *mut u8,
             &mut enc_response_len_out,
             &mut sig_out,