Merge branch 'master' into feature/sp_plugged

jovfer · web-flow · commit 96a3293bff94 · 2018-06-07T13:21:57.000+03:00
diff --git a/libindy/src/commands/anoncreds/issuer.rs b/libindy/src/commands/anoncreds/issuer.rs
@@ -187,7 +187,7 @@ impl IssuerCommandExecutor {
             .map_err(|err| CommonError::InvalidStructure(format!("Cannot deserialize AttributeNames: {:?}", err)))?;
 
         if attrs.is_empty() {
-            return Err(IndyError::CommonError(CommonError::InvalidStructure(format!("List of Schema attributes is empty"))));
+            return Err(IndyError::CommonError(CommonError::InvalidStructure("List of Schema attributes is empty".to_string())));
         }
 
         let schema_id = Schema::schema_id(issuer_did, name, version);
@@ -440,15 +440,15 @@ impl IssuerCommandExecutor {
                 rev_reg_info.curr_id = 1 + rev_reg_info.curr_id;
 
                 if rev_reg_info.curr_id > rev_reg_def.value.max_cred_num {
-                    return Err(IndyError::AnoncredsError(AnoncredsError::RevocationRegistryFull(format!("RevocationRegistryAccumulator is full"))));
+                    return Err(IndyError::AnoncredsError(AnoncredsError::RevocationRegistryFull("RevocationRegistryAccumulator is full".to_string())));
                 }
 
                 if rev_reg_def.value.issuance_type == IssuanceType::ISSUANCE_ON_DEMAND {
                     rev_reg_info.used_ids.insert(rev_reg_info.curr_id.clone());
                 }
 
                 let blob_storage_reader_handle = blob_storage_reader_handle
-                    .ok_or(IndyError::CommonError(CommonError::InvalidStructure(format!("TailsReaderHandle not found"))))?;
+                    .ok_or(IndyError::CommonError(CommonError::InvalidStructure("TailsReaderHandle not found".to_string())))?;
 
                 let sdk_tails_accessor = SDKTailsAccessor::new(self.blob_storage_service.clone(),
                                                                blob_storage_reader_handle,
@@ -695,4 +695,4 @@ impl IssuerCommandExecutor {
     fn _wallet_get_rev_reg_info(&self, wallet_handle: i32, key: &str) -> Result<RevocationRegistryInfo, WalletError> {
         self.wallet_service.get_indy_object(wallet_handle, &key, &RecordOptions::id_value(), &mut String::new())
     }
-}
+}
diff --git a/libindy/src/commands/anoncreds/tails.rs b/libindy/src/commands/anoncreds/tails.rs
@@ -28,7 +28,7 @@ impl SDKTailsAccessor {
                tails_reader_handle: i32,
                rev_reg_def: &RevocationRegistryDefinitionV1) -> Result<SDKTailsAccessor, CommonError> {
         let tails_hash = rev_reg_def.value.tails_hash.from_base58()
-            .map_err(|_| CommonError::InvalidState(format!("Invalid base58 for Tails hash")))?;
+            .map_err(|_| CommonError::InvalidState("Invalid base58 for Tails hash".to_string()))?;
 
         let tails_reader_handle = tails_service.open_blob(tails_reader_handle,
                                                           &rev_reg_def.value.tails_location,
diff --git a/libindy/src/commands/did.rs b/libindy/src/commands/did.rs
@@ -217,7 +217,7 @@ impl DidCommandExecutor {
         let (did, key) = self.crypto_service.create_my_did(&my_did_info)?;
 
         if self.wallet_service.record_exists::<Did>(wallet_handle, &did.did)? {
-            return Err(IndyError::DidError(DidError::AlreadyExistsError(format!("Did already exists"))));
+            return Err(IndyError::DidError(DidError::AlreadyExistsError("Did already exists".to_string())));
         };
 
         self.wallet_service.add_indy_object(wallet_handle, &did.did, &did, "{}")?;
@@ -553,7 +553,7 @@ impl DidCommandExecutor {
             GetNymReplyResult::GetNymReplyResultV0(res) => {
                 let gen_nym_result_data = GetNymResultDataV0::from_json(&res.data)
                     .map_err(map_err_trace!())
-                    .map_err(|_| CommonError::InvalidState(format!("Invalid GetNymResultData json")))?;
+                    .map_err(|_| CommonError::InvalidState("Invalid GetNymResultData json".to_string()))?;
 
                 TheirDidInfo::new(gen_nym_result_data.dest, gen_nym_result_data.verkey)
             }
diff --git a/libindy/src/commands/ledger.rs b/libindy/src/commands/ledger.rs
@@ -399,7 +399,7 @@ impl LedgerCommandExecutor {
                 request.remove("signature");
                 request.remove("signatures");
                 request
-            }).ok_or(CommonError::InvalidState(format!("Cannot deserialize request")))?;
+            }).ok_or(CommonError::InvalidState("Cannot deserialize request".to_string()))?;
 
         let serialized_request = serialize_signature(message_without_signatures)?;
         let signature = self.crypto_service.sign(&my_key, &serialized_request.as_bytes().to_vec())?;
@@ -859,4 +859,4 @@ impl LedgerCommandExecutor {
 enum SignatureType {
     Single,
     Multi
-}
+}
diff --git a/libindy/src/commands/payments.rs b/libindy/src/commands/payments.rs
@@ -282,7 +282,7 @@ impl PaymentsCommandExecutor {
                 while let Ok(Some(payment_address)) = search.fetch_next_record() {
                     match payment_address.get_value() {
                         Some(value) => list_addresses.push(value.to_string()),
-                        None => cb(Err(IndyError::CommonError(CommonError::InvalidState(format!("Record value not found")))))
+                        None => cb(Err(IndyError::CommonError(CommonError::InvalidState("Record value not found".to_string()))))
                     }
                 }
 
diff --git a/libindy/src/services/anoncreds/issuer.rs b/libindy/src/services/anoncreds/issuer.rs
@@ -108,13 +108,13 @@ impl Issuer {
             if rev_idx.is_some() {
                 let rev_idx = rev_idx.unwrap();
                 let rev_reg = rev_reg
-                    .ok_or(CommonError::InvalidState(format!("RevocationRegistry not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationRegistry not found".to_string()))?;
                 let rev_key_priv = rev_key_priv
-                    .ok_or(CommonError::InvalidState(format!("RevocationKeyPrivate not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationKeyPrivate not found".to_string()))?;
                 let rev_reg_def = rev_reg_def
-                    .ok_or(CommonError::InvalidState(format!("RevocationRegistryDefinitionValue not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationRegistryDefinitionValue not found".to_string()))?;
                 let rev_tails_accessor = rev_tails_accessor
-                    .ok_or(CommonError::InvalidState(format!("RevocationTailsAccessor not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationTailsAccessor not found".to_string()))?;
 
                 CryptoIssuer::sign_credential_with_revoc(&cred_request.prover_did,
                                                          &cred_request.blinded_ms,
@@ -177,4 +177,4 @@ impl Issuer {
 
         Ok(rev_reg_delta)
     }
-}
+}
diff --git a/libindy/src/services/anoncreds/prover.rs b/libindy/src/services/anoncreds/prover.rs
@@ -183,8 +183,8 @@ impl Prover {
                 .ok_or(CommonError::InvalidStructure(format!("CredentialDefinition not found by id: {:?}", credential.cred_def_id)))?;
 
             let rev_state = if cred_def.value.revocation.is_some() {
-                let timestamp = cred_key.timestamp.clone().ok_or(CommonError::InvalidStructure(format!("Timestamp not found")))?;
-                let rev_reg_id = credential.rev_reg_id.clone().ok_or(CommonError::InvalidStructure(format!("Revocation Registry Id not found")))?;
+                let timestamp = cred_key.timestamp.clone().ok_or(CommonError::InvalidStructure("Timestamp not found".to_string()))?;
+                let rev_reg_id = credential.rev_reg_id.clone().ok_or(CommonError::InvalidStructure("Revocation Registry Id not found".to_string()))?;
                 let rev_states_for_timestamp = rev_states.get(&rev_reg_id)
                     .ok_or(CommonError::InvalidStructure(format!("RevocationState not found by id: {:?}", rev_reg_id)))?;
                 Some(rev_states_for_timestamp.get(&timestamp)
@@ -439,4 +439,4 @@ impl Prover {
 
         Ok(sub_proof_request)
     }
-}
+}
diff --git a/libindy/src/services/anoncreds/verifier.rs b/libindy/src/services/anoncreds/verifier.rs
@@ -40,8 +40,8 @@ impl Verifier {
                 .ok_or(CommonError::InvalidStructure(format!("CredentialDefinition not found for id: {:?}", identifier.cred_def_id)))?;
 
             let (rev_reg_def, rev_reg) = if cred_def.value.revocation.is_some() {
-                let timestamp = identifier.timestamp.clone().ok_or(CommonError::InvalidStructure(format!("Timestamp not found")))?;
-                let rev_reg_id = identifier.rev_reg_id.clone().ok_or(CommonError::InvalidStructure(format!("Revocation Registry Id not found")))?;
+                let timestamp = identifier.timestamp.clone().ok_or(CommonError::InvalidStructure("Timestamp not found".to_string()))?;
+                let rev_reg_id = identifier.rev_reg_id.clone().ok_or(CommonError::InvalidStructure("Revocation Registry Id not found".to_string()))?;
                 let rev_reg_def = Some(rev_reg_defs.get(&rev_reg_id)
                     .ok_or(CommonError::InvalidStructure(format!("RevocationRegistryDefinition not found for id: {:?}", identifier.rev_reg_id)))?);
                 let rev_regs_for_cred = rev_regs.get(&rev_reg_id)
@@ -111,4 +111,4 @@ impl Verifier {
 
         Ok(predicates_for_credential)
     }
-}
+}
diff --git a/libindy/src/services/ledger/mod.rs b/libindy/src/services/ledger/mod.rs
@@ -113,7 +113,7 @@ impl LedgerService {
         info!("build_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);
 
         if raw.is_none() && hash.is_none() && enc.is_none() {
-            return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));
+            return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));
         }
         if let Some(ref raw) = raw {
             serde_json::from_str::<serde_json::Value>(raw)
@@ -138,7 +138,7 @@ impl LedgerService {
         info!("build_get_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);
 
         if raw.is_none() && hash.is_none() && enc.is_none() {
-            return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));
+            return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));
         }
         let operation = GetAttribOperation::new(dest.to_string(), raw, hash, enc);
 
diff --git a/libindy/src/services/pool/catchup.rs b/libindy/src/services/pool/catchup.rs
@@ -78,7 +78,7 @@ impl CatchupHandler {
                 //sending ledger status
                 //TODO not send ledger status directly as response on ping, wait pongs from all nodes?
                 let ls: LedgerStatus = LedgerStatus {
-                    txnSeqNo: self.nodes.len(),
+                    txnSeqNo: self.merkle_tree.count,
                     merkleRoot: self.merkle_tree.root_hash().as_slice().to_base58(),
                     ledgerId: 0,
                     ppSeqNo: None,
@@ -268,7 +268,7 @@ impl CatchupHandler {
             let index = process.pending_reps.get_min_index()?;
             {
                 let &mut (ref mut first_resp, node_idx) = process.pending_reps.get_mut(index)
-                    .ok_or(CommonError::InvalidStructure(format!("Element not Found")))?;
+                    .ok_or(CommonError::InvalidStructure("Element not Found".to_string()))?;
                 if first_resp.min_tx()? - 1 != process.merkle_tree.count() { break; }
 
                 let mut temp_mt = process.merkle_tree.clone();
@@ -289,6 +289,7 @@ impl CatchupHandler {
                     return Ok(CatchupStepResult::FailedAtNode(node_idx));
                 }
 
+                self.merkle_tree = temp_mt.clone();
                 PoolWorker::dump_new_txns(&self.pool_name, &vec_to_dump)?;
 
                 process.merkle_tree = temp_mt;
diff --git a/libindy/src/services/pool/types.rs b/libindy/src/services/pool/types.rs
@@ -44,10 +44,10 @@ fn string_or_number<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
         },
         Ok(serde_json::Value::Number(n)) => match n.as_u64() {
             Some(num) => Ok(Some(num)),
-            None => Err(serde::de::Error::custom(format!("Invalid Node transaction")))
+            None => Err(serde::de::Error::custom("Invalid Node transaction".to_string()))
         },
         Ok(serde_json::Value::Null) => Ok(None),
-        _ => Err(serde::de::Error::custom(format!("Invalid Node transaction"))),
+        _ => Err(serde::de::Error::custom("Invalid Node transaction".to_string())),
     }
 }
 
@@ -247,7 +247,7 @@ impl CatchupRep {
                 Some(m) => if val < m { min = Some(val) }
             }
         }
-        min.ok_or(CommonError::InvalidStructure(format!("Empty Map")))
+        min.ok_or(CommonError::InvalidStructure("Empty Map".to_string()))
     }
 }
 
@@ -554,4 +554,4 @@ pub struct RequestToSend {
 pub struct MessageToProcess {
     pub message: String,
     pub node_idx: usize,
-}
+}
diff --git a/libindy/src/services/wallet/mod.rs b/libindy/src/services/wallet/mod.rs
@@ -239,7 +239,11 @@ impl WalletService {
     pub fn delete_wallet(&self, name: &str, credentials: &str) -> Result<(), WalletError> {
         trace!("delete_wallet >>> name: {:?}, credentials: {:?}", name, credentials);
 
-        let descriptor_json = _read_file(_wallet_descriptor_path(name))?; // FIXME: Better error!)?;
+        let wallet_descriptor_path = _wallet_descriptor_path(name);
+        if !wallet_descriptor_path.exists() {
+            return Err(WalletError::NotFound("Wallet descriptor path does not exist.".to_string()));
+        }
+        let descriptor_json = _read_file(wallet_descriptor_path)?; // FIXME: Better error!)?;
         let descriptor: WalletDescriptor = WalletDescriptor::from_json(&descriptor_json)?;
 
         let storage_types = self.storage_types.borrow();
@@ -271,7 +275,11 @@ impl WalletService {
     pub fn open_wallet(&self, name: &str, runtime_config: Option<&str>, credentials: &str) -> Result<i32, WalletError> {
         trace!("open_wallet >>> name: {:?}, runtime_config: {:?}, credentials: {:?}", name, runtime_config, credentials);
 
-        let descriptor_json = _read_file(_wallet_descriptor_path(name))?; // FIXME: Better error!)?;
+        let wallet_descriptor_path = _wallet_descriptor_path(name);
+        if !wallet_descriptor_path.exists() {
+            return Err(WalletError::NotFound("Wallet descriptor path does not exist.".to_string()));
+        }
+        let descriptor_json = _read_file(wallet_descriptor_path)?;
         let descriptor: WalletDescriptor = WalletDescriptor::from_json(&descriptor_json)?;
 
         let storage_types = self.storage_types.borrow();
@@ -725,7 +733,7 @@ fn _read_config(name: &str) -> Result<(String, WalletConfig), WalletError> {
     let config_path = _wallet_config_path(name);
     let config_json = _read_file(config_path)?;
     let config = serde_json::from_str::<WalletConfig>(&config_json)
-        .map_err(|err| CommonError::InvalidState(format!("Cannot deserialize Storage Config")))?;
+        .map_err(|_| CommonError::InvalidState("Cannot deserialize Storage Config".to_string()))?;
     Ok((config_json, config))
 }
 
@@ -911,6 +919,15 @@ mod tests {
         wallet_service.open_wallet("test_wallet", None, &_credentials()).unwrap();
     }
 
+    #[test]
+    fn wallet_service_open_unknown_wallet() {
+        _cleanup();
+
+        let wallet_service = WalletService::new();
+        let res = wallet_service.open_wallet("test_wallet_unknown", None, &_credentials());
+        assert_match!(Err(WalletError::NotFound(_)), res);
+    }
+
     #[test]
     fn wallet_service_open_works_for_plugged() {
         TestUtils::cleanup_indy_home();
@@ -1559,4 +1576,4 @@ mod tests {
         assert_eq!("type", record.get_type().unwrap());
         assert_eq!("value1", record.get_value().unwrap());
     }
-}
+}
diff --git a/libindy/src/services/wallet/wallet.rs b/libindy/src/services/wallet/wallet.rs
@@ -137,7 +137,7 @@ impl EncryptedValue {
         // value_key is stored as NONCE || CYPHERTEXT. Lenth of CYPHERTHEXT is length of DATA + length of TAG.
         const ENCRYPTED_KEY_LEN: usize = ChaCha20Poly1305IETF::TAGBYTES + ChaCha20Poly1305IETF::NONCEBYTES + ChaCha20Poly1305IETF::KEYBYTES;
         if joined_data.len() < ENCRYPTED_KEY_LEN {
-            return Err(CommonError::InvalidStructure(format!("Unable to split value_key from value: value too short")));
+            return Err(CommonError::InvalidStructure("Unable to split value_key from value: value too short".to_string()));
         }
 
         let value_key = joined_data[..ENCRYPTED_KEY_LEN].to_owned();
diff --git a/libindy/src/utils/crypto/box_/sodium.rs b/libindy/src/utils/crypto/box_/sodium.rs
@@ -26,7 +26,7 @@ pub struct CryptoBox {}
 impl CryptoBox {
     pub fn encrypt(private_key: &[u8], public_key: &[u8], doc: &[u8], nonce: &[u8]) -> Result<Vec<u8>, CommonError> {
         if nonce.len() != 24 {
-            return Err(CommonError::InvalidStructure(format!("Invalid nonce")))
+            return Err(CommonError::InvalidStructure("Invalid nonce".to_string()))
         }
 
         Ok(box_::seal(
@@ -39,7 +39,7 @@ impl CryptoBox {
 
     pub fn decrypt(private_key: &[u8], public_key: &[u8], doc: &[u8], nonce: &[u8]) -> Result<Vec<u8>, CommonError> {
         if nonce.len() != 24 {
-            return Err(CommonError::InvalidStructure(format!("Invalid nonce")))
+            return Err(CommonError::InvalidStructure("Invalid nonce".to_string()))
         }
 
         box_::open(
@@ -57,7 +57,7 @@ impl CryptoBox {
 
     pub fn create_key_pair_for_signature(seed: Option<&[u8]>) -> Result<(Vec<u8>, Vec<u8>), CommonError> {
         if seed.is_some() && seed.unwrap().len() != 32 {
-            return Err(CommonError::InvalidStructure(format!("Invalid seed")));
+            return Err(CommonError::InvalidStructure("Invalid seed".to_string()));
         }
 
         let (public_key, private_key) =
@@ -74,7 +74,7 @@ impl CryptoBox {
 
     pub fn sign(private_key: &[u8], doc: &[u8]) -> Result<Vec<u8>, CommonError> {
         if private_key.len() != 64 {
-            return Err(CommonError::InvalidStructure(format!("Invalid sign key")));
+            return Err(CommonError::InvalidStructure("Invalid sign key".to_string()));
         }
 
         let mut pr_key: [u8; 64] = [0; 64];
@@ -88,11 +88,11 @@ impl CryptoBox {
 
     pub fn verify(public_key: &[u8], doc: &[u8], sign: &[u8]) -> Result<bool, CommonError> {
         if sign.len() != 64 {
-            return Err(CommonError::InvalidStructure(format!("Invalid signature")));
+            return Err(CommonError::InvalidStructure("Invalid signature".to_string()));
         }
 
         if public_key.len() != 32 {
-            return Err(CommonError::InvalidStructure(format!("Invalid verkey")));
+            return Err(CommonError::InvalidStructure("Invalid verkey".to_string()));
         }
 
         let mut signature: [u8; 64] = [0; 64];
@@ -107,7 +107,7 @@ impl CryptoBox {
 
     pub fn sk_to_curve25519(sk: &[u8]) -> Result<Vec<u8>, CommonError> {
         if sk.len() != 64 {
-            return Err(CommonError::InvalidStructure(format!("Invalid signkey")));
+            return Err(CommonError::InvalidStructure("Invalid signkey".to_string()));
         }
 
         let mut from: [u8; 64] = [0; 64];
@@ -121,7 +121,7 @@ impl CryptoBox {
 
     pub fn vk_to_curve25519(pk: &[u8]) -> Result<Vec<u8>, CommonError> {
         if pk.len() != 32 {
-            return Err(CommonError::InvalidStructure(format!("Invalid verkey")));
+            return Err(CommonError::InvalidStructure("Invalid verkey".to_string()));
         }
 
         let mut from: [u8; 32] = [0; 32];
@@ -191,4 +191,4 @@ mod tests {
         let skc_exp = vec!(144, 112, 64, 101, 69, 167, 61, 44, 220, 148, 58, 187, 108, 73, 11, 247, 130, 161, 158, 40, 100, 1, 40, 27, 76, 148, 209, 240, 195, 35, 153, 121);
         assert_eq!(skc_exp, skc_test);
     }
-}
+}
diff --git a/libindy/tests/wallet.rs b/libindy/tests/wallet.rs
@@ -318,7 +318,7 @@ mod medium_cases {
             TestUtils::cleanup_storage();
 
             let res = WalletUtils::delete_wallet(WALLET, None);
-            assert_eq!(res.unwrap_err(), ErrorCode::CommonIOError);
+            assert_eq!(res.unwrap_err(), ErrorCode::WalletNotFoundError);
 
             TestUtils::cleanup_storage();
         }
@@ -330,7 +330,7 @@ mod medium_cases {
             WalletUtils::create_wallet(POOL, WALLET, None, None, None).unwrap();
             WalletUtils::delete_wallet(WALLET, None).unwrap();
             let res = WalletUtils::delete_wallet(WALLET, None);
-            assert_eq!(res.unwrap_err(), ErrorCode::CommonIOError);
+            assert_eq!(res.unwrap_err(), ErrorCode::WalletNotFoundError);
 
             TestUtils::cleanup_storage();
         }
@@ -355,7 +355,7 @@ mod medium_cases {
             TestUtils::cleanup_storage();
 
             let res = WalletUtils::open_wallet(WALLET, None, None);
-            assert_eq!(res.unwrap_err(), ErrorCode::CommonIOError);
+            assert_eq!(res.unwrap_err(), ErrorCode::WalletNotFoundError);
 
             TestUtils::cleanup_storage();
         }
diff --git a/wrappers/ios/libindy-pod/Indy-demoTests/Case Tests/Wallet/WalletHighCases.m b/wrappers/ios/libindy-pod/Indy-demoTests/Case Tests/Wallet/WalletHighCases.m
diff --git a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/wallet/DeleteWalletTest.java b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/wallet/DeleteWalletTest.java
diff --git a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/wallet/OpenWalletTest.java b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/wallet/OpenWalletTest.java
diff --git a/wrappers/python/tests/wallet/test_delete_wallet.py b/wrappers/python/tests/wallet/test_delete_wallet.py
diff --git a/wrappers/python/tests/wallet/test_open_wallet.py b/wrappers/python/tests/wallet/test_open_wallet.py

Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,7 @@ impl PaymentsCommandExecutor {`
`282`	`282`	`while let Ok(Some(payment_address)) = search.fetch_next_record() {`
`283`	`283`	`match payment_address.get_value() {`
`284`	`284`	`Some(value) => list_addresses.push(value.to_string()),`
`285`		`- None => cb(Err(IndyError::CommonError(CommonError::InvalidState(format!("Record value not found")))))`
	`285`	`+ None => cb(Err(IndyError::CommonError(CommonError::InvalidState("Record value not found".to_string()))))`
`286`	`286`	`}`
`287`	`287`	`}`
`288`	`288`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ impl LedgerService {`
`113`	`113`	`info!("build_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);`
`114`	`114`
`115`	`115`	`if raw.is_none() && hash.is_none() && enc.is_none() {`
`116`		`- return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));`
	`116`	`+ return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));`
`117`	`117`	`}`
`118`	`118`	`if let Some(ref raw) = raw {`
`119`	`119`	`serde_json::from_str::<serde_json::Value>(raw)`
`@@ -138,7 +138,7 @@ impl LedgerService {`
`138`	`138`	`info!("build_get_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);`
`139`	`139`
`140`	`140`	`if raw.is_none() && hash.is_none() && enc.is_none() {`
`141`		`- return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));`
	`141`	`+ return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));`
`142`	`142`	`}`
`143`	`143`	`let operation = GetAttribOperation::new(dest.to_string(), raw, hash, enc);`
`144`	`144`