Include ~timing decorator on presentation request messages (#545)

* Include ~timing decorator on presentation request messages

Signed-off-by: Patrik Stas <[email protected]>

* Include ~timing decorator on all outgoing messages

Signed-off-by: Patrik Stas <[email protected]>

* Add tests to verify messages built by presentation verifier

Signed-off-by: Patrik Stas <[email protected]>

* Add ~timing on ProblemReport, add message tests for issues

Signed-off-by: Patrik Stas <[email protected]>

* Reformat

Signed-off-by: Patrik Stas <[email protected]>

* Add messages tests for credential issuance

Signed-off-by: Patrik Stas <[email protected]>

* Cargo fix

Signed-off-by: Patrik Stas <[email protected]>

* Refactor and test building handshake-reuse messages

Signed-off-by: Patrik Stas <[email protected]>

* Move building trustping messages to protocols module

Signed-off-by: Patrik Stas <[email protected]>

* Add tests for message building of invitee side of connection protocol

Signed-off-by: Patrik Stas <[email protected]>

* Refactor, add tests for message building of inviter side of connection protocol

Signed-off-by: Patrik Stas <[email protected]>

* Cargo fmt

Signed-off-by: Patrik Stas <[email protected]>

* Cargo fix

Signed-off-by: Patrik Stas <[email protected]>

* Address code review

Signed-off-by: Patrik Stas <[email protected]>

* Cargo fix

Signed-off-by: Patrik Stas <[email protected]>

Signed-off-by: Patrik Stas <[email protected]>

Author: Patrik-Stas

aries_vcx/Cargo.toml

@@ -54,4 +54,4 @@ derive_builder = "0.10.2"
 tokio = { version = "1.15.0" }
 
 [target.'cfg(target_os = "android")'.dependencies]
-android_logger = "0.5"
+android_logger = "0.5"

aries_vcx/src/handlers/connection/connection.rs

@@ -19,9 +19,6 @@ use crate::handlers::connection::cloud_agent::CloudAgentInfo;
 use crate::handlers::connection::legacy_agent_info::LegacyAgentInfo;
 use crate::handlers::connection::public_agent::PublicAgent;
 use crate::handlers::discovery::{respond_discovery_query, send_discovery_query};
-use crate::handlers::out_of_band::receiver::send_handshake_reuse;
-use crate::handlers::out_of_band::sender::send_handshake_reuse_accepted;
-use crate::handlers::trust_ping::util::handle_ping;
 use crate::handlers::trust_ping::TrustPingSender;
 use crate::messages::a2a::protocol_registry::ProtocolRegistry;
 use crate::messages::a2a::A2AMessage;
@@ -32,6 +29,8 @@ use crate::messages::discovery::disclose::{Disclose, ProtocolDescriptor};
 use crate::protocols::connection::invitee::state_machine::{InviteeFullState, InviteeState, SmConnectionInvitee};
 use crate::protocols::connection::inviter::state_machine::{InviterFullState, InviterState, SmConnectionInviter};
 use crate::protocols::connection::pairwise_info::PairwiseInfo;
+use crate::protocols::oob::{build_handshake_reuse_accepted_msg, build_handshake_reuse_msg};
+use crate::protocols::trustping::build_ping_response;
 use crate::protocols::SendClosure;
 use crate::utils::send_message;
 use crate::utils::serialization::SerializableObjectWithState;
@@ -417,14 +416,23 @@ impl Connection {
         match message {
             A2AMessage::Ping(ping) => {
                 info!("Answering ping, thread: {}", ping.get_thread_id());
-                handle_ping(wallet_handle, &ping, pw_vk, &did_doc, send_message).await?;
+                if ping.response_requested {
+                    send_message(
+                        wallet_handle,
+                        pw_vk.to_string(),
+                        did_doc.clone(),
+                        build_ping_response(&ping).to_a2a_message(),
+                    )
+                    .await?;
+                }
             }
             A2AMessage::OutOfBandHandshakeReuse(handshake_reuse) => {
                 info!(
                     "Answering OutOfBandHandshakeReuse message, thread: {}",
                     handshake_reuse.get_thread_id()
                 );
-                send_handshake_reuse_accepted(wallet_handle, &handshake_reuse, pw_vk, &did_doc).await?;
+                let msg = build_handshake_reuse_accepted_msg(&handshake_reuse)?;
+                send_message(wallet_handle, pw_vk.to_string(), did_doc.clone(), msg.to_a2a_message()).await?;
             }
             A2AMessage::Query(query) => {
                 let supported_protocols = ProtocolRegistry::init().get_protocols_for_query(query.query.as_deref());
@@ -691,19 +699,20 @@ impl Connection {
         }))
     }
 
-    fn parse_generic_message(message: &str) -> A2AMessage {
+    fn build_basic_message(message: &str) -> A2AMessage {
         match ::serde_json::from_str::<A2AMessage>(message) {
             Ok(a2a_message) => a2a_message,
             Err(_) => BasicMessage::create()
                 .set_content(message.to_string())
                 .set_time()
+                .set_out_time()
                 .to_a2a_message(),
         }
     }
 
     pub async fn send_generic_message(&self, wallet_handle: WalletHandle, message: &str) -> VcxResult<String> {
         trace!("Connection::send_generic_message >>> message: {:?}", message);
-        let message = Self::parse_generic_message(message);
+        let message = Self::build_basic_message(message);
         let send_message = self.send_message_closure(wallet_handle)?;
         send_message(message).await.map(|_| String::new())
     }
@@ -748,8 +757,13 @@ impl Connection {
             VcxErrorKind::NotReady,
             format!("Can't send handshake-reuse to the counterparty, because their did doc is not available"),
         ))?;
-        send_handshake_reuse(wallet_handle, &oob.id.0, &self.pairwise_info().pw_vk, &did_doc).await?;
-        Ok(())
+        send_message(
+            wallet_handle,
+            self.pairwise_info().pw_vk.clone(),
+            did_doc.clone(),
+            build_handshake_reuse_msg(&oob).to_a2a_message(),
+        )
+        .await
     }
 
     pub async fn delete(&self, agency_client: &AgencyClient) -> VcxResult<()> {

aries_vcx/src/handlers/discovery/mod.rs

@@ -14,7 +14,7 @@ pub async fn send_discovery_query(
     did_doc: &DidDoc,
     pw_vk: &str,
 ) -> VcxResult<()> {
-    let query_ = Query::create().set_query(query).set_comment(comment);
+    let query_ = Query::create().set_query(query).set_comment(comment).set_out_time();
     send_message(
         wallet_handle,
         pw_vk.to_string(),
@@ -33,7 +33,8 @@ pub async fn respond_discovery_query(
 ) -> VcxResult<()> {
     let disclose = Disclose::create()
         .set_protocols(supported_protocols)
-        .set_thread_id(&query.id.0.clone());
+        .set_thread_id(&query.id.0.clone())
+        .set_out_time();
 
     send_message(
         wallet_handle,

aries_vcx/src/handlers/issuance/issuer.rs

@@ -8,7 +8,7 @@ use crate::error::prelude::*;
 use crate::handlers::connection::connection::Connection;
 use crate::libindy::utils::anoncreds::libindy_issuer_create_credential_offer;
 use crate::messages::a2a::A2AMessage;
-use crate::messages::issuance::credential_offer::{CredentialOffer, OfferInfo};
+use crate::messages::issuance::credential_offer::OfferInfo;
 use crate::messages::issuance::credential_proposal::CredentialProposal;
 use crate::messages::issuance::CredentialPreviewData;
 use crate::messages::mime_type::MimeType;
@@ -105,17 +105,17 @@ impl Issuer {
     ) -> VcxResult<()> {
         let credential_preview = _build_credential_preview(&offer_info.credential_json)?;
         let libindy_cred_offer = libindy_issuer_create_credential_offer(wallet_handle, &offer_info.cred_def_id).await?;
-        let cred_offer_msg = CredentialOffer::create()
-            .set_id(&self.issuer_sm.thread_id()?)
-            .set_offers_attach(&libindy_cred_offer)?
-            .set_credential_preview_data(credential_preview)
-            .set_comment(comment);
-        self.issuer_sm = self.issuer_sm.clone().set_offer(cred_offer_msg, &offer_info)?;
+        self.issuer_sm = self.issuer_sm.clone().build_credential_offer_msg(
+            &libindy_cred_offer,
+            credential_preview,
+            comment,
+            &offer_info,
+        )?;
         Ok(())
     }
 
     pub fn get_credential_offer_msg(&self) -> VcxResult<A2AMessage> {
-        let offer = self.issuer_sm.get_credential_offer()?;
+        let offer = self.issuer_sm.get_credential_offer_msg()?;
         Ok(offer.to_a2a_message())
     }
 

aries_vcx/src/handlers/out_of_band/mod.rs

@@ -6,6 +6,7 @@ use crate::messages::attachment::Attachments;
 use crate::utils::service_resolvable::ServiceResolvable;
 // TODO: move to messages
 use crate::messages::mime_type::MimeType;
+use crate::messages::timing::Timing;
 
 pub mod receiver;
 pub mod sender;
@@ -44,6 +45,9 @@ pub struct OutOfBandInvitation {
     pub services: Vec<ServiceResolvable>,
     #[serde(rename = "requests~attach")]
     pub requests_attach: Attachments,
+    #[serde(rename = "~timing")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timing: Option<Timing>,
 }
 
 a2a_message!(OutOfBandInvitation);

aries_vcx/src/handlers/out_of_band/receiver.rs

@@ -1,10 +1,7 @@
 use std::clone::Clone;
 
-use indy_sys::WalletHandle;
-
 use agency_client::agency_client::AgencyClient;
 
-use crate::did_doc::DidDoc;
 use crate::error::prelude::*;
 use crate::handlers::connection::connection::Connection;
 use crate::handlers::out_of_band::OutOfBandInvitation;
@@ -14,37 +11,17 @@ use crate::messages::connection::invite::Invitation;
 use crate::messages::issuance::credential::Credential;
 use crate::messages::issuance::credential_offer::CredentialOffer;
 use crate::messages::issuance::credential_request::CredentialRequest;
-use crate::messages::out_of_band::handshake_reuse::OutOfBandHandshakeReuse;
+
 use crate::messages::proof_presentation::presentation::Presentation;
 use crate::messages::proof_presentation::presentation_request::PresentationRequest;
-use crate::utils::send_message;
+
 use crate::utils::service_resolvable::ServiceResolvable;
 
 #[derive(Default, Debug, PartialEq, Clone)]
 pub struct OutOfBandReceiver {
     pub oob: OutOfBandInvitation,
 }
 
-pub async fn send_handshake_reuse(
-    wallet_handle: WalletHandle,
-    oob_id: &str,
-    pw_vk: &str,
-    did_doc: &DidDoc,
-) -> VcxResult<()> {
-    let reuse_msg = OutOfBandHandshakeReuse::default()
-        .set_thread_id_matching_id()
-        .set_parent_thread_id(oob_id);
-    send_message(
-        wallet_handle,
-        pw_vk.to_string(),
-        did_doc.clone(),
-        reuse_msg.to_a2a_message(),
-    )
-    .await
-    .ok();
-    Ok(())
-}
-
 impl OutOfBandReceiver {
     pub fn create_from_a2a_msg(msg: &A2AMessage) -> VcxResult<Self> {
         trace!("OutOfBandReceiver::create_from_a2a_msg >>> msg: {:?}", msg);

aries_vcx/src/handlers/out_of_band/sender.rs

@@ -1,45 +1,17 @@
-use indy_sys::WalletHandle;
-
-use crate::did_doc::DidDoc;
 use crate::error::prelude::*;
 use crate::handlers::out_of_band::{GoalCode, HandshakeProtocol, OutOfBandInvitation};
 use crate::messages::a2a::message_family::MessageFamilies;
 use crate::messages::a2a::message_type::MessageType;
 use crate::messages::a2a::A2AMessage;
 use crate::messages::attachment::AttachmentId;
-use crate::messages::out_of_band::handshake_reuse::OutOfBandHandshakeReuse;
-use crate::messages::out_of_band::handshake_reuse_accepted::OutOfBandHandshakeReuseAccepted;
-use crate::utils::send_message;
+
 use crate::utils::service_resolvable::ServiceResolvable;
 
 #[derive(Default, Debug, PartialEq, Clone)]
 pub struct OutOfBandSender {
     pub oob: OutOfBandInvitation,
 }
 
-pub async fn send_handshake_reuse_accepted(
-    wallet_handle: WalletHandle,
-    handshake_reuse: &OutOfBandHandshakeReuse,
-    pw_vk: &str,
-    did_doc: &DidDoc,
-) -> VcxResult<()> {
-    let thread_id = handshake_reuse.get_thread_id();
-    let pthread_id = handshake_reuse.thread.pthid.as_deref().ok_or(VcxError::from_msg(
-        VcxErrorKind::InvalidOption,
-        "Parent thread id missing",
-    ))?;
-    let ack_msg = OutOfBandHandshakeReuseAccepted::default()
-        .set_thread_id(&thread_id)
-        .set_parent_thread_id(pthread_id);
-    send_message(
-        wallet_handle,
-        pw_vk.to_string(),
-        did_doc.clone(),
-        ack_msg.to_a2a_message(),
-    )
-    .await
-}
-
 impl OutOfBandSender {
     pub fn create() -> Self {
         Self::default()

aries_vcx/src/handlers/trust_ping/mod.rs

@@ -1,11 +1,9 @@
 use crate::error::{VcxError, VcxErrorKind, VcxResult};
-use crate::messages::a2a::MessageId;
+
 use crate::messages::trust_ping::ping::Ping;
 use crate::messages::trust_ping::ping_response::PingResponse;
+use crate::protocols::trustping::build_ping;
 use crate::protocols::SendClosure;
-use crate::utils::uuid;
-
-pub mod util;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 pub struct TrustPingSender {
@@ -16,10 +14,7 @@ pub struct TrustPingSender {
 
 impl TrustPingSender {
     pub fn build(request_response: bool, comment: Option<String>) -> TrustPingSender {
-        // todo : Remove different Default implementation for MessageId in tests, then we can remove this override
-        let ping = Ping::create(MessageId(uuid::uuid()))
-            .set_request_response(request_response)
-            .set_comment(comment);
+        let ping = build_ping(request_response, comment);
         Self {
             ping,
             ping_sent: false,
@@ -64,9 +59,9 @@ impl TrustPingSender {
 #[cfg(feature = "general_test")]
 mod unit_tests {
     use crate::error::VcxResult;
-    use crate::handlers::trust_ping::util::build_ping_response;
     use crate::handlers::trust_ping::TrustPingSender;
     use crate::messages::a2a::A2AMessage;
+    use crate::protocols::trustping::build_ping_response;
     use crate::protocols::SendClosure;
     use crate::utils::devsetup::SetupMocks;
 

aries_vcx/src/handlers/util.rs

@@ -1,5 +1,5 @@
 use crate::error::{VcxError, VcxErrorKind, VcxResult};
-use crate::global::settings;
+
 use crate::messages::a2a::A2AMessage;
 
 pub fn verify_thread_id(thread_id: &str, message: &A2AMessage) -> VcxResult<()> {

aries_vcx/src/messages/a2a/mod.rs

@@ -1,5 +1,5 @@
 use serde::{de, ser, Deserialize, Deserializer, Serialize, Serializer};
-use serde_json::{Map, Value};
+use serde_json::Value;
 
 use log;
 
@@ -410,6 +410,7 @@ pub mod test_a2a_serialization {
             label: "foobar".to_string(),
             connection: Default::default(),
             thread: None,
+            timing: None,
         });
         let serialized = serde_json::to_string(&a2a_msg).unwrap();
 

aries_vcx/src/messages/ack.rs

@@ -1,15 +1,24 @@
 use crate::messages::a2a::{A2AMessage, MessageId};
 use crate::messages::thread::Thread;
+use crate::messages::timing::Timing;
+use crate::timing_optional;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 pub struct Ack {
     #[serde(rename = "@id")]
     pub id: MessageId,
-    status: AckStatus,
+    pub status: AckStatus,
     #[serde(rename = "~thread")]
     pub thread: Thread,
+    #[serde(rename = "~timing")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timing: Option<Timing>,
 }
 
+threadlike!(Ack);
+a2a_message!(Ack);
+timing_optional!(Ack);
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum AckStatus {
     #[serde(rename = "OK")]
@@ -37,9 +46,6 @@ impl Ack {
     }
 }
 
-threadlike!(Ack);
-a2a_message!(Ack);
-
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct PleaseAck {}
 
@@ -64,6 +70,7 @@ pub mod test_utils {
             id: MessageId::id(),
             status: AckStatus::Fail,
             thread: _thread(),
+            timing: None,
         }
     }
 
@@ -72,6 +79,7 @@ pub mod test_utils {
             id: MessageId::id(),
             status: AckStatus::Ok,
             thread: _thread_random(),
+            timing: None,
         }
     }
 
@@ -80,6 +88,7 @@ pub mod test_utils {
             id: MessageId::id(),
             status: AckStatus::Fail,
             thread: _thread_1(),
+            timing: None,
         }
     }
 }