* Remove boilerplate in crypto module

* Hygiene refactoring of wallet code
* Avoid of creation wallet configuration files
* Wallet API changes to allow wallet access in cluster

Signed-off-by: Vyacheslav Gudkov <[email protected]>

Author: Vyacheslav Gudkov

libindy/Cargo.toml

@@ -20,11 +20,12 @@ path = "src/lib.rs"
 crate-type = ["staticlib","rlib", "cdylib"]
 
 [features]
-default = ["bn_openssl", "box_sodium", "sealedbox_sodium", "base58_rust_base58", "xsalsa20_sodium", "chacha20poly1305_ietf_sodium", "pair_amcl", "hash_openssl", "local_nodes_pool", "revocation_tests", "pwhash_argon2i13_sodium", "hmacsha256_sodium"]
+default = ["bn_openssl", "box_sodium", "sealedbox_sodium", "base58_rust_base58", "base64_rust_base64", "xsalsa20_sodium", "chacha20poly1305_ietf_sodium", "pair_amcl", "hash_openssl", "local_nodes_pool", "revocation_tests", "pwhash_argon2i13_sodium", "hmacsha256_sodium", "memzero_sodium"]
 bn_openssl = ["openssl", "int_traits"]
 box_sodium = ["sodiumoxide"]
 sealedbox_sodium = ["sodiumoxide"]
 base58_rust_base58 = ["rust-base58"]
+base64_rust_base64 = ["base64"]
 xsalsa20_sodium = ["sodiumoxide"]
 chacha20poly1305_ietf_sodium = ["sodiumoxide"]
 pwhash_argon2i13_sodium = ["sodiumoxide"]
@@ -34,6 +35,7 @@ local_nodes_pool = []
 revocation_tests = []
 sodium_static = []
 hmacsha256_sodium = ["sodiumoxide"]
+memzero_sodium = ["sodiumoxide"]
 
 [dependencies]
 indy-crypto = { version = "=0.4.1", optional = true }
@@ -52,7 +54,7 @@ rand = "0.3"
 rusqlite = "0.13.0"
 libsqlite3-sys = "0.9.1"
 rust-base58 = {version = "0.0.4", optional = true}
-base64 = "0.6.0"
+base64 = {version = "0.6.0", optional = true}
 serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"

libindy/src/api/mod.rs

@@ -70,6 +70,45 @@ pub enum ErrorCode
     // Caller passed invalid value as param 14 (null, invalid json and etc..)
     CommonInvalidParam14 = 116,
 
+    // Caller passed invalid value as param 15 (null, invalid json and etc..)
+    CommonInvalidParam15 = 117,
+
+    // Caller passed invalid value as param 16 (null, invalid json and etc..)
+    CommonInvalidParam16 = 118,
+
+    // Caller passed invalid value as param 17 (null, invalid json and etc..)
+    CommonInvalidParam17 = 119,
+
+    // Caller passed invalid value as param 18 (null, invalid json and etc..)
+    CommonInvalidParam18 = 120,
+
+    // Caller passed invalid value as param 19 (null, invalid json and etc..)
+    CommonInvalidParam19 = 121,
+
+    // Caller passed invalid value as param 20 (null, invalid json and etc..)
+    CommonInvalidParam20 = 122,
+
+    // Caller passed invalid value as param 21 (null, invalid json and etc..)
+    CommonInvalidParam21 = 123,
+
+    // Caller passed invalid value as param 22 (null, invalid json and etc..)
+    CommonInvalidParam22 = 124,
+
+    // Caller passed invalid value as param 23 (null, invalid json and etc..)
+    CommonInvalidParam23 = 125,
+
+    // Caller passed invalid value as param 24 (null, invalid json and etc..)
+    CommonInvalidParam24 = 126,
+
+    // Caller passed invalid value as param 25 (null, invalid json and etc..)
+    CommonInvalidParam25 = 127,
+
+    // Caller passed invalid value as param 26 (null, invalid json and etc..)
+    CommonInvalidParam26 = 128,
+
+    // Caller passed invalid value as param 27 (null, invalid json and etc..)
+    CommonInvalidParam27 = 129,
+
     // Wallet errors
     // Caller passed invalid wallet handle
     WalletInvalidHandle = 200,

libindy/src/api/wallet.rs

@@ -9,6 +9,7 @@ use errors::wallet::WalletError;
 use errors::indy::IndyError;
 use domain::crypto::key::{KeyInfo, Key};
 use domain::crypto::combo_box::ComboBox;
+use utils::crypto::base64;
 use services::wallet::{WalletService, RecordOptions};
 use services::crypto::CryptoService;
 
@@ -19,7 +20,6 @@ use std::result;
 
 type Result<T> = result::Result<T, IndyError>;
 
-use base64;
 
 pub enum CryptoCommand {
     CreateKey(

libindy/src/commands/crypto.rs

@@ -1,6 +1,3 @@
-extern crate indy_crypto;
-extern crate serde_json;
-
 use errors::common::CommonError;
 use errors::did::DidError;
 use errors::wallet::WalletError;
@@ -10,11 +7,11 @@ use domain::crypto::did::{MyDidInfo, Did, TheirDidInfo, TheirDid, TemporaryDid,
 use domain::ledger::response::Reply;
 use domain::ledger::nym::{GetNymReplyResult, GetNymResultDataV0};
 use domain::ledger::attrib::{GetAttrReplyResult, AttribData, Endpoint};
-use services::pool::PoolService;
 use services::wallet::{WalletService, RecordOptions, SearchOptions};
 use services::crypto::CryptoService;
 use services::ledger::LedgerService;
 
+use serde_json;
 use std::error::Error;
 use std::rc::Rc;
 use std::str;
@@ -24,10 +21,7 @@ use commands::ledger::LedgerCommand;
 use commands::{Command, CommandExecutor};
 use std::collections::HashMap;
 use utils::sequence::SequenceUtils;
-use utils::crypto::base58::Base58;
-use self::indy_crypto::utils::json::{JsonEncodable, JsonDecodable};
-
-use super::utils::check_wallet_and_pool_handles_consistency;
+use utils::crypto::base58;
 
 pub enum DidCommand {
     CreateAndStoreMyDid(
@@ -105,10 +99,6 @@ macro_rules! ensure_their_did {
     ($self_:ident, $wallet_handle:ident, $pool_handle:ident, $their_did:ident, $deferred_cmd:expr, $cb:ident) => (match $self_._wallet_get_their_did($wallet_handle, &$their_did) {
           Ok(val) => val,
           Err(WalletError::ItemNotFound) => {
-
-              check_wallet_and_pool_handles_consistency!($self_.wallet_service, $self_.pool_service,
-                                                         $wallet_handle, $pool_handle, $cb);
-
               // No their their_did present in the wallet. Defer this command until it is fetched from ledger.
               return $self_._fetch_their_did_from_ledger($wallet_handle, $pool_handle, &$their_did, $deferred_cmd);
             }
@@ -117,20 +107,17 @@ macro_rules! ensure_their_did {
 }
 
 pub struct DidCommandExecutor {
-    pool_service: Rc<PoolService>,
     wallet_service: Rc<WalletService>,
     crypto_service: Rc<CryptoService>,
     ledger_service: Rc<LedgerService>,
     deferred_commands: RefCell<HashMap<i32, DidCommand>>,
 }
 
 impl DidCommandExecutor {
-    pub fn new(pool_service: Rc<PoolService>,
-               wallet_service: Rc<WalletService>,
+    pub fn new(wallet_service: Rc<WalletService>,
                crypto_service: Rc<CryptoService>,
                ledger_service: Rc<LedgerService>) -> DidCommandExecutor {
         DidCommandExecutor {
-            pool_service,
             wallet_service,
             crypto_service,
             ledger_service,
@@ -208,7 +195,7 @@ impl DidCommandExecutor {
                                my_did_info_json: &str) -> Result<(String, String), IndyError> {
         debug!("create_and_store_my_did >>> wallet_handle: {:?}, my_did_info_json: {:?}", wallet_handle, my_did_info_json);
 
-        let my_did_info = MyDidInfo::from_json(&my_did_info_json)
+        let my_did_info: MyDidInfo = serde_json::from_str(&my_did_info_json)
             .map_err(map_err_trace!())
             .map_err(|err|
                 CommonError::InvalidStructure(
@@ -238,7 +225,7 @@ impl DidCommandExecutor {
 
         self.crypto_service.validate_did(my_did)?;
 
-        let key_info: KeyInfo = KeyInfo::from_json(key_info_json)
+        let key_info: KeyInfo = serde_json::from_str(key_info_json)
             .map_err(map_err_trace!())
             .map_err(|err|
                 CommonError::InvalidStructure(format!("Invalid KeyInfo json: {}", err.description())))?;
@@ -284,7 +271,7 @@ impl DidCommandExecutor {
                        their_did_info_json: &str) -> Result<(), IndyError> {
         debug!("store_their_did >>> wallet_handle: {:?}, their_did_info_json: {:?}", wallet_handle, their_did_info_json);
 
-        let their_did_info = TheirDidInfo::from_json(their_did_info_json)
+        let their_did_info: TheirDidInfo = serde_json::from_str(their_did_info_json)
             .map_err(map_err_trace!())
             .map_err(|err|
                 CommonError::InvalidStructure(format!("Invalid TheirDidInfo json: {}", err.description())))?;
@@ -305,8 +292,8 @@ impl DidCommandExecutor {
 
         let did_record = self.wallet_service.get_indy_record::<Did>(wallet_handle, &my_did, &RecordOptions::full())?;
 
-        let did = did_record.get_value()
-            .and_then(|tags_json| Did::from_json(&tags_json).ok())
+        let did: Did = did_record.get_value()
+            .and_then(|tags_json| serde_json::from_str(&tags_json).ok())
             .ok_or(CommonError::InvalidStructure(format!("Cannot deserialize Did: {:?}", my_did)))?;
 
         let meta: Option<String> = did_record.get_tags()
@@ -318,7 +305,7 @@ impl DidCommandExecutor {
             metadata: meta
         };
 
-        let res = did_with_meta.to_json()
+        let res = serde_json::to_string(&did_with_meta)
             .map_err(|err|
                 IndyError::CommonError(CommonError::InvalidState(format!("Can't serialize DID {}", err))))?;
 
@@ -338,8 +325,8 @@ impl DidCommandExecutor {
         while let Some(did_record) = did_search.fetch_next_record()? {
             let did_id = did_record.get_id();
 
-            let did = did_record.get_value()
-                .and_then(|tags_json| Did::from_json(&tags_json).ok())
+            let did: Did = did_record.get_value()
+                .and_then(|tags_json| serde_json::from_str(&tags_json).ok())
                 .ok_or(CommonError::InvalidStructure(format!("Cannot deserialize Did: {:?}", did_id)))?;
 
             let meta: Option<String> = did_record.get_tags()
@@ -434,11 +421,10 @@ impl DidCommandExecutor {
 
         let endpoint = Endpoint::new(address.to_string(), Some(transport_key.to_string()));
 
-        let res = self.wallet_service.upsert_indy_object(wallet_handle, &did, &endpoint)?;
+        self.wallet_service.upsert_indy_object(wallet_handle, &did, &endpoint)?;
 
-        debug!("set_endpoint_for_did <<< res: {:?}", res);
-
-        Ok(res)
+        debug!("set_endpoint_for_did <<<");
+        Ok(())
     }
 
     fn get_endpoint_for_did(&self,
@@ -456,9 +442,6 @@ impl DidCommandExecutor {
         match endpoint {
             Ok(endpoint) => cb(Ok((endpoint.ha, endpoint.verkey))),
             Err(WalletError::ItemNotFound) => {
-                check_wallet_and_pool_handles_consistency!(self.wallet_service, self.pool_service,
-                                                           wallet_handle, pool_handle, cb);
-
                 return self._fetch_attrib_from_ledger(wallet_handle,
                                                       pool_handle,
                                                       &did,
@@ -517,13 +500,13 @@ impl DidCommandExecutor {
         self.crypto_service.validate_did(&did)?;
         self.crypto_service.validate_key(&verkey)?;
 
-        let did = Base58::decode(&did)?;
-        let dverkey = Base58::decode(&verkey)?;
+        let did = base58::decode(&did)?;
+        let dverkey = base58::decode(&verkey)?;
 
         let (first_part, second_part) = dverkey.split_at(16);
 
         let res = if first_part.eq(did.as_slice()) {
-            format!("~{}", Base58::encode(second_part))
+            format!("~{}", base58::encode(second_part))
         } else {
             verkey
         };
@@ -546,13 +529,13 @@ impl DidCommandExecutor {
 
         let get_nym_reply = get_nym_reply_result?;
 
-        let get_nym_response: Reply<GetNymReplyResult> = Reply::from_json(&get_nym_reply)
+        let get_nym_response: Reply<GetNymReplyResult> = serde_json::from_str(&get_nym_reply)
             .map_err(map_err_trace!())
             .map_err(|err| CommonError::InvalidState(format!("Invalid GetNymReplyResult json: {:?}", err)))?;
 
         let their_did_info = match get_nym_response.result() {
             GetNymReplyResult::GetNymReplyResultV0(res) => {
-                let gen_nym_result_data = GetNymResultDataV0::from_json(&res.data)
+                let gen_nym_result_data: GetNymResultDataV0 = serde_json::from_str(&res.data)
                     .map_err(map_err_trace!())
                     .map_err(|_| CommonError::InvalidState("Invalid GetNymResultData json".to_string()))?;
 
@@ -583,7 +566,7 @@ impl DidCommandExecutor {
 
         let get_attrib_reply = get_attrib_reply_result?;
 
-        let get_attrib_reply: Reply<GetAttrReplyResult> = Reply::from_json(&get_attrib_reply)
+        let get_attrib_reply: Reply<GetAttrReplyResult> = serde_json::from_str(&get_attrib_reply)
             .map_err(map_err_trace!())
             .map_err(|err| CommonError::InvalidState(format!("Invalid GetAttrReplyResult json {:?}", err)))?;
 
@@ -592,7 +575,7 @@ impl DidCommandExecutor {
             GetAttrReplyResult::GetAttrReplyResultV1(res) => (res.txn.data.raw, res.txn.data.did)
         };
 
-        let attrib_data = AttribData::from_json(&raw)
+        let attrib_data: AttribData = serde_json::from_str(&raw)
             .map_err(map_err_trace!())
             .map_err(|err| CommonError::InvalidState(format!("Invalid GetAttReply json: {:?}", err)))?;
 

libindy/src/commands/did.rs

@@ -1,8 +1,3 @@
-extern crate serde_json;
-extern crate indy_crypto;
-
-use self::serde_json::Value;
-
 use api::ledger::{CustomFree, CustomTransactionParser};
 
 use errors::common::CommonError;
@@ -16,19 +11,16 @@ use domain::crypto::key::Key;
 use domain::crypto::did::Did;
 use services::wallet::{WalletService, RecordOptions};
 use services::ledger::LedgerService;
+use utils::crypto::base58;
+use utils::crypto::signature_serializer::serialize_signature;
 
-
-use super::utils::check_wallet_and_pool_handles_consistency;
-
+use serde_json;
+use serde_json::Value;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::error::Error;
 use std::rc::Rc;
 
-use utils::crypto::base58::Base58;
-
-use utils::crypto::signature_serializer::serialize_signature;
-
 pub enum LedgerCommand {
     SignAndSubmitRequest(
         i32, // pool handle
@@ -365,8 +357,6 @@ impl LedgerCommandExecutor {
         debug!("sign_and_submit_request >>> pool_handle: {:?}, wallet_handle: {:?}, submitter_did: {:?}, request_json: {:?}",
                pool_handle, wallet_handle, submitter_did, request_json);
 
-        check_wallet_and_pool_handles_consistency!(self.wallet_service, self.pool_service,
-                                                   wallet_handle, pool_handle, cb);
         match self._sign_request(wallet_handle, submitter_did, request_json, SignatureType::Single) {
             Ok(signed_request) => self.submit_request(pool_handle, signed_request.as_str(), cb),
             Err(err) => cb(Err(err))
@@ -406,14 +396,14 @@ impl LedgerCommandExecutor {
         let signature = self.crypto_service.sign(&my_key, &serialized_request.as_bytes().to_vec())?;
 
         match signature_type {
-            SignatureType::Single => { request["signature"] = Value::String(Base58::encode(&signature)); }
+            SignatureType::Single => { request["signature"] = Value::String(base58::encode(&signature)); }
             SignatureType::Multi => {
                 request.as_object_mut()
                     .map(|request| {
                         if !request.contains_key("signatures") {
                             request.insert("signatures".to_string(), Value::Object(serde_json::Map::new()));
                         }
-                        request["signatures"].as_object_mut().unwrap().insert(submitter_did.to_string(), Value::String(Base58::encode(&signature)));
+                        request["signatures"].as_object_mut().unwrap().insert(submitter_did.to_string(), Value::String(base58::encode(&signature)));
                     });
             }
         }

libindy/src/commands/ledger.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-mod utils;
-
 pub mod anoncreds;
 pub mod blob_storage;
 pub mod crypto;
@@ -89,7 +86,7 @@ impl CommandExecutor {
                 let crypto_command_executor = CryptoCommandExecutor::new(wallet_service.clone(), crypto_service.clone());
                 let ledger_command_executor = LedgerCommandExecutor::new(pool_service.clone(), crypto_service.clone(), wallet_service.clone(), ledger_service.clone());
                 let pool_command_executor = PoolCommandExecutor::new(pool_service.clone());
-                let did_command_executor = DidCommandExecutor::new(pool_service.clone(), wallet_service.clone(), crypto_service.clone(), ledger_service.clone());
+                let did_command_executor = DidCommandExecutor::new(wallet_service.clone(), crypto_service.clone(), ledger_service.clone());
                 let wallet_command_executor = WalletCommandExecutor::new(wallet_service.clone());
                 let pairwise_command_executor = PairwiseCommandExecutor::new(wallet_service.clone());
                 let blob_storage_command_executor = BlobStorageCommandExecutor::new(blob_storage_service.clone());

libindy/src/commands/mod.rs

@@ -10,7 +10,7 @@ use std::rc::Rc;
 use std::collections::HashMap;
 use utils::sequence::SequenceUtils;
 use std::cell::RefCell;
-use self::indy_crypto::utils::json::{JsonEncodable, JsonDecodable};
+use self::indy_crypto::utils::json::JsonEncodable;
 
 use std::result;
 
@@ -237,12 +237,12 @@ impl NonSecretsCommandExecutor {
 
         self._check_type(type_)?;
 
-        RecordOptions::from_json(options_json)
+        serde_json::from_str::<RecordOptions>(options_json)
             .map_err(|err| CommonError::InvalidStructure(format!("Cannot deserialize Options Json: {:?}", err)))?;
 
         let record = self.wallet_service.get_record(wallet_handle, type_, id, &options_json)?;
 
-        let res = record.to_json()
+        let res = serde_json::to_string(&record)
             .map_err(|err| CommonError::InvalidState(format!("Cannot serialize WalletRecord: {:?}", err)))?;
 
         trace!("get_record <<< res: {:?}", res);
@@ -259,7 +259,7 @@ impl NonSecretsCommandExecutor {
 
         self._check_type(type_)?;
 
-        SearchOptions::from_json(options_json)
+        serde_json::from_str::<SearchOptions>(options_json)
             .map_err(|err| CommonError::InvalidStructure(format!("Cannot deserialize Options Json: {:?}", err)))?;
 
         let search = self.wallet_service.search_records(wallet_handle, type_, query_json, &options_json)?;