Updated Libindy and Libnullpay

Signed-off-by: artem.ivanov <[email protected]>

Author: Artemkaaas

libindy/debian/changelog

@@ -24,7 +24,7 @@ libindy (1.5.0) unstable; urgency=medium
   [the main payments operations](https://github.com/hyperledger/indy-sdk/tree/master/doc/design/007-cli-payments):
   * Creation of payment address
   * Listing of payment addresses
-  * Getting list of UTXO for payment address
+  * Getting list of sources for payment address
   * Sending payment transaction
   * Adding fees to transactions
   * Getting transactions fees amount

libindy/include/indy_payment.h

@@ -48,19 +48,19 @@ pub enum PaymentsCommand {
     ParseResponseWithFeesAck(
         i32, //handle
         Result<String, PaymentsError>),
-    BuildGetUtxoRequest(
+    BuildGetSourcesRequest(
         i32, //wallet_handle
         String, //submitter did
         String, //payment address
         Box<Fn(Result<(String, String), IndyError>) + Send>),
-    BuildGetUtxoRequestAck(
+    BuildGetSourcesRequestAck(
         i32, //handle
         Result<String, PaymentsError>),
-    ParseGetUtxoResponse(
+    ParseGetSourcesResponse(
         String, //type
         String, //response
         Box<Fn(Result<String, IndyError>) + Send>),
-    ParseGetUtxoResponseAck(
+    ParseGetSourcesResponseAck(
         i32, //cmd_handle
         Result<String, PaymentsError>),
     BuildPaymentReq(
@@ -164,21 +164,21 @@ impl PaymentsCommandExecutor {
                 info!(target: "payments_command_executor", "ParseResponseWithFeesAck command received");
                 self.parse_response_with_fees_ack(cmd_handle, result);
             }
-            PaymentsCommand::BuildGetUtxoRequest(wallet_handle, submitter_did, payment_address, cb) => {
-                info!(target: "payments_command_executor", "BuildGetUtxoRequest command received");
-                self.build_get_utxo_request(wallet_handle, &submitter_did, &payment_address, cb);
+            PaymentsCommand::BuildGetSourcesRequest(wallet_handle, submitter_did, payment_address, cb) => {
+                info!(target: "payments_command_executor", "BuildGetSourcesRequest command received");
+                self.build_get_sources_request(wallet_handle, &submitter_did, &payment_address, cb);
             }
-            PaymentsCommand::BuildGetUtxoRequestAck(cmd_handle, result) => {
-                info!(target: "payments_command_executor", "BuildGetUtxoRequestAck command received");
-                self.build_get_utxo_request_ack(cmd_handle, result);
+            PaymentsCommand::BuildGetSourcesRequestAck(cmd_handle, result) => {
+                info!(target: "payments_command_executor", "BuildGetSourcesRequestAck command received");
+                self.build_get_sources_request_ack(cmd_handle, result);
             }
-            PaymentsCommand::ParseGetUtxoResponse(type_, response, cb) => {
-                info!(target: "payments_command_executor", "ParseGetUtxoResponse command received");
-                self.parse_get_utxo_response(&type_, &response, cb);
+            PaymentsCommand::ParseGetSourcesResponse(type_, response, cb) => {
+                info!(target: "payments_command_executor", "ParseGetSourcesResponse command received");
+                self.parse_get_sources_response(&type_, &response, cb);
             }
-            PaymentsCommand::ParseGetUtxoResponseAck(cmd_handle, result) => {
-                info!(target: "payments_command_executor", "ParseGetUtxoResponseAck command received");
-                self.parse_get_utxo_response_ack(cmd_handle, result);
+            PaymentsCommand::ParseGetSourcesResponseAck(cmd_handle, result) => {
+                info!(target: "payments_command_executor", "ParseGetSourcesResponseAck command received");
+                self.parse_get_sources_response_ack(cmd_handle, result);
             }
             PaymentsCommand::BuildPaymentReq(wallet_handle, submitter_did, inputs, outputs, cb) => {
                 info!(target: "payments_command_executor", "BuildPaymentReq command received");
@@ -351,8 +351,8 @@ impl PaymentsCommandExecutor {
         trace!("parse_response_with_fees_ack <<<");
     }
 
-    fn build_get_utxo_request(&self, wallet_handle: i32, submitter_did: &str, payment_address: &str, cb: Box<Fn(Result<(String, String), IndyError>) + Send>) {
-        trace!("build_get_utxo_request >>> wallet_handle: {:?}, submitter_did: {:?}, payment_address: {:?}", wallet_handle, submitter_did, payment_address);
+    fn build_get_sources_request(&self, wallet_handle: i32, submitter_did: &str, payment_address: &str, cb: Box<Fn(Result<(String, String), IndyError>) + Send>) {
+        trace!("build_get_sources_request >>> wallet_handle: {:?}, submitter_did: {:?}, payment_address: {:?}", wallet_handle, submitter_did, payment_address);
         match self.crypto_service.validate_did(submitter_did).map_err(map_err_err!()) {
             Err(err) => return cb(Err(IndyError::from(err))),
             _ => ()
@@ -372,28 +372,28 @@ impl PaymentsCommandExecutor {
         let method_copy = method.to_string();
 
         self._process_method(
-            Box::new(move |get_utxo_txn_json| cb(get_utxo_txn_json.map(|s| (s, method.to_string())))),
-            &|i| self.payments_service.build_get_utxo_request(i, &method_copy, wallet_handle, &submitter_did, payment_address)
+            Box::new(move |get_sources_txn_json| cb(get_sources_txn_json.map(|s| (s, method.to_string())))),
+            &|i| self.payments_service.build_get_sources_request(i, &method_copy, wallet_handle, &submitter_did, payment_address)
         );
-        trace!("build_get_utxo_request <<<");
+        trace!("build_get_sources_request <<<");
     }
 
-    fn build_get_utxo_request_ack(&self, cmd_handle: i32, result: Result<String, PaymentsError>) {
-        trace!("build_get_utxo_request_ack >>> result: {:?}", result);
-        self._common_ack_payments(cmd_handle, result, "BuildGetUtxoRequestAck");
-        trace!("build_get_utxo_request_ack <<<");
+    fn build_get_sources_request_ack(&self, cmd_handle: i32, result: Result<String, PaymentsError>) {
+        trace!("build_get_sources_request_ack >>> result: {:?}", result);
+        self._common_ack_payments(cmd_handle, result, "BuildGetSourcesRequestAck");
+        trace!("build_get_sources_request_ack <<<");
     }
 
-    fn parse_get_utxo_response(&self, type_: &str, response: &str, cb: Box<Fn(Result<String, IndyError>) + Send>) {
-        trace!("parse_get_utxo_response >>> response: {:?}", response);
-        self._process_method(cb, &|i| self.payments_service.parse_get_utxo_response(i, type_, response));
-        trace!("parse_get_utxo_response <<<");
+    fn parse_get_sources_response(&self, type_: &str, response: &str, cb: Box<Fn(Result<String, IndyError>) + Send>) {
+        trace!("parse_get_sources_response >>> response: {:?}", response);
+        self._process_method(cb, &|i| self.payments_service.parse_get_sources_response(i, type_, response));
+        trace!("parse_get_sources_response <<<");
     }
 
-    fn parse_get_utxo_response_ack(&self, cmd_handle: i32, result: Result<String, PaymentsError>) {
-        trace!("parse_get_utxo_response_ack >>> result: {:?}", result);
-        self._common_ack_payments(cmd_handle, result, "ParseGetUtxoResponseAck");
-        trace!("parse_get_utxo_response_ack <<<");
+    fn parse_get_sources_response_ack(&self, cmd_handle: i32, result: Result<String, PaymentsError>) {
+        trace!("parse_get_sources_response_ack >>> result: {:?}", result);
+        self._common_ack_payments(cmd_handle, result, "ParseGetSourcesResponseAck");
+        trace!("parse_get_sources_response_ack <<<");
     }
 
     fn build_payment_req(&self, wallet_handle: i32, submitter_did: &str, inputs: &str, outputs: &str, cb: Box<Fn(Result<(String, String), IndyError>) + Send>) {

libindy/src/api/payments.rs

@@ -20,8 +20,8 @@ pub struct PaymentsMethod {
     create_address: CreatePaymentAddressCB,
     add_request_fees: AddRequestFeesCB,
     parse_response_with_fees: ParseResponseWithFeesCB,
-    build_get_utxo_request: BuildGetUTXORequestCB,
-    parse_get_utxo_response: ParseGetUTXOResponseCB,
+    build_get_sources_request: BuildGetSourcesRequestCB,
+    parse_get_sources_response: ParseGetSourcesResponseCB,
     build_payment_req: BuildPaymentReqCB,
     parse_payment_response: ParsePaymentResponseCB,
     build_mint_req: BuildMintReqCB,
@@ -36,8 +36,8 @@ impl PaymentsMethodCBs {
     pub fn new(create_address: CreatePaymentAddressCB,
                add_request_fees: AddRequestFeesCB,
                parse_response_with_fees: ParseResponseWithFeesCB,
-               build_get_utxo_request: BuildGetUTXORequestCB,
-               parse_get_utxo_response: ParseGetUTXOResponseCB,
+               build_get_sources_request: BuildGetSourcesRequestCB,
+               parse_get_sources_response: ParseGetSourcesResponseCB,
                build_payment_req: BuildPaymentReqCB,
                parse_payment_response: ParsePaymentResponseCB,
                build_mint_req: BuildMintReqCB,
@@ -48,8 +48,8 @@ impl PaymentsMethodCBs {
             create_address,
             add_request_fees,
             parse_response_with_fees,
-            build_get_utxo_request,
-            parse_get_utxo_response,
+            build_get_sources_request,
+            parse_get_sources_response,
             build_payment_req,
             parse_payment_response,
             build_mint_req,
@@ -126,35 +126,35 @@ impl PaymentsService {
         res
     }
 
-    pub fn build_get_utxo_request(&self, cmd_handle: i32, type_: &str, wallet_handle: i32, submitter_did: &str, address: &str) -> Result<(), PaymentsError> {
-        trace!("build_get_utxo_request >>> type_: {:?}, wallet_handle: {:?}, submitter_did: {:?}, address: {:?}", type_, wallet_handle, submitter_did, address);
-        let build_get_utxo_request: BuildGetUTXORequestCB = self.methods.borrow().get(type_)
-            .ok_or(PaymentsError::UnknownType(format!("Unknown payment method {}", type_)))?.build_get_utxo_request;
+    pub fn build_get_sources_request(&self, cmd_handle: i32, type_: &str, wallet_handle: i32, submitter_did: &str, address: &str) -> Result<(), PaymentsError> {
+        trace!("build_get_sources_request >>> type_: {:?}, wallet_handle: {:?}, submitter_did: {:?}, address: {:?}", type_, wallet_handle, submitter_did, address);
+        let build_get_sources_request: BuildGetSourcesRequestCB = self.methods.borrow().get(type_)
+            .ok_or(PaymentsError::UnknownType(format!("Unknown payment method {}", type_)))?.build_get_sources_request;
 
         let submitter_did = CString::new(submitter_did)?;
         let address = CString::new(address)?;
 
-        let err = build_get_utxo_request(cmd_handle, wallet_handle, submitter_did.as_ptr(), address.as_ptr(), cbs::build_get_utxo_request_cb(cmd_handle));
+        let err = build_get_sources_request(cmd_handle, wallet_handle, submitter_did.as_ptr(), address.as_ptr(), cbs::build_get_sources_request_cb(cmd_handle));
 
         let res = PaymentsService::consume_result(err);
 
-        trace!("build_get_utxo_request <<< result: {:?}", res);
+        trace!("build_get_sources_request <<< result: {:?}", res);
 
         res
     }
 
-    pub fn parse_get_utxo_response(&self, cmd_handle: i32, type_: &str, response: &str) -> Result<(), PaymentsError> {
-        trace!("parse_get_utxo_response >>> type_: {:?}, response: {:?}", type_, response);
-        let parse_get_utxo_response: ParseGetUTXOResponseCB = self.methods.borrow().get(type_)
-            .ok_or(PaymentsError::UnknownType(format!("Unknown payment method {}", type_)))?.parse_get_utxo_response;
+    pub fn parse_get_sources_response(&self, cmd_handle: i32, type_: &str, response: &str) -> Result<(), PaymentsError> {
+        trace!("parse_get_sources_response >>> type_: {:?}, response: {:?}", type_, response);
+        let parse_get_sources_response: ParseGetSourcesResponseCB = self.methods.borrow().get(type_)
+            .ok_or(PaymentsError::UnknownType(format!("Unknown payment method {}", type_)))?.parse_get_sources_response;
 
         let response = CString::new(response)?;
 
-        let err = parse_get_utxo_response(cmd_handle, response.as_ptr(), cbs::parse_get_utxo_response_cb(cmd_handle));
+        let err = parse_get_sources_response(cmd_handle, response.as_ptr(), cbs::parse_get_sources_response_cb(cmd_handle));
 
         let res = PaymentsService::consume_result(err);
 
-        trace!("parse_get_utxo_response <<< result: {:?}", res);
+        trace!("parse_get_sources_response <<< result: {:?}", res);
 
         res
     }
@@ -298,13 +298,13 @@ impl PaymentsService {
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("No outputs for transaction".to_string())));
         }
 
-        let payment_address_set: HashSet<String> = outputs.into_iter().map(|s| s.payment_address).collect();
-        if payment_address_set.len() != outputs_len {
+        let recipient_set: HashSet<String> = outputs.into_iter().map(|s| s.recipient).collect();
+        if recipient_set.len() != outputs_len {
             error!("Several equal payment addresses");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("Several equal payment addresses".to_string())));
         }
 
-        let payment_methods: Vec<Option<String>> = payment_address_set.into_iter().map(|s| self._parse_method_from_payment_address(s.as_str())).collect();
+        let payment_methods: Vec<Option<String>> = recipient_set.into_iter().map(|s| self._parse_method_from_payment_address(s.as_str())).collect();
         if payment_methods.contains(&None) {
             error!("Some payment addresses are incorrectly formed");
             return Err(PaymentsError::CommonError(CommonError::InvalidStructure("Some payment addresses are incorrectly formed".to_string())));
@@ -354,8 +354,7 @@ impl PaymentsService {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Output {
-    #[serde(rename = "paymentAddress")]
-    payment_address: String,
+    pub recipient: String,
     amount: i32,
     extra: Option<String>
 }
@@ -405,16 +404,16 @@ mod cbs {
         send_ack(cmd_handle, Box::new(move |cmd_handle, result| PaymentsCommand::ParseResponseWithFeesAck(cmd_handle, result)))
     }
 
-    pub fn build_get_utxo_request_cb(cmd_handle: i32) -> Option<extern fn(command_handle: i32,
-                                                                          err: ErrorCode,
-                                                                          c_str: *const c_char) -> ErrorCode> {
-        send_ack(cmd_handle, Box::new(move |cmd_handle, result| PaymentsCommand::BuildGetUtxoRequestAck(cmd_handle, result)))
+    pub fn build_get_sources_request_cb(cmd_handle: i32) -> Option<extern fn(command_handle: i32,
+                                                                             err: ErrorCode,
+                                                                             c_str: *const c_char) -> ErrorCode> {
+        send_ack(cmd_handle, Box::new(move |cmd_handle, result| PaymentsCommand::BuildGetSourcesRequestAck(cmd_handle, result)))
     }
 
-    pub fn parse_get_utxo_response_cb(cmd_handle: i32) -> Option<extern fn(command_handle: i32,
-                                                                           err: ErrorCode,
-                                                                           c_str: *const c_char) -> ErrorCode> {
-        send_ack(cmd_handle, Box::new(move |cmd_handle, result| PaymentsCommand::ParseGetUtxoResponseAck(cmd_handle, result)))
+    pub fn parse_get_sources_response_cb(cmd_handle: i32) -> Option<extern fn(command_handle: i32,
+                                                                              err: ErrorCode,
+                                                                              c_str: *const c_char) -> ErrorCode> {
+        send_ack(cmd_handle, Box::new(move |cmd_handle, result| PaymentsCommand::ParseGetSourcesResponseAck(cmd_handle, result)))
     }
 
     pub fn build_payment_req_cb(cmd_handle: i32) -> Option<extern fn(command_handle: i32,