From ed4d4dacfc4d6b439b4624402ba61d6c5c7cae24 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Fri, 22 Jan 2021 02:43:19 +0300 Subject: [PATCH 01/12] Add API calls for frozen ledgers Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 2 + libindy/src/api/ledger.rs | 55 +++++++++++++++++++ libindy/src/commands/ledger.rs | 39 +++++++++++++ libindy/src/domain/ledger/constants.rs | 2 + libindy/src/domain/ledger/ledgers_freeze.rs | 31 +++++++++++ libindy/src/domain/ledger/mod.rs | 1 + libindy/src/services/ledger/mod.rs | 11 ++++ .../src/services/metrics/command_metrics.rs | 4 ++ 8 files changed, 145 insertions(+) create mode 100644 libindy/src/domain/ledger/ledgers_freeze.rs diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index b82bb5aee7..5804fca41e 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -2270,6 +2270,8 @@ fn get_txn_title(role: &serde_json::Value) -> serde_json::Value { Some("120") => "AUTH_RULE", Some("121") => "GET_AUTH_RULE", Some("122") => "AUTH_RULES", + Some("123") => "FREEZE_LEDGERS", + Some("124") => "GET_FROZEN_LEDGERS", Some(val) => val, _ => "-" }.to_string()) diff --git a/libindy/src/api/ledger.rs b/libindy/src/api/ledger.rs index 9ce9e78873..398c439970 100644 --- a/libindy/src/api/ledger.rs +++ b/libindy/src/api/ledger.rs @@ -1792,6 +1792,61 @@ pub extern fn indy_get_response_metadata(command_handle: CommandHandle, res } +#[no_mangle] +pub extern fn indy_get_frozen_ledgers_request (command_handle: CommandHandle, + submitter_did: *const c_char, + txn_type: *const c_char, + cb: Option) -> ErrorCode { + trace!("indy_build_get_frozen_ledgers_request: entities >>> submitter_did: {:?}, txn_type: {:?}", submitter_did, txn_type); + + check_useful_validatable_string!(submitter_did, ErrorCode::CommonInvalidParam2, DidValue); + check_useful_c_str!(txn_type, ErrorCode::CommonInvalidParam3); + check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam9); + + let result = CommandExecutor::instance() + .send(Command::Ledger(LedgerCommand::BuildGetFrozenLedgersRequest( + submitter_did, + boxed_callback_string!("indy_build_get_frozen_ledgers_request", cb, command_handle) + ))); + + let res = prepare_result!(result); + + trace!("indy_build_get_frozen_ledgers_request: <<< res: {:?}", res); + + res +} + +#[no_mangle] +pub extern fn indy_build_freeze_ledgers_request (command_handle: CommandHandle, + submitter_did: *const c_char, + txn_type: *const c_char, + ledgers_ids: *const c_char, + cb: Option) -> ErrorCode { + trace!("indy_build_freeze_ledgers_request: entities >>> submitter_did: {:?}, txn_type: {:?}, ledgers_ids: {:?}", submitter_did, txn_type, ledgers_ids); + + check_useful_validatable_string!(submitter_did, ErrorCode::CommonInvalidParam2, DidValue); + check_useful_c_str!(txn_type, ErrorCode::CommonInvalidParam3); + check_useful_json!(ledgers_ids, ErrorCode::CommonInvalidParam4, Vec); + check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam5); + + let result = CommandExecutor::instance() + .send(Command::Ledger(LedgerCommand::BuildFreezeLedgersRequest( + submitter_did, + ledgers_ids, + boxed_callback_string!("indy_build_freeze_ledgers_request", cb, command_handle) + ))); + + let res = prepare_result!(result); + + trace!("indy_build_freeze_ledgers_request: <<< res: {:?}", res); + + res +} + /// Builds a AUTH_RULE request. Request to change authentication rules for a ledger transaction. /// /// #Params diff --git a/libindy/src/commands/ledger.rs b/libindy/src/commands/ledger.rs index 79bca4ccc2..ba4164f1d4 100644 --- a/libindy/src/commands/ledger.rs +++ b/libindy/src/commands/ledger.rs @@ -276,6 +276,13 @@ pub enum LedgerCommand { String, // request json DidValue, // endorser did Box) + Send>), + BuildGetFrozenLedgersRequest( + DidValue, // submitter did + Box) + Send>), + BuildFreezeLedgersRequest( + DidValue, // submitter did + Vec, // ledgers ids + Box) + Send>), } pub struct LedgerCommandExecutor { @@ -528,6 +535,14 @@ impl LedgerCommandExecutor { cb(self.append_request_endorser(&request_json, &endorser_did)); } + LedgerCommand::BuildFreezeLedgersRequest(submitter_did, ledgers_ids, cb) => { + debug!(target: "ledger_command_executor", "BuildFreezeLedgersRequest command received"); + cb(self.build_freeze_ledgers_request(&submitter_did, ledgers_ids)); + } + LedgerCommand::BuildGetFrozenLedgersRequest(submitter_did, cb) => { + debug!(target: "ledger_command_executor", "BuildGetFrozenLedgersRequest command received"); + cb(self.build_get_frozen_ledgers_request(&submitter_did)); + } }; } @@ -1308,6 +1323,30 @@ impl LedgerCommandExecutor { let pool_response = try_cb!(pool_response, cb); cb(self.ledger_service.parse_get_cred_def_response(&pool_response, id.get_method().as_ref().map(String::as_str))) } + + fn build_freeze_ledgers_request(&self, submitter_did: &DidValue, ledgers_ids: Vec) -> IndyResult{ + debug!("build_freeze_ledgers_request >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); + + self.crypto_service.validate_did(&submitter_did)?; + + let res = self.ledger_service.build_freeze_ledgers_request(&submitter_did, ledgers_ids)?; + + debug!("build_freeze_ledgers_request <<< res: {:?}", res); + + Ok(res) + } + + fn build_get_frozen_ledgers_request(&self, submitter_did: &DidValue) -> IndyResult { + debug!("build_get_frozen_ledgers_request >>> submitter_did: {:?}", submitter_did); + + self.crypto_service.validate_did(&submitter_did)?; + + let res = self.ledger_service.build_get_frozen_ledgers_request(&submitter_did)?; + + debug!("build_get_frozen_ledgers_request <<< res: {:?}", res); + + Ok(res) + } } enum SignatureType { diff --git a/libindy/src/domain/ledger/constants.rs b/libindy/src/domain/ledger/constants.rs index 6ce73b8fc3..95d1fb1a61 100644 --- a/libindy/src/domain/ledger/constants.rs +++ b/libindy/src/domain/ledger/constants.rs @@ -25,6 +25,8 @@ pub const GET_VALIDATOR_INFO: &str = "119"; pub const AUTH_RULE: &str = "120"; pub const GET_AUTH_RULE: &str = "121"; pub const AUTH_RULES: &str = "122"; +pub const FREEZE_LEDGERS: &str = "123"; +pub const GET_FROZEN_LEDGERS: &str = "124"; pub const GET_DDO: &str = "120";//TODO change number pub const REQUESTS: [&str; 25] = [NODE, NYM, GET_TXN, ATTRIB, SCHEMA, CRED_DEF, GET_ATTR, GET_NYM, GET_SCHEMA, diff --git a/libindy/src/domain/ledger/ledgers_freeze.rs b/libindy/src/domain/ledger/ledgers_freeze.rs new file mode 100644 index 0000000000..2d5665cb2b --- /dev/null +++ b/libindy/src/domain/ledger/ledgers_freeze.rs @@ -0,0 +1,31 @@ +use crate::domain::ledger::constants::{FREEZE_LEDGERS, GET_FROZEN_LEDGERS}; + +#[derive(Serialize, PartialEq, Debug)] +pub struct FreezeLedgersOperation { + #[serde(rename = "type")] + pub _type: String, + pub ledgers_ids: Vec, +} + +impl FreezeLedgersOperation { + pub fn new(ledgers_ids: Vec) -> FreezeLedgersOperation { + FreezeLedgersOperation { + ledgers_ids, + _type: FREEZE_LEDGERS.to_string() + } + } +} + +#[derive(Serialize, PartialEq, Debug)] +pub struct GetFrozenLedgersOperation { + #[serde(rename = "type")] + pub _type: String +} + +impl GetFrozenLedgersOperation { + pub fn new() -> GetFrozenLedgersOperation { + GetFrozenLedgersOperation { + _type: GET_FROZEN_LEDGERS.to_string() + } + } +} diff --git a/libindy/src/domain/ledger/mod.rs b/libindy/src/domain/ledger/mod.rs index c2b0309a77..d85faad860 100644 --- a/libindy/src/domain/ledger/mod.rs +++ b/libindy/src/domain/ledger/mod.rs @@ -14,3 +14,4 @@ pub mod validator_info; pub mod constants; pub mod auth_rule; pub mod author_agreement; +pub mod ledgers_freeze; diff --git a/libindy/src/services/ledger/mod.rs b/libindy/src/services/ledger/mod.rs index 610ea68745..58ffc43e73 100644 --- a/libindy/src/services/ledger/mod.rs +++ b/libindy/src/services/ledger/mod.rs @@ -27,6 +27,7 @@ use crate::domain::ledger::txn::{GetTxnOperation, LedgerType}; use crate::domain::ledger::validator_info::GetValidatorInfoOperation; use crate::domain::ledger::auth_rule::*; use crate::domain::ledger::author_agreement::*; +use crate::domain::ledger::ledgers_freeze::{FreezeLedgersOperation, GetFrozenLedgersOperation}; use indy_api_types::errors::prelude::*; use indy_utils::crypto::hash::hash as openssl_hash; @@ -394,6 +395,16 @@ impl LedgerService { old_value.map(String::from), new_value.map(String::from), constraint) } + #[logfn(Info)] + pub fn build_freeze_ledgers_request(&self, submitter_did: &DidValue, ledgers_ids: Vec) -> IndyResult { + build_result!(FreezeLedgersOperation, Some(submitter_did), ledgers_ids) + } + + #[logfn(Info)] + pub fn build_get_frozen_ledgers_request(&self, submitter_did: &DidValue) -> IndyResult { + build_result!(GetFrozenLedgersOperation, Some(submitter_did)) + } + #[logfn(Info)] pub fn build_auth_rules_request(&self, submitter_did: &DidValue, rules: AuthRules) -> IndyResult { build_result!(AuthRulesOperation, Some(submitter_did), rules) diff --git a/libindy/src/services/metrics/command_metrics.rs b/libindy/src/services/metrics/command_metrics.rs index 6c8e33ec70..baa64e63d9 100644 --- a/libindy/src/services/metrics/command_metrics.rs +++ b/libindy/src/services/metrics/command_metrics.rs @@ -191,6 +191,8 @@ impl From<&Command> for CommandMetric { LedgerCommand::BuildGetAcceptanceMechanismsRequest(_, _, _, _) => { CommandMetric::LedgerCommandBuildGetAcceptanceMechanismsRequest } LedgerCommand::AppendTxnAuthorAgreementAcceptanceToRequest(_, _, _, _, _, _, _) => { CommandMetric::LedgerCommandAppendTxnAuthorAgreementAcceptanceToRequest } LedgerCommand::AppendRequestEndorser(_, _, _) => { CommandMetric::LedgerCommandAppendRequestEndorser } + LedgerCommand::BuildGetFrozenLedgersRequest(_,_,) => { CommandMetric::LedgerCommandBuildGetFrozenLedgersRequest } + LedgerCommand::BuildFreezeLedgersRequest(_,_,_,) => { CommandMetric::LedgerCommandBuildFreezeLedgersRequest } } } Command::Pool(cmd) => { @@ -427,6 +429,8 @@ pub enum CommandMetric { LedgerCommandBuildGetAcceptanceMechanismsRequest, LedgerCommandAppendTxnAuthorAgreementAcceptanceToRequest, LedgerCommandAppendRequestEndorser, + LedgerCommandBuildGetFrozenLedgersRequest, + LedgerCommandBuildFreezeLedgersRequest, // PoolCommand PoolCommandCreate, PoolCommandDelete, From e0b8fa8004f0a6b99cdc263d94391a181e41e2e3 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Fri, 22 Jan 2021 17:51:24 +0300 Subject: [PATCH 02/12] Add tests for frozen ledgers Signed-off-by: Anton Denishchenko --- libindy/src/api/ledger.rs | 14 ++++----- libindy/src/domain/ledger/ledgers_freeze.rs | 2 +- libindy/tests/ledger.rs | 16 ++++++++++ libindy/tests/utils/ledger.rs | 7 +++++ wrappers/rust/indy-sys/src/ledger.rs | 11 +++++++ wrappers/rust/src/ledger.rs | 33 +++++++++++++++++++++ 6 files changed, 73 insertions(+), 10 deletions(-) diff --git a/libindy/src/api/ledger.rs b/libindy/src/api/ledger.rs index 398c439970..1cd69ced92 100644 --- a/libindy/src/api/ledger.rs +++ b/libindy/src/api/ledger.rs @@ -1795,15 +1795,13 @@ pub extern fn indy_get_response_metadata(command_handle: CommandHandle, #[no_mangle] pub extern fn indy_get_frozen_ledgers_request (command_handle: CommandHandle, submitter_did: *const c_char, - txn_type: *const c_char, cb: Option) -> ErrorCode { - trace!("indy_build_get_frozen_ledgers_request: entities >>> submitter_did: {:?}, txn_type: {:?}", submitter_did, txn_type); + trace!("indy_build_get_frozen_ledgers_request: entities >>> submitter_did: {:?}", submitter_did); check_useful_validatable_string!(submitter_did, ErrorCode::CommonInvalidParam2, DidValue); - check_useful_c_str!(txn_type, ErrorCode::CommonInvalidParam3); - check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam9); + check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam3); let result = CommandExecutor::instance() .send(Command::Ledger(LedgerCommand::BuildGetFrozenLedgersRequest( @@ -1821,17 +1819,15 @@ pub extern fn indy_get_frozen_ledgers_request (command_handle: CommandHandle, #[no_mangle] pub extern fn indy_build_freeze_ledgers_request (command_handle: CommandHandle, submitter_did: *const c_char, - txn_type: *const c_char, ledgers_ids: *const c_char, cb: Option) -> ErrorCode { - trace!("indy_build_freeze_ledgers_request: entities >>> submitter_did: {:?}, txn_type: {:?}, ledgers_ids: {:?}", submitter_did, txn_type, ledgers_ids); + trace!("indy_build_freeze_ledgers_request: entities >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); check_useful_validatable_string!(submitter_did, ErrorCode::CommonInvalidParam2, DidValue); - check_useful_c_str!(txn_type, ErrorCode::CommonInvalidParam3); - check_useful_json!(ledgers_ids, ErrorCode::CommonInvalidParam4, Vec); - check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam5); + check_useful_json!(ledgers_ids, ErrorCode::CommonInvalidParam3, Vec); + check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam4); let result = CommandExecutor::instance() .send(Command::Ledger(LedgerCommand::BuildFreezeLedgersRequest( diff --git a/libindy/src/domain/ledger/ledgers_freeze.rs b/libindy/src/domain/ledger/ledgers_freeze.rs index 2d5665cb2b..6292b4930a 100644 --- a/libindy/src/domain/ledger/ledgers_freeze.rs +++ b/libindy/src/domain/ledger/ledgers_freeze.rs @@ -1,4 +1,4 @@ -use crate::domain::ledger::constants::{FREEZE_LEDGERS, GET_FROZEN_LEDGERS}; +use super::constants::{FREEZE_LEDGERS, GET_FROZEN_LEDGERS}; #[derive(Serialize, PartialEq, Debug)] pub struct FreezeLedgersOperation { diff --git a/libindy/tests/ledger.rs b/libindy/tests/ledger.rs index b8ef9a6c7a..be6ac49d1f 100644 --- a/libindy/tests/ledger.rs +++ b/libindy/tests/ledger.rs @@ -201,6 +201,22 @@ mod high_cases { } } + mod frozen_ledgers { + use super::*; + + #[test] + fn indy_build_freeze_ledgers_request() { + let ledgers_ids = json!(vec![0, 1, 10, 23]); + let res = ledger::build_freeze_ledgers_request(DID_TRUSTEE, &ledgers_ids.to_string()); + } + + #[test] + fn indy_get_frozen_ledgers_request() { + let res = ledger::get_frozen_ledgers_request(DID_TRUSTEE); + } + + } + mod multi_sign_request { use super::*; diff --git a/libindy/tests/utils/ledger.rs b/libindy/tests/utils/ledger.rs index bc28b6e69d..1740b9b1fa 100644 --- a/libindy/tests/utils/ledger.rs +++ b/libindy/tests/utils/ledger.rs @@ -420,4 +420,11 @@ pub fn post_qualified_entities() -> (&'static str, &'static str) { (SCHEMA_ID_V2, CRED_DEF_ID_V2) } +} +pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) { + ledger::build_freeze_ledgers_request(submitter_did, ledgers_ids).wait(); +} + +pub fn get_frozen_ledgers_request(submitter_did: &str) { + ledger::get_frozen_ledgers_request(submitter_did).wait(); } \ No newline at end of file diff --git a/wrappers/rust/indy-sys/src/ledger.rs b/wrappers/rust/indy-sys/src/ledger.rs index 2be8c99d13..307d058c2b 100644 --- a/wrappers/rust/indy-sys/src/ledger.rs +++ b/wrappers/rust/indy-sys/src/ledger.rs @@ -305,6 +305,17 @@ extern { request_json: CString, endorser_did: CString, cb: Option) -> Error; + + #[no_mangle] + pub fn indy_build_freeze_ledgers_request(command_handle: CommandHandle, + submitter_did: CString, + ledgers_ids: CString, + cb: Option) -> Error; + + #[no_mangle] + pub fn indy_get_frozen_ledgers_request(command_handle: CommandHandle, + submitter_did: CString, + cb: Option) -> Error; } pub type CustomTransactionParser = extern fn(reply_from_node: CString, parsed_sp: *mut CString) -> Error; diff --git a/wrappers/rust/src/ledger.rs b/wrappers/rust/src/ledger.rs index 5551f47022..e3e3418b9a 100644 --- a/wrappers/rust/src/ledger.rs +++ b/wrappers/rust/src/ledger.rs @@ -1510,4 +1510,37 @@ fn _append_request_endorser(command_handle: CommandHandle, endorser_did.as_ptr(), cb) }) +} + +pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) -> Box> { + let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string(); + let err = _build_freeze_ledgers_request(command_handle, submitter_did, ledgers_ids, cb); + ResultHandler::str(command_handle, err, receiver) +} + +fn _build_freeze_ledgers_request(command_handle: CommandHandle, submitter_did: &str, ledgers_ids: &str, cb: Option) -> ErrorCode { + let submitter_did = c_str!(submitter_did); + + ErrorCode::from(unsafe { + ledger::indy_build_freeze_ledgers_request(command_handle, + submitter_did.as_ptr(), + ledgers_ids.as_ptr() as *const i8, + cb) + }) +} + +pub fn get_frozen_ledgers_request(submitter_did: &str) -> Box> { + let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string(); + let err = _get_frozen_ledgers_request(command_handle, submitter_did, cb); + ResultHandler::str(command_handle, err, receiver) +} + +fn _get_frozen_ledgers_request(command_handle: CommandHandle, submitter_did: &str, cb: Option) -> ErrorCode { + let submitter_did = c_str!(submitter_did); + + ErrorCode::from(unsafe { + ledger::indy_get_frozen_ledgers_request(command_handle, + submitter_did.as_ptr(), + cb) + }) } \ No newline at end of file From ee93dfa95474f864785905c79bf67230157b95ed Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Wed, 27 Jan 2021 13:07:54 +0300 Subject: [PATCH 03/12] Add tests for rust and python wrappers Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 118 ++++++++++++++++++ cli/src/libindy/ledger.rs | 8 ++ libindy/src/api/ledger.rs | 46 +++---- libindy/tests/ledger.rs | 15 ++- libindy/tests/utils/ledger.rs | 8 +- wrappers/python/indy/ledger.py | 42 +++++++ .../test_build_freeze_ledgers_request.py | 9 ++ .../test_build_get_frozen_ledgers_request.py | 8 ++ wrappers/rust/indy-sys/src/ledger.rs | 2 +- wrappers/rust/src/ledger.rs | 8 +- wrappers/rust/tests/ledger.rs | 37 ++++++ 11 files changed, 268 insertions(+), 33 deletions(-) create mode 100644 wrappers/python/tests/ledger/test_build_freeze_ledgers_request.py create mode 100644 wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index 5804fca41e..97d99a7c49 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -2042,6 +2042,79 @@ pub mod get_acceptance_mechanisms_command { } } +pub mod freeze_ledgers_command { + use super::*; + + command!(CommandMetadata::build("freeze-ledgers", r#"Freeze all ledgers"#) + .add_required_param("ledgers_ids", "List ledgers for freeze.") + .add_example("ledger freeze-ledgers") + .finalize() + ); + + fn execute(ctx: &CommandContext, params: &CommandParams) -> Result<(), ()> { + trace!("execute >> ctx {:?} params {:?}", ctx, params); + + let submitter_did = ensure_active_did(&ctx)?; + let (wallet_handle, wallet_name) = ensure_opened_wallet(&ctx)?; + let ledgers_ids = get_str_param("ledgers_ids", params).map_err(error_err!())?; + + let request = Ledger::build_freeze_ledgers_request(&submitter_did, ledgers_ids) + .map_err(|err| handle_indy_error(err, None, None, None))?; + + let (_, response) = send_write_request!(&ctx, params, &request, wallet_handle, &wallet_name, &submitter_did); + + let result = handle_transaction_response(response)?; + + println!("result {:?}", result); + + trace!("execute <<"); + Ok(()) + } +} + +pub mod get_frozen_ledgers_command { + use super::*; + use serde_json::Value; + + command!(CommandMetadata::build("get-frozen-ledgers", r#"Get a list of frozen ledgers"#) + .add_example("ledger get-frozen-ledgers") + .finalize() + ); + + fn execute(ctx: &CommandContext, params: &CommandParams) -> Result<(), ()> { + trace!("execute >> ctx {:?} params {:?}", ctx, params); + + let submitter_did = ensure_active_did(&ctx)?; + + let request = Ledger::build_get_frozen_ledgers_request(&submitter_did) + .map_err(|err| handle_indy_error(err, None, None, None))?; + + let (_, response) = send_read_request!(&ctx, params, &request, Some(&submitter_did)); + let result = handle_transaction_response(response)?; + + // Flattering ap into vector + let result = result.as_object() + .expect("top level object is not a map") + .iter() + .map(|kv| { + let key = kv.0; + let value = kv.1; + + let mut flat_value = value.as_object() + .expect("inner object is not a map").clone(); + + let ledger_id = serde_json::to_value(&key).unwrap(); + flat_value.insert("ledger_id".to_owned(), ledger_id); + + serde_json::to_value(&flat_value).unwrap() + }).collect::>(); + + print_frozen_ledgers(result); + trace!("execute <<"); + Ok(()) + } +} + pub fn set_author_agreement(ctx: &CommandContext, request: &mut String) -> Result<(), ()> { if let Some((text, version, acc_mech_type, time_of_acceptance)) = get_transaction_author_info(&ctx) { if acc_mech_type.is_empty() { @@ -2112,6 +2185,18 @@ pub fn print_response_receipts(receipts: Option>) -> Resu Ok(()) } +pub fn print_frozen_ledgers(frozen_ledgers: Vec) -> Result<(), ()> { + println_succ!("Following Receipts has been received."); + print_list_table(&frozen_ledgers, + &[("ledger_id", "Ledger id"), + ("ledger", "Payment Address of recipient"), + ("state", "Amount"), + ("seq_no", "Extra")], + ""); + + Ok(()) +} + fn parse_payment_fees(fees: &[&str]) -> Result { let mut fees_map: HashMap = HashMap::new(); @@ -5081,6 +5166,39 @@ pub mod tests { } } + mod frozen_ledgers { + use super::*; + + #[test] + pub fn freeze_ledgers() { + let ctx = setup_with_wallet_and_pool(); + + let (_, path_str) = _path(); + { + let cmd = freeze_ledgers_command::new(); + let mut params = CommandParams::new(); + params.insert("ledgers_ids", json!(vec![0, 1, 10, 23]).to_string()); + cmd.execute(&ctx, ¶ms).unwrap_err(); + } + + tear_down(); + } + + #[test] + pub fn get_frozen_ledgers() { + let ctx = setup_with_wallet_and_pool(); + + let (_, path_str) = _path(); + { + let cmd = get_frozen_ledgers_command::new(); + let mut params = CommandParams::new(); + cmd.execute(&ctx, ¶ms).unwrap_err(); + } + + tear_down(); + } + } + fn _path() -> (::std::path::PathBuf, String) { let mut path = crate::utils::environment::EnvironmentUtils::indy_home_path(); path.push("transaction"); diff --git a/cli/src/libindy/ledger.rs b/cli/src/libindy/ledger.rs index dfca1c03ae..b6d09bec60 100644 --- a/cli/src/libindy/ledger.rs +++ b/cli/src/libindy/ledger.rs @@ -147,4 +147,12 @@ impl Ledger { endorser_did: &str) -> Result { ledger::append_request_endorser(request_json, endorser_did).wait() } + + pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) -> Result { + ledger::build_freeze_ledgers_request(submitter_did, ledgers_ids).wait() + } + + pub fn build_get_frozen_ledgers_request(submitter_did: &str) -> Result { + ledger::build_get_frozen_ledgers_request(submitter_did).wait() + } } \ No newline at end of file diff --git a/libindy/src/api/ledger.rs b/libindy/src/api/ledger.rs index 1cd69ced92..9922f11426 100644 --- a/libindy/src/api/ledger.rs +++ b/libindy/src/api/ledger.rs @@ -1793,52 +1793,52 @@ pub extern fn indy_get_response_metadata(command_handle: CommandHandle, } #[no_mangle] -pub extern fn indy_get_frozen_ledgers_request (command_handle: CommandHandle, - submitter_did: *const c_char, - cb: Option) -> ErrorCode { - trace!("indy_build_get_frozen_ledgers_request: entities >>> submitter_did: {:?}", submitter_did); +pub extern fn indy_build_freeze_ledgers_request (command_handle: CommandHandle, + submitter_did: *const c_char, + ledgers_ids: *const c_char, + cb: Option) -> ErrorCode { + trace!("indy_build_freeze_ledgers_request: entities >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); check_useful_validatable_string!(submitter_did, ErrorCode::CommonInvalidParam2, DidValue); - check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam3); + check_useful_json!(ledgers_ids, ErrorCode::CommonInvalidParam3, Vec); + check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam4); let result = CommandExecutor::instance() - .send(Command::Ledger(LedgerCommand::BuildGetFrozenLedgersRequest( + .send(Command::Ledger(LedgerCommand::BuildFreezeLedgersRequest( submitter_did, - boxed_callback_string!("indy_build_get_frozen_ledgers_request", cb, command_handle) + ledgers_ids, + boxed_callback_string!("indy_build_freeze_ledgers_request", cb, command_handle) ))); let res = prepare_result!(result); - trace!("indy_build_get_frozen_ledgers_request: <<< res: {:?}", res); + trace!("indy_build_freeze_ledgers_request: <<< res: {:?}", res); res } #[no_mangle] -pub extern fn indy_build_freeze_ledgers_request (command_handle: CommandHandle, - submitter_did: *const c_char, - ledgers_ids: *const c_char, - cb: Option) -> ErrorCode { - trace!("indy_build_freeze_ledgers_request: entities >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); +pub extern fn indy_build_get_frozen_ledgers_request (command_handle: CommandHandle, + submitter_did: *const c_char, + cb: Option) -> ErrorCode { + trace!("indy_build_get_frozen_ledgers_request: entities >>> submitter_did: {:?}", submitter_did); check_useful_validatable_string!(submitter_did, ErrorCode::CommonInvalidParam2, DidValue); - check_useful_json!(ledgers_ids, ErrorCode::CommonInvalidParam3, Vec); - check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam4); + check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam3); let result = CommandExecutor::instance() - .send(Command::Ledger(LedgerCommand::BuildFreezeLedgersRequest( + .send(Command::Ledger(LedgerCommand::BuildGetFrozenLedgersRequest( submitter_did, - ledgers_ids, - boxed_callback_string!("indy_build_freeze_ledgers_request", cb, command_handle) + boxed_callback_string!("indy_build_get_frozen_ledgers_request", cb, command_handle) ))); let res = prepare_result!(result); - trace!("indy_build_freeze_ledgers_request: <<< res: {:?}", res); + trace!("indy_build_get_frozen_ledgers_request: <<< res: {:?}", res); res } diff --git a/libindy/tests/ledger.rs b/libindy/tests/ledger.rs index be6ac49d1f..70a38a6ec3 100644 --- a/libindy/tests/ledger.rs +++ b/libindy/tests/ledger.rs @@ -208,13 +208,26 @@ mod high_cases { fn indy_build_freeze_ledgers_request() { let ledgers_ids = json!(vec![0, 1, 10, 23]); let res = ledger::build_freeze_ledgers_request(DID_TRUSTEE, &ledgers_ids.to_string()); + + match res { + Ok(_) => {}, + Err(ec) => { + assert!(false, "indy_build_freeze_ledgers_request returned error_code {:?}", ec); + } + } } #[test] fn indy_get_frozen_ledgers_request() { let res = ledger::get_frozen_ledgers_request(DID_TRUSTEE); - } + match res { + Ok(res) => {println!("{:?}",res)}, + Err(ec) => { + assert!(false, "indy_get_frozen_ledgers_request returned error_code {:?}", ec); + } + } + } } mod multi_sign_request { diff --git a/libindy/tests/utils/ledger.rs b/libindy/tests/utils/ledger.rs index 1740b9b1fa..ce9d230fc3 100644 --- a/libindy/tests/utils/ledger.rs +++ b/libindy/tests/utils/ledger.rs @@ -421,10 +421,10 @@ pub fn post_qualified_entities() -> (&'static str, &'static str) { (SCHEMA_ID_V2, CRED_DEF_ID_V2) } } -pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) { - ledger::build_freeze_ledgers_request(submitter_did, ledgers_ids).wait(); +pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) -> Result { + ledger::build_freeze_ledgers_request(submitter_did, ledgers_ids).wait() } -pub fn get_frozen_ledgers_request(submitter_did: &str) { - ledger::get_frozen_ledgers_request(submitter_did).wait(); +pub fn get_frozen_ledgers_request(submitter_did: &str) -> Result { + ledger::build_get_frozen_ledgers_request(submitter_did).wait() } \ No newline at end of file diff --git a/wrappers/python/indy/ledger.py b/wrappers/python/indy/ledger.py index 721b02198b..5092786acc 100644 --- a/wrappers/python/indy/ledger.py +++ b/wrappers/python/indy/ledger.py @@ -1838,3 +1838,45 @@ async def append_request_endorser(request_json: str, res = request_json.decode() logger.debug("append_request_endorser: <<< res: %r", res) return res + +async def build_freeze_ledgers_request(submitter_did: str, ledgers_ids: str) -> str: + + logger = logging.getLogger(__name__) + logger.debug("build_freeze_ledgers_request: >>> submitter_did: %r", + submitter_did) + + if not hasattr(build_freeze_ledgers_request, "cb"): + logger.debug("build_freeze_ledgers_request: Creating callback") + build_freeze_ledgers_request.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p)) + + c_submitter_did = c_char_p(submitter_did.encode('utf-8')) + c_ledgers_ids = c_char_p(ledgers_ids.encode('utf-8')) + + request_json = await do_call('indy_build_freeze_ledgers_request', + c_submitter_did, + c_ledgers_ids, + build_freeze_ledgers_request.cb) + + res = request_json.decode() + logger.debug("build_freeze_ledgers_request: <<< res: %r", res) + return res + +async def build_get_frozen_ledgers_request(submitter_did: str) -> str: + + logger = logging.getLogger(__name__) + logger.debug("build_get_frozen_ledgers_request: >>> submitter_did: %r", + submitter_did) + + if not hasattr(build_get_frozen_ledgers_request, "cb"): + logger.debug("build_get_frozen_ledgers_request: Creating callback") + build_get_frozen_ledgers_request.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p)) + + c_submitter_did = c_char_p(submitter_did.encode('utf-8')) + + request_json = await do_call('indy_build_get_frozen_ledgers_request', + c_submitter_did, + build_get_frozen_ledgers_request.cb) + + res = request_json.decode() + logger.debug("build_get_frozen_ledgers_request: <<< res: %r", res) + return res diff --git a/wrappers/python/tests/ledger/test_build_freeze_ledgers_request.py b/wrappers/python/tests/ledger/test_build_freeze_ledgers_request.py new file mode 100644 index 0000000000..5dfa18aad7 --- /dev/null +++ b/wrappers/python/tests/ledger/test_build_freeze_ledgers_request.py @@ -0,0 +1,9 @@ +from indy import ledger + +import json +import pytest + +@pytest.mark.asyncio +async def test_build_freeze_ledgers_request(did_trustee): + ledgers_ids = '[6, 78, 75]' + response = json.loads(await ledger.build_freeze_ledgers_request(did_trustee, ledgers_ids)) diff --git a/wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py b/wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py new file mode 100644 index 0000000000..281e23c37b --- /dev/null +++ b/wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py @@ -0,0 +1,8 @@ +from indy import ledger + +import json +import pytest + +@pytest.mark.asyncio +async def test_build_get_frozen_ledgers_request(did_trustee): + response = json.loads(await ledger.build_get_frozen_ledgers_request(did_trustee)) diff --git a/wrappers/rust/indy-sys/src/ledger.rs b/wrappers/rust/indy-sys/src/ledger.rs index 307d058c2b..902136c104 100644 --- a/wrappers/rust/indy-sys/src/ledger.rs +++ b/wrappers/rust/indy-sys/src/ledger.rs @@ -313,7 +313,7 @@ extern { cb: Option) -> Error; #[no_mangle] - pub fn indy_get_frozen_ledgers_request(command_handle: CommandHandle, + pub fn indy_build_get_frozen_ledgers_request(command_handle: CommandHandle, submitter_did: CString, cb: Option) -> Error; } diff --git a/wrappers/rust/src/ledger.rs b/wrappers/rust/src/ledger.rs index e3e3418b9a..aad96f8400 100644 --- a/wrappers/rust/src/ledger.rs +++ b/wrappers/rust/src/ledger.rs @@ -1529,17 +1529,17 @@ fn _build_freeze_ledgers_request(command_handle: CommandHandle, submitter_did: & }) } -pub fn get_frozen_ledgers_request(submitter_did: &str) -> Box> { +pub fn build_get_frozen_ledgers_request(submitter_did: &str) -> Box> { let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string(); - let err = _get_frozen_ledgers_request(command_handle, submitter_did, cb); + let err = _build_get_frozen_ledgers_request(command_handle, submitter_did, cb); ResultHandler::str(command_handle, err, receiver) } -fn _get_frozen_ledgers_request(command_handle: CommandHandle, submitter_did: &str, cb: Option) -> ErrorCode { +fn _build_get_frozen_ledgers_request(command_handle: CommandHandle, submitter_did: &str, cb: Option) -> ErrorCode { let submitter_did = c_str!(submitter_did); ErrorCode::from(unsafe { - ledger::indy_get_frozen_ledgers_request(command_handle, + ledger::indy_build_get_frozen_ledgers_request(command_handle, submitter_did.as_ptr(), cb) }) diff --git a/wrappers/rust/tests/ledger.rs b/wrappers/rust/tests/ledger.rs index 10a871b1db..b39a1b43e3 100644 --- a/wrappers/rust/tests/ledger.rs +++ b/wrappers/rust/tests/ledger.rs @@ -564,6 +564,43 @@ mod test_build_cred_def_request { } } +#[cfg(test)] +mod test_build_freeze_ledgers_request { + use super::*; + + #[test] + pub fn test_build_freeze_ledgers_request() { + let wallet = Wallet::new(); + let (did, _) = did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); + let ledgers_ids: &str = &json!(vec![0u64, 1u64, 10u64, 23u64]).to_string(); + + match ledger::build_freeze_ledgers_request(&did, ledgers_ids).wait() { + Ok(_) => {}, + Err(ec) => { + assert!(false, "build_freeze_ledgers_request returned error_code {:?}", ec); + } + } + } +} + +#[cfg(test)] +mod test_build_get_frozen_ledgers_request { + use super::*; + + #[test] + pub fn test_build_get_frozen_ledgers_request() { + let wallet = Wallet::new(); + let (did, _) = did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); + + match ledger::build_get_frozen_ledgers_request(&did).wait() { + Ok(_) => {}, + Err(ec) => { + assert!(false, "build_get_frozen_ledgers_request returned error_code {:?}", ec); + } + } + } +} + #[cfg(test)] mod test_build_get_cred_def_request {} From 469378a602e97db611cfe80ed8cfe827bd85aca5 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Wed, 27 Jan 2021 14:18:32 +0300 Subject: [PATCH 04/12] Fix CLI tests for frozen ledgers Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index 97d99a7c49..2cbd9cde0e 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -5171,7 +5171,7 @@ pub mod tests { #[test] pub fn freeze_ledgers() { - let ctx = setup_with_wallet_and_pool(); + let ctx = setup(); let (_, path_str) = _path(); { @@ -5186,7 +5186,7 @@ pub mod tests { #[test] pub fn get_frozen_ledgers() { - let ctx = setup_with_wallet_and_pool(); + let ctx = setup(); let (_, path_str) = _path(); { From 6e69875c7136ef9fa26e1d9fbd22f40039bf3e53 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Wed, 27 Jan 2021 15:40:45 +0300 Subject: [PATCH 05/12] Add test for java wrappers Signed-off-by: Anton Denishchenko --- .../org/hyperledger/indy/sdk/LibIndy.java | 7 ++- .../hyperledger/indy/sdk/ledger/Ledger.java | 43 +++++++++++-- .../indy/sdk/ledger/GetFrozenLedgersTest.java | 61 +++++++++++++++++++ 3 files changed, 103 insertions(+), 8 deletions(-) create mode 100644 wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java diff --git a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java index 50d9619f9b..b88d943f04 100644 --- a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java +++ b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java @@ -1,11 +1,12 @@ package org.hyperledger.indy.sdk; +import com.sun.jna.*; +import com.sun.jna.ptr.PointerByReference; + import java.io.File; import java.util.HashMap; import java.util.Map; -import com.sun.jna.*; -import com.sun.jna.ptr.PointerByReference; import static com.sun.jna.Native.detach; public abstract class LibIndy { @@ -87,6 +88,8 @@ public interface API extends Library { public int indy_build_get_acceptance_mechanisms_request(int command_handle, String submitter_did, int timestamp, String version, Callback cb); public int indy_append_txn_author_agreement_acceptance_to_request(int command_handle, String request_json, String text, String version, String hash, String acc_mech_type, long time_of_acceptance, Callback cb); public int indy_append_request_endorser(int command_handle, String request_json, String endorser_did, Callback cb); + public int indy_build_freeze_ledgers_request(int command_handle, String submitter_did, String ledgers_ids, Callback cb); + public int indy_build_get_frozen_ledgers_request(int command_handle, String submitter_did, Callback cb); // did.rs diff --git a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java index cb1457cc93..602eadd4a0 100644 --- a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java +++ b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java @@ -1,18 +1,16 @@ package org.hyperledger.indy.sdk.ledger; -import java.util.concurrent.CompletableFuture; - +import com.sun.jna.Callback; import org.hyperledger.indy.sdk.IndyException; import org.hyperledger.indy.sdk.IndyJava; import org.hyperledger.indy.sdk.LibIndy; import org.hyperledger.indy.sdk.ParamGuard; +import org.hyperledger.indy.sdk.ledger.LedgerResults.ParseRegistryResponseResult; +import org.hyperledger.indy.sdk.ledger.LedgerResults.ParseResponseResult; import org.hyperledger.indy.sdk.pool.Pool; import org.hyperledger.indy.sdk.wallet.Wallet; -import org.hyperledger.indy.sdk.ledger.LedgerResults.ParseResponseResult; -import org.hyperledger.indy.sdk.ledger.LedgerResults.ParseRegistryResponseResult; - -import com.sun.jna.Callback; +import java.util.concurrent.CompletableFuture; /** * ledger.rs API @@ -1785,4 +1783,37 @@ public static CompletableFuture appendRequestEndorser( return future; } + + public static CompletableFuture GetFreezeLedgersRequest(String submitterDid, String ledgersIds) throws IndyException { + ParamGuard.notNullOrWhiteSpace(submitterDid, "submitterDid"); + + CompletableFuture future = new CompletableFuture(); + int commandHandle = addFuture(future); + + int result = LibIndy.api.indy_build_freeze_ledgers_request( + commandHandle, + submitterDid, + ledgersIds, + buildRequestCb); + + checkResult(future, result); + + return future; + } + + public static CompletableFuture GetFrozenLedgersRequest(String submitterDid) throws IndyException { + ParamGuard.notNullOrWhiteSpace(submitterDid, "submitterDid"); + + CompletableFuture future = new CompletableFuture(); + int commandHandle = addFuture(future); + + int result = LibIndy.api.indy_build_get_frozen_ledgers_request( + commandHandle, + submitterDid, + buildRequestCb); + + checkResult(future, result); + + return future; + } } diff --git a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java new file mode 100644 index 0000000000..862e13c258 --- /dev/null +++ b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java @@ -0,0 +1,61 @@ +package org.hyperledger.indy.sdk.ledger; + +import org.hyperledger.indy.sdk.did.Did; +import org.hyperledger.indy.sdk.did.DidResults; +import org.json.JSONObject; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.Timeout; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.TimeUnit; + +public class GetFrozenLedgersTest extends LedgerIntegrationTest { + @Rule + public Timeout globalTimeout = new Timeout(1, TimeUnit.MINUTES); + + @Test + public void TestGetFrozenLedgersRequest() throws Exception { + DidResults.CreateAndStoreMyDidResult trusteeDidResult = Did.createAndStoreMyDid(wallet, TRUSTEE_IDENTITY_JSON).get(); + + DidResults.CreateAndStoreMyDidResult myDidResult = Did.createAndStoreMyDid(wallet, "{}").get(); + String did = myDidResult.getDid(); + + String request = Ledger.GetFrozenLedgersRequest(did).get(); + JSONObject expectedResult = new JSONObject() + .put("operation", new JSONObject() + .put("type", "124") + ); + + System.out.println(request); + assert (new JSONObject(request).toMap().entrySet() + .containsAll(expectedResult.toMap().entrySet())); + } + + @Test + public void TestFreezeLedgersRequest() throws Exception { + DidResults.CreateAndStoreMyDidResult trusteeDidResult = Did.createAndStoreMyDid(wallet, TRUSTEE_IDENTITY_JSON).get(); + + DidResults.CreateAndStoreMyDidResult myDidResult = Did.createAndStoreMyDid(wallet, "{}").get(); + String did = myDidResult.getDid(); + + String ledgersIds = "[0,1,28,345]"; + String request = Ledger.GetFreezeLedgersRequest(did, ledgersIds).get(); + + List expe = new ArrayList(); + expe.add(0); + expe.add(1); + expe.add(28); + expe.add(345); + + JSONObject expectedResult = new JSONObject() + .put("operation", new JSONObject() + .put("type", "123") + .put("ledgers_ids", expe) + ); + + assert (new JSONObject(request).toMap().entrySet() + .containsAll(expectedResult.toMap().entrySet())); + } +} From f8a34b363cbd787f3284dcfe59f323683c0db6ef Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Thu, 28 Jan 2021 11:58:22 +0300 Subject: [PATCH 06/12] Fix CLI for frozen ledgers Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index 2cbd9cde0e..315f30b638 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -2047,7 +2047,7 @@ pub mod freeze_ledgers_command { command!(CommandMetadata::build("freeze-ledgers", r#"Freeze all ledgers"#) .add_required_param("ledgers_ids", "List ledgers for freeze.") - .add_example("ledger freeze-ledgers") + .add_example("ledger freeze-ledgers ledgers_ids=[1,2,3]") .finalize() ); @@ -2109,10 +2109,22 @@ pub mod get_frozen_ledgers_command { serde_json::to_value(&flat_value).unwrap() }).collect::>(); - print_frozen_ledgers(result); + print_frozen_ledgers(result)?; trace!("execute <<"); Ok(()) } + + fn print_frozen_ledgers(frozen_ledgers: Vec) -> Result<(), ()> { + println_succ!("Following Receipts has been received."); + print_list_table(&frozen_ledgers, + &[("ledger_id", "Ledger id"), + ("ledger", "Payment Address of recipient"), + ("state", "Amount"), + ("seq_no", "Extra")], + ""); + + Ok(()) + } } pub fn set_author_agreement(ctx: &CommandContext, request: &mut String) -> Result<(), ()> { @@ -2185,18 +2197,6 @@ pub fn print_response_receipts(receipts: Option>) -> Resu Ok(()) } -pub fn print_frozen_ledgers(frozen_ledgers: Vec) -> Result<(), ()> { - println_succ!("Following Receipts has been received."); - print_list_table(&frozen_ledgers, - &[("ledger_id", "Ledger id"), - ("ledger", "Payment Address of recipient"), - ("state", "Amount"), - ("seq_no", "Extra")], - ""); - - Ok(()) -} - fn parse_payment_fees(fees: &[&str]) -> Result { let mut fees_map: HashMap = HashMap::new(); @@ -5173,7 +5173,6 @@ pub mod tests { pub fn freeze_ledgers() { let ctx = setup(); - let (_, path_str) = _path(); { let cmd = freeze_ledgers_command::new(); let mut params = CommandParams::new(); @@ -5188,10 +5187,9 @@ pub mod tests { pub fn get_frozen_ledgers() { let ctx = setup(); - let (_, path_str) = _path(); { let cmd = get_frozen_ledgers_command::new(); - let mut params = CommandParams::new(); + let params = CommandParams::new(); cmd.execute(&ctx, ¶ms).unwrap_err(); } From d07edfce8b508334983418feb0cbec8216fc7320 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Fri, 29 Jan 2021 02:35:30 +0300 Subject: [PATCH 07/12] Fix tests and add docs for frozen ledgers Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 14 +++--- cli/src/libindy/ledger.rs | 4 +- cli/src/main.rs | 2 + libindy/src/api/ledger.rs | 44 +++++++++++++++--- libindy/src/commands/ledger.rs | 16 +++---- libindy/src/domain/ledger/constants.rs | 8 ++-- libindy/src/domain/ledger/ledgers_freeze.rs | 12 ++--- libindy/src/services/ledger/mod.rs | 6 +-- .../src/services/metrics/command_metrics.rs | 4 +- libindy/tests/ledger.rs | 8 ++-- libindy/tests/utils/ledger.rs | 4 +- .../org/hyperledger/indy/sdk/LibIndy.java | 2 +- .../hyperledger/indy/sdk/ledger/Ledger.java | 37 +++++++++++++-- .../indy/sdk/ledger/GetFrozenLedgersTest.java | 8 ++-- wrappers/python/indy/ledger.py | 45 +++++++++++++++---- ...y => test_build_ledgers_freeze_request.py} | 4 +- wrappers/rust/indy-sys/src/ledger.rs | 2 +- wrappers/rust/src/ledger.rs | 36 ++++++++++++--- wrappers/rust/tests/ledger.rs | 8 ++-- 19 files changed, 194 insertions(+), 70 deletions(-) rename wrappers/python/tests/ledger/{test_build_freeze_ledgers_request.py => test_build_ledgers_freeze_request.py} (52%) diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index 315f30b638..ee9c9ea0a4 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -2042,12 +2042,12 @@ pub mod get_acceptance_mechanisms_command { } } -pub mod freeze_ledgers_command { +pub mod ledgers_freeze_command { use super::*; - command!(CommandMetadata::build("freeze-ledgers", r#"Freeze all ledgers"#) + command!(CommandMetadata::build("ledgers-freeze", r#"Freeze all ledgers"#) .add_required_param("ledgers_ids", "List ledgers for freeze.") - .add_example("ledger freeze-ledgers ledgers_ids=[1,2,3]") + .add_example("ledger ledgers-freeze ledgers_ids=[1,2,3]") .finalize() ); @@ -2058,7 +2058,7 @@ pub mod freeze_ledgers_command { let (wallet_handle, wallet_name) = ensure_opened_wallet(&ctx)?; let ledgers_ids = get_str_param("ledgers_ids", params).map_err(error_err!())?; - let request = Ledger::build_freeze_ledgers_request(&submitter_did, ledgers_ids) + let request = Ledger::build_ledgers_freeze_request(&submitter_did, ledgers_ids) .map_err(|err| handle_indy_error(err, None, None, None))?; let (_, response) = send_write_request!(&ctx, params, &request, wallet_handle, &wallet_name, &submitter_did); @@ -2355,7 +2355,7 @@ fn get_txn_title(role: &serde_json::Value) -> serde_json::Value { Some("120") => "AUTH_RULE", Some("121") => "GET_AUTH_RULE", Some("122") => "AUTH_RULES", - Some("123") => "FREEZE_LEDGERS", + Some("123") => "LEDGERS_FREEZE", Some("124") => "GET_FROZEN_LEDGERS", Some(val) => val, _ => "-" @@ -5170,11 +5170,11 @@ pub mod tests { use super::*; #[test] - pub fn freeze_ledgers() { + pub fn ledgers_freeze() { let ctx = setup(); { - let cmd = freeze_ledgers_command::new(); + let cmd = ledgers_freeze_command::new(); let mut params = CommandParams::new(); params.insert("ledgers_ids", json!(vec![0, 1, 10, 23]).to_string()); cmd.execute(&ctx, ¶ms).unwrap_err(); diff --git a/cli/src/libindy/ledger.rs b/cli/src/libindy/ledger.rs index b6d09bec60..88b0da84d7 100644 --- a/cli/src/libindy/ledger.rs +++ b/cli/src/libindy/ledger.rs @@ -148,8 +148,8 @@ impl Ledger { ledger::append_request_endorser(request_json, endorser_did).wait() } - pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) -> Result { - ledger::build_freeze_ledgers_request(submitter_did, ledgers_ids).wait() + pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: &str) -> Result { + ledger::build_ledgers_freeze_request(submitter_did, ledgers_ids).wait() } pub fn build_get_frozen_ledgers_request(submitter_did: &str) -> Result { diff --git a/cli/src/main.rs b/cli/src/main.rs index 9881c49844..d66e5884c4 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -188,6 +188,8 @@ fn build_executor() -> CommandExecutor { .add_command(ledger::get_acceptance_mechanisms_command::new()) .add_command(ledger::endorse_transaction_command::new()) .add_command(ledger::taa_disable_all_command::new()) + .add_command(ledger::ledgers_freeze_command::new()) + .add_command(ledger::get_frozen_ledgers_command::new()) .finalize_group() .add_group(payment_address::group::new()) .add_command(payment_address::new_command::new()) diff --git a/libindy/src/api/ledger.rs b/libindy/src/api/ledger.rs index 9922f11426..f4fa183e76 100644 --- a/libindy/src/api/ledger.rs +++ b/libindy/src/api/ledger.rs @@ -1792,33 +1792,67 @@ pub extern fn indy_get_response_metadata(command_handle: CommandHandle, res } +/// Builds a LEDGERS_FREEZE request. Request to freeze list of ledgers. +/// +/// #Params +/// command_handle: command handle to map callback to caller context. +/// submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). +/// ledgers_ids: list ids for freeze ledgers (json format). +/// cb: Callback that takes command result as parameter. +/// +/// #Returns +/// Request result as json. +/// +/// #Errors +/// Common* #[no_mangle] -pub extern fn indy_build_freeze_ledgers_request (command_handle: CommandHandle, +pub extern fn indy_build_ledgers_freeze_request (command_handle: CommandHandle, submitter_did: *const c_char, ledgers_ids: *const c_char, cb: Option) -> ErrorCode { - trace!("indy_build_freeze_ledgers_request: entities >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); + trace!("indy_build_ledgers_freeze_request: entities >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); check_useful_validatable_string!(submitter_did, ErrorCode::CommonInvalidParam2, DidValue); check_useful_json!(ledgers_ids, ErrorCode::CommonInvalidParam3, Vec); check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam4); let result = CommandExecutor::instance() - .send(Command::Ledger(LedgerCommand::BuildFreezeLedgersRequest( + .send(Command::Ledger(LedgerCommand::BuildLedgersFreezeRequest( submitter_did, ledgers_ids, - boxed_callback_string!("indy_build_freeze_ledgers_request", cb, command_handle) + boxed_callback_string!("indy_build_ledgers_freeze_request", cb, command_handle) ))); let res = prepare_result!(result); - trace!("indy_build_freeze_ledgers_request: <<< res: {:?}", res); + trace!("indy_build_ledgers_freeze_request: <<< res: {:?}", res); res } +/// Builds a GET_FROZEN_LEDGERS request. Request to get list of frozen ledgers. +/// frozen ledgers are defined by LEDGERS_FREEZE request. +/// +/// #Params +/// command_handle: command handle to map callback to caller context. +/// submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). +/// cb: Callback that takes command result as parameter. +/// +/// #Returns +/// Request result as json. +/// { +/// : { +/// "ledger": String - Ledger root hash, +/// "state": String - State root hash, +/// "seq_no": u64 - the latest transaction seqNo for particular Node, +/// }, +/// ... +/// } +/// +/// #Errors +/// Common* #[no_mangle] pub extern fn indy_build_get_frozen_ledgers_request (command_handle: CommandHandle, submitter_did: *const c_char, diff --git a/libindy/src/commands/ledger.rs b/libindy/src/commands/ledger.rs index ba4164f1d4..50647a8f70 100644 --- a/libindy/src/commands/ledger.rs +++ b/libindy/src/commands/ledger.rs @@ -279,7 +279,7 @@ pub enum LedgerCommand { BuildGetFrozenLedgersRequest( DidValue, // submitter did Box) + Send>), - BuildFreezeLedgersRequest( + BuildLedgersFreezeRequest( DidValue, // submitter did Vec, // ledgers ids Box) + Send>), @@ -535,9 +535,9 @@ impl LedgerCommandExecutor { cb(self.append_request_endorser(&request_json, &endorser_did)); } - LedgerCommand::BuildFreezeLedgersRequest(submitter_did, ledgers_ids, cb) => { - debug!(target: "ledger_command_executor", "BuildFreezeLedgersRequest command received"); - cb(self.build_freeze_ledgers_request(&submitter_did, ledgers_ids)); + LedgerCommand::BuildLedgersFreezeRequest(submitter_did, ledgers_ids, cb) => { + debug!(target: "ledger_command_executor", "BuildLedgersFreezeRequest command received"); + cb(self.build_ledgers_freeze_request(&submitter_did, ledgers_ids)); } LedgerCommand::BuildGetFrozenLedgersRequest(submitter_did, cb) => { debug!(target: "ledger_command_executor", "BuildGetFrozenLedgersRequest command received"); @@ -1324,14 +1324,14 @@ impl LedgerCommandExecutor { cb(self.ledger_service.parse_get_cred_def_response(&pool_response, id.get_method().as_ref().map(String::as_str))) } - fn build_freeze_ledgers_request(&self, submitter_did: &DidValue, ledgers_ids: Vec) -> IndyResult{ - debug!("build_freeze_ledgers_request >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); + fn build_ledgers_freeze_request(&self, submitter_did: &DidValue, ledgers_ids: Vec) -> IndyResult{ + debug!("build_ledgers_freeze_request >>> submitter_did: {:?}, ledgers_ids: {:?}", submitter_did, ledgers_ids); self.crypto_service.validate_did(&submitter_did)?; - let res = self.ledger_service.build_freeze_ledgers_request(&submitter_did, ledgers_ids)?; + let res = self.ledger_service.build_ledgers_freeze_request(&submitter_did, ledgers_ids)?; - debug!("build_freeze_ledgers_request <<< res: {:?}", res); + debug!("build_ledgers_freeze_request <<< res: {:?}", res); Ok(res) } diff --git a/libindy/src/domain/ledger/constants.rs b/libindy/src/domain/ledger/constants.rs index 95d1fb1a61..18cdd787d0 100644 --- a/libindy/src/domain/ledger/constants.rs +++ b/libindy/src/domain/ledger/constants.rs @@ -25,14 +25,14 @@ pub const GET_VALIDATOR_INFO: &str = "119"; pub const AUTH_RULE: &str = "120"; pub const GET_AUTH_RULE: &str = "121"; pub const AUTH_RULES: &str = "122"; -pub const FREEZE_LEDGERS: &str = "123"; +pub const LEDGERS_FREEZE: &str = "123"; pub const GET_FROZEN_LEDGERS: &str = "124"; pub const GET_DDO: &str = "120";//TODO change number -pub const REQUESTS: [&str; 25] = [NODE, NYM, GET_TXN, ATTRIB, SCHEMA, CRED_DEF, GET_ATTR, GET_NYM, GET_SCHEMA, +pub const REQUESTS: [&str; 27] = [NODE, NYM, GET_TXN, ATTRIB, SCHEMA, CRED_DEF, GET_ATTR, GET_NYM, GET_SCHEMA, GET_CRED_DEF, POOL_UPGRADE, POOL_RESTART, POOL_CONFIG, REVOC_REG_DEF, REVOC_REG_ENTRY, GET_REVOC_REG_DEF, GET_REVOC_REG, GET_REVOC_REG_DELTA, GET_VALIDATOR_INFO, AUTH_RULE, GET_DDO, TXN_AUTHR_AGRMT, TXN_AUTHR_AGRMT_AML, - GET_TXN_AUTHR_AGRMT, GET_TXN_AUTHR_AGRMT_AML]; + GET_TXN_AUTHR_AGRMT, GET_TXN_AUTHR_AGRMT_AML, LEDGERS_FREEZE, GET_FROZEN_LEDGERS]; pub const TRUSTEE: &str = "0"; pub const STEWARD: &str = "2"; @@ -73,6 +73,8 @@ pub fn txn_name_to_code(txn: &str) -> Option<&str> { "TXN_AUTHR_AGRMT_AML" => Some(TXN_AUTHR_AGRMT_AML), "GET_TXN_AUTHR_AGRMT" => Some(GET_TXN_AUTHR_AGRMT), "GET_TXN_AUTHR_AGRMT_AML" => Some(GET_TXN_AUTHR_AGRMT_AML), + "LEDGERS_FREEZE" => Some(LEDGERS_FREEZE), + "GET_FROZEN_LEDGERS" => Some(GET_FROZEN_LEDGERS), val => Some(val) } } \ No newline at end of file diff --git a/libindy/src/domain/ledger/ledgers_freeze.rs b/libindy/src/domain/ledger/ledgers_freeze.rs index 6292b4930a..3f48b4277b 100644 --- a/libindy/src/domain/ledger/ledgers_freeze.rs +++ b/libindy/src/domain/ledger/ledgers_freeze.rs @@ -1,17 +1,17 @@ -use super::constants::{FREEZE_LEDGERS, GET_FROZEN_LEDGERS}; +use super::constants::{LEDGERS_FREEZE, GET_FROZEN_LEDGERS}; #[derive(Serialize, PartialEq, Debug)] -pub struct FreezeLedgersOperation { +pub struct LedgersFreezeOperation { #[serde(rename = "type")] pub _type: String, pub ledgers_ids: Vec, } -impl FreezeLedgersOperation { - pub fn new(ledgers_ids: Vec) -> FreezeLedgersOperation { - FreezeLedgersOperation { +impl LedgersFreezeOperation { + pub fn new(ledgers_ids: Vec) -> LedgersFreezeOperation { + LedgersFreezeOperation { ledgers_ids, - _type: FREEZE_LEDGERS.to_string() + _type: LEDGERS_FREEZE.to_string() } } } diff --git a/libindy/src/services/ledger/mod.rs b/libindy/src/services/ledger/mod.rs index 58ffc43e73..07799bd9d6 100644 --- a/libindy/src/services/ledger/mod.rs +++ b/libindy/src/services/ledger/mod.rs @@ -27,7 +27,7 @@ use crate::domain::ledger::txn::{GetTxnOperation, LedgerType}; use crate::domain::ledger::validator_info::GetValidatorInfoOperation; use crate::domain::ledger::auth_rule::*; use crate::domain::ledger::author_agreement::*; -use crate::domain::ledger::ledgers_freeze::{FreezeLedgersOperation, GetFrozenLedgersOperation}; +use crate::domain::ledger::ledgers_freeze::{LedgersFreezeOperation, GetFrozenLedgersOperation}; use indy_api_types::errors::prelude::*; use indy_utils::crypto::hash::hash as openssl_hash; @@ -396,8 +396,8 @@ impl LedgerService { } #[logfn(Info)] - pub fn build_freeze_ledgers_request(&self, submitter_did: &DidValue, ledgers_ids: Vec) -> IndyResult { - build_result!(FreezeLedgersOperation, Some(submitter_did), ledgers_ids) + pub fn build_ledgers_freeze_request(&self, submitter_did: &DidValue, ledgers_ids: Vec) -> IndyResult { + build_result!(LedgersFreezeOperation, Some(submitter_did), ledgers_ids) } #[logfn(Info)] diff --git a/libindy/src/services/metrics/command_metrics.rs b/libindy/src/services/metrics/command_metrics.rs index baa64e63d9..66768b82d7 100644 --- a/libindy/src/services/metrics/command_metrics.rs +++ b/libindy/src/services/metrics/command_metrics.rs @@ -192,7 +192,7 @@ impl From<&Command> for CommandMetric { LedgerCommand::AppendTxnAuthorAgreementAcceptanceToRequest(_, _, _, _, _, _, _) => { CommandMetric::LedgerCommandAppendTxnAuthorAgreementAcceptanceToRequest } LedgerCommand::AppendRequestEndorser(_, _, _) => { CommandMetric::LedgerCommandAppendRequestEndorser } LedgerCommand::BuildGetFrozenLedgersRequest(_,_,) => { CommandMetric::LedgerCommandBuildGetFrozenLedgersRequest } - LedgerCommand::BuildFreezeLedgersRequest(_,_,_,) => { CommandMetric::LedgerCommandBuildFreezeLedgersRequest } + LedgerCommand::BuildLedgersFreezeRequest(_,_,_,) => { CommandMetric::LedgerCommandBuildLedgersFreezeRequest } } } Command::Pool(cmd) => { @@ -430,7 +430,7 @@ pub enum CommandMetric { LedgerCommandAppendTxnAuthorAgreementAcceptanceToRequest, LedgerCommandAppendRequestEndorser, LedgerCommandBuildGetFrozenLedgersRequest, - LedgerCommandBuildFreezeLedgersRequest, + LedgerCommandBuildLedgersFreezeRequest, // PoolCommand PoolCommandCreate, PoolCommandDelete, diff --git a/libindy/tests/ledger.rs b/libindy/tests/ledger.rs index 70a38a6ec3..ca4b2c751b 100644 --- a/libindy/tests/ledger.rs +++ b/libindy/tests/ledger.rs @@ -205,14 +205,14 @@ mod high_cases { use super::*; #[test] - fn indy_build_freeze_ledgers_request() { - let ledgers_ids = json!(vec![0, 1, 10, 23]); - let res = ledger::build_freeze_ledgers_request(DID_TRUSTEE, &ledgers_ids.to_string()); + fn indy_build_ledgers_freeze_request() { + let ledgers_ids = json!(vec![0u64, 1u64, 10u64, 23u64]); + let res = ledger::build_ledgers_freeze_request(DID_TRUSTEE, &ledgers_ids.to_string()); match res { Ok(_) => {}, Err(ec) => { - assert!(false, "indy_build_freeze_ledgers_request returned error_code {:?}", ec); + assert!(false, "indy_build_ledgers_freeze_request returned error_code {:?}", ec); } } } diff --git a/libindy/tests/utils/ledger.rs b/libindy/tests/utils/ledger.rs index ce9d230fc3..6d39c4d0dd 100644 --- a/libindy/tests/utils/ledger.rs +++ b/libindy/tests/utils/ledger.rs @@ -421,8 +421,8 @@ pub fn post_qualified_entities() -> (&'static str, &'static str) { (SCHEMA_ID_V2, CRED_DEF_ID_V2) } } -pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) -> Result { - ledger::build_freeze_ledgers_request(submitter_did, ledgers_ids).wait() +pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: &str) -> Result { + ledger::build_ledgers_freeze_request(submitter_did, ledgers_ids).wait() } pub fn get_frozen_ledgers_request(submitter_did: &str) -> Result { diff --git a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java index b88d943f04..1e97488446 100644 --- a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java +++ b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/LibIndy.java @@ -88,7 +88,7 @@ public interface API extends Library { public int indy_build_get_acceptance_mechanisms_request(int command_handle, String submitter_did, int timestamp, String version, Callback cb); public int indy_append_txn_author_agreement_acceptance_to_request(int command_handle, String request_json, String text, String version, String hash, String acc_mech_type, long time_of_acceptance, Callback cb); public int indy_append_request_endorser(int command_handle, String request_json, String endorser_did, Callback cb); - public int indy_build_freeze_ledgers_request(int command_handle, String submitter_did, String ledgers_ids, Callback cb); + public int indy_build_ledgers_freeze_request(int command_handle, String submitter_did, String ledgers_ids, Callback cb); public int indy_build_get_frozen_ledgers_request(int command_handle, String submitter_did, Callback cb); // did.rs diff --git a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java index 602eadd4a0..14a10f3606 100644 --- a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java +++ b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java @@ -1784,13 +1784,24 @@ public static CompletableFuture appendRequestEndorser( return future; } - public static CompletableFuture GetFreezeLedgersRequest(String submitterDid, String ledgersIds) throws IndyException { + /** + * Request to freeze list of ledgers. + * + * @param command_handle - command handle to map callback to caller context. + * @param submitter_did - (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). + * @param ledgers_ids - list ids for freeze ledgers (json format). + * @param cb - Callback that takes command result as parameter. + * + * @return A future resolving to a request result as json. + * @throws IndyException Thrown if an error occurs when calling the underlying SDK. + */ + public static CompletableFuture buildLedgersFreezeRequest(String submitterDid, String ledgersIds) throws IndyException { ParamGuard.notNullOrWhiteSpace(submitterDid, "submitterDid"); CompletableFuture future = new CompletableFuture(); int commandHandle = addFuture(future); - int result = LibIndy.api.indy_build_freeze_ledgers_request( + int result = LibIndy.api.indy_build_ledgers_freeze_request( commandHandle, submitterDid, ledgersIds, @@ -1801,7 +1812,27 @@ public static CompletableFuture GetFreezeLedgersRequest(String submitter return future; } - public static CompletableFuture GetFrozenLedgersRequest(String submitterDid) throws IndyException { + /** + * Request to get list of frozen ledgers. + * Frozen ledgers are defined by ledgers freeze request. + * + * @param command_handle - command handle to map callback to caller context. + * @param submitter_did - (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). + * @param cb - Callback that takes command result as parameter. + * + * @return A future resolving to a request result as json. + * { + * : { + * "ledger": String - Ledger root hash, + * "state": String - State root hash, + * "seq_no": u64 - the latest transaction seqNo for particular Node, + * }, + * ... + * } + * + * @throws IndyException Thrown if an error occurs when calling the underlying SDK. + */ + public static CompletableFuture buildGetFrozenLedgersRequest(String submitterDid) throws IndyException { ParamGuard.notNullOrWhiteSpace(submitterDid, "submitterDid"); CompletableFuture future = new CompletableFuture(); diff --git a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java index 862e13c258..0f2ac62c93 100644 --- a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java +++ b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java @@ -16,13 +16,13 @@ public class GetFrozenLedgersTest extends LedgerIntegrationTest { public Timeout globalTimeout = new Timeout(1, TimeUnit.MINUTES); @Test - public void TestGetFrozenLedgersRequest() throws Exception { + public void TestBuildGetFrozenLedgersRequest() throws Exception { DidResults.CreateAndStoreMyDidResult trusteeDidResult = Did.createAndStoreMyDid(wallet, TRUSTEE_IDENTITY_JSON).get(); DidResults.CreateAndStoreMyDidResult myDidResult = Did.createAndStoreMyDid(wallet, "{}").get(); String did = myDidResult.getDid(); - String request = Ledger.GetFrozenLedgersRequest(did).get(); + String request = Ledger.buildGetFrozenLedgersRequest(did).get(); JSONObject expectedResult = new JSONObject() .put("operation", new JSONObject() .put("type", "124") @@ -34,14 +34,14 @@ public void TestGetFrozenLedgersRequest() throws Exception { } @Test - public void TestFreezeLedgersRequest() throws Exception { + public void TestLedgersFreezeRequest() throws Exception { DidResults.CreateAndStoreMyDidResult trusteeDidResult = Did.createAndStoreMyDid(wallet, TRUSTEE_IDENTITY_JSON).get(); DidResults.CreateAndStoreMyDidResult myDidResult = Did.createAndStoreMyDid(wallet, "{}").get(); String did = myDidResult.getDid(); String ledgersIds = "[0,1,28,345]"; - String request = Ledger.GetFreezeLedgersRequest(did, ledgersIds).get(); + String request = Ledger.buildLedgersFreezeRequest(did, ledgersIds).get(); List expe = new ArrayList(); expe.add(0); diff --git a/wrappers/python/indy/ledger.py b/wrappers/python/indy/ledger.py index 5092786acc..a617768ced 100644 --- a/wrappers/python/indy/ledger.py +++ b/wrappers/python/indy/ledger.py @@ -1839,30 +1839,59 @@ async def append_request_endorser(request_json: str, logger.debug("append_request_endorser: <<< res: %r", res) return res -async def build_freeze_ledgers_request(submitter_did: str, ledgers_ids: str) -> str: + +async def build_ledgers_freeze_request(submitter_did: str, ledgers_ids: str) -> str: + """ + Request to freeze list of ledgers. + + :param command_handle: command handle to map callback to caller context. + :param submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). + :param ledgers_ids: list ids for freeze ledgers (json format). + :param cb: Callback that takes command result as parameter. + + :return: Request result as json. + """ logger = logging.getLogger(__name__) - logger.debug("build_freeze_ledgers_request: >>> submitter_did: %r", + logger.debug("build_ledgers_freeze_request: >>> submitter_did: %r", submitter_did) - if not hasattr(build_freeze_ledgers_request, "cb"): - logger.debug("build_freeze_ledgers_request: Creating callback") - build_freeze_ledgers_request.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p)) + if not hasattr(build_ledgers_freeze_request, "cb"): + logger.debug("build_ledgers_freeze_request: Creating callback") + build_ledgers_freeze_request.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p)) c_submitter_did = c_char_p(submitter_did.encode('utf-8')) c_ledgers_ids = c_char_p(ledgers_ids.encode('utf-8')) - request_json = await do_call('indy_build_freeze_ledgers_request', + request_json = await do_call('indy_build_ledgers_freeze_request', c_submitter_did, c_ledgers_ids, - build_freeze_ledgers_request.cb) + build_ledgers_freeze_request.cb) res = request_json.decode() - logger.debug("build_freeze_ledgers_request: <<< res: %r", res) + logger.debug("build_ledgers_freeze_request: <<< res: %r", res) return res + async def build_get_frozen_ledgers_request(submitter_did: str) -> str: + """ + Request to get list of frozen ledgers. + Frozen ledgers are defined by ledgers freeze request. + + :param command_handle: command handle to map callback to caller context. + :param submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). + :param cb: Callback that takes command result as parameter. + :return A future resolving to a request result as json. + { + : { + ledger: Ledger root hash, + state": State root hash, + seq_no: the latest transaction seqNo for particular Node, + }, + ... + } + """ logger = logging.getLogger(__name__) logger.debug("build_get_frozen_ledgers_request: >>> submitter_did: %r", submitter_did) diff --git a/wrappers/python/tests/ledger/test_build_freeze_ledgers_request.py b/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py similarity index 52% rename from wrappers/python/tests/ledger/test_build_freeze_ledgers_request.py rename to wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py index 5dfa18aad7..4d20c77982 100644 --- a/wrappers/python/tests/ledger/test_build_freeze_ledgers_request.py +++ b/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py @@ -4,6 +4,6 @@ import pytest @pytest.mark.asyncio -async def test_build_freeze_ledgers_request(did_trustee): +async def test_build_ledgers_freeze_request(did_trustee): ledgers_ids = '[6, 78, 75]' - response = json.loads(await ledger.build_freeze_ledgers_request(did_trustee, ledgers_ids)) + response = json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) diff --git a/wrappers/rust/indy-sys/src/ledger.rs b/wrappers/rust/indy-sys/src/ledger.rs index 902136c104..f888dd5535 100644 --- a/wrappers/rust/indy-sys/src/ledger.rs +++ b/wrappers/rust/indy-sys/src/ledger.rs @@ -307,7 +307,7 @@ extern { cb: Option) -> Error; #[no_mangle] - pub fn indy_build_freeze_ledgers_request(command_handle: CommandHandle, + pub fn indy_build_ledgers_freeze_request(command_handle: CommandHandle, submitter_did: CString, ledgers_ids: CString, cb: Option) -> Error; diff --git a/wrappers/rust/src/ledger.rs b/wrappers/rust/src/ledger.rs index aad96f8400..d11fdbbd3d 100644 --- a/wrappers/rust/src/ledger.rs +++ b/wrappers/rust/src/ledger.rs @@ -1511,24 +1511,50 @@ fn _append_request_endorser(command_handle: CommandHandle, cb) }) } - -pub fn build_freeze_ledgers_request(submitter_did: &str, ledgers_ids: &str) -> Box> { +/// Request to freeze list of ledgers. +/// +/// # Arguments +/// * `command_handle`: command handle to map callback to caller context. +/// * `submitter_did`: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). +/// * `ledgers_ids`: list ids for freeze ledgers (json format). +/// * `cb`: Callback that takes command result as parameter. +/// +/// # Returns +/// Updated request result as json. +pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: &str) -> Box> { let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string(); - let err = _build_freeze_ledgers_request(command_handle, submitter_did, ledgers_ids, cb); + let err = _build_ledgers_freeze_request(command_handle, submitter_did, ledgers_ids, cb); ResultHandler::str(command_handle, err, receiver) } -fn _build_freeze_ledgers_request(command_handle: CommandHandle, submitter_did: &str, ledgers_ids: &str, cb: Option) -> ErrorCode { +fn _build_ledgers_freeze_request(command_handle: CommandHandle, submitter_did: &str, ledgers_ids: &str, cb: Option) -> ErrorCode { let submitter_did = c_str!(submitter_did); ErrorCode::from(unsafe { - ledger::indy_build_freeze_ledgers_request(command_handle, + ledger::indy_build_ledgers_freeze_request(command_handle, submitter_did.as_ptr(), ledgers_ids.as_ptr() as *const i8, cb) }) } +/// Request to get list of frozen ledgers. +/// +/// # Arguments +/// * `command_handle`: command handle to map callback to caller context. +/// * `submitter_did`: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). +/// * `cb`: Callback that takes command result as parameter. +/// +/// # Returns +/// Request result as json. +/// { +/// : { +/// "ledger": String - Ledger root hash, +/// "state": String - State root hash, +/// "seq_no": u64 - the latest transaction seqNo for particular Node, +/// }, +/// ... +/// } pub fn build_get_frozen_ledgers_request(submitter_did: &str) -> Box> { let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string(); let err = _build_get_frozen_ledgers_request(command_handle, submitter_did, cb); diff --git a/wrappers/rust/tests/ledger.rs b/wrappers/rust/tests/ledger.rs index b39a1b43e3..12e59d5cb1 100644 --- a/wrappers/rust/tests/ledger.rs +++ b/wrappers/rust/tests/ledger.rs @@ -565,19 +565,19 @@ mod test_build_cred_def_request { } #[cfg(test)] -mod test_build_freeze_ledgers_request { +mod test_build_ledgers_freeze_request { use super::*; #[test] - pub fn test_build_freeze_ledgers_request() { + pub fn test_build_ledgers_freeze_request() { let wallet = Wallet::new(); let (did, _) = did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); let ledgers_ids: &str = &json!(vec![0u64, 1u64, 10u64, 23u64]).to_string(); - match ledger::build_freeze_ledgers_request(&did, ledgers_ids).wait() { + match ledger::build_ledgers_freeze_request(&did, ledgers_ids).wait() { Ok(_) => {}, Err(ec) => { - assert!(false, "build_freeze_ledgers_request returned error_code {:?}", ec); + assert!(false, "build_ledgers_freeze_request returned error_code {:?}", ec); } } } From 734d1d92be107ae129ef858cac0c0d2c3947dc4d Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Fri, 29 Jan 2021 13:53:06 +0300 Subject: [PATCH 08/12] Fix rust wrappers for frozen ledgers Signed-off-by: Anton Denishchenko --- wrappers/rust/src/ledger.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/wrappers/rust/src/ledger.rs b/wrappers/rust/src/ledger.rs index d11fdbbd3d..a8ea5e002a 100644 --- a/wrappers/rust/src/ledger.rs +++ b/wrappers/rust/src/ledger.rs @@ -1529,11 +1529,12 @@ pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: &str) -> B fn _build_ledgers_freeze_request(command_handle: CommandHandle, submitter_did: &str, ledgers_ids: &str, cb: Option) -> ErrorCode { let submitter_did = c_str!(submitter_did); + let ledgers_ids = c_str!(ledgers_ids); ErrorCode::from(unsafe { ledger::indy_build_ledgers_freeze_request(command_handle, submitter_did.as_ptr(), - ledgers_ids.as_ptr() as *const i8, + ledgers_ids.as_ptr(), cb) }) } From 1650666913c984ff03a261849e36f25a0a22d758 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Fri, 29 Jan 2021 16:33:53 +0300 Subject: [PATCH 09/12] Change const codes for frozen ledgers Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 4 ++-- libindy/src/domain/ledger/constants.rs | 4 ++-- .../org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index ee9c9ea0a4..d7b14baf0a 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -2336,6 +2336,8 @@ fn get_txn_title(role: &serde_json::Value) -> serde_json::Value { Some("5") => "TXN_AUTHR_AGRMT_AML", Some("6") => "GET_TXN_AUTHR_AGRMT", Some("7") => "GET_TXN_AUTHR_AGRMT_AML", + Some("9") => "LEDGERS_FREEZE", + Some("10") => "GET_FROZEN_LEDGERS", Some("100") => "ATTRIB", Some("101") => "SCHEMA", Some("104") => "GET_ATTR", @@ -2355,8 +2357,6 @@ fn get_txn_title(role: &serde_json::Value) -> serde_json::Value { Some("120") => "AUTH_RULE", Some("121") => "GET_AUTH_RULE", Some("122") => "AUTH_RULES", - Some("123") => "LEDGERS_FREEZE", - Some("124") => "GET_FROZEN_LEDGERS", Some(val) => val, _ => "-" }.to_string()) diff --git a/libindy/src/domain/ledger/constants.rs b/libindy/src/domain/ledger/constants.rs index 18cdd787d0..d918c13ade 100644 --- a/libindy/src/domain/ledger/constants.rs +++ b/libindy/src/domain/ledger/constants.rs @@ -6,6 +6,8 @@ pub const TXN_AUTHR_AGRMT_AML: &str = "5"; pub const GET_TXN_AUTHR_AGRMT: &str = "6"; pub const GET_TXN_AUTHR_AGRMT_AML: &str = "7"; pub const DISABLE_ALL_TXN_AUTHR_AGRMTS: &str = "8"; +pub const LEDGERS_FREEZE: &str = "9"; +pub const GET_FROZEN_LEDGERS: &str = "10"; pub const ATTRIB: &str = "100"; pub const SCHEMA: &str = "101"; pub const CRED_DEF: &str = "102"; @@ -25,8 +27,6 @@ pub const GET_VALIDATOR_INFO: &str = "119"; pub const AUTH_RULE: &str = "120"; pub const GET_AUTH_RULE: &str = "121"; pub const AUTH_RULES: &str = "122"; -pub const LEDGERS_FREEZE: &str = "123"; -pub const GET_FROZEN_LEDGERS: &str = "124"; pub const GET_DDO: &str = "120";//TODO change number pub const REQUESTS: [&str; 27] = [NODE, NYM, GET_TXN, ATTRIB, SCHEMA, CRED_DEF, GET_ATTR, GET_NYM, GET_SCHEMA, diff --git a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java index 0f2ac62c93..c0c631d8c7 100644 --- a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java +++ b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java @@ -25,7 +25,7 @@ public void TestBuildGetFrozenLedgersRequest() throws Exception { String request = Ledger.buildGetFrozenLedgersRequest(did).get(); JSONObject expectedResult = new JSONObject() .put("operation", new JSONObject() - .put("type", "124") + .put("type", "10") ); System.out.println(request); @@ -51,7 +51,7 @@ public void TestLedgersFreezeRequest() throws Exception { JSONObject expectedResult = new JSONObject() .put("operation", new JSONObject() - .put("type", "123") + .put("type", "9") .put("ledgers_ids", expe) ); From 4d3fb65ccdda2b8cb9500b34c63abea6bf20a826 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Thu, 4 Feb 2021 23:37:33 +0300 Subject: [PATCH 10/12] Fix wrappers tests for frozen ledgers Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 50 +++++++++---------- cli/src/commands/mod.rs | 24 +++++++++ cli/src/libindy/ledger.rs | 2 +- libindy/src/api/ledger.rs | 6 +-- libindy/src/domain/ledger/ledgers_freeze.rs | 4 +- libindy/src/services/ledger/mod.rs | 41 +++++++++++++++ libindy/tests/ledger.rs | 6 +-- libindy/tests/utils/ledger.rs | 2 +- .../hyperledger/indy/sdk/ledger/Ledger.java | 7 +-- .../indy/sdk/ledger/GetFrozenLedgersTest.java | 36 ++++++++----- wrappers/python/indy/ledger.py | 9 ++-- .../test_build_ledgers_freeze_request.py | 10 +++- wrappers/rust/src/ledger.rs | 8 +-- wrappers/rust/tests/ledger.rs | 16 +++++- 14 files changed, 159 insertions(+), 62 deletions(-) diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index d7b14baf0a..d5a486fe48 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -2045,20 +2045,19 @@ pub mod get_acceptance_mechanisms_command { pub mod ledgers_freeze_command { use super::*; - command!(CommandMetadata::build("ledgers-freeze", r#"Freeze all ledgers"#) - .add_required_param("ledgers_ids", "List ledgers for freeze.") - .add_example("ledger ledgers-freeze ledgers_ids=[1,2,3]") + command!(CommandMetadata::build("ledgers-freeze", r#"Freeze ledgers"#) + .add_required_param("ledgers_ids", "List of ledgers IDs for freezing.") + .add_example("ledger ledgers-freeze ledgers_ids=1,2,3") .finalize() ); fn execute(ctx: &CommandContext, params: &CommandParams) -> Result<(), ()> { trace!("execute >> ctx {:?} params {:?}", ctx, params); - + let ledgers_ids = get_number_tuple_array_param("ledgers_ids", params); let submitter_did = ensure_active_did(&ctx)?; let (wallet_handle, wallet_name) = ensure_opened_wallet(&ctx)?; - let ledgers_ids = get_str_param("ledgers_ids", params).map_err(error_err!())?; - let request = Ledger::build_ledgers_freeze_request(&submitter_did, ledgers_ids) + let request = Ledger::build_ledgers_freeze_request(&submitter_did, ledgers_ids?) .map_err(|err| handle_indy_error(err, None, None, None))?; let (_, response) = send_write_request!(&ctx, params, &request, wallet_handle, &wallet_name, &submitter_did); @@ -2074,7 +2073,6 @@ pub mod ledgers_freeze_command { pub mod get_frozen_ledgers_command { use super::*; - use serde_json::Value; command!(CommandMetadata::build("get-frozen-ledgers", r#"Get a list of frozen ledgers"#) .add_example("ledger get-frozen-ledgers") @@ -2090,24 +2088,24 @@ pub mod get_frozen_ledgers_command { .map_err(|err| handle_indy_error(err, None, None, None))?; let (_, response) = send_read_request!(&ctx, params, &request, Some(&submitter_did)); - let result = handle_transaction_response(response)?; + let handle_response = handle_transaction_response(response)?; // Flattering ap into vector - let result = result.as_object() - .expect("top level object is not a map") - .iter() - .map(|kv| { - let key = kv.0; - let value = kv.1; + let handle_response = handle_response.as_object() + .expect("top level object is not a map"); - let mut flat_value = value.as_object() - .expect("inner object is not a map").clone(); + let mut result = Vec::new(); + for (key, value) in handle_response { + let mut flat_value = value.as_object() + .expect("inner object is not a map").clone(); - let ledger_id = serde_json::to_value(&key).unwrap(); - flat_value.insert("ledger_id".to_owned(), ledger_id); + let ledger_id = serde_json::to_value(&key) + .map_err(|_| println_err!("Invalid format of Outputs: Ledger ID is incorrect."))?; + flat_value.insert("ledger_id".to_owned(), ledger_id); - serde_json::to_value(&flat_value).unwrap() - }).collect::>(); + result.push(serde_json::to_value(&flat_value) + .map_err(|_| println_err!("Invalid format of Outputs: result is incorrect."))?); + } print_frozen_ledgers(result)?; trace!("execute <<"); @@ -2115,13 +2113,13 @@ pub mod get_frozen_ledgers_command { } fn print_frozen_ledgers(frozen_ledgers: Vec) -> Result<(), ()> { - println_succ!("Following Receipts has been received."); + println_succ!("Frozen ledgers has been received."); print_list_table(&frozen_ledgers, &[("ledger_id", "Ledger id"), - ("ledger", "Payment Address of recipient"), - ("state", "Amount"), - ("seq_no", "Extra")], - ""); + ("ledger", "Ledger root hash"), + ("state", "State root hash"), + ("seq_no", "Last sequance number")], + "No frozen ledgers found."); Ok(()) } @@ -5176,7 +5174,7 @@ pub mod tests { { let cmd = ledgers_freeze_command::new(); let mut params = CommandParams::new(); - params.insert("ledgers_ids", json!(vec![0, 1, 10, 23]).to_string()); + params.insert("ledgers_ids", "0,1,10,237".to_string()); cmd.execute(&ctx, ¶ms).unwrap_err(); } diff --git a/cli/src/commands/mod.rs b/cli/src/commands/mod.rs index 34f237c4e8..3f1a8fd607 100644 --- a/cli/src/commands/mod.rs +++ b/cli/src/commands/mod.rs @@ -166,6 +166,30 @@ pub fn get_str_tuple_array_param<'a>(name: &'a str, params: &'a CommandParams) - } } +pub fn get_number_tuple_array_param<'a>(name: &'a str, params: &'a CommandParams) -> Result, ()> { + match params.get(name) { + Some(v) if !v.is_empty() => { + let tuples: Vec<&str> = v.split(",").collect(); + if tuples.is_empty() { + println_err!("Parameter \"{}\" has invalid format", name); + Err(()) + } else { + let mut result: Vec = Vec::new(); + for item in tuples { + println!("{:?}",item); + result.push(item.parse::().map_err(|err| + println_err!("Can't parse number parameter \"{}\": value: \"{}\", err \"{}\"", name, item, err))?); + } + Ok(result) + } + } + _ => { + println_err!("No required \"{}\" parameter present", name); + Err(()) + } + } +} + pub fn get_opt_str_tuple_array_param<'a>(name: &'a str, params: &'a CommandParams) -> Result>, ()> { match params.get(name) { Some(v) => diff --git a/cli/src/libindy/ledger.rs b/cli/src/libindy/ledger.rs index 88b0da84d7..4b1e2e543e 100644 --- a/cli/src/libindy/ledger.rs +++ b/cli/src/libindy/ledger.rs @@ -148,7 +148,7 @@ impl Ledger { ledger::append_request_endorser(request_json, endorser_did).wait() } - pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: &str) -> Result { + pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: Vec) -> Result { ledger::build_ledgers_freeze_request(submitter_did, ledgers_ids).wait() } diff --git a/libindy/src/api/ledger.rs b/libindy/src/api/ledger.rs index f4fa183e76..fc1bc0872f 100644 --- a/libindy/src/api/ledger.rs +++ b/libindy/src/api/ledger.rs @@ -1797,7 +1797,7 @@ pub extern fn indy_get_response_metadata(command_handle: CommandHandle, /// #Params /// command_handle: command handle to map callback to caller context. /// submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). -/// ledgers_ids: list ids for freeze ledgers (json format). +/// ledgers_ids: list of ledgers IDs for freezing ledgers (json format). /// cb: Callback that takes command result as parameter. /// /// #Returns @@ -1806,7 +1806,7 @@ pub extern fn indy_get_response_metadata(command_handle: CommandHandle, /// #Errors /// Common* #[no_mangle] -pub extern fn indy_build_ledgers_freeze_request (command_handle: CommandHandle, +pub extern fn indy_build_ledgers_freeze_request(command_handle: CommandHandle, submitter_did: *const c_char, ledgers_ids: *const c_char, cb: Option) -> LedgersFreezeOperation { LedgersFreezeOperation { - ledgers_ids, - _type: LEDGERS_FREEZE.to_string() + _type: LEDGERS_FREEZE.to_string(), + ledgers_ids } } } diff --git a/libindy/src/services/ledger/mod.rs b/libindy/src/services/ledger/mod.rs index 07799bd9d6..7d944b0f55 100644 --- a/libindy/src/services/ledger/mod.rs +++ b/libindy/src/services/ledger/mod.rs @@ -877,6 +877,47 @@ mod tests { ledger_service.validate_action(&request).unwrap(); } + #[test] + fn build_ledgers_freeze_request_work_with_valid_data() { + let ledger_service = LedgerService::new(); + let ledgers_ids = vec![0,1,50,873]; + let res = ledger_service.build_ledgers_freeze_request(&identifier(), ledgers_ids); + + match res { + Ok(_) => {}, + Err(ec) => { + assert!(false, "build_ledgers_freeze_request_work_with_valid_data returned error_code {:?}", ec); + } + } + } + + #[test] + fn build_get_frozen_ledgers_request_work_with_valid_data() { + let ledger_service = LedgerService::new(); + let res = ledger_service.build_get_frozen_ledgers_request(&identifier()); + + match res { + Ok(_) => {}, + Err(ec) => { + assert!(false, "build_get_frozen_ledgers_request_work_with_valid_data returned error_code {:?}", ec); + } + } + } + + #[test] + fn build_ledgers_freeze_request_work_with_empty_data() { + let ledger_service = LedgerService::new(); + let ledgers_ids = vec![]; + let res = ledger_service.build_ledgers_freeze_request(&identifier(), ledgers_ids); + + match res { + Ok(_) => {}, + Err(ec) => { + assert!(false, "build_ledgers_freeze_request_work_with_empty_data returned error_code {:?}", ec); + } + } + } + mod auth_rule { use super::*; diff --git a/libindy/tests/ledger.rs b/libindy/tests/ledger.rs index ca4b2c751b..4133253c20 100644 --- a/libindy/tests/ledger.rs +++ b/libindy/tests/ledger.rs @@ -206,8 +206,8 @@ mod high_cases { #[test] fn indy_build_ledgers_freeze_request() { - let ledgers_ids = json!(vec![0u64, 1u64, 10u64, 23u64]); - let res = ledger::build_ledgers_freeze_request(DID_TRUSTEE, &ledgers_ids.to_string()); + let ledgers_ids = vec![0u64, 1u64, 10u64, 23u64]; + let res = ledger::build_ledgers_freeze_request(DID_TRUSTEE, ledgers_ids); match res { Ok(_) => {}, @@ -222,7 +222,7 @@ mod high_cases { let res = ledger::get_frozen_ledgers_request(DID_TRUSTEE); match res { - Ok(res) => {println!("{:?}",res)}, + Ok(_) => {}, Err(ec) => { assert!(false, "indy_get_frozen_ledgers_request returned error_code {:?}", ec); } diff --git a/libindy/tests/utils/ledger.rs b/libindy/tests/utils/ledger.rs index 6d39c4d0dd..951ff02d41 100644 --- a/libindy/tests/utils/ledger.rs +++ b/libindy/tests/utils/ledger.rs @@ -421,7 +421,7 @@ pub fn post_qualified_entities() -> (&'static str, &'static str) { (SCHEMA_ID_V2, CRED_DEF_ID_V2) } } -pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: &str) -> Result { +pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: Vec) -> Result { ledger::build_ledgers_freeze_request(submitter_did, ledgers_ids).wait() } diff --git a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java index 14a10f3606..a951af5c30 100644 --- a/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java +++ b/wrappers/java/src/main/java/org/hyperledger/indy/sdk/ledger/Ledger.java @@ -10,6 +10,7 @@ import org.hyperledger.indy.sdk.pool.Pool; import org.hyperledger.indy.sdk.wallet.Wallet; +import java.util.List; import java.util.concurrent.CompletableFuture; /** @@ -1789,13 +1790,13 @@ public static CompletableFuture appendRequestEndorser( * * @param command_handle - command handle to map callback to caller context. * @param submitter_did - (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). - * @param ledgers_ids - list ids for freeze ledgers (json format). + * @param ledgers_ids - List of ledgers IDs for freezing. * @param cb - Callback that takes command result as parameter. * * @return A future resolving to a request result as json. * @throws IndyException Thrown if an error occurs when calling the underlying SDK. */ - public static CompletableFuture buildLedgersFreezeRequest(String submitterDid, String ledgersIds) throws IndyException { + public static CompletableFuture buildLedgersFreezeRequest(String submitterDid, List ledgersIds) throws IndyException { ParamGuard.notNullOrWhiteSpace(submitterDid, "submitterDid"); CompletableFuture future = new CompletableFuture(); @@ -1804,7 +1805,7 @@ public static CompletableFuture buildLedgersFreezeRequest(String submitt int result = LibIndy.api.indy_build_ledgers_freeze_request( commandHandle, submitterDid, - ledgersIds, + ledgersIds.toString(), buildRequestCb); checkResult(future, result); diff --git a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java index c0c631d8c7..00403147e3 100644 --- a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java +++ b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java @@ -7,7 +7,7 @@ import org.junit.Test; import org.junit.rules.Timeout; -import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.concurrent.TimeUnit; @@ -17,8 +17,6 @@ public class GetFrozenLedgersTest extends LedgerIntegrationTest { @Test public void TestBuildGetFrozenLedgersRequest() throws Exception { - DidResults.CreateAndStoreMyDidResult trusteeDidResult = Did.createAndStoreMyDid(wallet, TRUSTEE_IDENTITY_JSON).get(); - DidResults.CreateAndStoreMyDidResult myDidResult = Did.createAndStoreMyDid(wallet, "{}").get(); String did = myDidResult.getDid(); @@ -35,27 +33,39 @@ public void TestBuildGetFrozenLedgersRequest() throws Exception { @Test public void TestLedgersFreezeRequest() throws Exception { - DidResults.CreateAndStoreMyDidResult trusteeDidResult = Did.createAndStoreMyDid(wallet, TRUSTEE_IDENTITY_JSON).get(); - DidResults.CreateAndStoreMyDidResult myDidResult = Did.createAndStoreMyDid(wallet, "{}").get(); String did = myDidResult.getDid(); - String ledgersIds = "[0,1,28,345]"; + List ledgersIds = Arrays.asList(0, 1, 28 ,345); String request = Ledger.buildLedgersFreezeRequest(did, ledgersIds).get(); - List expe = new ArrayList(); - expe.add(0); - expe.add(1); - expe.add(28); - expe.add(345); - + List expectedLedgersIds = Arrays.asList(0, 1, 28 ,345); JSONObject expectedResult = new JSONObject() .put("operation", new JSONObject() .put("type", "9") - .put("ledgers_ids", expe) + .put("ledgers_ids", expectedLedgersIds) ); assert (new JSONObject(request).toMap().entrySet() .containsAll(expectedResult.toMap().entrySet())); } + + @Test + public void TestLedgersFreezeRequestWithEmptyData() throws Exception { + DidResults.CreateAndStoreMyDidResult myDidResult = Did.createAndStoreMyDid(wallet, "{}").get(); + String did = myDidResult.getDid(); + + List ledgersIds = Arrays.asList(); + String request = Ledger.buildLedgersFreezeRequest(did, ledgersIds).get(); + + List expectedLedgersIds = Arrays.asList(); + JSONObject expectedResult = new JSONObject() + .put("operation", new JSONObject() + .put("type", "9") + .put("ledgers_ids", expectedLedgersIds) + ); + + assert (new JSONObject(request).toMap().entrySet() + .containsAll(expectedResult.toMap().entrySet())); + } } diff --git a/wrappers/python/indy/ledger.py b/wrappers/python/indy/ledger.py index a617768ced..59ed157b1b 100644 --- a/wrappers/python/indy/ledger.py +++ b/wrappers/python/indy/ledger.py @@ -1,6 +1,6 @@ from .libindy import do_call, create_cb -from typing import Optional +from typing import Optional, List from ctypes import * import logging @@ -1840,13 +1840,13 @@ async def append_request_endorser(request_json: str, return res -async def build_ledgers_freeze_request(submitter_did: str, ledgers_ids: str) -> str: +async def build_ledgers_freeze_request(submitter_did: str, ledgers_ids: List[int]) -> str: """ Request to freeze list of ledgers. :param command_handle: command handle to map callback to caller context. :param submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). - :param ledgers_ids: list ids for freeze ledgers (json format). + :param ledgers_ids: List of ledgers IDs for freezing. :param cb: Callback that takes command result as parameter. :return: Request result as json. @@ -1861,7 +1861,8 @@ async def build_ledgers_freeze_request(submitter_did: str, ledgers_ids: str) -> build_ledgers_freeze_request.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p)) c_submitter_did = c_char_p(submitter_did.encode('utf-8')) - c_ledgers_ids = c_char_p(ledgers_ids.encode('utf-8')) + json_ledgers_ids = '[' + ','.join(str(e) for e in ledgers_ids) + ']' + c_ledgers_ids = c_char_p(json_ledgers_ids.encode('utf-8')) request_json = await do_call('indy_build_ledgers_freeze_request', c_submitter_did, diff --git a/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py b/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py index 4d20c77982..49f6a35a23 100644 --- a/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py +++ b/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py @@ -2,8 +2,14 @@ import json import pytest +from typing import List @pytest.mark.asyncio async def test_build_ledgers_freeze_request(did_trustee): - ledgers_ids = '[6, 78, 75]' - response = json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) + ledgers_ids: List[int] = [0, 6, 78, 751] + json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) + +@pytest.mark.asyncio +async def test_build_ledgers_freeze_request_with_empty_data(did_trustee): + ledgers_ids: List[int] = [] + json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) diff --git a/wrappers/rust/src/ledger.rs b/wrappers/rust/src/ledger.rs index a8ea5e002a..825e421f3f 100644 --- a/wrappers/rust/src/ledger.rs +++ b/wrappers/rust/src/ledger.rs @@ -1,3 +1,4 @@ +use serde_json::json; use {ErrorCode, IndyError}; use std::ffi::CString; @@ -1516,14 +1517,15 @@ fn _append_request_endorser(command_handle: CommandHandle, /// # Arguments /// * `command_handle`: command handle to map callback to caller context. /// * `submitter_did`: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). -/// * `ledgers_ids`: list ids for freeze ledgers (json format). +/// * `ledgers_ids`: list of ledgers IDs for freezing (json format). /// * `cb`: Callback that takes command result as parameter. /// /// # Returns /// Updated request result as json. -pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: &str) -> Box> { +pub fn build_ledgers_freeze_request(submitter_did: &str, ledgers_ids: Vec) -> Box> { let (receiver, command_handle, cb) = ClosureHandler::cb_ec_string(); - let err = _build_ledgers_freeze_request(command_handle, submitter_did, ledgers_ids, cb); + let json_ledgers_ids: &str = &json!(ledgers_ids).to_string(); + let err = _build_ledgers_freeze_request(command_handle, submitter_did, json_ledgers_ids, cb); ResultHandler::str(command_handle, err, receiver) } diff --git a/wrappers/rust/tests/ledger.rs b/wrappers/rust/tests/ledger.rs index 12e59d5cb1..c4b4781adb 100644 --- a/wrappers/rust/tests/ledger.rs +++ b/wrappers/rust/tests/ledger.rs @@ -572,7 +572,7 @@ mod test_build_ledgers_freeze_request { pub fn test_build_ledgers_freeze_request() { let wallet = Wallet::new(); let (did, _) = did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); - let ledgers_ids: &str = &json!(vec![0u64, 1u64, 10u64, 23u64]).to_string(); + let ledgers_ids: Vec = vec![0u64, 1u64, 10u64, 236u64]; match ledger::build_ledgers_freeze_request(&did, ledgers_ids).wait() { Ok(_) => {}, @@ -581,6 +581,20 @@ mod test_build_ledgers_freeze_request { } } } + + #[test] + pub fn test_build_ledgers_freeze_request_with_empty_data() { + let wallet = Wallet::new(); + let (did, _) = did::create_and_store_my_did(wallet.handle, "{}").wait().unwrap(); + let ledgers_ids: Vec = vec![]; + + match ledger::build_ledgers_freeze_request(&did, ledgers_ids).wait() { + Ok(_) => {}, + Err(ec) => { + assert!(false, "test_build_ledgers_freeze_request_with_empty_data returned error_code {:?}", ec); + } + } + } } #[cfg(test)] From eded24ccb517073adf14d84bd1594d3908da8581 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Sun, 7 Feb 2021 18:11:34 +0300 Subject: [PATCH 11/12] Add wrappers test for nodejs Signed-off-by: Anton Denishchenko --- libindy/include/indy_ledger.h | 51 +++++++++++++++++++ .../indy/sdk/ledger/GetFrozenLedgersTest.java | 6 +-- wrappers/nodejs/src/index.js | 12 +++++ wrappers/nodejs/src/indy.cc | 37 ++++++++++++++ wrappers/nodejs/test/ledger.js | 19 +++++++ wrappers/python/indy/ledger.py | 3 +- .../test_build_get_frozen_ledgers_request.py | 7 +++ .../test_build_ledgers_freeze_request.py | 38 ++++++++++++-- 8 files changed, 165 insertions(+), 8 deletions(-) diff --git a/libindy/include/indy_ledger.h b/libindy/include/indy_ledger.h index ac530d1d43..01e5c50bfa 100644 --- a/libindy/include/indy_ledger.h +++ b/libindy/include/indy_ledger.h @@ -1256,6 +1256,57 @@ extern "C" { const char* request_json) ); + /// Builds a LEDGERS_FREEZE request. Request to freeze list of ledgers. + /// + /// #Params + /// command_handle: command handle to map callback to caller context. + /// submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). + /// ledgers_ids: list of ledgers IDs for freezing ledgers (json format). + /// cb: Callback that takes command result as parameter. + /// + /// #Returns + /// Request result as json. + /// + /// #Errors + /// Common* + extern indy_error_t indy_build_ledgers_freeze_request(indy_handle_t command_handle, + const char * submitter_did, + const char * ledgers_ids, + + void (*cb)(indy_handle_t command_handle_, + indy_error_t err, + const char* request_json) + ); + + /// Builds a GET_FROZEN_LEDGERS request. Request to get list of frozen ledgers. + /// frozen ledgers are defined by LEDGERS_FREEZE request. + /// + /// #Params + /// command_handle: command handle to map callback to caller context. + /// submitter_did: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). + /// cb: Callback that takes command result as parameter. + /// + /// #Returns + /// Request result as json. + /// { + /// : { + /// "ledger": String - Ledger root hash, + /// "state": String - State root hash, + /// "seq_no": u64 - the latest transaction seqNo for particular Node, + /// }, + /// ... + /// } + /// + /// #Errors + /// Common* + extern indy_error_t indy_build_get_frozen_ledgers_request(indy_handle_t command_handle, + const char * submitter_did, + + void (*cb)(indy_handle_t command_handle_, + indy_error_t err, + const char* request_json) + ); + /// Builds a GET_TXN_AUTHR_AGRMT_AML request. Request to get a list of acceptance mechanisms from the ledger /// valid for specified time or the latest one. /// diff --git a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java index 00403147e3..da59c9f796 100644 --- a/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java +++ b/wrappers/java/src/test/java/org/hyperledger/indy/sdk/ledger/GetFrozenLedgersTest.java @@ -39,11 +39,10 @@ public void TestLedgersFreezeRequest() throws Exception { List ledgersIds = Arrays.asList(0, 1, 28 ,345); String request = Ledger.buildLedgersFreezeRequest(did, ledgersIds).get(); - List expectedLedgersIds = Arrays.asList(0, 1, 28 ,345); JSONObject expectedResult = new JSONObject() .put("operation", new JSONObject() .put("type", "9") - .put("ledgers_ids", expectedLedgersIds) + .put("ledgers_ids", ledgersIds) ); assert (new JSONObject(request).toMap().entrySet() @@ -58,11 +57,10 @@ public void TestLedgersFreezeRequestWithEmptyData() throws Exception { List ledgersIds = Arrays.asList(); String request = Ledger.buildLedgersFreezeRequest(did, ledgersIds).get(); - List expectedLedgersIds = Arrays.asList(); JSONObject expectedResult = new JSONObject() .put("operation", new JSONObject() .put("type", "9") - .put("ledgers_ids", expectedLedgersIds) + .put("ledgers_ids", ledgersIds) ); assert (new JSONObject(request).toMap().entrySet() diff --git a/wrappers/nodejs/src/index.js b/wrappers/nodejs/src/index.js index 5ed18fc764..09f74c94a5 100644 --- a/wrappers/nodejs/src/index.js +++ b/wrappers/nodejs/src/index.js @@ -636,6 +636,18 @@ indy.buildGetAcceptanceMechanismsRequest = function buildGetAcceptanceMechanisms return cb.promise } +indy.buildLedgersFreezeRequest = function buildLedgersFreezeRequest (submitterDid, ledgersIds, cb) { + cb = wrapIndyCallback(cb, fromJson) + capi.buildLedgersFreezeRequest(submitterDid, JSON.stringify(ledgersIds), cb) + return cb.promise +} + +indy.buildGetFrozenLedgersRequest = function buildGetFrozenLedgersRequest (submitterDid, cb) { + cb = wrapIndyCallback(cb, fromJson) + capi.buildGetFrozenLedgersRequest(submitterDid, cb) + return cb.promise +} + indy.appendTxnAuthorAgreementAcceptanceToRequest = function appendTxnAuthorAgreementAcceptanceToRequest (request, text, version, taaDigest, accMechType, timeOfAcceptance, cb) { cb = wrapIndyCallback(cb, fromJson) capi.appendTxnAuthorAgreementAcceptanceToRequest(toJson(request), text, version, taaDigest, accMechType, timeOfAcceptance, cb) diff --git a/wrappers/nodejs/src/indy.cc b/wrappers/nodejs/src/indy.cc index bb773f8562..f399f82065 100644 --- a/wrappers/nodejs/src/indy.cc +++ b/wrappers/nodejs/src/indy.cc @@ -2371,6 +2371,41 @@ NAN_METHOD(buildGetAcceptanceMechanismsRequest) { delete arg2; } +void buildLedgersFreezeRequest_cb(indy_handle_t handle, indy_error_t xerr, const char* arg0) { + IndyCallback* icb = IndyCallback::getCallback(handle); + if(icb != nullptr){ + icb->cbString(xerr, arg0); + } +} +NAN_METHOD(buildLedgersFreezeRequest) { + INDY_ASSERT_NARGS(buildLedgersFreezeRequest, 3) + INDY_ASSERT_STRING(buildLedgersFreezeRequest, 0, submitterDid) + INDY_ASSERT_STRING(buildLedgersFreezeRequest, 1, ledgersIds) + INDY_ASSERT_FUNCTION(buildLedgersFreezeRequest, 2) + const char* arg0 = argToCString(info[0]); + const char* arg1 = argToCString(info[1]); + IndyCallback* icb = argToIndyCb(info[2]); + indyCalled(icb, indy_build_ledgers_freeze_request(icb->handle, arg0, arg1, buildLedgersFreezeRequest_cb)); + delete arg0; + delete arg1; +} + +void buildGetFrozenLedgersRequest_cb(indy_handle_t handle, indy_error_t xerr, const char* arg0) { + IndyCallback* icb = IndyCallback::getCallback(handle); + if(icb != nullptr){ + icb->cbString(xerr, arg0); + } +} +NAN_METHOD(buildGetFrozenLedgersRequest) { + INDY_ASSERT_NARGS(buildGetFrozenLedgersRequest, 2) + INDY_ASSERT_STRING(buildGetFrozenLedgersRequest, 0, submitterDid) + INDY_ASSERT_FUNCTION(buildGetFrozenLedgersRequest, 1) + const char* arg0 = argToCString(info[0]); + IndyCallback* icb = argToIndyCb(info[1]); + indyCalled(icb, indy_build_get_frozen_ledgers_request(icb->handle, arg0, buildGetFrozenLedgersRequest_cb)); + delete arg0; +} + void appendTxnAuthorAgreementAcceptanceToRequest_cb(indy_handle_t handle, indy_error_t xerr, const char* arg0) { IndyCallback* icb = IndyCallback::getCallback(handle); if(icb != nullptr){ @@ -3732,6 +3767,8 @@ NAN_MODULE_INIT(InitAll) { Nan::Export(target, "buildGetTxnAuthorAgreementRequest", buildGetTxnAuthorAgreementRequest); Nan::Export(target, "buildAcceptanceMechanismsRequest", buildAcceptanceMechanismsRequest); Nan::Export(target, "buildGetAcceptanceMechanismsRequest", buildGetAcceptanceMechanismsRequest); + Nan::Export(target, "buildLedgersFreezeRequest", buildLedgersFreezeRequest); + Nan::Export(target, "buildGetFrozenLedgersRequest", buildGetFrozenLedgersRequest); Nan::Export(target, "appendTxnAuthorAgreementAcceptanceToRequest", appendTxnAuthorAgreementAcceptanceToRequest); Nan::Export(target, "appendRequestEndorser", appendRequestEndorser); Nan::Export(target, "getResponseMetadata", getResponseMetadata); diff --git a/wrappers/nodejs/test/ledger.js b/wrappers/nodejs/test/ledger.js index 59c116953f..85e9b2a43a 100644 --- a/wrappers/nodejs/test/ledger.js +++ b/wrappers/nodejs/test/ledger.js @@ -206,6 +206,25 @@ test('ledger', async function (t) { req = await indy.buildGetAcceptanceMechanismsRequest(null, 123379200, null) t.deepEqual(req['operation'], { 'type': '7', 'timestamp': 123379200 }) + // ledgers freeze + var ledgersIds = [0, 3, 76, 874] + req = await indy.buildLedgersFreezeRequest(trusteeDid, ledgersIds) + t.deepEqual(req['operation'], { 'type': '9', 'ledgers_ids': ledgersIds }) + + ledgersIds = [] + req = await indy.buildLedgersFreezeRequest(trusteeDid, ledgersIds) + t.deepEqual(req['operation'], { 'type': '9', 'ledgers_ids': ledgersIds }) + + var err = await t.throwsAsync(indy.buildLedgersFreezeRequest(trusteeDid, ['0', '3', '76', '874'])) + t.is(err.indyName, 'CommonInvalidStructure') + + err = await t.throwsAsync(indy.buildLedgersFreezeRequest(trusteeDid, '[0, 3, 76, 874]')) + t.is(err.indyName, 'CommonInvalidStructure') + + // frozen ledgers + req = await indy.buildGetFrozenLedgersRequest(trusteeDid) + t.deepEqual(req['operation'], { 'type': '10' }) + // author agreement acceptance data req = await indy.appendTxnAuthorAgreementAcceptanceToRequest(req, 'indy agreement', '1.0.0', null, 'acceptance mechanism label 1', 123379200) var expectedMeta = { diff --git a/wrappers/python/indy/ledger.py b/wrappers/python/indy/ledger.py index 59ed157b1b..a50dbf098e 100644 --- a/wrappers/python/indy/ledger.py +++ b/wrappers/python/indy/ledger.py @@ -4,6 +4,7 @@ from ctypes import * import logging +import json async def sign_and_submit_request(pool_handle: int, @@ -1861,7 +1862,7 @@ async def build_ledgers_freeze_request(submitter_did: str, ledgers_ids: List[int build_ledgers_freeze_request.cb = create_cb(CFUNCTYPE(None, c_int32, c_int32, c_char_p)) c_submitter_did = c_char_p(submitter_did.encode('utf-8')) - json_ledgers_ids = '[' + ','.join(str(e) for e in ledgers_ids) + ']' + json_ledgers_ids = json.dumps(ledgers_ids) c_ledgers_ids = c_char_p(json_ledgers_ids.encode('utf-8')) request_json = await do_call('indy_build_ledgers_freeze_request', diff --git a/wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py b/wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py index 281e23c37b..47f7e037ec 100644 --- a/wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py +++ b/wrappers/python/tests/ledger/test_build_get_frozen_ledgers_request.py @@ -5,4 +5,11 @@ @pytest.mark.asyncio async def test_build_get_frozen_ledgers_request(did_trustee): + expected_response = { + "identifier": did_trustee, + "operation": { + "type": "10" + } + } response = json.loads(await ledger.build_get_frozen_ledgers_request(did_trustee)) + assert expected_response.items() <= response.items() diff --git a/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py b/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py index 49f6a35a23..c6c2f1e617 100644 --- a/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py +++ b/wrappers/python/tests/ledger/test_build_ledgers_freeze_request.py @@ -1,15 +1,47 @@ from indy import ledger +from typing import List +from indy.error import CommonInvalidStructure import json import pytest -from typing import List @pytest.mark.asyncio async def test_build_ledgers_freeze_request(did_trustee): ledgers_ids: List[int] = [0, 6, 78, 751] - json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) + expected_response = { + "identifier": did_trustee, + "operation": { + "type": "9", + 'ledgers_ids': ledgers_ids + } + } + response = json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) + assert expected_response.items() <= response.items() @pytest.mark.asyncio async def test_build_ledgers_freeze_request_with_empty_data(did_trustee): ledgers_ids: List[int] = [] - json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) + expected_response = { + "identifier": did_trustee, + "operation": { + "type": "9", + 'ledgers_ids': ledgers_ids + } + } + + response = json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) + assert expected_response.items() <= response.items() + +@pytest.mark.asyncio +async def test_build_ledgers_freeze_request_with_str_data(did_trustee): + ledgers_ids = ["0", "6", "78", "751"] + + with pytest.raises(CommonInvalidStructure): + json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) + +@pytest.mark.asyncio +async def test_build_ledgers_freeze_request_with_no_data(did_trustee): + ledgers_ids = None + + with pytest.raises(CommonInvalidStructure): + json.loads(await ledger.build_ledgers_freeze_request(did_trustee, ledgers_ids)) From d1c6bf5c5a5d42a288875a689c38639459126ed7 Mon Sep 17 00:00:00 2001 From: Anton Denishchenko Date: Mon, 8 Feb 2021 15:50:09 +0300 Subject: [PATCH 12/12] Refactoring after review Signed-off-by: Anton Denishchenko --- cli/src/commands/ledger.rs | 10 +++++----- wrappers/rust/src/ledger.rs | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/cli/src/commands/ledger.rs b/cli/src/commands/ledger.rs index d5a486fe48..da47f4ca46 100644 --- a/cli/src/commands/ledger.rs +++ b/cli/src/commands/ledger.rs @@ -2095,15 +2095,15 @@ pub mod get_frozen_ledgers_command { .expect("top level object is not a map"); let mut result = Vec::new(); - for (key, value) in handle_response { - let mut flat_value = value.as_object() + for (response_ledger_key, response_ledger_value) in handle_response { + let mut ledger_info = response_ledger_value.as_object() .expect("inner object is not a map").clone(); - let ledger_id = serde_json::to_value(&key) + let ledger_id = serde_json::to_value(&response_ledger_key) .map_err(|_| println_err!("Invalid format of Outputs: Ledger ID is incorrect."))?; - flat_value.insert("ledger_id".to_owned(), ledger_id); + ledger_info.insert("ledger_id".to_owned(), ledger_id); - result.push(serde_json::to_value(&flat_value) + result.push(serde_json::to_value(&ledger_info) .map_err(|_| println_err!("Invalid format of Outputs: result is incorrect."))?); } diff --git a/wrappers/rust/src/ledger.rs b/wrappers/rust/src/ledger.rs index 825e421f3f..8b5871ceac 100644 --- a/wrappers/rust/src/ledger.rs +++ b/wrappers/rust/src/ledger.rs @@ -1517,7 +1517,7 @@ fn _append_request_endorser(command_handle: CommandHandle, /// # Arguments /// * `command_handle`: command handle to map callback to caller context. /// * `submitter_did`: (Optional) DID of the read request sender (if not provided then default Libindy DID will be used). -/// * `ledgers_ids`: list of ledgers IDs for freezing (json format). +/// * `ledgers_ids`: list of ledgers IDs for freezing. /// * `cb`: Callback that takes command result as parameter. /// /// # Returns