From b3031800cd95601c2d9cd2d24034364d1496b073 Mon Sep 17 00:00:00 2001
From: DanConwayDev <DanConwayDev@protonmail.com>
Date: Tue, 4 Nov 2025 08:50:29 +0000
Subject: Migrate to standard NIP-01 't' tags for audit events

- Changed from custom single-letter tags (g, r, c) to standard 't' tags
- Tag values now use descriptive prefixes:
  - 'grasp-audit-test-event' (marker tag)
  - 'audit-{run-id}' (run identification)
  - 'audit-cleanup-after-{timestamp}' (cleanup time)
- Updated audit_tags() in src/audit.rs
- Updated query filtering in src/client.rs
- Updated all tests to verify 't' tag usage
- All tests passing: 12/12 unit tests, 1/1 integration test
- CLI verified working with new tag scheme

This follows standard Nostr conventions and avoids potential
conflicts with other uses of single-letter tags. The 't' tag
is specifically designed for categorization/topics per NIP-01.
---
 grasp-audit/src/audit.rs  | 54 +++++++++++++++++++++--------------------------
 grasp-audit/src/client.rs | 13 ++++--------
 2 files changed, 28 insertions(+), 39 deletions(-)

(limited to 'grasp-audit/src')

diff --git a/grasp-audit/src/audit.rs b/grasp-audit/src/audit.rs
index e902ace..fad4bf2 100644
--- a/grasp-audit/src/audit.rs
+++ b/grasp-audit/src/audit.rs
@@ -65,22 +65,21 @@ impl AuditConfig {
     pub fn audit_tags(&self) -> Vec<Tag> {
         use nostr_sdk::prelude::{Alphabet, SingleLetterTag};
         
+        // Use "t" tags for categorization (standard NIP-01 hashtag type)
+        let t_tag = SingleLetterTag::lowercase(Alphabet::T);
+        
         vec![
-            // Use single-letter tags for filtering support
-            // "g" = grasp-audit marker
             Tag::custom(
-                TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::G)),
-                vec!["grasp-audit"]
+                TagKind::SingleLetter(t_tag),
+                vec!["grasp-audit-test-event"]
             ),
-            // "r" = audit run ID
             Tag::custom(
-                TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::R)),
-                vec![self.run_id.clone()]
+                TagKind::SingleLetter(t_tag),
+                vec![format!("audit-{}", self.run_id)]
             ),
-            // "c" = cleanup timestamp
             Tag::custom(
-                TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::C)),
-                vec![self.cleanup_after.to_string()]
+                TagKind::SingleLetter(t_tag),
+                vec![format!("audit-cleanup-after-{}", self.cleanup_after.as_u64())]
             ),
         ]
     }
@@ -159,35 +158,30 @@ mod tests {
         
         assert_eq!(tags.len(), 3);
         
-        let g_tag = SingleLetterTag::lowercase(Alphabet::G);
-        let r_tag = SingleLetterTag::lowercase(Alphabet::R);
-        let c_tag = SingleLetterTag::lowercase(Alphabet::C);
+        let t_tag = SingleLetterTag::lowercase(Alphabet::T);
         
-        // Check "g" tag (grasp-audit marker)
-        assert!(tags.iter().any(|t| {
-            if let TagKind::SingleLetter(letter) = t.kind() {
-                letter == g_tag
+        // All tags should be "t" tags (hashtags)
+        for tag in &tags {
+            if let TagKind::SingleLetter(letter) = tag.kind() {
+                assert_eq!(letter, t_tag);
             } else {
-                false
+                panic!("Expected SingleLetter tag");
             }
+        }
+        
+        // Check for "t" tag with "grasp-audit-test-event"
+        assert!(tags.iter().any(|t| {
+            t.content() == Some("grasp-audit-test-event")
         }));
         
-        // Check "r" tag (audit run ID)
+        // Check for "t" tag with "audit-{run_id}"
         assert!(tags.iter().any(|t| {
-            if let TagKind::SingleLetter(letter) = t.kind() {
-                letter == r_tag
-            } else {
-                false
-            }
+            t.content().map(|c| c.starts_with("audit-ci-")).unwrap_or(false)
         }));
         
-        // Check "c" tag (cleanup timestamp)
+        // Check for "t" tag with "audit-cleanup-after-{timestamp}"
         assert!(tags.iter().any(|t| {
-            if let TagKind::SingleLetter(letter) = t.kind() {
-                letter == c_tag
-            } else {
-                false
-            }
+            t.content().map(|c| c.starts_with("audit-cleanup-after-")).unwrap_or(false)
         }));
     }
     
diff --git a/grasp-audit/src/client.rs b/grasp-audit/src/client.rs
index d78b33c..4831d3f 100644
--- a/grasp-audit/src/client.rs
+++ b/grasp-audit/src/client.rs
@@ -95,16 +95,11 @@ impl AuditClient {
         
         if self.config.mode == AuditMode::CI {
             // In CI mode, only see our own audit events
-            // Filter by "g" tag (grasp-audit marker) and "r" tag (run ID)
+            // Filter by "t" tags (hashtags)
+            let t_tag = SingleLetterTag::lowercase(Alphabet::T);
             filter = filter
-                .custom_tag(
-                    SingleLetterTag::lowercase(Alphabet::G),
-                    "grasp-audit"
-                )
-                .custom_tag(
-                    SingleLetterTag::lowercase(Alphabet::R),
-                    &self.config.run_id
-                );
+                .custom_tag(t_tag, "grasp-audit-test-event")
+                .custom_tag(t_tag, format!("audit-{}", self.config.run_id));
         }
         // In Production mode, see all events (no filter modification)
         
-- 
cgit v1.2.3