lib

commit c1a3bbd5e1c66c57233880c0c2ce61b520c301fd
parent 3c3fc5a2d2c4306775b485f167a20361e2fa5a36
Author: triesap <tyson@radroots.org>
Date:   Sun, 14 Jun 2026 18:22:51 -0700

authority: redact signed event mismatch errors

Diffstat:
M
crates/authority/src/authorization.rs
 | 
38
++++++++++++++++++++++++++------------
M
crates/authority/src/error.rs
 | 
42
+++++++++++++++++++++++++++---------------

2 files changed, 53 insertions(+), 27 deletions(-)
diff --git a/crates/authority/src/authorization.rs b/crates/authority/src/authorization.rs
@@ -115,14 +115,14 @@ pub fn validate_signed_event_matches_draft(
     }
     if signed_event.tags != draft.tags {
         return Err(RadrootsAuthorityError::SignedEventTagsMismatch {
-            expected_tags: draft.tags.clone(),
-            actual_tags: signed_event.tags.clone(),
+            expected_len: draft.tags.len(),
+            actual_len: signed_event.tags.len(),
         });
     }
     if signed_event.content != draft.content {
         return Err(RadrootsAuthorityError::SignedEventContentMismatch {
-            expected_content: draft.content.clone(),
-            actual_content: signed_event.content.clone(),
+            expected_len: draft.content.len(),
+            actual_len: signed_event.content.len(),
         });
     }
     let computed_event_id = compute_nip01_event_id(
@@ -422,10 +422,17 @@ mod tests {
             },
         );
 
-        assert!(matches!(
-            sign_authorized_draft(&actor, &signer, &draft),
-            Err(RadrootsAuthorityError::SignedEventTagsMismatch { .. })
-        ));
+        let error = sign_authorized_draft(&actor, &signer, &draft).unwrap_err();
+
+        assert_eq!(
+            error,
+            RadrootsAuthorityError::SignedEventTagsMismatch {
+                expected_len: 1,
+                actual_len: 1
+            }
+        );
+        assert!(!format!("{error:?}").contains("listing-b"));
+        assert!(!error.to_string().contains("listing-b"));
     }
 
     #[test]
@@ -441,10 +448,17 @@ mod tests {
             },
         );
 
-        assert!(matches!(
-            sign_authorized_draft(&actor, &signer, &draft),
-            Err(RadrootsAuthorityError::SignedEventContentMismatch { .. })
-        ));
+        let error = sign_authorized_draft(&actor, &signer, &draft).unwrap_err();
+
+        assert_eq!(
+            error,
+            RadrootsAuthorityError::SignedEventContentMismatch {
+                expected_len: 2,
+                actual_len: 16
+            }
+        );
+        assert!(!format!("{error:?}").contains("changed"));
+        assert!(!error.to_string().contains("changed"));
     }
 
     #[test]
diff --git a/crates/authority/src/error.rs b/crates/authority/src/error.rs
@@ -3,9 +3,9 @@
 use core::fmt;
 
 #[cfg(not(feature = "std"))]
-use alloc::{string::String, vec::Vec};
+use alloc::string::String;
 #[cfg(feature = "std")]
-use std::{string::String, vec::Vec};
+use std::string::String;
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum RadrootsAuthorityError {
@@ -69,13 +69,13 @@ pub enum RadrootsAuthorityError {
     },
 
     SignedEventTagsMismatch {
-        expected_tags: Vec<Vec<String>>,
-        actual_tags: Vec<Vec<String>>,
+        expected_len: usize,
+        actual_len: usize,
     },
 
     SignedEventContentMismatch {
-        expected_content: String,
-        actual_content: String,
+        expected_len: usize,
+        actual_len: usize,
     },
 
     SignedEventComputedIdInvalid {
@@ -172,15 +172,19 @@ impl fmt::Display for RadrootsAuthorityError {
                 "signed event kind mismatch: expected {expected_kind}, got {actual_kind}"
             ),
             Self::SignedEventTagsMismatch {
-                expected_tags,
-                actual_tags,
+                expected_len,
+                actual_len,
             } => write!(
                 f,
-                "signed event tags mismatch: expected {expected_tags:?}, got {actual_tags:?}"
+                "signed event tags mismatch: expected {expected_len} tags, got {actual_len} tags"
+            ),
+            Self::SignedEventContentMismatch {
+                expected_len,
+                actual_len,
+            } => write!(
+                f,
+                "signed event content mismatch: expected {expected_len} bytes, got {actual_len} bytes"
             ),
-            Self::SignedEventContentMismatch { .. } => {
-                write!(f, "signed event content mismatch")
-            }
             Self::SignedEventComputedIdInvalid { message } => {
                 write!(
                     f,
@@ -259,11 +263,19 @@ mod tests {
         );
         assert_eq!(
             RadrootsAuthorityError::SignedEventTagsMismatch {
-                expected_tags: vec![vec!["t".to_owned(), "soil".to_owned()]],
-                actual_tags: vec![vec!["t".to_owned(), "seed".to_owned()]],
+                expected_len: 2,
+                actual_len: 1,
+            }
+            .to_string(),
+            "signed event tags mismatch: expected 2 tags, got 1 tags"
+        );
+        assert_eq!(
+            RadrootsAuthorityError::SignedEventContentMismatch {
+                expected_len: 17,
+                actual_len: 2,
             }
             .to_string(),
-            "signed event tags mismatch: expected [[\"t\", \"soil\"]], got [[\"t\", \"seed\"]]"
+            "signed event content mismatch: expected 17 bytes, got 2 bytes"
         );
     }