relay: NIP-09 a-tag deletion is a no-op for kind:30023 (and all non-workflow addressables)

[tlongwell-block]

Summary

handle_a_tag_deletion in crates/sprout-relay/src/handlers/side_effects.rs (≈line 1330) only implements a side-effect branch for KIND_WORKFLOW_DEF. All other addressable kinds — including kind:30023 (NIP-23 long-form) — fall through to the _ => arm which only emits a debug log. The kind:5 deletion event is accepted and stored, but the targeted addressable row is never soft-deleted, so subsequent REQs still return it.

Why this matters

sprout-cli is gaining notes rm for the team knowledge-base workflow (NIP-23 editable notes). The semantically correct NIP-09 deletion of a parameterized-replaceable note targets its a coordinate (30023:<pubkey>:<slug>), not just the event id — otherwise a future re-set of the same slug could be shadowed by a stale tombstone or cause confusion about which event id is authoritative.

The CLI's v1 workaround is to include both an e-tag (current event id, which works via the existing soft-delete path) and an a-tag (forward-compatible, currently a no-op). Once this relay-side gap is closed, rm becomes more robust without any CLI change.

Code pointers

• crates/sprout-relay/src/handlers/side_effects.rs:1330 — handle_a_tag_deletion; the _ => branch is the gap.
• crates/sprout-db/src/event.rs — soft_delete_event(event_id) exists; no soft_delete_by_coordinate analogue.
• Read-path filtering in crates/sprout-relay/src/handlers/req.rs already gates on deleted_at IS NULL, so once the side-effect path soft-deletes the row, REQs hide it automatically.

Proposed fix (sketch, non-binding)

1. Add sprout_db::event::soft_delete_addressable(pool, kind, pubkey, d_tag) -> Result<bool> that updates deleted_at on the row matching (kind, pubkey, d_tag). The d_tag column already exists and is indexed for NIP-33 kinds.
2. In handle_a_tag_deletion, replace the unconditional _ => debug log with a call to that helper for any parameterized-replaceable kind (or a documented allowlist if we want to be cautious). Workflow-specific logic stays where it is.

Validation already done

• e-tag deletion path works fully for kind:30023 (deleted_at set; REQs hide it).
• a-tag kind:5 events are accepted by validation (validate_standard_deletion_event correctly checks author ownership via pubkey-in-coordinate), but have no DB-level effect.

Scope

Out of scope: rebroadcast / discovery of the deletion event to other relays. This issue is purely about the local read-path consistency.

[BradGroux]

This was fixed by merged PR #719 and appears stale.

Current main has the exact generic NIP-33 branch requested here: every parameterized-replaceable kind other than the workflow-specific branch calls soft_delete_by_coordinate, including kind 30023:

buzz/crates/buzz-relay/src/handlers/side_effects.rs

Lines 2038 to 2079 in 7e34bee

	// Generic NIP-33 (parameterized-replaceable) soft-delete by coordinate.
	//
	// Listed after the workflow branch so workflow's bespoke deletion
	// (which doesn't soft-delete the `events` row by design — that's a
	// separate concern) takes precedence. For every other addressable
	// kind, including kind:30023 (NIP-23 long-form), we soft-delete the
	// live row matching `(kind, pubkey, d_tag)` so REQs stop returning it.
	// See https://github.com/block/sprout/issues/714.
	k if is_parameterized_replaceable(k) => {
	let pubkey_bytes = match hex::decode(pubkey_hex) {
	Ok(b) => b,
	Err(e) => {
	return Err(anyhow::anyhow!(
	"invalid pubkey hex in a-tag {pubkey_hex}: {e}"
	));
	}
	};
	// Safe cast: NIP-33 kinds are 30000–39999, well within i32.
	let kind_i32 = k as i32;
	let deleted = state
	.db
	.soft_delete_by_coordinate(tenant.community(), kind_i32, &pubkey_bytes, d_tag)
	.await
	.map_err(|e| {
	anyhow::anyhow!(
	"failed to soft-delete by coordinate {kind_i32}:{pubkey_hex}:{d_tag}: {e}"
	)
	})?;
	if deleted {
	tracing::info!(
	kind = k,
	d_tag = d_tag,
	"NIP-09 a-tag deletion: soft-deleted addressable event by coordinate"
	);
	} else {
	tracing::debug!(
	kind = k,
	d_tag = d_tag,
	"NIP-09 a-tag deletion: no live row matched coordinate"
	);
	}
	}

The database helper updates the live row matching (community_id, kind, pubkey, d_tag) and returns whether a row was affected:

buzz/crates/buzz-db/src/event.rs

Lines 719 to 749 in 7e34bee

	/// Soft-delete the live row for an addressable coordinate
	/// `(kind, pubkey, d_tag)` — the NIP-33 replacement key.
	///
	/// Used by `handle_a_tag_deletion` to honour NIP-09 a-tag deletions for any
	/// parameterized-replaceable kind. The WHERE clause mirrors
	/// `replace_parameterized_event` so the coordinate semantics stay consistent:
	/// `channel_id` is intentionally NOT in the key (NIP-33 replacement is global
	/// per the spec — `channel_id` is stored for query scoping, not identity).
	///
	/// Returns `Ok(true)` if a row was deleted, `Ok(false)` if no live row matched
	/// (already deleted, or never existed).
	pub async fn soft_delete_by_coordinate(
	pool: &PgPool,
	community_id: CommunityId,
	kind: i32,
	pubkey: &[u8],
	d_tag: &str,
	) -> Result<bool> {
	let result = sqlx::query(
	"UPDATE events SET deleted_at = NOW() \
	WHERE community_id = $1 AND kind = $2 AND pubkey = $3 AND d_tag = $4 AND deleted_at IS NULL",
	)
	.bind(community_id.as_uuid())
	.bind(kind)
	.bind(pubkey)
	.bind(d_tag)
	.execute(pool)
	.await?;
	Ok(result.rows_affected() > 0)
	}

There is also an issue-specific relay regression test that publishes kind 30023, deletes it with an a coordinate, and verifies the subsequent REQ is empty:

buzz/crates/buzz-test-client/tests/e2e_long_form.rs

Lines 312 to 390 in 7e34bee

	/// NIP-09 a-tag deletion: a kind:5 deletion targeting the addressable
	/// coordinate `30023:<pubkey>:<d-tag>` causes the live event row for that
	/// coordinate to be soft-deleted, so subsequent REQs no longer return it.
	///
	/// Regression test for issue #714 — before the fix,
	/// `handle_a_tag_deletion` only handled the workflow kind and silently
	/// no-op'd for kind:30023.
	#[tokio::test]
	#[ignore]
	async fn test_long_form_a_tag_deletion() {
	let url = relay_url();
	let keys = Keys::generate();
	let mut client = BuzzTestClient::connect(&url, &keys).await.expect("connect");
	// Publish a note.
	let d_tag = format!("a-del-{}", uuid::Uuid::new_v4().simple());
	let note = build_long_form_event(&keys, &d_tag, "Doomed Article", "Body.", vec![]);
	let note_id = note.id;
	let ok = client.send_event(note).await.expect("send note");
	assert!(ok.accepted, "note should be accepted: {}", ok.message);
	// Sanity check it's queryable before deletion.
	let sid_pre = sub_id("a-del-pre");
	let filter_pre = Filter::new()
	.kind(Kind::Custom(KIND_LONG_FORM))
	.author(keys.public_key())
	.custom_tag(SingleLetterTag::lowercase(Alphabet::D), d_tag.as_str());
	client
	.subscribe(&sid_pre, vec![filter_pre])
	.await
	.expect("subscribe pre");
	let pre = client
	.collect_until_eose(&sid_pre, Duration::from_secs(5))
	.await
	.expect("collect pre");
	assert!(
	pre.iter().any(|e| e.id == note_id),
	"note should be queryable before deletion"
	);
	// Build the addressable coordinate and emit a kind:5 deletion targeting it.
	let a_coord = format!(
	"{}:{}:{}",
	KIND_LONG_FORM,
	keys.public_key().to_hex(),
	d_tag
	);
	let del = EventBuilder::new(Kind::EventDeletion, "")
	.tags(vec![Tag::parse(["a", &a_coord]).unwrap()])
	.sign_with_keys(&keys)
	.unwrap();
	let ok_del = client.send_event(del).await.expect("send deletion");
	assert!(
	ok_del.accepted,
	"a-tag deletion should be accepted: {}",
	ok_del.message
	);
	// Query — should now be empty.
	let sid_post = sub_id("a-del-post");
	let filter_post = Filter::new()
	.kind(Kind::Custom(KIND_LONG_FORM))
	.author(keys.public_key())
	.custom_tag(SingleLetterTag::lowercase(Alphabet::D), d_tag.as_str());
	client
	.subscribe(&sid_post, vec![filter_post])
	.await
	.expect("subscribe post");
	let post = client
	.collect_until_eose(&sid_post, Duration::from_secs(5))
	.await
	.expect("collect post");
	assert!(
	post.is_empty(),
	"a-tag deletion should remove the note from REQ results (got {} events)",
	post.len()
	);
	client.disconnect().await.expect("disconnect");

The implementation landed in commit 504cfea via #719: 504cfea

I confirmed the relevant Rust crates compile while checking this issue; the exact relay regression remains an ignored test requiring a live relay, so I did not claim a fresh E2E pass. Suggested maintainer action: close as completed by #719. #717 remains the separately scoped workflow-row case and has open PR #2268.