add e tags to deletes to be safe

marykatefain · marykatefain · commit 19220f720f43 · 2025-05-27T07:57:36.000+02:00
diff --git a/src/components/profile/CommonGroupsListImproved.tsx b/src/components/profile/CommonGroupsListImproved.tsx
@@ -13,6 +13,7 @@ import { useAuthor } from "@/hooks/useAuthor";
 import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
 import { Separator } from "@/components/ui/separator";
 import { KINDS } from "@/lib/nostr-kinds";
+import { useGroupDeletionRequests } from "@/hooks/useGroupDeletionRequests";
 
 interface CommonGroup {
   id: string;
@@ -263,6 +264,17 @@ export function CommonGroupsListImproved({ profileUserPubkey }: CommonGroupsList
     enabled: !!nostr && !!user && !!profileUserPubkey && user.pubkey !== profileUserPubkey,
   });
 
+  // Get group IDs for deletion checking
+  const groupIds = commonGroups?.map(group => group.id) || [];
+  const { data: deletionRequests } = useGroupDeletionRequests(groupIds);
+
+  // Filter out deleted groups
+  const filteredCommonGroups = commonGroups?.filter(group => {
+    if (!deletionRequests) return true;
+    const deletionRequest = deletionRequests.get(group.id);
+    return !(deletionRequest?.isValid || false);
+  }) || [];
+
   // Don't show anything if viewing own profile
   if (!user || !profileUserPubkey || user.pubkey === profileUserPubkey) {
     return null;
@@ -292,7 +304,7 @@ export function CommonGroupsListImproved({ profileUserPubkey }: CommonGroupsList
     );
   }
 
-  if (!commonGroups || commonGroups.length === 0) {
+  if (!filteredCommonGroups || filteredCommonGroups.length === 0) {
     return null; // Don't show section if no common groups
   }
 
@@ -304,12 +316,12 @@ export function CommonGroupsListImproved({ profileUserPubkey }: CommonGroupsList
           <h3 className="text-lg font-semibold">Shared Groups</h3>
         </div>
         <Badge variant="secondary" className="text-xs font-medium">
-          {commonGroups.length} {commonGroups.length === 1 ? 'group' : 'groups'}
+          {filteredCommonGroups.length} {filteredCommonGroups.length === 1 ? 'group' : 'groups'}
         </Badge>
       </div>
       
       <div className="space-y-3">
-        {commonGroups.map((group) => (
+        {filteredCommonGroups.map((group) => (
           <Link
             key={group.id}
             to={`/group/${encodeURIComponent(group.id)}`}
diff --git a/src/hooks/useGroupDeletionRequests.ts b/src/hooks/useGroupDeletionRequests.ts
@@ -27,12 +27,47 @@ export function useGroupDeletionRequests(groupIds: string[]) {
       try {
         const signal = AbortSignal.any([c.signal, AbortSignal.timeout(5000)]);
         
-        // Query for kind 5 deletion events that reference groups via 'a' tags
-        const deletionEvents = await nostr.query([{
-          kinds: [KINDS.DELETION],
-          "#a": groupIds,
-          limit: 1000 // Should be enough for deletion requests
-        }], { signal });
+        // Query for kind 5 deletion events that reference groups via 'a' tags or 'e' tags
+        // We need to extract event IDs from group IDs for 'e' tag filtering
+        const groupEventIds: string[] = [];
+        
+        // For each group ID, we need to query for the actual group event to get its event ID
+        // This is needed for 'e' tag compatibility
+        for (const groupId of groupIds) {
+          const parts = groupId.split(":");
+          if (parts.length === 3 && parts[0] === KINDS.GROUP.toString()) {
+            const [, pubkey, identifier] = parts;
+            try {
+              const groupEvents = await nostr.query([{
+                kinds: [KINDS.GROUP],
+                authors: [pubkey],
+                "#d": [identifier],
+                limit: 1
+              }], { signal: AbortSignal.timeout(2000) });
+              
+              if (groupEvents.length > 0) {
+                groupEventIds.push(groupEvents[0].id);
+              }
+            } catch (error) {
+              // If we can't fetch the group event, skip it for 'e' tag filtering
+              console.warn("Could not fetch group event for deletion filtering:", groupId, error);
+            }
+          }
+        }
+
+        // Query for deletion events using both 'a' tags and 'e' tags
+        const deletionEvents = await nostr.query([
+          {
+            kinds: [KINDS.DELETION],
+            "#a": groupIds,
+            limit: 500
+          },
+          ...(groupEventIds.length > 0 ? [{
+            kinds: [KINDS.DELETION],
+            "#e": groupEventIds,
+            limit: 500
+          }] : [])
+        ], { signal });
 
         const deletionMap = new Map<string, GroupDeletionRequest>();
 
@@ -43,6 +78,7 @@ export function useGroupDeletionRequests(groupIds: string[]) {
             tag[0] === "a" && tag[1] && tag[1].startsWith(`${KINDS.GROUP}:`)
           );
 
+          // Process 'a' tags (addressable event references)
           for (const aTag of aTags) {
             const groupId = aTag[1];
             
@@ -68,6 +104,57 @@ export function useGroupDeletionRequests(groupIds: string[]) {
               });
             }
           }
+
+          // Also check 'e' tags for event ID references
+          // This provides compatibility with relays that primarily use 'e' tags for deletions
+          const eTags = deletionEvent.tags.filter(tag => tag[0] === "e" && tag[1]);
+          
+          if (eTags.length > 0) {
+            // For 'e' tag processing, we need to be more careful since we need to match
+            // event IDs to group IDs. We'll query for the referenced events to validate them.
+            for (const eTag of eTags) {
+              const eventId = eTag[1];
+              
+              try {
+                // Query for the referenced event to see if it's a group event
+                const referencedEvents = await nostr.query([{
+                  ids: [eventId],
+                  kinds: [KINDS.GROUP],
+                  limit: 1
+                }], { signal: AbortSignal.timeout(2000) });
+                
+                if (referencedEvents.length > 0) {
+                  const groupEvent = referencedEvents[0];
+                  const dTag = groupEvent.tags.find(tag => tag[0] === "d");
+                  
+                  if (dTag) {
+                    const groupId = `${KINDS.GROUP}:${groupEvent.pubkey}:${dTag[1]}`;
+                    
+                    // Check if this group is in our target list
+                    if (groupIds.includes(groupId)) {
+                      // Validate that the deletion request is from the group owner
+                      const isValid = deletionEvent.pubkey === groupEvent.pubkey;
+                      
+                      // Only store the most recent valid deletion request for each group
+                      const existing = deletionMap.get(groupId);
+                      if (!existing || (isValid && deletionEvent.created_at > existing.deletionEvent.created_at)) {
+                        deletionMap.set(groupId, {
+                          deletionEvent,
+                          groupId,
+                          isValid,
+                          reason: deletionEvent.content || undefined
+                        });
+                      }
+                    }
+                  }
+                }
+              } catch (error) {
+                // If we can't fetch the referenced event, skip this 'e' tag
+                console.warn("Could not fetch referenced event for deletion validation:", eventId, error);
+                continue;
+              }
+            }
+          }
         }
 
         return deletionMap;
diff --git a/src/pages/GroupDetail.tsx b/src/pages/GroupDetail.tsx
@@ -387,10 +387,12 @@ export default function GroupDetail() {
 
     try {
       // Create a kind 5 deletion event referencing the group
+      // Include both 'a' tag (addressable event) and 'e' tag (event ID) for maximum relay compatibility
       await publishEvent({
         kind: KINDS.DELETION,
         tags: [
           ["a", `${KINDS.GROUP}:${community.pubkey}:${parsedId.identifier}`],
+          ["e", community.id],
           ["k", KINDS.GROUP.toString()]
         ],
         content: "Requesting deletion of this group",
diff --git a/src/pages/Profile.tsx b/src/pages/Profile.tsx
@@ -63,7 +63,7 @@ import {
 } from "@/components/ui/dropdown-menu";
 import { QRCodeModal } from "@/components/QRCodeModal";
 import { CommonGroupsListImproved } from "@/components/profile/CommonGroupsListImproved";
-import { useIsGroupDeleted } from "@/hooks/useGroupDeletionRequests";
+import { useIsGroupDeleted, useGroupDeletionRequests } from "@/hooks/useGroupDeletionRequests";
 
 // Hook to get shared group IDs
 function useSharedGroupIds(profileUserPubkey: string): string[] {
@@ -428,6 +428,10 @@ function UserGroupsList({
   const profileMetadata = profileAuthor.data?.metadata;
   const profileDisplayName = profileMetadata?.name || profileUserPubkey.slice(0, 8);
 
+  // Get group IDs for deletion checking
+  const groupIds = groups?.map(group => group.id) || [];
+  const { data: deletionRequests } = useGroupDeletionRequests(groupIds);
+
   if (isLoading) {
     return (
       <div className="space-y-4">
@@ -460,14 +464,22 @@ function UserGroupsList({
     );
   }
 
-  // Create a map to deduplicate groups by ID and filter out shared groups
+  // Create a map to deduplicate groups by ID and filter out shared groups and deleted groups
   const uniqueGroups = new Map<string, UserGroup>();
   for (const group of groups) {
     // Skip if this group is in the shared groups list (only when viewing another user's profile)
     if (!isCurrentUser && sharedGroupIds.includes(group.id)) {
       continue;
     }
     
+    // Skip if this group has been deleted
+    if (deletionRequests) {
+      const deletionRequest = deletionRequests.get(group.id);
+      if (deletionRequest?.isValid) {
+        continue;
+      }
+    }
+    
     // Only add if not already in the map, or replace with newer version
     if (
       !uniqueGroups.has(group.id) ||
