Implement NIP-62 Request to Vanish support

alltheseas · claude · alltheseas · commit 86b052e1b321 · 2026-03-19T12:26:29.000-05:00
Two-phase approach: writer thread sets a VanishPubkey marker instantly
(blocking re-storage), cron thread sweeps and deletes events in batches
every 30s to avoid long write locks. Deletes all authored events up to
the vanish timestamp plus kind 1059 gift wraps addressed via p-tag.
Kind 62 events are preserved for bookkeeping and protected from kind 5
deletion.

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/golpe.yaml b/golpe.yaml
@@ -110,6 +110,12 @@ tablesRaw:
   EventPayload:
     flags: 'MDB_INTEGERKEY'
 
+  ## NIP-62: Tracks pubkeys that have requested vanishing
+  ## keys are 32-byte binary pubkeys
+  ## vals are uint64_t vanish timestamp (max created_at from vanish requests)
+  VanishPubkey:
+    flags: ''
+
 config:
   - name: db
     desc: "Directory that contains the strfry LMDB database"
diff --git a/src/apps/relay/RelayCron.cpp b/src/apps/relay/RelayCron.cpp
@@ -62,6 +62,105 @@ void RelayServer::runCron() {
 
 
 
+    // NIP-62: Delete events for vanished pubkeys
+
+    cron.repeat(30 * 1'000'000UL, [&]{
+        if (!cfg().relay__nip62__enabled) return;
+
+        struct VanishEntry {
+            std::string pubkey;
+            uint64_t vanishTs;
+        };
+
+        std::vector<VanishEntry> vanishEntries;
+        std::vector<uint64_t> vanishLevIds;
+        const uint64_t batchLimit = 10000;
+
+        {
+            auto txn = env.txn_ro();
+
+            // Collect all vanish entries
+            {
+                auto cursor = lmdb::cursor::open(txn, env.dbi_VanishPubkey);
+                std::string_view k, v;
+                if (cursor.get(k, v, MDB_FIRST)) {
+                    do {
+                        if (k.size() == 32 && v.size() == sizeof(uint64_t)) {
+                            vanishEntries.push_back({std::string(k), lmdb::from_sv<uint64_t>(v)});
+                        }
+                    } while (cursor.get(k, v, MDB_NEXT));
+                }
+            }
+
+            for (auto &entry : vanishEntries) {
+                // Scan pubkey index for events authored by this pubkey
+                auto searchPrefix = std::string(entry.pubkey);
+                auto startKey = makeKey_StringUint64(searchPrefix, 0);
+
+                env.generic_foreachFull(txn, env.dbi_Event__pubkey, startKey, lmdb::to_sv<uint64_t>(0), [&](auto k, auto v) {
+                    if (!k.starts_with(searchPrefix)) return false;
+
+                    auto levId = lmdb::from_sv<uint64_t>(v);
+                    auto ev = env.lookup_Event(txn, levId);
+                    if (!ev) return true;
+
+                    PackedEventView packed(ev->buf);
+
+                    // Skip kind 62 events (preserve bookkeeping)
+                    if (packed.kind() == 62) return true;
+
+                    if (packed.created_at() <= entry.vanishTs) {
+                        vanishLevIds.push_back(levId);
+                        if (vanishLevIds.size() >= batchLimit) {
+                            return false;
+                        }
+                    }
+
+                    return true;
+                });
+
+                // Scan tag index for gift wraps (kind 1059) addressed to this pubkey
+                if (vanishLevIds.size() < batchLimit) {
+                    auto tagPrefix = std::string("p") + entry.pubkey;
+                    auto tagStartKey = makeKey_StringUint64(tagPrefix, 0);
+
+                    env.generic_foreachFull(txn, env.dbi_Event__tag, tagStartKey, lmdb::to_sv<uint64_t>(0), [&](auto k, auto v) {
+                        if (k.size() != tagPrefix.size() + 8 || !k.starts_with(tagPrefix)) return false;
+
+                        auto levId = lmdb::from_sv<uint64_t>(v);
+                        auto ev = env.lookup_Event(txn, levId);
+                        if (!ev) return true;
+
+                        PackedEventView packed(ev->buf);
+
+                        // Delete all gift wraps (kind 1059) addressed to this pubkey (spec says ALL, no timestamp qualifier)
+                        if (packed.kind() == 1059) {
+                            vanishLevIds.push_back(levId);
+                            if (vanishLevIds.size() >= batchLimit) {
+                                return false;
+                            }
+                        }
+
+                        return true;
+                    });
+                }
+
+            }
+        }
+
+        if (vanishLevIds.size() > 0) {
+            auto txn = env.txn_rw();
+            NegentropyFilterCache neFilterCache;
+
+            uint64_t numDeleted = deleteEvents(txn, neFilterCache, vanishLevIds);
+
+            txn.commit();
+
+            if (numDeleted) LI << "NIP-62 vanish: deleted " << numDeleted << " events";
+        }
+    });
+
+
     cron.run();
 
     while (1) std::this_thread::sleep_for(std::chrono::seconds(1'000'000));
diff --git a/src/apps/relay/RelayIngester.cpp b/src/apps/relay/RelayIngester.cpp
@@ -185,6 +185,37 @@ void RelayServer::ingesterProcessEvent(lmdb::txn &txn, RelayServerCtx &rsctx, ui
         }
     }
 
+    // NIP-62: Validate kind 62 (Request to Vanish) relay tags
+    if (packed.kind() == 62) {
+        auto idHex = to_hex(packed.id());
+
+        if (!cfg().relay__nip62__enabled) {
+            sendOKResponse(connId, idHex, false, "blocked: NIP-62 not enabled on this relay");
+            return;
+        }
+
+        bool foundMatchingRelay = false;
+        std::string serviceUrl = cfg().relay__auth__serviceUrl;
+
+        for (const auto &tagj : origJson.at("tags").get_array()) {
+            const auto &tag = tagj.get_array();
+            if (tag.size() < 2) continue;
+            auto tagName = tag[0].as<std::string_view>();
+            if (tagName != "relay") continue;
+            auto tagVal = tag[1].as<std::string_view>();
+
+            if (tagVal == "ALL_RELAYS" || (!serviceUrl.empty() && tagVal == serviceUrl)) {
+                foundMatchingRelay = true;
+                break;
+            }
+        }
+
+        if (!foundMatchingRelay) {
+            sendOKResponse(connId, idHex, false, "blocked: vanish request not targeting this relay");
+            return;
+        }
+    }
+
     {
         auto existing = lookupEventById(txn, packed.id());
         if (existing) {
diff --git a/src/apps/relay/RelayWebsocket.cpp b/src/apps/relay/RelayWebsocket.cpp
@@ -58,6 +58,7 @@ void RelayServer::runWebsocket(ThreadPool<MsgWebsocket>::Thread &thr) {
         if (cfg().relay__auth__enabled && cfg().relay__auth__serviceUrl.size() > 0) output.push_back(42);
         if (cfg().relay__maxFilterLimitCount > 0) output.push_back(45);
         if (cfg().relay__negentropy__enabled) output.push_back(77);
+        if (cfg().relay__nip62__enabled) output.push_back(62);
 
         std::sort(output.get_array().begin(), output.get_array().end());
 
diff --git a/src/apps/relay/golpe.yaml b/src/apps/relay/golpe.yaml
@@ -136,6 +136,10 @@ config:
     desc: "Maximum records that sync will process before returning an error"
     default: 1000000
 
+  - name: relay__nip62__enabled
+    desc: "Enable NIP-62 Request to Vanish support"
+    default: true
+
   - name: relay__filterValidation__enabled
     desc: "Enable strict filter validation for REQ messages"
     default: false
diff --git a/src/events.cpp b/src/events.cpp
@@ -271,11 +271,42 @@ void writeEvents(lmdb::txn &txn, NegentropyFilterCache &neFilterCache, std::vect
                 continue;
             }
 
-            if (env.lookup_Event__deletion(txn, std::string(packed.id()) + std::string(packed.pubkey()))) {
+            if (packed.kind() != 62 && env.lookup_Event__deletion(txn, std::string(packed.id()) + std::string(packed.pubkey()))) {
                 ev.status = EventWriteStatus::Deleted;
                 continue;
             }
 
+            // NIP-62: Reject events from vanished pubkeys (except kind 62 itself)
+            {
+                std::string_view vanishVal;
+                if (packed.kind() != 62 && env.dbi_VanishPubkey.get(txn, packed.pubkey(), vanishVal)) {
+                    uint64_t vanishTs = lmdb::from_sv<uint64_t>(vanishVal);
+                    if (packed.created_at() <= vanishTs) {
+                        ev.status = EventWriteStatus::Deleted;
+                        continue;
+                    }
+                }
+            }
+
+            // NIP-62: Reject gift wraps addressed to vanished pubkeys
+            if (packed.kind() == 1059) {
+                bool vanished = false;
+                packed.foreachTag([&](char tagName, std::string_view tagVal){
+                    if (tagName == 'p') {
+                        std::string_view vanishVal;
+                        if (env.dbi_VanishPubkey.get(txn, tagVal, vanishVal)) {
+                            vanished = true;
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                if (vanished) {
+                    ev.status = EventWriteStatus::Deleted;
+                    continue;
+                }
+            }
+
             if (isReplaceableKind(packed.kind()) || isParamReplaceableKind(packed.kind())) {
                 std::optional<std::string> replace;
 
@@ -332,9 +363,12 @@ void writeEvents(lmdb::txn &txn, NegentropyFilterCache &neFilterCache, std::vect
                 packed.foreachTag([&](char tagName, std::string_view tagVal){
                     if (tagName == 'e') {
                         auto otherEv = lookupEventById(txn, tagVal);
-                        if (otherEv && PackedEventView(otherEv->buf).pubkey() == packed.pubkey()) {
-                            if (logDeletions) LI << "Deleting event (kind 5, e-tag). id=" << to_hex(tagVal);
-                            levIdsToDelete.push_back(otherEv->primaryKeyId);
+                        if (otherEv) {
+                            PackedEventView otherPacked(otherEv->buf);
+                            if (otherPacked.pubkey() == packed.pubkey() && otherPacked.kind() != 62) {
+                                if (logDeletions) LI << "Deleting event (kind 5, e-tag). id=" << to_hex(tagVal);
+                                levIdsToDelete.push_back(otherEv->primaryKeyId);
+                            }
                         }
                     } else if (tagName == 'a') {
                         try { // parsing a-tag can fail
@@ -365,6 +399,20 @@ void writeEvents(lmdb::txn &txn, NegentropyFilterCache &neFilterCache, std::vect
                 });
             }
 
+            // NIP-62: Set vanish marker for kind 62 events
+            if (packed.kind() == 62 && cfg().relay__nip62__enabled) {
+                std::string_view existingVal;
+                uint64_t existingTs = 0;
+                if (env.dbi_VanishPubkey.get(txn, packed.pubkey(), existingVal)) {
+                    existingTs = lmdb::from_sv<uint64_t>(existingVal);
+                }
+                if (packed.created_at() > existingTs) {
+                    uint64_t newTs = packed.created_at();
+                    env.dbi_VanishPubkey.put(txn, packed.pubkey(), lmdb::to_sv<uint64_t>(newTs));
+                    LI << "NIP-62 vanish marker set for pubkey=" << to_hex(packed.pubkey()) << " ts=" << newTs;
+                }
+            }
+
             if (ev.status == EventWriteStatus::Pending) {
                 ev.levId = env.insert_Event(txn, ev.packedStr);
 
diff --git a/strfry.conf b/strfry.conf
@@ -171,6 +171,11 @@ relay {
         maxSyncEvents = 1000000
     }
 
+    nip62 {
+        # Enable NIP-62 Request to Vanish support
+        enabled = true
+    }
+
     filterValidation {
         # Enable strict filter validation for REQ messages
         enabled = false
