Add verify functionality for libindy

Signed-off-by: Nikita Khateev <[email protected]>

Author: Nikita Khateev

libindy/src/api/payments.rs

@@ -254,7 +254,6 @@ pub type BuildGetTxnFeesReqCB = extern fn(command_handle: i32,
 ///
 /// # Params
 /// command_handle: command handle to map callback to context
-/// payment_method: payment method to use
 /// resp_json: response for Indy request for getting fees
 ///
 /// # Return
@@ -270,6 +269,47 @@ pub type ParseGetTxnFeesResponseCB = extern fn(command_handle: i32,
                                                                     err: ErrorCode,
                                                                     fees_json: *const c_char) -> ErrorCode>) -> ErrorCode;
 
+/// Builds Indy request for information to verify the receipt
+///
+/// # Params
+/// command_handle
+/// wallet_handle
+/// submitter_did
+/// receipt -- receipt to verify
+///
+/// # Return
+/// verify_txn_json -- request to be sent to ledger
+
+pub type BuildVerifyReqCB = extern fn(command_handle: i32,
+                                      wallet_handle: i32,
+                                      submitter_did: *const c_char,
+                                      receipt: *const c_char,
+                                      cb: Option<extern fn(command_handle_: i32,
+                                                           err: ErrorCode,
+                                                           verify_txn_json: *const c_char) -> ErrorCode>) -> ErrorCode;
+
+/// Parses Indy response with information to verify receipt
+///
+/// # Params
+/// command_handle
+/// resp_json -- response of the ledger for verify txn
+///
+/// # Return
+/// txn_json: {
+///     sources: [<str>, ]
+///     receipts: [ {
+///         recipient: <str>, // payment address of recipient
+///         receipt: <str>, // receipt that can be used for payment referencing and verification
+///         amount: <int>, // amount
+///     }, ]
+///     extra: <str>, //optional data
+/// }
+pub type ParseVerifyResponseCB = extern fn(command_handle: i32,
+                                           resp_json: *const c_char,
+                                           cb: Option<extern fn(command_handle_: i32,
+                                                                err: ErrorCode,
+                                                                txn_json: *const c_char) -> ErrorCode>) -> ErrorCode;
+
 /// Register custom payment implementation.
 ///
 /// It allows library user to provide custom payment method implementation as set of handlers.
@@ -300,6 +340,8 @@ pub extern fn indy_register_payment_method(command_handle: i32,
                                            build_set_txn_fees_req: Option<BuildSetTxnFeesReqCB>,
                                            build_get_txn_fees_req: Option<BuildGetTxnFeesReqCB>,
                                            parse_get_txn_fees_response: Option<ParseGetTxnFeesResponseCB>,
+                                           build_verify_req: Option<BuildVerifyReqCB>,
+                                           parse_verify_response: Option<ParseVerifyResponseCB>,
                                            cb: Option<extern fn(command_handle_: i32,
                                                                 err: ErrorCode)>) -> ErrorCode {
     trace!("indy_register_payment_method: >>> payment_method: {:?}", payment_method);
@@ -316,7 +358,9 @@ pub extern fn indy_register_payment_method(command_handle: i32,
     check_useful_c_callback!(build_set_txn_fees_req, ErrorCode::CommonInvalidParam11);
     check_useful_c_callback!(build_get_txn_fees_req, ErrorCode::CommonInvalidParam12);
     check_useful_c_callback!(parse_get_txn_fees_response, ErrorCode::CommonInvalidParam13);
-    check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam14);
+    check_useful_c_callback!(build_verify_req, ErrorCode::CommonInvalidParam14);
+    check_useful_c_callback!(parse_verify_response, ErrorCode::CommonInvalidParam15);
+    check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam16);
 
     trace!("indy_register_payment_method: entities >>> payment_method: {:?}", payment_method);
 
@@ -331,7 +375,9 @@ pub extern fn indy_register_payment_method(command_handle: i32,
         build_mint_req,
         build_set_txn_fees_req,
         build_get_txn_fees_req,
-        parse_get_txn_fees_response
+        parse_get_txn_fees_response,
+        build_verify_req,
+        parse_verify_response,
     );
     let result =
         CommandExecutor::instance().send(
@@ -998,4 +1044,104 @@ pub extern fn indy_parse_get_txn_fees_response(command_handle: i32,
     trace!("indy_parse_get_txn_fees_response: <<< res: {:?}", res);
 
     res
+}
+
+/// Builds Indy request for information to verify the receipt
+///
+/// # Params
+/// command_handle
+/// wallet_handle
+/// submitter_did
+/// receipt -- receipt to verify
+///
+/// # Return
+/// verify_txn_json -- request to be sent to ledger
+/// payment_method
+#[no_mangle]
+pub extern fn indy_build_verify_req(command_handle: i32,
+                                    wallet_handle: i32,
+                                    submitter_did: *const c_char,
+                                    receipt: *const c_char,
+                                    cb: Option<extern fn(command_handle_: i32,
+                                                         err: ErrorCode,
+                                                         verify_txn_json: *const c_char,
+                                                         payment_method: *const c_char)>) -> ErrorCode {
+    trace!("indy_build_verify_req: >>> wallet_handle {:?}, submitter_did: {:?}, receipt: {:?}", wallet_handle, submitter_did, receipt);
+    check_useful_c_str!(submitter_did, ErrorCode::CommonInvalidParam3);
+    check_useful_c_str!(receipt, ErrorCode::CommonInvalidParam4);
+    check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam5);
+
+    trace!("indy_build_verify_req: entities >>> wallet_handle {:?}, submitter_did: {:?}, receipt: {:?}", wallet_handle, submitter_did, receipt);
+
+    let result = CommandExecutor::instance()
+        .send(Command::Payments(
+            PaymentsCommand::BuildVerifyReq(
+                wallet_handle,
+                submitter_did,
+                receipt,
+                Box::new(move |result| {
+                    let (err, verify_txn_json, payment_method) = result_to_err_code_2!(result, String::new(), String::new());
+                    trace!("indy_build_verify_req: verify_txn_json: {:?}, payment_method: {:?}", verify_txn_json, payment_method);
+                    let verify_txn_json = CStringUtils::string_to_cstring(verify_txn_json);
+                    let payment_method = CStringUtils::string_to_cstring(payment_method);
+                    cb(command_handle, err, verify_txn_json.as_ptr(), payment_method.as_ptr());
+                })
+        )));
+
+    let result = result_to_err_code!(result);
+
+    trace!("indy_build_verify_req: <<< result: {:?}", result);
+
+    result
+}
+
+/// Parses Indy response with information to verify receipt
+///
+/// # Params
+/// command_handle
+/// payment_method
+/// resp_json -- response of the ledger for verify txn
+///
+/// # Return
+/// txn_json: {
+///     sources: [<str>, ]
+///     receipts: [ {
+///         recipient: <str>, // payment address of recipient
+///         receipt: <str>, // receipt that can be used for payment referencing and verification
+///         amount: <int>, // amount
+///     }, ]
+///     extra: <str>, //optional data
+/// }
+#[no_mangle]
+pub extern fn indy_parse_verify_response(command_handle: i32,
+                                          payment_method: *const c_char,
+                                          resp_json: *const c_char,
+                                          cb: Option<extern fn(command_handle_: i32,
+                                                               err: ErrorCode,
+                                                               txn_json: *const c_char)>) -> ErrorCode {
+    trace!("indy_parse_payment_response: >>> resp_json: {:?}", resp_json);
+    check_useful_c_str!(payment_method, ErrorCode::CommonInvalidParam2);
+    check_useful_c_str!(resp_json, ErrorCode::CommonInvalidParam3);
+    check_useful_c_callback!(cb, ErrorCode::CommonInvalidParam4);
+
+    trace!("indy_parse_payment_response: entities >>> resp_json: {:?}", resp_json);
+
+    let result = CommandExecutor::instance()
+        .send(Command::Payments(
+            PaymentsCommand::ParseVerifyResponse(
+                payment_method,
+                resp_json,
+                Box::new(move |result| {
+                    let (err, txn_json) = result_to_err_code_1!(result, String::new());
+                    trace!("indy_build_verify_req: txn_json: {:?}", txn_json);
+                    let txn_json = CStringUtils::string_to_cstring(txn_json);
+                    cb(command_handle, err, txn_json.as_ptr());
+                })
+            )));
+
+    let result = result_to_err_code!(result);
+
+    trace!("indy_parse_payment_response: <<< result: {:?}", result);
+
+    result
 }

libindy/src/commands/payments.rs

@@ -109,6 +109,21 @@ pub enum PaymentsCommand {
         String, //response
         Box<Fn(Result<String, IndyError>) + Send>),
     ParseGetTxnFeesResponseAck(
+        i32,
+        Result<String, PaymentsError>),
+    BuildVerifyReq(
+        i32, //wallet_handle
+        String, //submitter_did
+        String, //receipt
+        Box<Fn(Result<(String, String), IndyError>) + Send>),
+    BuildVerifyReqAck(
+        i32,
+        Result<String, PaymentsError>),
+    ParseVerifyResponse(
+        String, //payment_method
+        String, //resp_json
+        Box<Fn(Result<String, IndyError>) + Send>),
+    ParseVerifyResponseAck(
         i32,
         Result<String, PaymentsError>)
 }
@@ -228,6 +243,22 @@ impl PaymentsCommandExecutor {
                 info!(target: "payments_command_executor", "ParseGetTxnFeesResponseAck command received");
                 self.parse_get_txn_fees_response_ack(cmd_handle, result);
             }
+            PaymentsCommand::BuildVerifyReq(wallet_handle, submitter_did, receipt, cb) => {
+                info!(target: "payments_command_executor", "BuildVerifyReq command received");
+                self.build_verify_request(wallet_handle, &submitter_did, &receipt, cb);
+            }
+            PaymentsCommand::BuildVerifyReqAck(command_handle, result) => {
+                info!(target: "payments_command_executor", "BuildVerifyReqAck command received");
+                self.build_verify_request_ack(command_handle, result);
+            }
+            PaymentsCommand::ParseVerifyResponse(payment_method, resp_json, cb) => {
+                info!(target: "payments_command_executor", "ParseVerifyResponse command received");
+                self.parse_verify_response(&payment_method, &resp_json, cb);
+            }
+            PaymentsCommand::ParseVerifyResponseAck(command_handle, result) => {
+                info!(target: "payments_command_executor", "ParseVerifyResponseAck command received");
+                self.parse_verify_response_ack(command_handle, result);
+            }
         }
     }
 
@@ -537,6 +568,50 @@ impl PaymentsCommandExecutor {
         trace!("parse_get_txn_fees_response_ack <<<");
     }
 
+    fn build_verify_request(&self, wallet_handle: i32, submitter_did: &str, receipt: &str, cb: Box<Fn(Result<(String, String), IndyError>) + Send>) {
+        trace!("build_verify_request >>> wallet_handle: {:?}, submitter_did: {:?}, receipt: {:?}", wallet_handle, submitter_did, receipt);
+        match self.crypto_service.validate_did(submitter_did).map_err(map_err_err!()) {
+            Err(err) => return cb(Err(IndyError::from(err))),
+            _ => ()
+        }
+        match self.wallet_service.check(wallet_handle).map_err(map_err_err!()) {
+            Err(err) => return cb(Err(IndyError::from(err))),
+            _ => (),
+        };
+
+        let method = match self.payments_service.parse_method_from_payment_address(receipt) {
+            Ok(method) => method,
+            Err(err) => {
+                cb(Err(IndyError::from(err)));
+                return;
+            }
+        };
+        let method_copy = method.to_string();
+        self._process_method(
+            Box::new(move |get_sources_txn_json| cb(get_sources_txn_json.map(|s| (s, method.to_string())))),
+            &|i| self.payments_service.build_verify_req(i, &method_copy, wallet_handle, &submitter_did, receipt)
+        );
+        trace!("build_get_payment_sources_request <<<");
+    }
+
+    fn build_verify_request_ack(&self, cmd_handle: i32, result: Result<String, PaymentsError>) {
+        trace!("build_verify_request_ack >>> result: {:?}", result);
+        self._common_ack_payments(cmd_handle, result, "BuildVerifyRequestAck");
+        trace!("build_verify_request_ack <<<");
+    }
+
+    fn parse_verify_response(&self, type_: &str, resp_json: &str, cb: Box<Fn(Result<String, IndyError>) + Send>) {
+        trace!("parse_verify_response >>> response: {:?}", resp_json);
+        self._process_method(cb, &|i| self.payments_service.parse_verify_response(i, type_, resp_json));
+        trace!("parse_verify_response <<<");
+    }
+
+    fn parse_verify_response_ack(&self, cmd_handle: i32, result: Result<String, PaymentsError>) {
+        trace!("parse_verify_response_ack >>> result: {:?}", result);
+        self._common_ack_payments(cmd_handle, result, "ParseVerifyResponseAck");
+        trace!("parse_verify_response_ack <<<");
+    }
+
     // HELPERS
 
     fn _process_method(&self, cb: Box<Fn(Result<String, IndyError>) + Send>,

libindy/src/services/payments.rs

@@ -28,6 +28,8 @@ pub struct PaymentsMethod {
     build_set_txn_fees_req: BuildSetTxnFeesReqCB,
     build_get_txn_fees_req: BuildGetTxnFeesReqCB,
     parse_get_txn_fees_response: ParseGetTxnFeesResponseCB,
+    build_verify_req: BuildVerifyReqCB,
+    parse_verify_response: ParseVerifyResponseCB,
 }
 
 pub type PaymentsMethodCBs = PaymentsMethod;
@@ -43,7 +45,9 @@ impl PaymentsMethodCBs {
                build_mint_req: BuildMintReqCB,
                build_set_txn_fees_req: BuildSetTxnFeesReqCB,
                build_get_txn_fees_req: BuildGetTxnFeesReqCB,
-               parse_get_txn_fees_response: ParseGetTxnFeesResponseCB) -> Self {
+               parse_get_txn_fees_response: ParseGetTxnFeesResponseCB,
+               build_verify_req: BuildVerifyReqCB,
+               parse_verify_response: ParseVerifyResponseCB) -> Self {
         PaymentsMethodCBs {
             create_address,
             add_request_fees,
@@ -56,6 +60,8 @@ impl PaymentsMethodCBs {
             build_set_txn_fees_req,
             build_get_txn_fees_req,
             parse_get_txn_fees_response,
+            build_verify_req,
+            parse_verify_response,
         }
     }
 }
@@ -259,6 +265,39 @@ impl PaymentsService {
         res
     }
 
+    pub fn build_verify_req(&self, cmd_handle: i32, type_: &str, wallet_handle: i32, submitter_did: &str, receipt: &str) -> Result<(), PaymentsError> {
+        trace!("build_verify_req >>> type_: {:?}, wallet_handle: {:?}, submitter_did: {:?}, receipt: {:?}", type_, wallet_handle, submitter_did, receipt);
+        let build_verify_req: BuildVerifyReqCB = self.methods.borrow().get(type_)
+            .ok_or(PaymentsError::UnknownType(format!("Unknown payment method {}", type_)))?.build_verify_req;
+
+        let submitter_did = CString::new(submitter_did)?;
+        let receipt = CString::new(receipt)?;
+
+        let err = build_verify_req(cmd_handle, wallet_handle, submitter_did.as_ptr(), receipt.as_ptr(), cbs::build_verify_req(cmd_handle));
+
+        let res = PaymentsService::consume_result(err);
+
+        trace!("build_verify_req <<< result: {:?}", res);
+
+        res
+    }
+
+    pub fn parse_verify_response(&self, cmd_handle: i32, type_: &str, resp_json: &str) -> Result<(), PaymentsError> {
+        trace!("parse_verify_response >>> type_: {:?}, resp_json: {:?}", type_, resp_json);
+        let parse_verify_response: ParseVerifyResponseCB = self.methods.borrow().get(type_)
+            .ok_or(PaymentsError::UnknownType(format!("Unknown payment method {}", type_)))?.parse_verify_response;
+
+        let resp_json = CString::new(resp_json)?;
+
+        let err = parse_verify_response(cmd_handle, resp_json.as_ptr(), cbs::parse_verify_response(cmd_handle));
+
+        let res = PaymentsService::consume_result(err);
+
+        trace!("parse_verify_response <<< result: {:?}", res);
+
+        res
+    }
+
     pub fn parse_method_from_inputs(&self, inputs: &str) -> Result<String, PaymentsError> {
         trace!("parse_method_from_inputs >>> inputs: {:?}", inputs);
         let inputs: Vec<&str> = serde_json::from_str(inputs).map_err(|_| PaymentsError::CommonError(CommonError::InvalidStructure("Unable to parse inputs".to_string())))?;
@@ -452,6 +491,18 @@ mod cbs {
         send_ack(cmd_handle, Box::new(move |cmd_handle, result| PaymentsCommand::ParseGetTxnFeesResponseAck(cmd_handle, result)))
     }
 
+    pub fn build_verify_req(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::BuildVerifyReqAck(cmd_handle, result)))
+    }
+
+    pub fn parse_verify_response(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::ParseVerifyResponseAck(cmd_handle, result)))
+    }
+
     fn send_ack(cmd_handle: i32, builder: Box<Fn(i32, Result<String, PaymentsError>) -> PaymentsCommand + Send>) -> Option<extern fn(command_handle: i32,
                                                                                                                                      err: ErrorCode,
                                                                                                                                      c_str: *const c_char) -> ErrorCode> {