Print colored CESR message when trace log level is enabled

Cargo.toml

@@ -112,3 +112,9 @@ tsp_sdk = { path = "./tsp_sdk", version = "0.8.1" }
 
 [patch.crates-io]
 askar-storage = { git = "https://github.com/openwallet-foundation/askar.git" }
+
+# these are patched to prevent log level from being force to info level
+# should be fixed once PRs are merged and new versions are released
+affinidi-data-integrity = { git = "https://github.com/michielp1807/affinidi-tdk-rs.git" }
+affinidi-secrets-resolver = { git = "https://github.com/michielp1807/affinidi-tdk-rs.git" }
+didwebvh-rs = { git = "https://github.com/decentralized-identity/didwebvh-rs", rev = "05ef9f19ec08e88d945e1bdce595a007422ccb32" }

examples/src/cli.rs

@@ -9,8 +9,7 @@ use tracing::{debug, error, info, trace};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 use tsp_sdk::{
     Aliases, AskarSecureStorage, AsyncSecureStore, Error, ExportVid, OwnedVid, ReceivedTspMessage,
-    RelationshipStatus, SecureStorage, VerifiedVid, Vid,
-    cesr::{self, color_format},
+    RelationshipStatus, SecureStorage, VerifiedVid, Vid, cesr,
     definitions::Digest,
     vid::{VidError, did::webvh::WebvhMetadata, verify_vid, vid_to_did_document},
 };
@@ -635,15 +634,6 @@ async fn run() -> Result<(), Error> {
                 }
             };
 
-            if args.verbose {
-                let cesr_message = vid_wallet
-                    .as_store()
-                    .seal_message(&sender_vid, &receiver_vid, non_confidential_data, &message)?
-                    .1;
-                println!("CESR-encoded message:");
-                println!("{}", color_format(&cesr_message).unwrap());
-            }
-
             info!(
                 "sent message ({} bytes) from {sender_vid} to {receiver_vid}",
                 message.len()

tsp_sdk/src/async_store.rs

@@ -539,27 +539,33 @@ impl AsyncSecureStore {
             let db_inner = db.clone();
             let self_inner = self_clone.clone();
             async move {
-                match message {
-                    Ok(mut m) => match db_inner.open_message(&mut m) {
-                        Err(Error::UnverifiedSource(unknown_vid, _)) => {
-                            debug!("Verifying VID: {}", unknown_vid);
-                            self_inner.verify_vid(&unknown_vid, None).await?;
-                            db_inner.open_message(&mut m)
-                        }
-                        Err(Error::Crypto(CryptoError::Verify(vid, _))) => {
-                            debug!("Re-verifying VID: {}", vid);
-                            self_inner.verify_vid(&vid, None).await?;
-                            db_inner.open_message(&mut m)
-                        }
-                        maybe_message => maybe_message,
+                let mut message = message?;
+
+                if tracing::enabled!(tracing::Level::TRACE) {
+                    println!(
+                        "CESR-encoded message: {}",
+                        crate::cesr::color_format(&message)?
+                    );
+                }
+
+                match db_inner.open_message(&mut message) {
+                    Err(Error::UnverifiedSource(unknown_vid, _)) => {
+                        debug!("Verifying VID: {}", unknown_vid);
+                        self_inner.verify_vid(&unknown_vid, None).await?;
+                        db_inner.open_message(&mut message)
+                    }
+                    Err(Error::Crypto(CryptoError::Verify(vid, _))) => {
+                        debug!("Re-verifying VID: {}", vid);
+                        self_inner.verify_vid(&vid, None).await?;
+                        db_inner.open_message(&mut message)
                     }
-                    .map(|msg| msg.into_owned())
-                    .map_err(|e| {
-                        tracing::error!("{}", e);
-                        e
-                    }),
-                    Err(e) => Err(e.into()),
+                    maybe_message => maybe_message,
                 }
+                .map(|msg| msg.into_owned())
+                .map_err(|e| {
+                    tracing::error!("{}", e);
+                    e
+                })
             }
         })))
     }

tsp_sdk/src/transport/mod.rs

@@ -12,6 +12,14 @@ mod tls;
 pub use error::TransportError;
 
 pub async fn send_message(transport: &Url, tsp_message: &[u8]) -> Result<(), TransportError> {
+    if tracing::enabled!(tracing::Level::TRACE) {
+        println!(
+            "CESR-encoded message: {}",
+            crate::cesr::color_format(tsp_message)
+                .map_err(|_| TransportError::InvalidMessageReceived("DecodeError".to_string()))?
+        );
+    }
+
     match transport.scheme() {
         tcp::SCHEME => tcp::send_message(tsp_message, transport).await,
         tls::SCHEME => tls::send_message(tsp_message, transport).await,