Merge pull request hyperledger-indy#952 from KitHat/master

jovfer · web-flow · commit ff227b6169cf · 2018-07-17T11:41:37.000+03:00
Add utxo already spent error to libnullpay
diff --git a/libnullpay/src/lib.rs b/libnullpay/src/lib.rs
@@ -203,4 +203,7 @@ pub enum ErrorCode
 
     // Insufficient funds on inputs
     PaymentInsufficientFundsError = 702,
+
+    // No such source on a ledger
+    PaymentSourceDoesNotExistError = 703,
 }
diff --git a/libnullpay/src/payment_method.rs b/libnullpay/src/payment_method.rs
@@ -68,6 +68,23 @@ pub mod add_request_fees {
 
         trace!("FEE: {}", fee);
 
+        let ec = _check_inputs_existance(&inputs_json);
+        if ec != ErrorCode::Success {
+            ledger::build_get_txn_request(
+                submitter_did.as_str(),
+                None,
+                1,
+                Box::new(move |ec, res| {
+                    let ec = if ec == ErrorCode::Success {
+                        _add_response(&res, "NO_UTXO")
+                    } else { ec };
+                    trace!("libnullpay::add_request_fees::handle >>");
+                    _process_callback(cmd_handle, ec, res, cb);
+                }),
+            );
+            return ErrorCode::Success;
+        }
+
         let total_amount = _count_total_inputs(&inputs_json);
         let total_payments = _count_total_payments(&outputs_json);
 
@@ -188,6 +205,7 @@ pub mod build_payment_req {
 
                 let total_balance = _count_total_inputs(&inputs_json);
                 let total_payments = _count_total_payments(&outputs_json);
+                let ec_existance = _check_inputs_existance(&inputs_json);
 
                 let seq_no = payment_ledger::add_txn(inputs_json.clone(), outputs_json.clone());
 
@@ -202,7 +220,9 @@ pub mod build_payment_req {
                         1,
                         Box::new(move |ec, res| {
                             if ec == ErrorCode::Success {
-                                if total_balance >= total_payments {
+                                if ec_existance != ErrorCode::Success {
+                                    _add_response(&res, "NO_UTXO");
+                                } else if total_balance >= total_payments {
                                     _process_inputs(&inputs_json);
                                     let infos = _process_outputs(&outputs_json, seq_no);
 
@@ -362,6 +382,16 @@ fn _check_inputs(inputs: &Vec<String>, payment_addresses: &Vec<String>) -> bool
         })
 }
 
+fn _check_inputs_existance(inputs: &Vec<String>) -> ErrorCode {
+    for input in inputs {
+        match utxo_cache::get_balanse_of_utxo(input) {
+            None => return ErrorCode::PaymentSourceDoesNotExistError,
+            _ => ()
+        }
+    }
+    ErrorCode::Success
+}
+
 fn _process_inputs(inputs: &Vec<String>) {
     inputs.into_iter().for_each(|s| {
         utxo_cache::remove_utxo(s);
diff --git a/libnullpay/src/services/response_storage.rs b/libnullpay/src/services/response_storage.rs
@@ -35,6 +35,7 @@ pub fn get_response(response: &str) -> Result<String, ErrorCode> {
     let mut responses = RESPONSES.lock().unwrap();
     match responses.remove(req_id.to_string().as_str()) {
         Some(ref resp) if resp == "INSUFFICIENT_FUNDS" => Err(ErrorCode::PaymentInsufficientFundsError),
+        Some(ref resp) if resp == "NO_UTXO" => Err(ErrorCode::PaymentSourceDoesNotExistError),
         Some(resp) => Ok(resp),
         None => Err(ErrorCode::CommonInvalidState)
     }
diff --git a/libnullpay/tests/payments.rs b/libnullpay/tests/payments.rs
@@ -285,6 +285,57 @@ mod high_cases {
             test_utils::cleanup_storage();
         }
 
+        #[test]
+        pub fn add_request_works_for_spent_utxo() {
+            test_utils::cleanup_storage();
+            plugin::init_plugin();
+            let wallet_handle = wallet::create_and_open_wallet().unwrap();
+            let pool_handle = pool::create_and_open_pool_ledger(POOL_NAME).unwrap();
+
+            let (trustee_did, _) = did::create_and_store_my_did(wallet_handle, Some(TRUSTEE_SEED)).unwrap();
+            let (my_did, my_vk) = did::create_and_store_my_did(wallet_handle, None).unwrap();
+            let (my_did_2, my_vk_2) = did::create_and_store_my_did(wallet_handle, None).unwrap();
+            let nym_req = ledger::build_nym_request(&trustee_did, &my_did, &my_vk, "aaa", "TRUSTEE").unwrap();
+            let nym_req_2 = ledger::build_nym_request(&trustee_did, &my_did_2, &my_vk_2, "aaa", "TRUSTEE").unwrap();
+
+            let addresses = payments_utils::create_addresses(vec!["{}", "{}"], wallet_handle, PAYMENT_METHOD_NAME);
+
+            let mint: Vec<(String, i32, Option<&str>)> = addresses.clone().into_iter().enumerate().map(|(i, addr)| (addr, ((i+3)*10) as i32, None)).collect();
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, my_did.as_str());
+
+            payments_utils::set_request_fees(wallet_handle, pool_handle, SUBMITTER_DID, PAYMENT_METHOD_NAME, r#"{"1": 10, "101": 10}"#);
+
+            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let addr_1 = addresses.get(0).unwrap();
+            let utxos_1: Vec<String> = utxos.get(addr_1.as_str()).unwrap().into_iter().map(|info| info.txo.clone()).collect();
+            let inputs = serde_json::to_string(&utxos_1).unwrap();
+
+            let outputs = vec![UTXOOutput {
+                payment_address: addresses.get(1).unwrap().to_string(),
+                amount: 19,
+                extra: None
+            }, UTXOOutput {
+                payment_address: addresses.get(0).unwrap().to_string(),
+                amount: 1,
+                extra: None
+            }];
+            let outputs = serde_json::to_string(&outputs).unwrap();
+
+            let (nym_req_with_fees, payment_method) = payments::add_request_fees(wallet_handle, SUBMITTER_DID, nym_req.as_str(), inputs.as_str(), outputs.as_str()).unwrap();
+            let nym_resp = ledger::sign_and_submit_request(pool_handle, wallet_handle, trustee_did.as_str(), nym_req_with_fees.as_str()).unwrap();
+            payments::parse_response_with_fees(payment_method.as_str(), nym_resp.as_str()).unwrap();
+
+            let (nym_req_with_fees_2, payment_method) = payments::add_request_fees(wallet_handle, SUBMITTER_DID, nym_req_2.as_str(), inputs.as_str(), outputs.as_str()).unwrap();
+            let nym_resp_2 = ledger::sign_and_submit_request(pool_handle, wallet_handle, trustee_did.as_str(), nym_req_with_fees_2.as_str()).unwrap();
+            let ec = payments::parse_response_with_fees(payment_method.as_str(), nym_resp_2.as_str()).unwrap_err();
+            assert_eq!(ec, ErrorCode::PaymentSourceDoesNotExistError);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+
         #[test]
         pub fn add_request_fees_works_for_utxo_not_correspond_to_wallet() {
             test_utils::cleanup_storage();
@@ -450,6 +501,50 @@ mod high_cases {
             test_utils::cleanup_storage();
         }
 
+        #[test]
+        pub fn payments_work_for_spent_utxo() {
+            test_utils::cleanup_storage();
+            plugin::init_plugin();
+            let wallet_handle = wallet::create_and_open_wallet().unwrap();
+            let pool_handle = pool::create_and_open_pool_ledger(POOL_NAME).unwrap();
+
+            let addresses = payments_utils::create_addresses(vec!["{}", "{}"], wallet_handle, PAYMENT_METHOD_NAME);
+
+            let mint: Vec<(String, i32, Option<&str>)> = addresses.clone().into_iter().enumerate().map(|(i, addr)| (addr, ((i + 2) * 10) as i32, None)).collect();
+            payments_utils::mint_tokens(mint, wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let utxos = payments_utils::get_utxos_with_balance(addresses.clone(), wallet_handle, pool_handle, SUBMITTER_DID);
+
+            let addr_1 = addresses.get(0).unwrap();
+            let utxos_1: Vec<String> = utxos.get(addr_1.as_str()).unwrap().into_iter().map(|info| info.txo.clone()).collect();
+            let inputs = serde_json::to_string(&utxos_1).unwrap();
+
+            let outputs = vec![UTXOOutput {
+                payment_address: addresses.get(1).unwrap().to_string(),
+                amount: 19,
+                extra: None
+            }, UTXOOutput {
+                payment_address: addresses.get(0).unwrap().to_string(),
+                amount: 1,
+                extra: None
+            }];
+            let outputs = serde_json::to_string(&outputs).unwrap();
+
+            let (payment_req, payment_method) = payments::build_payment_req(wallet_handle, SUBMITTER_DID, inputs.as_str(), outputs.as_str()).unwrap();
+            let payment_resp = ledger::submit_request(pool_handle, payment_req.as_str()).unwrap();
+            payments::parse_payment_response(payment_method.as_str(), payment_resp.as_str()).unwrap();
+
+            let (payment_req, payment_method) = payments::build_payment_req(wallet_handle, SUBMITTER_DID, inputs.as_str(), outputs.as_str()).unwrap();
+            let payment_resp = ledger::submit_request(pool_handle, payment_req.as_str()).unwrap();
+            let ec = payments::parse_payment_response(payment_method.as_str(), payment_resp.as_str()).unwrap_err();
+
+            assert_eq!(ec, ErrorCode::PaymentSourceDoesNotExistError);
+
+            pool::close(pool_handle).unwrap();
+            wallet::close_wallet(wallet_handle).unwrap();
+            test_utils::cleanup_storage();
+        }
+
         #[test]
         pub fn payment_request_works_for_utxo_not_correspond_to_wallet() {
             test_utils::cleanup_storage();
diff --git a/libnullpay/tests/utils/wallet.rs b/libnullpay/tests/utils/wallet.rs
@@ -1,7 +1,6 @@
 use nullpay::ErrorCode;
 
 use std::ffi::CString;
-use std::ptr::null;
 use std::os::raw::c_char;
 
 pub const DEFAULT_WALLET_CREDENTIALS: &'static str = r#"{"key":"key"}"#;

Original file line number	Diff line number	Diff line change
`@@ -203,4 +203,7 @@ pub enum ErrorCode`
`203`	`203`
`204`	`204`	`// Insufficient funds on inputs`
`205`	`205`	`PaymentInsufficientFundsError = 702,`
	`206`	`+`
	`207`	`+ // No such source on a ledger`
	`208`	`+ PaymentSourceDoesNotExistError = 703,`
`206`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ pub fn get_response(response: &str) -> Result<String, ErrorCode> {`
`35`	`35`	`let mut responses = RESPONSES.lock().unwrap();`
`36`	`36`	`match responses.remove(req_id.to_string().as_str()) {`
`37`	`37`	`Some(ref resp) if resp == "INSUFFICIENT_FUNDS" => Err(ErrorCode::PaymentInsufficientFundsError),`
	`38`	`+ Some(ref resp) if resp == "NO_UTXO" => Err(ErrorCode::PaymentSourceDoesNotExistError),`
`38`	`39`	`Some(resp) => Ok(resp),`
`39`	`40`	`None => Err(ErrorCode::CommonInvalidState)`
`40`	`41`	`}`