Add unbanpubkey and unallowpubkey

event_easyjson.go

@@ -74,8 +74,6 @@ func easyjsonDecodeEvent(in *jlexer.Lexer, out *Event) {
 			if len(b) == 128 {
 				xhex.Decode(out.Sig[:], b)
 			}
-		default:
-			in.SkipRecursive()
 		}
 		in.WantComma()
 	}

eventstore/bleve/bleve_test.go

@@ -2,13 +2,10 @@ package bleve
 
 import (
 	"os"
-	"path/filepath"
 	"testing"
 
 	"fiatjaf.com/nostr"
 	"fiatjaf.com/nostr/eventstore/lmdb"
-	"fiatjaf.com/nostr/eventstore/slicestore"
-	"github.com/pemistahl/lingua-go"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -24,7 +21,6 @@ func TestBleveFlow(t *testing.T) {
 	bl := BleveBackend{
 		Path:          "/tmp/blevetest-bleve",
 		RawEventStore: bb,
-		Languages:     []lingua.Language{lingua.English},
 	}
 	err := bl.Init()
 	require.NoError(t, err, "init")
@@ -78,184 +74,3 @@ func TestBleveFlow(t *testing.T) {
 		assert.Equal(t, 1, n)
 	}
 }
-
-func TestSearch(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "test_search_pyramid")
-	require.NoError(t, err)
-	defer os.RemoveAll(tempDir)
-
-	db := &slicestore.SliceStore{}
-	db.Init()
-
-	index := &BleveBackend{
-		Path:          filepath.Join(tempDir, "test_index"),
-		RawEventStore: db,
-		Languages: []lingua.Language{
-			lingua.English,
-			lingua.Portuguese,
-			lingua.Italian,
-		},
-	}
-	err = index.Init()
-	require.NoError(t, err)
-	defer index.Close()
-
-	pirateEvents := []nostr.Event{
-		{
-			ID:        nostr.MustIDFromHex("0000000000000000000000000000000000000000000000000000000000000001"),
-			PubKey:    nostr.MustPubKeyFromHex("0000000000000000000000000000000000000000000000000000000000000001"),
-			CreatedAt: nostr.Timestamp(1609459200),
-			Kind:      1,
-			Content:   "Ahoy mateys! I've discovered a treasure chest filled with gold doubloons and silver pieces buried beneath the old palm tree on Skull Island. The secret map shows an X marks the spot where the legendary pirate Blackbeard hid his most valuable plunder. The chest contains rubies, emeralds, and ancient coins from sunken Spanish galleons. https://www.youtube.com/watch?v=enTAromEeHo&t=88s",
-			Tags:      nil,
-		},
-		{
-			ID:        nostr.MustIDFromHex("0000000000000000000000000000000000000000000000000000000000000002"),
-			PubKey:    nostr.MustPubKeyFromHex("0000000000000000000000000000000000000000000000000000000000000001"),
-			CreatedAt: nostr.Timestamp(1609545600),
-			Kind:      1111,
-			Content:   "The treasure map I found reveals the location of Captain Morgan's lost gold mine deep in the Caribbean waters. Following the ancient compass directions leads to a hidden cave filled with golden artifacts, jeweled swords, and the crown jewels of forgotten kingdoms. The secret passage is guarded by mysterious symbols only known to the brotherhood of the sea. https://www.youtube.com/watch?v=yBtyNIqZios",
-			Tags:      nil,
-		},
-		{
-			ID:        nostr.MustIDFromHex("0000000000000000000000000000000000000000000000000000000000000003"),
-			PubKey:    nostr.MustPubKeyFromHex("0000000000000000000000000000000000000000000000000000000000000003"),
-			CreatedAt: nostr.Timestamp(1609632000),
-			Kind:      1,
-			Content:   "Legends speak of the Emerald City of the Lost Pirates, a mythical place where streets are paved with gold and buildings adorned with precious gems. The secret entrance can only be found during a full moon when the tides reveal a hidden path across the coral reefs. Ancient scrolls tell of guardians protecting treasure vaults containing the world's most valuable gems.",
-			Tags:      nil,
-		},
-		{
-			ID:        nostr.MustIDFromHex("0000000000000000000000000000000000000000000000000000000000000004"),
-			PubKey:    nostr.MustPubKeyFromHex("0000000000000000000000000000000000000000000000000000000000000004"),
-			CreatedAt: nostr.Timestamp(1609545601),
-			Kind:      1111,
-			Content:   "Bom dia seus piratas melequentos, onde está esse bendito tesouro? nostr:nprofile1qqsv6jemsnaq925ddfqjhwm3du3k0zk7dnj2ksk2k4hcfkf80mzf56spz9mhxue69uhkzcnpvdshgefwvdhk6tmjzyj",
-			Tags:      nil,
-		},
-		{
-			ID:        nostr.MustIDFromHex("0000000000000000000000000000000000000000000000000000000000000005"),
-			PubKey:    nostr.MustPubKeyFromHex("0000000000000000000000000000000000000000000000000000000000000005"),
-			CreatedAt: nostr.Timestamp(1609545602),
-			Kind:      30023,
-			Content:   "I pirati dei Caraibi del XVII e XVIII secolo sono diventati leggendari per la loro ricerca di tesori. Questi avventurieri del mare saccheggiavano navi cariche d'oro, argento e pietre preziose provenienti dalle colonie spagnole del Nuovo Mondo.\n\nSecondo la leggenda, molti pirati seppellivano i loro tesori su isole remote, creando mappe segrete con la famosa \"X\" che segnava il punto. Capitani famosi come Barbanera, Capitan Kidd e Henry Morgan sono entrati nell'immaginario collettivo come custodi di ricchezze nascoste.\n\nAnche se la maggior parte dei tesori dei pirati sono probabilmente solo miti, alcuni sono stati davvero ritrovati. Il fascino di questi bottini nascosti continua ad ispirare storie, film e cacciatori di tesori ancora oggi.",
-			Tags:      nil,
-		},
-	}
-
-	for _, event := range pirateEvents {
-		err := db.SaveEvent(event)
-		require.NoError(t, err)
-		err = index.SaveEvent(event)
-		require.NoError(t, err)
-	}
-
-	testCases := []struct {
-		name     string
-		filter   nostr.Filter
-		expected int
-	}{
-		{
-			name: "search for 'gold'",
-			filter: nostr.Filter{
-				Search: "gold",
-			},
-			expected: 3, // all events mention gold
-		},
-		{
-			name: "search for 'treasure'",
-			filter: nostr.Filter{
-				Search: "treasure",
-			},
-			expected: 3, // all events mention treasure
-		},
-		{
-			name: "search for 'emerald' together with 'astronomical'",
-			filter: nostr.Filter{
-				Search: "astronomical emeralds",
-			},
-			expected: 0, // no events mention emeralds together with astronomical
-		},
-		{
-			name: "search for 'secret map'",
-			filter: nostr.Filter{
-				Search: "\"secret map\"",
-			},
-			expected: 1, // only one event mentions secret map
-		},
-		{
-			name: "search with kind filter",
-			filter: nostr.Filter{
-				Search: "gold",
-				Kinds:  []nostr.Kind{1},
-			},
-			expected: 2, // only two events are kind 1
-		},
-		{
-			name: "search in portuguese",
-			filter: nostr.Filter{
-				Search: "melequento",
-			},
-			expected: 1,
-		},
-		{
-			name: "search with exact match",
-			filter: nostr.Filter{
-				Search: "\"the secret entrance can only be found during a full moon\"",
-			},
-			expected: 1,
-		},
-		{
-			name: "search with OR across languages",
-			filter: nostr.Filter{
-				Search: "melequento OR matey",
-			},
-			expected: 2,
-		},
-		{
-			name: "search with exact reference found in the text",
-			filter: nostr.Filter{
-				Search: "tesouro nostr:nprofile1qqsv6jemsnaq925ddfqjhwm3du3k0zk7dnj2ksk2k4hcfkf80mzf56spzpmhxue69uhkyctwv9hxztnrdaksmfp5mw", // this is the same pubkey from above, but it's a different nprofile
-			},
-			expected: 1,
-		},
-		{
-			name: "search for URL",
-			filter: nostr.Filter{
-				Search: "https://www.youtube.com/watch?v=yBtyNIqZios treasure",
-			},
-			expected: 1,
-		},
-		{
-			name: "search for host/domain of URL",
-			filter: nostr.Filter{
-				Search: "www.youtube.com",
-			},
-			expected: 2,
-		},
-		{
-			name: "mentioning the author should include their notes in the result",
-			filter: nostr.Filter{
-				Search: " nostr:npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqshp52w2",
-			},
-			expected: 2,
-		},
-		{
-			name: "mentioning the author should include their notes in the result",
-			filter: nostr.Filter{
-				Search: "found gold? nostr:npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqshp52w2",
-			},
-			expected: 1,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			var count int
-			for range index.QueryEvents(tc.filter, 10) {
-				count++
-			}
-			require.Equal(t, tc.expected, count)
-		})
-	}
-}

eventstore/cmd/eventstore/main.go

@@ -19,7 +19,7 @@ import (
 
 var (
 	db  eventstore.Store
-	end = func() {}
+	end func()
 )
 
 var app = &cli.Command{

eventstore/mmm/freeranges.go

@@ -2,32 +2,14 @@ package mmm
 
 import (
 	"cmp"
-	"encoding/binary"
 	"fmt"
-	"iter"
-	"runtime"
 	"slices"
-	"syscall"
-	"unsafe"
 
-	"fiatjaf.com/nostr"
-	"fiatjaf.com/nostr/eventstore/codec/betterbinary"
 	"github.com/PowerDNS/lmdb-go/lmdb"
 )
 
 const LARGE_FREERANGE = 142
 
-// AllFreeRanges returns an iterator of (start_pos, size) of all free ranges, in positional order.
-func (b *MultiMmapManager) AllFreeRanges() iter.Seq2[uint64, uint32] {
-	return func(yield func(uint64, uint32) bool) {
-		for _, pos := range b.freeRangesAll {
-			if !yield(pos.start, pos.size) {
-				return
-			}
-		}
-	}
-}
-
 func (b *MultiMmapManager) gatherFreeRanges(txn *lmdb.Txn) error {
 	cursor, err := txn.OpenCursor(b.indexId)
 	if err != nil {
@@ -168,184 +150,3 @@ func (b *MultiMmapManager) mergeNewFreeRange(newFreeRange position) {
 		}
 	}
 }
-
-func (b *MultiMmapManager) Defragment(n int) error {
-	for range min(n, len(b.freeRangesAll)-1) {
-		if err := b.DefragmentOne(); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Defragment a single free range
-func (b *MultiMmapManager) DefragmentOne() error {
-	if b.ReadOnly {
-		return ReadOnly
-	}
-
-	b.writeMutex.Lock()
-	defer b.writeMutex.Unlock()
-
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	if len(b.freeRangesAll) < 2 {
-		return nil
-	}
-
-	mmmtxn, err := b.lmdbEnv.BeginTxn(nil, 0)
-	if err != nil {
-		return fmt.Errorf("failed to begin mmm transaction: %w", err)
-	}
-	defer mmmtxn.Abort()
-
-	type layerTxn struct {
-		il  *IndexingLayer
-		txn *lmdb.Txn
-	}
-	layerTxns := make(map[uint16]*layerTxn)
-	defer func() {
-		for _, lt := range layerTxns {
-			lt.txn.Abort()
-		}
-	}()
-
-	// will put stuff into the first free range
-	fr := b.freeRangesAll[0]
-
-	// where the free range ends, the events start (any number of them)
-	eventsStart := fr.start + uint64(fr.size)
-	eventsEnd := b.freeRangesAll[1].start // and they end when the next free range starts
-
-	fmt.Println("# defrag", fr, eventsStart, eventsEnd)
-
-	c := uint64(0) // this tracks our relative position inside the events section
-	for (eventsStart + c) < eventsEnd {
-		var evt nostr.Event
-		if err := betterbinary.Unmarshal(b.mmapf[(eventsStart+c):eventsEnd], &evt); err != nil {
-			id := betterbinary.GetID(b.mmapf[(eventsStart + c):eventsEnd])
-			return fmt.Errorf("failed to read event (%x) from mmap: %w", id[:], err)
-		}
-
-		// now that we have an event we'll update its pos on the id index and on every layer:
-		oldVal, err := mmmtxn.Get(b.indexId, evt.ID[0:8])
-		if err != nil {
-			return fmt.Errorf("failed to read val (%x) from index: %w", evt.ID[:], err)
-		}
-
-		// current position
-		pos := positionFromBytes(oldVal[0:12])
-
-		// new position (from the beginning of the free range before + relative position)
-		fmt.Println("  moving event", evt.ID, "from", pos)
-		pos.start = fr.start + uint64(c)
-
-		// update this cursor
-		c += uint64(pos.size)
-		fmt.Println("  to", pos, "...", c, "layers:", oldVal[12:])
-
-		// prepare and save id index
-		newVal := make([]byte, len(oldVal))
-		writeBytesFromPosition(newVal, pos)
-		copy(newVal[12:], oldVal[12:])
-		if err := mmmtxn.Put(b.indexId, evt.ID[0:8], newVal, 0); err != nil {
-			return fmt.Errorf("failed to write new pos to id index: %w", err)
-		}
-
-		for s := 12; s < len(oldVal); s += 2 {
-			layer := binary.BigEndian.Uint16(oldVal[s : s+2])
-			lt, ok := layerTxns[layer]
-			if !ok {
-				il := b.layers.ByID(layer)
-				if il == nil {
-					fmt.Println(b.layers)
-					panic(fmt.Errorf("missing layer %d", layer))
-				}
-				txn, err := il.lmdbEnv.BeginTxn(nil, 0)
-				if err != nil {
-					return fmt.Errorf("failed to begin layer txn for layer %d: %w", il.id, err)
-				}
-				txn.RawRead = true
-				lt = &layerTxn{il: il, txn: txn}
-				layerTxns[il.id] = lt
-			}
-
-			fmt.Println("    layer", lt.il.id)
-
-			for k := range lt.il.getIndexKeysForEvent(evt) {
-				fmt.Println("      index", k.dbi, k.key)
-				if err := lt.txn.Del(k.dbi, k.key, oldVal[0:12]); err != nil {
-					return fmt.Errorf("failed to delete old index entry for %x: %w", evt.ID[:], err)
-				}
-				if err := lt.txn.Put(k.dbi, k.key, newVal[0:12], 0); err != nil {
-					return fmt.Errorf("failed to insert new index entry for %x: %w", evt.ID[:], err)
-				}
-			}
-		}
-	}
-
-	// now that we have updated all the pointers, just copy all the bytes between the two free ranges
-	copy(b.mmapf[fr.start:], b.mmapf[fr.start+uint64(fr.size):eventsEnd])
-
-	// delete this free range if it's one of the big ones
-	if fr.isLarge() {
-		for l, lfr := range b.freeRangesLarge {
-			if lfr.start == fr.start {
-				fmt.Println("  deleting large fr", l, lfr)
-				b.freeRangesLarge[l] = b.freeRangesLarge[len(b.freeRangesLarge)-1]
-				b.freeRangesLarge = b.freeRangesLarge[0 : len(b.freeRangesLarge)-1]
-				break
-			}
-		}
-	}
-
-	// now we have some space left at the end of this events section that is a free range
-	remainingSpaceStart := fr.start + c
-
-	// it must be merged with the next free range
-	updated := position{
-		start: remainingSpaceStart,
-		size:  b.freeRangesAll[1].size + uint32(eventsEnd) - uint32(remainingSpaceStart),
-	}
-	nextWasLarge := b.freeRangesAll[1].isLarge()
-	fmt.Println("  updating next", updated)
-	b.freeRangesAll[1] = updated
-
-	if nextWasLarge {
-		for l, lfr := range b.freeRangesLarge {
-			if lfr.start == eventsEnd {
-				fmt.Println("it is large:", l, lfr, "(now", updated, ")")
-				b.freeRangesLarge[l] = updated
-				break
-			}
-		}
-	} else if updated.isLarge() {
-		// if it wasn't large but now is, add it to the list of large free ranges
-		fmt.Println("  a new large fr was created", updated)
-		b.freeRangesLarge = append(b.freeRangesLarge, updated)
-	}
-
-	// msync
-	_, _, errno := syscall.Syscall(syscall.SYS_MSYNC,
-		uintptr(unsafe.Pointer(&b.mmapf[0])), uintptr(len(b.mmapf)), syscall.MS_SYNC)
-	if errno != 0 {
-		return fmt.Errorf("msync failed: %w", syscall.Errno(errno))
-	}
-
-	// commit transactions
-	if err := mmmtxn.Commit(); err != nil {
-		return fmt.Errorf("failed to commit mmm transaction: %w", err)
-	}
-	for lid, lt := range layerTxns {
-		if err := lt.txn.Commit(); err != nil {
-			return fmt.Errorf("failed to commit layer %d transaction: %w", lid, err)
-		}
-	}
-
-	// delete the first free range
-	b.freeRangesAll = slices.Delete(b.freeRangesAll, 0, 1)
-
-	return nil
-}

eventstore/mmm/freeranges_test.go

@@ -1,11 +1,8 @@
 package mmm
 
 import (
-	"cmp"
-	"fmt"
 	"math/rand/v2"
 	"os"
-	"slices"
 	"strings"
 	"testing"
 
@@ -128,100 +125,6 @@ func FuzzFreeRanges(f *testing.F) {
 	})
 }
 
-func TestDefragment(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "mmm-defrag-test-*")
-	require.NoError(t, err)
-	defer os.RemoveAll(tmpDir)
-
-	mmmm := &MultiMmapManager{Dir: tmpDir}
-	err = mmmm.Init()
-	require.NoError(t, err)
-	defer mmmm.Close()
-
-	il, err := mmmm.EnsureLayer("a")
-	require.NoError(t, err)
-	defer il.Close()
-
-	sk := nostr.MustSecretKeyFromHex("945e01e37662430162121b804d3645a86d97df9d256917d86735d0eb219393eb")
-
-	const nevents = 30
-	var stored [nevents]nostr.Event
-	for i := range nevents {
-		evt := nostr.Event{
-			CreatedAt: nostr.Timestamp(i),
-			Kind:      nostr.KindTextNote,
-			Tags:      nostr.Tags{},
-			Content:   fmt.Sprintf("============= event %d ============= "+strings.Repeat("+", 23), i),
-		}
-		evt.Sign(sk)
-		err := il.SaveEvent(evt)
-		require.NoError(t, err)
-		stored[i] = evt
-	}
-
-	toDelete := []int{0, 5, 10, 15, 20}
-	var remaining []nostr.Event
-	for i, evt := range stored {
-		if slices.Contains(toDelete, i) {
-			err := il.DeleteEvent(evt.ID)
-			require.NoError(t, err)
-		} else {
-			remaining = append(remaining, evt)
-		}
-	}
-
-	require.Len(t, toDelete, len(mmmm.freeRangesAll))
-
-	err = mmmm.Defragment(2)
-	require.NoError(t, err)
-
-	require.Len(t, mmmm.freeRangesAll, 3)
-	require.Len(t, remaining, nevents-len(toDelete))
-
-	// all remaining events still accessible with correct content via GetByID
-	for _, evt := range remaining {
-		gotEvt, layers := mmmm.GetByID(evt.ID)
-		require.NotNil(t, gotEvt, "event %s should exist after defrag", evt.ID)
-		require.NotEmpty(t, layers, "event %s should have layers after defrag", evt.ID)
-		require.Equal(t, evt.Content, gotEvt.Content, "event %s content should match after defrag", evt.ID)
-
-		// also accessible via a query
-		require.Equal(t, il, layers[0])
-	}
-
-	evts := slices.Collect(il.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{nostr.KindTextNote}}, 100))
-	require.Len(t, evts, nevents-len(toDelete))
-
-	// free range invariants hold after defrag
-	verifyFreeRangesInvariants(t, mmmm)
-
-	// no overlapping positions after defrag
-	mmmm.lmdbEnv.View(func(txn *lmdb.Txn) error {
-		cursor, err := txn.OpenCursor(mmmm.indexId)
-		require.NoError(t, err)
-		defer cursor.Close()
-
-		var allPositions []position
-		for _, val, err := cursor.Get(nil, nil, lmdb.First); err == nil; _, val, err = cursor.Get(nil, val, lmdb.Next) {
-			pos := positionFromBytes(val[0:12])
-			allPositions = append(allPositions, pos)
-		}
-
-		slices.SortFunc(allPositions, func(a, b position) int {
-			return cmp.Compare(a.start, b.start)
-		})
-
-		var lastEnd uint64
-		for _, pos := range allPositions {
-			if pos.start < lastEnd {
-				t.Fatalf("event overlap after defrag: %d < %d", pos.start, lastEnd)
-			}
-			lastEnd = pos.start + uint64(pos.size)
-		}
-		return nil
-	})
-}
-
 func countUsableFreeRanges(t *testing.T, mmmm *MultiMmapManager) (count int, space int) {
 	for _, fr := range mmmm.freeRangesAll {
 		if fr.size >= LARGE_FREERANGE {
@@ -239,13 +142,7 @@ func verifyFreeRangesInvariants(t *testing.T, mmmm *MultiMmapManager) {
 	all := mmmm.freeRangesAll
 	large := mmmm.freeRangesLarge
 
-	require.True(t, slices.IsSortedFunc(all, func(a, b position) int {
-		return cmp.Compare(a.start, b.start)
-	}), "free ranges aren't sorted by start position")
-
 	for _, l := range large {
-		require.True(t, l.isLarge())
-
 		found := false
 		for _, a := range all {
 			if l.start == a.start && l.size == a.size {
@@ -260,7 +157,7 @@ func verifyFreeRangesInvariants(t *testing.T, mmmm *MultiMmapManager) {
 		require.Greater(t, all[i].start, all[i-1].start, "all ranges should be sorted by start")
 	}
 
-	for i, fr := range all {
+	for i := range all {
 		for j := i + 1; j < len(all); j++ {
 			end1 := all[i].start + uint64(all[i].size)
 			end2 := all[j].start + uint64(all[j].size)
@@ -268,17 +165,6 @@ func verifyFreeRangesInvariants(t *testing.T, mmmm *MultiMmapManager) {
 				(all[j].start >= all[i].start && all[j].start < end1),
 				"ranges %v and %v overlap", all[i], all[j])
 		}
-
-		foundInLarge := false
-		for _, l := range large {
-			if l.start == fr.start {
-				foundInLarge = true
-				break
-			}
-		}
-		if !foundInLarge {
-			require.False(t, fr.isLarge())
-		}
 	}
 
 	mmmm.lmdbEnv.View(func(txn *lmdb.Txn) error {
@@ -290,191 +176,3 @@ func verifyFreeRangesInvariants(t *testing.T, mmmm *MultiMmapManager) {
 		return nil
 	})
 }
-
-func FuzzDefragment(f *testing.F) {
-	f.Add(0)
-	f.Fuzz(func(t *testing.T, seed int) {
-		tmpDir, err := os.MkdirTemp("", "mmm-defrag-fuzz-*")
-		require.NoError(t, err)
-		defer os.RemoveAll(tmpDir)
-
-		logger := zerolog.Nop()
-		rnd := rand.New(rand.NewPCG(uint64(seed), 0))
-
-		mmmm := &MultiMmapManager{
-			Dir:    tmpDir,
-			Logger: &logger,
-		}
-		err = mmmm.Init()
-		require.NoError(t, err)
-		defer mmmm.Close()
-
-		layerNames := []string{"a", "b", "c"}
-		var layers []*IndexingLayer
-		for _, name := range layerNames {
-			il, err := mmmm.EnsureLayer(name)
-			require.NoError(t, err)
-			defer il.Close()
-			layers = append(layers, il)
-		}
-
-		type indexedEvent struct {
-			evt nostr.Event
-			tag string
-		}
-		layerEvents := make([][]indexedEvent, len(layers))
-
-		sk := nostr.MustSecretKeyFromHex("945e01e37662430162121b804d3645a86d97df9d256917d86735d0eb219393eb")
-		pk := sk.Public()
-
-		totalEvents := rnd.IntN(500)
-		tChoices := []string{"foo", "bar", "banana"}
-		var written int
-
-		for written < totalEvents {
-			n := rnd.IntN(50) + 1
-			if n > totalEvents-written {
-				n = totalEvents - written
-			}
-
-			for i := 0; i < n; i++ {
-				sizeParam := rnd.IntN(2000)
-				content := strings.Repeat("z", sizeParam)
-
-				chosenTag := tChoices[rnd.IntN(3)]
-				evt := nostr.Event{
-					CreatedAt: nostr.Timestamp(rnd.Uint32()),
-					Kind:      nostr.KindTextNote,
-					Content:   content,
-					Tags:      nostr.Tags{{"t", chosenTag}},
-				}
-				evt.Sign(sk)
-
-				nLayers := rnd.IntN(len(layers)) + 1
-				perm := rnd.Perm(len(layers))
-				for pi := 0; pi < nLayers; pi++ {
-					li := perm[pi]
-					err := layers[li].SaveEvent(evt)
-					require.NoError(t, err)
-					layerEvents[li] = append(layerEvents[li], indexedEvent{evt, chosenTag})
-				}
-				written++
-			}
-
-			if n > 0 {
-				totalRemaining := 0
-				for _, levts := range layerEvents {
-					totalRemaining += len(levts)
-				}
-				if totalRemaining > 0 {
-					m := rnd.IntN(n)
-					if m > totalRemaining {
-						m = totalRemaining
-					}
-					for i := 0; i < m; i++ {
-						var nonEmpty []int
-						for li, levts := range layerEvents {
-							if len(levts) > 0 {
-								nonEmpty = append(nonEmpty, li)
-							}
-						}
-						if len(nonEmpty) == 0 {
-							break
-						}
-						li := nonEmpty[rnd.IntN(len(nonEmpty))]
-						idx := rnd.IntN(len(layerEvents[li]))
-						evtInfo := layerEvents[li][idx]
-						err := layers[li].DeleteEvent(evtInfo.evt.ID)
-						require.NoError(t, err)
-						layerEvents[li] = append(layerEvents[li][:idx], layerEvents[li][idx+1:]...)
-					}
-				}
-			}
-
-			if n > 0 {
-				o := rnd.IntN(n)
-				for i := 0; i < o; i++ {
-					if len(mmmm.freeRangesAll) > 1 {
-						param := rnd.IntN(len(mmmm.freeRangesAll))
-						err := mmmm.Defragment(param)
-						require.NoError(t, err)
-					}
-
-					verifyFreeRangesInvariants(t, mmmm)
-				}
-			}
-		}
-
-		// query each layer
-		for li, il := range layers {
-			levts := layerEvents[li]
-
-			// query by author
-			evts := slices.Collect(il.QueryEvents(nostr.Filter{Authors: []nostr.PubKey{pk}}, 10000))
-			require.Equal(t, len(levts), len(evts))
-
-			// query by author and kind
-			evts = slices.Collect(il.QueryEvents(nostr.Filter{Authors: []nostr.PubKey{pk}, Kinds: []nostr.Kind{nostr.KindTextNote}}, 10000))
-			require.Equal(t, len(levts), len(evts))
-
-			// query by "t" tag
-			for _, tagVal := range tChoices {
-				expected := 0
-				for _, ie := range levts {
-					if ie.tag == tagVal {
-						expected++
-					}
-				}
-				evts = slices.Collect(il.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"t": []string{tagVal}}}, 10000))
-				require.Equal(t, expected, len(evts))
-			}
-
-			// query with no parameters
-			allEvts := slices.Collect(il.QueryEvents(nostr.Filter{}, 10000))
-			require.Equal(t, len(levts), len(allEvts))
-		}
-
-		// build union of all events across all layers
-		allEventSet := make(map[string]nostr.Event)
-		for _, levts := range layerEvents {
-			for _, ie := range levts {
-				allEventSet[ie.evt.ID.String()] = ie.evt
-			}
-		}
-
-		// all events still accessible via GetByID
-		for _, evt := range allEventSet {
-			gotEvt, eventLayers := mmmm.GetByID(evt.ID)
-			require.NotNil(t, gotEvt)
-			require.NotEmpty(t, eventLayers)
-			require.Equal(t, evt.Content, gotEvt.Content)
-		}
-
-		verifyFreeRangesInvariants(t, mmmm)
-
-		mmmm.lmdbEnv.View(func(txn *lmdb.Txn) error {
-			cursor, err := txn.OpenCursor(mmmm.indexId)
-			require.NoError(t, err)
-			defer cursor.Close()
-
-			var allPositions []position
-			for _, val, err := cursor.Get(nil, nil, lmdb.First); err == nil; _, val, err = cursor.Get(nil, val, lmdb.Next) {
-				pos := positionFromBytes(val[0:12])
-				allPositions = append(allPositions, pos)
-			}
-
-			slices.SortFunc(allPositions, func(a, b position) int {
-				return cmp.Compare(a.start, b.start)
-			})
-
-			var lastEnd uint64
-			for _, pos := range allPositions {
-				if pos.start < lastEnd {
-					t.Fatalf("event overlap after defrag: %d < %d", pos.start, lastEnd)
-				}
-				lastEnd = pos.start + uint64(pos.size)
-			}
-			return nil
-		})
-	})
-}

eventstore/mmm/fuzz_test.go

@@ -142,11 +142,6 @@ func FuzzTest(f *testing.F) {
 			mmmm.Rescan()
 		}
 
-		// perform random defrags -- shouldn't break the database
-		if rnd.UintN(3) == 1 {
-			mmmm.Defragment(len(deleted) / 3)
-		}
-
 		for id, deletedlayers := range deleted {
 			evt, foundlayers := mmmm.GetByID(id)
 

eventstore/mmm/mmmm.go

@@ -341,7 +341,6 @@ func (b *MultiMmapManager) removeAllReferencesFromLayer(txn *lmdb.Txn, layerId u
 	return nil
 }
 
-//go:inline
 func (b *MultiMmapManager) loadEvent(pos position, eventReceiver *nostr.Event) error {
 	return betterbinary.Unmarshal(b.mmapf[pos.start:pos.start+uint64(pos.size)], eventReceiver)
 }

eventstore/mmm/position.go

@@ -17,6 +17,11 @@ func (poss positions) find(start uint64) (idx int) {
 	return idx
 }
 
+func (poss positions) del(start uint64) positions {
+	idx := poss.find(start)
+	return slices.Delete(poss, idx, idx+1)
+}
+
 func (poss positions) String() string {
 	str := strings.Builder{}
 	str.Grow(10 + 20*len(poss))
@@ -41,7 +46,6 @@ func (pos position) isLarge() bool {
 	return pos.size >= LARGE_FREERANGE
 }
 
-//go:inline
 func positionFromBytes(posb []byte) position {
 	return position{
 		size:  binary.BigEndian.Uint32(posb[0:4]),
@@ -49,7 +53,6 @@ func positionFromBytes(posb []byte) position {
 	}
 }
 
-//go:inline
 func writeBytesFromPosition(out []byte, pos position) {
 	binary.BigEndian.PutUint32(out[0:4], pos.size)
 	binary.BigEndian.PutUint64(out[4:12], pos.start)

eventstore/mmm/save.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"runtime"
-	"slices"
 	"syscall"
 	"unsafe"
 
@@ -120,8 +119,7 @@ func (b *MultiMmapManager) storeOn(
 					b.freeRangesLarge = b.freeRangesLarge[0 : len(b.freeRangesLarge)-1]
 
 					// also delete it from b.freeRangesAll
-					idx := b.freeRangesAll.find(fr.start)
+					b.freeRangesAll = b.freeRangesAll.del(fr.start)
-					b.freeRangesAll = slices.Delete(b.freeRangesAll, idx, idx+1)
 				} else {
 					// otherwise modify it in place
 					newFreeRange := position{
@@ -157,7 +155,7 @@ func (b *MultiMmapManager) storeOn(
 		}
 
 		// write to the mmap
-		if err := betterbinary.Marshal(evt, b.mmapf[pos.start:pos.start+uint64(pos.size)]); err != nil {
+		if err := betterbinary.Marshal(evt, b.mmapf[pos.start:]); err != nil {
 			return false, fmt.Errorf("error marshaling to %d: %w", pos.start, err)
 		}
 

eventstore/mmm/testdata/fuzz/FuzzDefragment/2ce076b09281c580

@@ -1,2 +0,0 @@
-go test fuzz v1
-int(-360)

eventstore/mmm/testdata/fuzz/FuzzDefragment/d5845b29b7a801f7

@@ -1,2 +0,0 @@
-go test fuzz v1
-int(-17)

eventstore/mmm/testdata/fuzz/FuzzTest/ffd0b6bc2949a534

@@ -1,5 +0,0 @@
-go test fuzz v1
-int(46)
-uint(84)
-uint(55)
-uint(5)

khatru/blossom/blob.go

@@ -13,9 +13,6 @@ type BlobIndex interface {
 	List(ctx context.Context, pubkey nostr.PubKey) iter.Seq[blossom.BlobDescriptor]
 	Get(ctx context.Context, sha256 string) (*blossom.BlobDescriptor, error)
 	Delete(ctx context.Context, sha256 string, pubkey nostr.PubKey) error
-
-	ListAllBlobs(ctx context.Context) iter.Seq2[nostr.PubKey, blossom.BlobDescriptor]
-	OwnersForBlob(ctx context.Context, sha256 string) []nostr.PubKey
 }
 
 var (

khatru/blossom/eventstorewrapper.go

@@ -59,30 +59,6 @@ func (es EventStoreBlobIndexWrapper) List(ctx context.Context, pubkey nostr.PubK
 	}
 }
 
-func (es EventStoreBlobIndexWrapper) ListAllBlobs(ctx context.Context) iter.Seq2[nostr.PubKey, blossom.BlobDescriptor] {
-	return func(yield func(nostr.PubKey, blossom.BlobDescriptor) bool) {
-		for evt := range es.Store.QueryEvents(nostr.Filter{
-			Kinds: []nostr.Kind{24242},
-		}, 1000) {
-			bd := es.parseEvent(evt)
-			if !yield(evt.PubKey, bd) {
-				return
-			}
-		}
-	}
-}
-
-func (es EventStoreBlobIndexWrapper) OwnersForBlob(ctx context.Context, sha256 string) []nostr.PubKey {
-	var owners []nostr.PubKey
-	for evt := range es.Store.QueryEvents(nostr.Filter{
-		Tags:  nostr.TagMap{"x": []string{sha256}},
-		Kinds: []nostr.Kind{24242},
-	}, 1000) {
-		owners = append(owners, evt.PubKey)
-	}
-	return owners
-}
-
 func (es EventStoreBlobIndexWrapper) Get(ctx context.Context, sha256 string) (*blossom.BlobDescriptor, error) {
 	next, stop := iter.Pull(
 		es.Store.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"x": []string{sha256}}, Kinds: []nostr.Kind{24242}, Limit: 1}, 1),

khatru/blossom/handlers.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"mime"
 	"net/http"
 	"regexp"
 	"strconv"
@@ -128,7 +129,7 @@ func (bs BlossomServer) handleUpload(w http.ResponseWriter, r *http.Request) {
 
 	hash := sha256.Sum256(b)
 	hhash := nostr.HexEncodeToString(hash[:])
-	mimeType := blossom.GetMIMEType(ext)
+	mimeType := mime.TypeByExtension(ext)
 	if mimeType == "" {
 		mimeType = "application/octet-stream"
 	}

khatru/blossom/memoryindex.go

@@ -59,25 +59,6 @@ func (x MemoryBlobIndex) List(ctx context.Context, pubkey nostr.PubKey) iter.Seq
 	}
 }
 
-func (x MemoryBlobIndex) ListAllBlobs(ctx context.Context) iter.Seq2[nostr.PubKey, blossom.BlobDescriptor] {
-	return func(yield func(nostr.PubKey, blossom.BlobDescriptor) bool) {
-		for _, v := range x.m.Range {
-			for _, owner := range v.owners {
-				if !yield(owner, v.blob) {
-					return
-				}
-			}
-		}
-	}
-}
-
-func (x MemoryBlobIndex) OwnersForBlob(ctx context.Context, sha256 string) []nostr.PubKey {
-	if val, ok := x.m.Load(sha256); ok {
-		return val.owners
-	}
-	return nil
-}
-
 func (x MemoryBlobIndex) Get(ctx context.Context, sha256 string) (*blossom.BlobDescriptor, error) {
 	if val, ok := x.m.Load(sha256); ok {
 		return &val.blob, nil

khatru/deleting.go

@@ -65,7 +65,7 @@ func (rl *Relay) handleDeleteRequest(ctx context.Context, evt nostr.Event) error
 			errg, ctx := errgroup.WithContext(ctx)
 			for target := range rl.QueryStored(ctx, f) {
 				// got the event, now check if the user can delete it
-				if rl.AllowDeleting == nil && target.PubKey == evt.PubKey || rl.AllowDeleting != nil && rl.AllowDeleting(ctx, target, evt) {
+				if target.PubKey == evt.PubKey {
 					// delete it
 					errg.Go(func() error {
 						if err := rl.DeleteEvent(ctx, target.ID); err != nil {

khatru/handlers.go

@@ -227,9 +227,6 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 						if writeErr == nil {
 							// this always returns "blocked: " whenever it returns an error
 							writeErr = rl.handleDeleteRequest(ctx, env.Event)
-							if writeErr == ErrNothingToDelete {
-								writeErr = nil
-							}
 						}
 					} else if env.Event.Kind.IsEphemeral() {
 						// this will also always return a prefixed reason
@@ -295,6 +292,9 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 				case *nostr.ReqEnvelope:
 					rl.removeListenerId(ws, env.SubscriptionID)
 
+					eose := sync.WaitGroup{}
+					eose.Add(len(env.Filters))
+
 					// a context just for the "stored events" request handler
 					reqCtx, cancelReqCtx := context.WithCancelCause(ctx)
 
@@ -303,7 +303,7 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 
 					// handle each filter separately -- dispatching events as they're loaded from databases
 					for _, filter := range env.Filters {
-						err := rl.handleRequest(reqCtx, env.SubscriptionID, ws, filter)
+						err := rl.handleRequest(reqCtx, env.SubscriptionID, &eose, ws, filter)
 						if err != nil {
 							// fail everything if any filter is rejected
 							reason := err.Error()
@@ -321,7 +321,11 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 						}
 					}
 
-					ws.WriteJSON(nostr.EOSEEnvelope(env.SubscriptionID))
+					go func() {
+						// when all events have been loaded from databases and dispatched we can fire the EOSE message
+						eose.Wait()
+						ws.WriteJSON(nostr.EOSEEnvelope(env.SubscriptionID))
+					}()
 				case *nostr.CloseEnvelope:
 					id := string(*env)
 					rl.removeListenerId(ws, id)
@@ -346,9 +350,6 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 						}
 						ws.authLock.Unlock()
 						ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: true})
-						if rl.OnAuth != nil {
-							rl.OnAuth(ctx, pubkey)
-						}
 					} else {
 						ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: false, Reason: "error: failed to authenticate: " + err.Error()})
 					}

khatru/nip86.go

@@ -43,12 +43,6 @@ type RelayManagementAPI struct {
 	Stats                       func(ctx context.Context) (nip86.Response, error)
 	GrantAdmin                  func(ctx context.Context, pubkey nostr.PubKey, methods []string) error
 	RevokeAdmin                 func(ctx context.Context, pubkey nostr.PubKey, methods []string) error
-	CreateRole                  func(ctx context.Context, id string, label string, description string, color int, order int) error
-	EditRole                    func(ctx context.Context, id string, label string, description string, color int, order int) error
-	DeleteRole                  func(ctx context.Context, id string) error
-	AssignRole                  func(ctx context.Context, pubkey nostr.PubKey, roleID string) error
-	UnassignRole                func(ctx context.Context, pubkey nostr.PubKey, roleID string) error
-	SignEvent                   func(ctx context.Context, kind nostr.Kind, createdAt nostr.Timestamp, tags nostr.Tags, content string) (nostr.Event, error)
 	Generic                     func(ctx context.Context, request nip86.Request) (nip86.Response, error)
 }
 
@@ -336,54 +330,6 @@ func (rl *Relay) HandleNIP86(w http.ResponseWriter, r *http.Request) {
 			} else {
 				resp.Result = true
 			}
-		case nip86.CreateRole:
-			if rl.ManagementAPI.CreateRole == nil {
-				resp.Error = fmt.Sprintf("method %s not supported", thing.MethodName())
-			} else if err := rl.ManagementAPI.CreateRole(ctx, thing.ID, thing.Label, thing.Description, thing.Color, thing.Order); err != nil {
-				resp.Error = err.Error()
-			} else {
-				resp.Result = true
-			}
-		case nip86.EditRole:
-			if rl.ManagementAPI.EditRole == nil {
-				resp.Error = fmt.Sprintf("method %s not supported", thing.MethodName())
-			} else if err := rl.ManagementAPI.EditRole(ctx, thing.ID, thing.Label, thing.Description, thing.Color, thing.Order); err != nil {
-				resp.Error = err.Error()
-			} else {
-				resp.Result = true
-			}
-		case nip86.DeleteRole:
-			if rl.ManagementAPI.DeleteRole == nil {
-				resp.Error = fmt.Sprintf("method %s not supported", thing.MethodName())
-			} else if err := rl.ManagementAPI.DeleteRole(ctx, thing.ID); err != nil {
-				resp.Error = err.Error()
-			} else {
-				resp.Result = true
-			}
-		case nip86.AssignRole:
-			if rl.ManagementAPI.AssignRole == nil {
-				resp.Error = fmt.Sprintf("method %s not supported", thing.MethodName())
-			} else if err := rl.ManagementAPI.AssignRole(ctx, thing.PubKey, thing.RoleID); err != nil {
-				resp.Error = err.Error()
-			} else {
-				resp.Result = true
-			}
-		case nip86.UnassignRole:
-			if rl.ManagementAPI.UnassignRole == nil {
-				resp.Error = fmt.Sprintf("method %s not supported", thing.MethodName())
-			} else if err := rl.ManagementAPI.UnassignRole(ctx, thing.PubKey, thing.RoleID); err != nil {
-				resp.Error = err.Error()
-			} else {
-				resp.Result = true
-			}
-		case nip86.SignEvent:
-			if rl.ManagementAPI.SignEvent == nil {
-				resp.Error = fmt.Sprintf("method %s not supported", thing.MethodName())
-			} else if result, err := rl.ManagementAPI.SignEvent(ctx, thing.Kind, thing.CreatedAt, thing.Tags, thing.Content); err != nil {
-				resp.Error = err.Error()
-			} else {
-				resp.Result = result
-			}
 		case nip86.ListDisallowedKinds:
 			if rl.ManagementAPI.ListDisallowedKinds == nil {
 				resp.Error = fmt.Sprintf("method %s not supported", thing.MethodName())

khatru/relay.go

@@ -75,7 +75,6 @@ type Relay struct {
 	DeleteEvent               func(ctx context.Context, id nostr.ID) error
 	OnEventSaved              func(ctx context.Context, event nostr.Event)
 	OnEventDeleted            func(ctx context.Context, deleted nostr.Event)
-	AllowDeleting             func(ctx context.Context, target, deletion nostr.Event) bool
 	OnEphemeralEvent          func(ctx context.Context, event nostr.Event)
 	OnRequest                 func(ctx context.Context, filter nostr.Filter) (reject bool, msg string)
 	OnCount                   func(ctx context.Context, filter nostr.Filter) (reject bool, msg string)
@@ -85,7 +84,6 @@ type Relay struct {
 	RejectConnection          func(r *http.Request) bool
 	OnConnect                 func(ctx context.Context)
 	OnDisconnect              func(ctx context.Context)
-	OnAuth                    func(ctx context.Context, pubkey nostr.PubKey)
 	OnListenerAdded           func(ws *WebSocket, ssid int, id string, filter nostr.Filter)
 	OnListenerRemoved         func(ws *WebSocket, ssid int, id string, filter nostr.Filter)
 	OverwriteRelayInformation func(ctx context.Context, r *http.Request, info nip11.RelayInformationDocument) nip11.RelayInformationDocument

khatru/responding.go

@@ -3,12 +3,15 @@ package khatru
 import (
 	"context"
 	"errors"
+	"sync"
 
 	"fiatjaf.com/nostr"
 	"fiatjaf.com/nostr/nip45/hyperloglog"
 )
 
-func (rl *Relay) handleRequest(ctx context.Context, id string, ws *WebSocket, filter nostr.Filter) error {
+func (rl *Relay) handleRequest(ctx context.Context, id string, eose *sync.WaitGroup, ws *WebSocket, filter nostr.Filter) error {
+	defer eose.Done()
+
 	// then check if we'll reject this filter (we apply this after overwriting
 	// because we may, for example, remove some things from the incoming filters
 	// that we know we don't support, and then if the end result is an empty

kinds.go

@@ -38,20 +38,10 @@ func (kind Kind) Name() string {
 		return "Seal"
 	case KindDirectMessage:
 		return "DirectMessage"
-	case KindFileMessage:
-		return "FileMessage"
 	case KindGenericRepost:
 		return "GenericRepost"
 	case KindReactionToWebsite:
 		return "ReactionToWebsite"
-	case KindPhoto:
-		return "Photo"
-	case KindNormalVideoEvent:
-		return "NormalVideoEvent"
-	case KindShortVideoEvent:
-		return "ShortVideoEvent"
-	case KindPublicMessage:
-		return "PublicMessage"
 	case KindChannelCreation:
 		return "ChannelCreation"
 	case KindChannelMetadata:
@@ -62,14 +52,12 @@ func (kind Kind) Name() string {
 		return "ChannelHideMessage"
 	case KindChannelMuteUser:
 		return "ChannelMuteUser"
-	case KindPodcastEpisode:
-		return "PodcastEpisode"
 	case KindChess:
 		return "Chess"
 	case KindMergeRequests:
 		return "MergeRequests"
-	case KindPollResponse:
+	case KindComment:
-		return "PollResponse"
+		return "Comment"
 	case KindBid:
 		return "Bid"
 	case KindBidConfirmation:
@@ -80,26 +68,10 @@ func (kind Kind) Name() string {
 		return "GiftWrap"
 	case KindFileMetadata:
 		return "FileMetadata"
-	case KindPoll:
-		return "Poll"
-	case KindComment:
-		return "Comment"
-	case KindVoiceMessage:
-		return "VoiceMessage"
-	case KindScroll:
-		return "Scroll"
-	case KindVoiceMessageComment:
-		return "VoiceMessageComment"
 	case KindLiveChatMessage:
 		return "LiveChatMessage"
-	case KindCodeSnippet:
-		return "CodeSnippet"
 	case KindPatch:
 		return "Patch"
-	case KindGitPullRequest:
-		return "GitPullRequest"
-	case KindGitPullRequestUpdate:
-		return "GitPullRequestUpdate"
 	case KindIssue:
 		return "Issue"
 	case KindReply:
@@ -128,24 +100,10 @@ func (kind Kind) Name() string {
 		return "TorrentComment"
 	case KindCoinjoinPool:
 		return "CoinjoinPool"
-	case KindDecoupledKeyClientAnnouncement:
-		return "DecoupledKeyClientAnnouncement"
-	case KindDecoupledEncryptionKeyDistribution:
-		return "DecoupledEncryptionKeyDistribution"
 	case KindCommunityPostApproval:
 		return "CommunityPostApproval"
 	case KindJobFeedback:
 		return "JobFeedback"
-	case KindReservedCashuWalletTokens:
-		return "ReservedCashuWalletTokens"
-	case KindCashuWalletTokens:
-		return "CashuWalletTokens"
-	case KindCashuWalletHistory:
-		return "CashuWalletHistory"
-	case KindGeocacheLog:
-		return "GeocacheLog"
-	case KindGeocacheProofOfFind:
-		return "GeocacheProofOfFind"
 	case KindSimpleGroupPutUser:
 		return "SimpleGroupPutUser"
 	case KindSimpleGroupRemoveUser:
@@ -194,24 +152,14 @@ func (kind Kind) Name() string {
 		return "SearchRelayList"
 	case KindSimpleGroupList:
 		return "SimpleGroupList"
-	case KindFavoriteRelaysList:
-		return "FavoriteRelaysList"
-	case KindPrivateEventRelayList:
-		return "PrivateEventRelayList"
 	case KindInterestList:
 		return "InterestList"
 	case KindNutZapInfo:
 		return "NutZapInfo"
-	case KindMediaFollows:
-		return "MediaFollows"
 	case KindEmojiList:
 		return "EmojiList"
-	case KindDecoupledKeyAnnouncement:
-		return "DecoupledKeyAnnouncement"
 	case KindDMRelayList:
 		return "DMRelayList"
-	case KindFavoritePodcasts:
-		return "FavoritePodcasts"
 	case KindUserServerList:
 		return "UserServerList"
 	case KindFileStorageServerList:
@@ -220,26 +168,8 @@ func (kind Kind) Name() string {
 		return "GoodWikiAuthorList"
 	case KindGoodWikiRelayList:
 		return "GoodWikiRelayList"
-	case KindPodcastMetadata:
-		return "PodcastMetadata"
-	case KindAuthoredPodcasts:
-		return "AuthoredPodcasts"
-	case KindRelayMonitorAnnouncement:
-		return "RelayMonitorAnnouncement"
-	case KindRoomPresence:
-		return "RoomPresence"
-	case KindUserGraspList:
-		return "UserGraspList"
-	case KindProxyAnnouncement:
-		return "ProxyAnnouncement"
-	case KindTransportMethodAnnouncement:
-		return "TransportMethodAnnouncement"
 	case KindNWCWalletInfo:
 		return "NWCWalletInfo"
-	case KindNsiteRoot:
-		return "NsiteRoot"
-	case KindCashuWalletEvent:
-		return "CashuWalletEvent"
 	case KindLightningPubRPC:
 		return "LightningPubRPC"
 	case KindClientAuthentication:
@@ -296,20 +226,10 @@ func (kind Kind) Name() string {
 		return "ReleaseArtifactSets"
 	case KindApplicationSpecificData:
 		return "ApplicationSpecificData"
-	case KindRelayDiscovery:
-		return "RelayDiscovery"
-	case KindAppCurationSet:
-		return "AppCurationSet"
 	case KindLiveEvent:
 		return "LiveEvent"
-	case KindInteractiveRoom:
-		return "InteractiveRoom"
-	case KindConferenceEvent:
-		return "ConferenceEvent"
 	case KindUserStatuses:
 		return "UserStatuses"
-	case KindSlideSet:
-		return "SlideSet"
 	case KindClassifiedListing:
 		return "ClassifiedListing"
 	case KindDraftClassifiedListing:
@@ -318,14 +238,20 @@ func (kind Kind) Name() string {
 		return "RepositoryAnnouncement"
 	case KindRepositoryState:
 		return "RepositoryState"
+	case KindSimpleGroupMetadata:
+		return "SimpleGroupMetadata"
+	case KindSimpleGroupAdmins:
+		return "SimpleGroupAdmins"
+	case KindSimpleGroupMembers:
+		return "SimpleGroupMembers"
+	case KindSimpleGroupRoles:
+		return "SimpleGroupRoles"
+	case KindSimpleGroupLiveKitParticipants:
+		return "SimpleGroupLiveKitParticipants"
 	case KindWikiArticle:
 		return "WikiArticle"
 	case KindRedirects:
 		return "Redirects"
-	case KindDraftEvent:
-		return "DraftEvent"
-	case KindLinkSet:
-		return "LinkSet"
 	case KindFeed:
 		return "Feed"
 	case KindDateCalendarEvent:
@@ -340,232 +266,158 @@ func (kind Kind) Name() string {
 		return "HandlerRecommendation"
 	case KindHandlerInformation:
 		return "HandlerInformation"
-	case KindSoftwareApplication:
+	case KindVideoEvent:
-		return "SoftwareApplication"
+		return "VideoEvent"
-	case KindLegacyNsiteFile:
+	case KindShortVideoEvent:
-		return "LegacyNsiteFile"
+		return "ShortVideoEvent"
 	case KindVideoViewEvent:
 		return "VideoViewEvent"
 	case KindCommunityDefinition:
 		return "CommunityDefinition"
+	case KindNsiteRoot:
+		return "NsiteRoot"
 	case KindNsiteNamed:
 		return "NsiteNamed"
-	case KindGeocacheListing:
-		return "GeocacheListing"
-	case KindGeocacheLogEntry:
-		return "GeocacheLogEntry"
-	case KindCashuMintAnnouncement:
-		return "CashuMintAnnouncement"
-	case KindFedimintAnnouncement:
-		return "FedimintAnnouncement"
-	case KindPeerToPeerOrderEvents:
-		return "PeerToPeerOrderEvents"
-	case KindSimpleGroupMetadata:
-		return "SimpleGroupMetadata"
-	case KindSimpleGroupAdmins:
-		return "SimpleGroupAdmins"
-	case KindSimpleGroupMembers:
-		return "SimpleGroupMembers"
-	case KindSimpleGroupRoles:
-		return "SimpleGroupRoles"
-	case KindSimpleGroupLiveKitParticipants:
-		return "SimpleGroupLiveKitParticipants"
-	case KindStarterPacks:
-		return "StarterPacks"
-	case KindMediaStarterPacks:
-		return "MediaStarterPacks"
-	case KindWebBookmarks:
-		return "WebBookmarks"
-
 	}
 	return "unknown"
 }
 
 const (
-	KindProfileMetadata                    Kind = 0
+	KindProfileMetadata                Kind = 0
-	KindTextNote                           Kind = 1
+	KindTextNote                       Kind = 1
-	KindRecommendServer                    Kind = 2
+	KindRecommendServer                Kind = 2
-	KindFollowList                         Kind = 3
+	KindFollowList                     Kind = 3
-	KindEncryptedDirectMessage             Kind = 4
+	KindEncryptedDirectMessage         Kind = 4
-	KindDeletion                           Kind = 5
+	KindDeletion                       Kind = 5
-	KindRepost                             Kind = 6
+	KindRepost                         Kind = 6
-	KindReaction                           Kind = 7
+	KindReaction                       Kind = 7
-	KindBadgeAward                         Kind = 8
+	KindBadgeAward                     Kind = 8
-	KindSimpleGroupChatMessage             Kind = 9
+	KindSimpleGroupChatMessage         Kind = 9
-	KindSimpleGroupThreadedReply           Kind = 10
+	KindSimpleGroupThreadedReply       Kind = 10
-	KindSimpleGroupThread                  Kind = 11
+	KindSimpleGroupThread              Kind = 11
-	KindSimpleGroupReply                   Kind = 12
+	KindSimpleGroupReply               Kind = 12
-	KindSeal                               Kind = 13
+	KindSeal                           Kind = 13
-	KindDirectMessage                      Kind = 14
+	KindDirectMessage                  Kind = 14
-	KindFileMessage                        Kind = 15
+	KindGenericRepost                  Kind = 16
-	KindGenericRepost                      Kind = 16
+	KindReactionToWebsite              Kind = 17
-	KindReactionToWebsite                  Kind = 17
+	KindChannelCreation                Kind = 40
-	KindPhoto                              Kind = 20
+	KindChannelMetadata                Kind = 41
-	KindNormalVideoEvent                   Kind = 21
+	KindChannelMessage                 Kind = 42
-	KindShortVideoEvent                    Kind = 22
+	KindChannelHideMessage             Kind = 43
-	KindPublicMessage                      Kind = 24
+	KindChannelMuteUser                Kind = 44
-	KindChannelCreation                    Kind = 40
+	KindChess                          Kind = 64
-	KindChannelMetadata                    Kind = 41
+	KindMergeRequests                  Kind = 818
-	KindChannelMessage                     Kind = 42
+	KindComment                        Kind = 1111
-	KindChannelHideMessage                 Kind = 43
+	KindBid                            Kind = 1021
-	KindChannelMuteUser                    Kind = 44
+	KindBidConfirmation                Kind = 1022
-	KindPodcastEpisode                     Kind = 54
+	KindOpenTimestamps                 Kind = 1040
-	KindChess                              Kind = 64
+	KindGiftWrap                       Kind = 1059
-	KindMergeRequests                      Kind = 818
+	KindFileMetadata                   Kind = 1063
-	KindPollResponse                       Kind = 1018
+	KindLiveChatMessage                Kind = 1311
-	KindBid                                Kind = 1021
+	KindPatch                          Kind = 1617
-	KindBidConfirmation                    Kind = 1022
+	KindIssue                          Kind = 1621
-	KindOpenTimestamps                     Kind = 1040
+	KindReply                          Kind = 1622
-	KindGiftWrap                           Kind = 1059
+	KindStatusOpen                     Kind = 1630
-	KindFileMetadata                       Kind = 1063
+	KindStatusApplied                  Kind = 1631
-	KindPoll                               Kind = 1068
+	KindStatusClosed                   Kind = 1632
-	KindComment                            Kind = 1111
+	KindStatusDraft                    Kind = 1633
-	KindVoiceMessage                       Kind = 1222
+	KindProblemTracker                 Kind = 1971
-	KindScroll                             Kind = 1227
+	KindReporting                      Kind = 1984
-	KindVoiceMessageComment                Kind = 1244
+	KindLabel                          Kind = 1985
-	KindLiveChatMessage                    Kind = 1311
+	KindRelayReviews                   Kind = 1986
-	KindCodeSnippet                        Kind = 1337
+	KindAIEmbeddings                   Kind = 1987
-	KindPatch                              Kind = 1617
+	KindTorrent                        Kind = 2003
-	KindGitPullRequest                     Kind = 1618
+	KindTorrentComment                 Kind = 2004
-	KindGitPullRequestUpdate               Kind = 1619
+	KindCoinjoinPool                   Kind = 2022
-	KindIssue                              Kind = 1621
+	KindCommunityPostApproval          Kind = 4550
-	KindReply                              Kind = 1622
+	KindJobFeedback                    Kind = 7000
-	KindStatusOpen                         Kind = 1630
+	KindSimpleGroupPutUser             Kind = 9000
-	KindStatusApplied                      Kind = 1631
+	KindSimpleGroupRemoveUser          Kind = 9001
-	KindStatusClosed                       Kind = 1632
+	KindSimpleGroupEditMetadata        Kind = 9002
-	KindStatusDraft                        Kind = 1633
+	KindSimpleGroupDeleteEvent         Kind = 9005
-	KindProblemTracker                     Kind = 1971
+	KindSimpleGroupCreateGroup         Kind = 9007
-	KindReporting                          Kind = 1984
+	KindSimpleGroupDeleteGroup         Kind = 9008
-	KindLabel                              Kind = 1985
+	KindSimpleGroupCreateInvite        Kind = 9009
-	KindRelayReviews                       Kind = 1986
+	KindSimpleGroupJoinRequest         Kind = 9021
-	KindAIEmbeddings                       Kind = 1987
+	KindSimpleGroupLeaveRequest        Kind = 9022
-	KindTorrent                            Kind = 2003
+	KindZapGoal                        Kind = 9041
-	KindTorrentComment                     Kind = 2004
+	KindNutZap                         Kind = 9321
-	KindCoinjoinPool                       Kind = 2022
+	KindTidalLogin                     Kind = 9467
-	KindDecoupledKeyClientAnnouncement     Kind = 4454
+	KindZapRequest                     Kind = 9734
-	KindDecoupledEncryptionKeyDistribution Kind = 4455
+	KindZap                            Kind = 9735
-	KindCommunityPostApproval              Kind = 4550
+	KindHighlights                     Kind = 9802
-	KindJobFeedback                        Kind = 7000
+	KindMuteList                       Kind = 10000
-	KindReservedCashuWalletTokens          Kind = 7374
+	KindPinList                        Kind = 10001
-	KindCashuWalletTokens                  Kind = 7375
+	KindRelayListMetadata              Kind = 10002
-	KindCashuWalletHistory                 Kind = 7376
+	KindBookmarkList                   Kind = 10003
-	KindGeocacheLog                        Kind = 7516
+	KindCommunityList                  Kind = 10004
-	KindGeocacheProofOfFind                Kind = 7517
+	KindPublicChatList                 Kind = 10005
-	KindSimpleGroupPutUser                 Kind = 9000
+	KindBlockedRelayList               Kind = 10006
-	KindSimpleGroupRemoveUser              Kind = 9001
+	KindSearchRelayList                Kind = 10007
-	KindSimpleGroupEditMetadata            Kind = 9002
+	KindSimpleGroupList                Kind = 10009
-	KindSimpleGroupDeleteEvent             Kind = 9005
+	KindInterestList                   Kind = 10015
-	KindSimpleGroupCreateGroup             Kind = 9007
+	KindNutZapInfo                     Kind = 10019
-	KindSimpleGroupDeleteGroup             Kind = 9008
+	KindEmojiList                      Kind = 10030
-	KindSimpleGroupCreateInvite            Kind = 9009
+	KindDMRelayList                    Kind = 10050
-	KindSimpleGroupJoinRequest             Kind = 9021
+	KindUserServerList                 Kind = 10063
-	KindSimpleGroupLeaveRequest            Kind = 9022
+	KindFileStorageServerList          Kind = 10096
-	KindZapGoal                            Kind = 9041
+	KindGoodWikiAuthorList             Kind = 10101
-	KindNutZap                             Kind = 9321
+	KindGoodWikiRelayList              Kind = 10102
-	KindTidalLogin                         Kind = 9467
+	KindNWCWalletInfo                  Kind = 13194
-	KindZapRequest                         Kind = 9734
+	KindNsiteRoot                      Kind = 15128
-	KindZap                                Kind = 9735
+	KindLightningPubRPC                Kind = 21000
-	KindHighlights                         Kind = 9802
+	KindClientAuthentication           Kind = 22242
-	KindMuteList                           Kind = 10000
+	KindNWCWalletRequest               Kind = 23194
-	KindPinList                            Kind = 10001
+	KindNWCWalletResponse              Kind = 23195
-	KindRelayListMetadata                  Kind = 10002
+	KindNostrConnect                   Kind = 24133
-	KindBookmarkList                       Kind = 10003
+	KindBlobs                          Kind = 24242
-	KindCommunityList                      Kind = 10004
+	KindHTTPAuth                       Kind = 27235
-	KindPublicChatList                     Kind = 10005
+	KindCategorizedPeopleList          Kind = 30000
-	KindBlockedRelayList                   Kind = 10006
+	KindCategorizedBookmarksList       Kind = 30001
-	KindSearchRelayList                    Kind = 10007
+	KindRelaySets                      Kind = 30002
-	KindSimpleGroupList                    Kind = 10009
+	KindBookmarkSets                   Kind = 30003
-	KindFavoriteRelaysList                 Kind = 10012
+	KindCuratedSets                    Kind = 30004
-	KindPrivateEventRelayList              Kind = 10013
+	KindCuratedVideoSets               Kind = 30005
-	KindInterestList                       Kind = 10015
+	KindMuteSets                       Kind = 30007
-	KindNutZapInfo                         Kind = 10019
+	KindProfileBadges                  Kind = 30008
-	KindMediaFollows                       Kind = 10020
+	KindBadgeDefinition                Kind = 30009
-	KindEmojiList                          Kind = 10030
+	KindInterestSets                   Kind = 30015
-	KindDecoupledKeyAnnouncement           Kind = 10044
+	KindStallDefinition                Kind = 30017
-	KindDMRelayList                        Kind = 10050
+	KindProductDefinition              Kind = 30018
-	KindFavoritePodcasts                   Kind = 10054
+	KindMarketplaceUI                  Kind = 30019
-	KindUserServerList                     Kind = 10063
+	KindProductSoldAsAuction           Kind = 30020
-	KindFileStorageServerList              Kind = 10096
+	KindArticle                        Kind = 30023
-	KindGoodWikiAuthorList                 Kind = 10101
+	KindDraftArticle                   Kind = 30024
-	KindGoodWikiRelayList                  Kind = 10102
+	KindEmojiSets                      Kind = 30030
-	KindPodcastMetadata                    Kind = 10154
+	KindModularArticleHeader           Kind = 30040
-	KindAuthoredPodcasts                   Kind = 10164
+	KindModularArticleContent          Kind = 30041
-	KindRelayMonitorAnnouncement           Kind = 10166
+	KindReleaseArtifactSets            Kind = 30063
-	KindRoomPresence                       Kind = 10312
+	KindApplicationSpecificData        Kind = 30078
-	KindUserGraspList                      Kind = 10317
+	KindLiveEvent                      Kind = 30311
-	KindProxyAnnouncement                  Kind = 10377
+	KindUserStatuses                   Kind = 30315
-	KindTransportMethodAnnouncement        Kind = 11111
+	KindClassifiedListing              Kind = 30402
-	KindNWCWalletInfo                      Kind = 13194
+	KindDraftClassifiedListing         Kind = 30403
-	KindNsiteRoot                          Kind = 15128
+	KindRepositoryAnnouncement         Kind = 30617
-	KindCashuWalletEvent                   Kind = 17375
+	KindRepositoryState                Kind = 30618
-	KindLightningPubRPC                    Kind = 21000
+	KindNsiteNamed                     Kind = 35128
-	KindClientAuthentication               Kind = 22242
+	KindSimpleGroupMetadata            Kind = 39000
-	KindNWCWalletRequest                   Kind = 23194
+	KindSimpleGroupAdmins              Kind = 39001
-	KindNWCWalletResponse                  Kind = 23195
+	KindSimpleGroupMembers             Kind = 39002
-	KindNostrConnect                       Kind = 24133
+	KindSimpleGroupRoles               Kind = 39003
-	KindBlobs                              Kind = 24242
+	KindSimpleGroupLiveKitParticipants Kind = 39004
-	KindHTTPAuth                           Kind = 27235
+	KindWikiArticle                    Kind = 30818
-	KindCategorizedPeopleList              Kind = 30000
+	KindRedirects                      Kind = 30819
-	KindCategorizedBookmarksList           Kind = 30001
+	KindFeed                           Kind = 31890
-	KindRelaySets                          Kind = 30002
+	KindDateCalendarEvent              Kind = 31922
-	KindBookmarkSets                       Kind = 30003
+	KindTimeCalendarEvent              Kind = 31923
-	KindCuratedSets                        Kind = 30004
+	KindCalendar                       Kind = 31924
-	KindCuratedVideoSets                   Kind = 30005
+	KindCalendarEventRSVP              Kind = 31925
-	KindMuteSets                           Kind = 30007
+	KindHandlerRecommendation          Kind = 31989
-	KindProfileBadges                      Kind = 30008
+	KindHandlerInformation             Kind = 31990
-	KindBadgeDefinition                    Kind = 30009
+	KindVideoEvent                     Kind = 34235
-	KindInterestSets                       Kind = 30015
+	KindShortVideoEvent                Kind = 34236
-	KindStallDefinition                    Kind = 30017
+	KindVideoViewEvent                 Kind = 34237
-	KindProductDefinition                  Kind = 30018
+	KindCommunityDefinition            Kind = 34550
-	KindMarketplaceUI                      Kind = 30019
-	KindProductSoldAsAuction               Kind = 30020
-	KindArticle                            Kind = 30023
-	KindDraftArticle                       Kind = 30024
-	KindEmojiSets                          Kind = 30030
-	KindModularArticleHeader               Kind = 30040
-	KindModularArticleContent              Kind = 30041
-	KindReleaseArtifactSets                Kind = 30063
-	KindApplicationSpecificData            Kind = 30078
-	KindRelayDiscovery                     Kind = 30166
-	KindAppCurationSet                     Kind = 30267
-	KindLiveEvent                          Kind = 30311
-	KindInteractiveRoom                    Kind = 30312
-	KindConferenceEvent                    Kind = 30313
-	KindUserStatuses                       Kind = 30315
-	KindSlideSet                           Kind = 30388
-	KindClassifiedListing                  Kind = 30402
-	KindDraftClassifiedListing             Kind = 30403
-	KindRepositoryAnnouncement             Kind = 30617
-	KindRepositoryState                    Kind = 30618
-	KindWikiArticle                        Kind = 30818
-	KindRedirects                          Kind = 30819
-	KindDraftEvent                         Kind = 31234
-	KindLinkSet                            Kind = 31388
-	KindFeed                               Kind = 31890
-	KindDateCalendarEvent                  Kind = 31922
-	KindTimeCalendarEvent                  Kind = 31923
-	KindCalendar                           Kind = 31924
-	KindCalendarEventRSVP                  Kind = 31925
-	KindHandlerRecommendation              Kind = 31989
-	KindHandlerInformation                 Kind = 31990
-	KindSoftwareApplication                Kind = 32267
-	KindLegacyNsiteFile                    Kind = 34128
-	KindVideoViewEvent                     Kind = 34237
-	KindCommunityDefinition                Kind = 34550
-	KindNsiteNamed                         Kind = 35128
-	KindGeocacheListing                    Kind = 37515
-	KindGeocacheLogEntry                   Kind = 37516
-	KindCashuMintAnnouncement              Kind = 38172
-	KindFedimintAnnouncement               Kind = 38173
-	KindPeerToPeerOrderEvents              Kind = 38383
-	KindSimpleGroupMetadata                Kind = 39000
-	KindSimpleGroupAdmins                  Kind = 39001
-	KindSimpleGroupMembers                 Kind = 39002
-	KindSimpleGroupRoles                   Kind = 39003
-	KindSimpleGroupLiveKitParticipants     Kind = 39004
-	KindStarterPacks                       Kind = 39089
-	KindMediaStarterPacks                  Kind = 39092
-	KindWebBookmarks                       Kind = 39701
 )
 
 func (kind Kind) IsRegular() bool {

nip29/group.go

@@ -8,18 +8,11 @@ import (
 	"strings"
 
 	"fiatjaf.com/nostr"
-	"fiatjaf.com/nostr/nip19"
 )
 
 type GroupAddress struct {
-	// URL of the relay that is hosting the group
 	Relay string
-
+	ID    string
-	// Group identifier ("d"/"h" tag)
-	ID string
-
-	// Public key of the relay, used to publish kind:39000/etc events
-	Self nostr.PubKey
 }
 
 func (gid GroupAddress) String() string {
@@ -27,10 +20,6 @@ func (gid GroupAddress) String() string {
 	return fmt.Sprintf("%s'%s", p.Host, gid.ID)
 }
 
-func (gid GroupAddress) Code() string {
-	return nip19.EncodeNaddr(gid.Self, 39000, gid.ID, []string{gid.Relay})
-}
-
 func (gid GroupAddress) IsValid() bool {
 	return gid.Relay != "" && gid.ID != ""
 }
@@ -39,6 +28,14 @@ func (gid GroupAddress) Equals(gid2 GroupAddress) bool {
 	return gid.Relay == gid2.Relay && gid.ID == gid2.ID
 }
 
+func ParseGroupAddress(raw string) (GroupAddress, error) {
+	spl := strings.Split(raw, "'")
+	if len(spl) != 2 {
+		return GroupAddress{}, fmt.Errorf("invalid group id")
+	}
+	return GroupAddress{ID: spl[1], Relay: nostr.NormalizeURL(spl[0])}, nil
+}
+
 type Group struct {
 	Address GroupAddress
 
@@ -66,12 +63,6 @@ type Group struct {
 	// indicates which event kinds this group supports
 	SupportedKinds []nostr.Kind
 
-	// arbitrary string indicating the parent group
-	Parent string
-
-	// ordered list of identifiers of child groups
-	Children []string
-
 	Roles       []*Role
 	InviteCodes []string
 
@@ -139,15 +130,15 @@ func (group Group) String() string {
 }
 
 // NewGroup takes a group address in the form "<id>'<relay-hostname>"
-func NewGroup(relayHost, groupId string) (Group, error) {
+func NewGroup(gadstr string) (Group, error) {
-	relayHost = nostr.NormalizeURL(relayHost)
+	gad, err := ParseGroupAddress(gadstr)
+	if err != nil {
+		return Group{}, fmt.Errorf("invalid group id '%s': %w", gadstr, err)
+	}
 
 	return Group{
-		Address: GroupAddress{
+		Address:             gad,
-			Relay: relayHost,
+		Name:                gad.ID,
-			ID:    groupId,
-		},
-		Name:                groupId,
 		Members:             make(map[nostr.PubKey][]*Role),
 		LiveKitParticipants: make([]nostr.PubKey, 0),
 	}, nil
@@ -212,14 +203,6 @@ func (group Group) ToMetadataEvent() nostr.Event {
 		evt.Tags = append(evt.Tags, tag)
 	}
 
-	if group.Parent != "" {
-		evt.Tags = append(evt.Tags, nostr.Tag{"parent", group.Parent})
-	}
-
-	for _, child := range group.Children {
-		evt.Tags = append(evt.Tags, nostr.Tag{"child", child})
-	}
-
 	return evt
 }
 
@@ -341,10 +324,6 @@ func (group *Group) MergeInMetadataEvent(evt *nostr.Event) error {
 						group.About = tag[1]
 					case "picture":
 						group.Picture = tag[1]
-					case "parent":
-						group.Parent = tag[1]
-					case "child":
-						group.Children = append(group.Children, tag[1])
 					}
 				}
 			}

nip29/moderation_actions.go

@@ -79,23 +79,40 @@ var moderationActionFactories = map[nostr.Kind]func(nostr.Event) (Action, error)
 	nostr.KindSimpleGroupEditMetadata: func(evt nostr.Event) (Action, error) {
 		ok := false
 		edit := EditMetadata{When: evt.CreatedAt}
+		y := true
+		n := false
+
+		hasName := false
+
+		// DEPRECATED: remove all the fields not tagged with Replace = true eventually
+		// edit-metadata to become a PUT rather than a PATCH
 
 		for _, tag := range evt.Tags {
 			if len(tag) >= 1 {
 				switch tag[0] {
 				case "name":
 					if len(tag) >= 2 {
-						edit.Group.Name = tag[1]
+						edit.NameValue = &tag[1]
+						if ok {
+							edit.Replace = true
+						}
 						ok = true
+						hasName = true
 					}
 				case "picture":
 					if len(tag) >= 2 {
-						edit.Group.Picture = tag[1]
+						edit.PictureValue = &tag[1]
+						if hasName {
+							edit.Replace = true
+						}
 						ok = true
 					}
 				case "about":
 					if len(tag) >= 2 {
-						edit.Group.About = tag[1]
+						edit.AboutValue = &tag[1]
+						if hasName {
+							edit.Replace = true
+						}
 						ok = true
 					}
 				case "supported_kinds":
@@ -107,33 +124,54 @@ var moderationActionFactories = map[nostr.Kind]func(nostr.Event) (Action, error)
 							kinds = append(kinds, nostr.Kind(kind))
 						}
 					}
-					edit.Group.SupportedKinds = kinds
+					edit.SupportedKindsValue = &kinds
-					ok = true
+					edit.Replace = true
 				case "closed":
-					edit.Group.Closed = true
+					edit.ClosedValue = &y
+					if hasName {
+						edit.Replace = true
+					}
+					ok = true
+				case "open":
+					edit.ClosedValue = &n
 					ok = true
 				case "restricted":
-					edit.Group.Restricted = true
+					edit.RestrictedValue = &y
+					if hasName {
+						edit.Replace = true
+					}
+					ok = true
+				case "unrestricted":
+					edit.RestrictedValue = &n
 					ok = true
 				case "hidden":
-					edit.Group.Hidden = true
+					edit.HiddenValue = &y
+					if hasName {
+						edit.Replace = true
+					}
+					ok = true
+				case "visible":
+					edit.HiddenValue = &n
 					ok = true
 				case "private":
-					edit.Group.Private = true
+					edit.PrivateValue = &y
-					ok = true
+					if hasName {
-				case "parent":
+						edit.Replace = true
-					if len(tag) >= 2 {
-						edit.Group.Parent = tag[1]
-						ok = true
 					}
+					ok = true
+				case "public":
+					edit.PrivateValue = &n
+					ok = true
 				case "livekit":
-					edit.Group.LiveKit = true
+					edit.LiveKitValue = &y
+					edit.Replace = true
+					ok = true
+				case "no-livekit":
+					edit.LiveKitValue = &n
+					ok = true
+				case "no-text":
+					edit.SupportedKindsValue = nil
 					ok = true
-				case "child":
-					if len(tag) >= 2 {
-						edit.Group.Children = append(edit.Group.Children, tag[1])
-						ok = true
-					}
 				}
 			}
 		}
@@ -242,26 +280,63 @@ func (a RemoveUser) Apply(group *Group) {
 }
 
 type EditMetadata struct {
-	Group
+	NameValue           *string
+	PictureValue        *string
+	AboutValue          *string
+	RestrictedValue     *bool
+	ClosedValue         *bool
+	HiddenValue         *bool
+	PrivateValue        *bool
+	LiveKitValue        *bool
+	SupportedKindsValue *[]nostr.Kind
 
-	When nostr.Timestamp
+	Replace bool
+	When    nostr.Timestamp
 }
 
 func (_ EditMetadata) Name() string { return "edit-metadata" }
 func (a EditMetadata) Apply(group *Group) {
 	group.LastMetadataUpdate = a.When
 
-	group.Name = a.Group.Name
+	if a.Replace {
-	group.Picture = a.Group.Picture
+		group.Name = ""
-	group.About = a.Group.About
+		group.Picture = ""
-	group.Restricted = a.Group.Restricted
+		group.About = ""
-	group.Closed = a.Group.Closed
+		group.Restricted = false
-	group.Hidden = a.Group.Hidden
+		group.Closed = false
-	group.Private = a.Group.Private
+		group.Hidden = false
-	group.LiveKit = a.Group.LiveKit
+		group.Private = false
-	group.SupportedKinds = a.Group.SupportedKinds
+		group.LiveKit = false
-	group.Parent = a.Group.Parent
+		group.SupportedKinds = nil
-	group.Children = a.Group.Children
+	}
+
+	if a.NameValue != nil {
+		group.Name = *a.NameValue
+	}
+	if a.PictureValue != nil {
+		group.Picture = *a.PictureValue
+	}
+	if a.AboutValue != nil {
+		group.About = *a.AboutValue
+	}
+	if a.RestrictedValue != nil {
+		group.Restricted = *a.RestrictedValue
+	}
+	if a.ClosedValue != nil {
+		group.Closed = *a.ClosedValue
+	}
+	if a.HiddenValue != nil {
+		group.Hidden = *a.HiddenValue
+	}
+	if a.PrivateValue != nil {
+		group.Private = *a.PrivateValue
+	}
+	if a.LiveKitValue != nil {
+		group.LiveKit = *a.LiveKitValue
+	}
+	if a.SupportedKindsValue != nil {
+		group.SupportedKinds = *a.SupportedKindsValue
+	}
 }
 
 type CreateGroup struct {

nip29/nip29_test.go

@@ -15,7 +15,7 @@ const (
 )
 
 func TestGroupEventBackAndForth(t *testing.T) {
-	group1, _ := NewGroup("relay.com", "xyz")
+	group1, _ := NewGroup("relay.com'xyz")
 	group1.Name = "banana"
 	group1.Private = true
 	meta1 := group1.ToMetadataEvent()
@@ -31,7 +31,7 @@ func TestGroupEventBackAndForth(t *testing.T) {
 	}
 	require.True(t, hasPrivate, "translation of group1 to metadata event failed: %s", meta1)
 
-	group2, _ := NewGroup("groups.com", "abc")
+	group2, _ := NewGroup("groups.com'abc")
 	alicePub, _ := nostr.PubKeyFromHex(ALICE)
 	group2.Members[alicePub] = []*Role{{Name: "nada"}}
 	admins2 := group2.ToAdminsEvent()

nip46/client.go

@@ -6,9 +6,7 @@ import (
 	"math/rand"
 	"net/url"
 	"strconv"
-	"sync"
 	"sync/atomic"
-	"time"
 	"unsafe"
 
 	"fiatjaf.com/nostr"
@@ -17,12 +15,6 @@ import (
 	"github.com/puzpuzpuz/xsync/v3"
 )
 
-var bunkerClientCtxKey = &struct{}{}
-
-func IsBunkerClientOperation(ctx context.Context) bool {
-	return ctx.Value(bunkerClientCtxKey) == true
-}
-
 type BunkerClient struct {
 	Relays []string
 
@@ -64,7 +56,6 @@ func ConnectBunker(
 		pool,
 		onAuth,
 	)
-
 	_, err = bunker.RPC(ctx, "connect", []string{nostr.HexEncodeToString(parsed.HostPubKey[:]), parsed.Secret})
 	return bunker, err
 }
@@ -140,19 +131,17 @@ func NewBunker(
 	}
 
 	cancellableCtx, cancel := context.WithCancel(ctx)
-	bunkerClientCtx := context.WithValue(cancellableCtx, bunkerClientCtxKey, true)
 	_ = cancel
 
-	events, eosed := pool.SubscribeManyNotifyEOSE(bunkerClientCtx, relays, nostr.Filter{
-		Tags:      nostr.TagMap{"p": []string{clientPublicKey.Hex()}},
-		Kinds:     []nostr.Kind{nostr.KindNostrConnect},
-		Since:     now,
-		LimitZero: true,
-	}, nostr.SubscriptionOptions{
-		Label: "bunker46client",
-	})
-
 	go func() {
+		events := pool.SubscribeMany(cancellableCtx, relays, nostr.Filter{
+			Tags:      nostr.TagMap{"p": []string{clientPublicKey.Hex()}},
+			Kinds:     []nostr.Kind{nostr.KindNostrConnect},
+			Since:     now,
+			LimitZero: true,
+		}, nostr.SubscriptionOptions{
+			Label: "bunker46client",
+		})
 		for ie := range events {
 			if ie.Kind != nostr.KindNostrConnect {
 				continue
@@ -185,15 +174,12 @@ func NewBunker(
 
 	// attempt switch_relays once every 10 times
 	if now%10 == 0 {
-		swctx, cancel := context.WithTimeout(ctx, time.Second*3)
+		if newRelays, _ := bunker.SwitchRelays(ctx); newRelays != nil {
-		if newRelays, _ := bunker.SwitchRelays(swctx); newRelays != nil {
+			cancel()
 			bunker = NewBunker(ctx, clientSecretKey, targetPublicKey, newRelays, pool, func(string) {})
 		}
-		cancel()
 	}
 
-	<-eosed
-
 	return bunker
 }
 
@@ -288,7 +274,7 @@ func (bunker *BunkerClient) NIP04Decrypt(
 }
 
 func (bunker *BunkerClient) RPC(ctx context.Context, method string, params []string) (string, error) {
-	id := bunker.idPrefix + "-" + strconv.FormatUint(bunker.serial.Add(1), 10) + "-" + method
+	id := bunker.idPrefix + "-" + strconv.FormatUint(bunker.serial.Add(1), 10)
 	req, err := json.Marshal(Request{
 		ID:     id,
 		Method: method,
@@ -317,23 +303,21 @@ func (bunker *BunkerClient) RPC(ctx context.Context, method string, params []str
 	bunker.listeners.Store(id, dispatcher)
 	defer bunker.listeners.Delete(id)
 	relayConnectionWorked := make(chan struct{})
-	relayConnectionWorkedO := sync.OnceFunc(func() {
-		close(relayConnectionWorked)
-	})
 	bunkerConnectionWorked := make(chan struct{})
-	bunkerConnectionWorkedO := sync.OnceFunc(func() {
-		close(bunkerConnectionWorked)
-	})
-
-	bunkerClientCtx := context.WithValue(ctx, bunkerClientCtxKey, true)
 
 	for _, url := range bunker.Relays {
 		go func(url string) {
 			relay, err := bunker.pool.EnsureRelay(url)
 			if err == nil {
-				relayConnectionWorkedO()
+				select {
-				if err := relay.Publish(bunkerClientCtx, evt); err == nil {
+				case relayConnectionWorked <- struct{}{}:
-					bunkerConnectionWorkedO()
+				default:
+				}
+				if err := relay.Publish(ctx, evt); err == nil {
+					select {
+					case bunkerConnectionWorked <- struct{}{}:
+					default:
+					}
 				}
 			}
 		}(url)

nip46/dynamic-signer.go

@@ -3,8 +3,6 @@ package nip46
 import (
 	"context"
 	"fmt"
-	"net/url"
-	"strconv"
 	"sync"
 
 	"fiatjaf.com/nostr"
@@ -52,50 +50,6 @@ func (p *DynamicSigner) Init() {
 	p.sessions = make(map[nostr.PubKey]map[nostr.PubKey]*Session)
 }
 
-// HandleNostrConnectURI works like HandleRequest, but takes a nostrconnect:// URI as input, as scanned/pasted
-// by the user, produced by the client. Since DynamicSigner can serve multiple handler keys, the caller must
-// specify which handlerPubkey should respond to this connection.
-func (p *DynamicSigner) HandleNostrConnectURI(ctx context.Context, handlerPubkey nostr.PubKey, uri *url.URL) (
-	resp Response,
-	eventResponse nostr.Event,
-	err error,
-) {
-	clientPublicKey, err := nostr.PubKeyFromHex(uri.Host)
-	if err != nil {
-		return resp, eventResponse, err
-	}
-
-	secret := uri.Query().Get("secret")
-
-	_, handlerSecret, err := p.GetHandlerSecretKey(ctx, handlerPubkey)
-	if err != nil {
-		return resp, eventResponse, fmt.Errorf("no private key for %s: %w", handlerPubkey, err)
-	}
-
-	// pretend they started with a request
-	conversationKey, err := nip44.GenerateConversationKey(clientPublicKey, handlerSecret)
-	if err != nil {
-		return resp, eventResponse, err
-	}
-	reqj, _ := json.Marshal(Request{
-		ID:     "nostrconnect-" + strconv.FormatInt(int64(nostr.Now()), 10),
-		Method: "imagined-nostrconnect",
-		Params: []string{clientPublicKey.Hex(), secret},
-	})
-	ciphertext, err := nip44.Encrypt(string(reqj), conversationKey)
-	if err != nil {
-		return resp, eventResponse, err
-	}
-
-	_, resp, eventResponse, err = p.HandleRequest(ctx, nostr.Event{
-		PubKey:  clientPublicKey,
-		Kind:    nostr.KindNostrConnect,
-		Content: ciphertext,
-		Tags:    nostr.Tags{nostr.Tag{"p", handlerPubkey.Hex()}},
-	})
-	return resp, eventResponse, err
-}
-
 func (p *DynamicSigner) HandleRequest(ctx context.Context, event nostr.Event) (
 	req Request,
 	resp Response,
@@ -164,19 +118,6 @@ func (p *DynamicSigner) HandleRequest(ctx context.Context, event nostr.Event) (
 	var resultErr error
 
 	switch req.Method {
-	case "imagined-nostrconnect":
-		// this is a fake request we pretend has existed, but was actually just we reading the nostrconnect:// uri
-		if len(req.Params) < 2 || req.Params[1] == "" {
-			resultErr = fmt.Errorf("needs a second argument 'secret'")
-			break
-		}
-		if p.OnConnect != nil {
-			if err := p.OnConnect(ctx, event.PubKey, req.Params[1]); err != nil {
-				resultErr = err
-				break
-			}
-		}
-		result = req.Params[1]
 	case "connect":
 		var secret string
 		if len(req.Params) >= 2 {

nip5a/nip5a.go

@@ -97,9 +97,7 @@ func (sm SiteManifest) ToEvent() nostr.Event {
 		event.Tags = append(event.Tags, nostr.Tag{"path", NormalizePath(path), hex.EncodeToString(hash[:])})
 	}
 	for _, s := range sm.Servers {
-		if ns, err := nostr.NormalizeHTTPURL(s); err == nil {
+		event.Tags = append(event.Tags, nostr.Tag{"server", s})
-			event.Tags = append(event.Tags, nostr.Tag{"server", ns})
-		}
 	}
 	if sm.Title != "" {
 		event.Tags = append(event.Tags, nostr.Tag{"title", sm.Title})

nip5a/nip5a_test.go

@@ -234,3 +234,4 @@ func mustHash(s string) [32]byte {
 	copy(h[:], b)
 	return h
 }
+

nip86/methods.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 	"net"
-	"strconv"
 
 	"fiatjaf.com/nostr"
 )
@@ -241,121 +240,6 @@ func DecodeRequest(req Request) (MethodParams, error) {
 			Pubkey:          pk,
 			DisallowMethods: disallowedMethods,
 		}, nil
-	case "createrole":
-		if len(req.Params) == 0 {
-			return nil, fmt.Errorf("invalid number of params for '%s'", req.Method)
-		}
-		id, ok := req.Params[0].(string)
-		if !ok {
-			return nil, fmt.Errorf("missing id param for '%s'", req.Method)
-		}
-		var label, description string
-		if len(req.Params) >= 2 {
-			label, _ = req.Params[1].(string)
-		}
-		if len(req.Params) >= 3 {
-			description, _ = req.Params[2].(string)
-		}
-		var color, order int
-		if len(req.Params) >= 4 {
-			color = coerceInt(req.Params[3])
-		}
-		if len(req.Params) >= 5 {
-			order = coerceInt(req.Params[4])
-		}
-		return CreateRole{id, label, description, color, order}, nil
-	case "editrole":
-		if len(req.Params) == 0 {
-			return nil, fmt.Errorf("invalid number of params for '%s'", req.Method)
-		}
-		id, ok := req.Params[0].(string)
-		if !ok {
-			return nil, fmt.Errorf("missing id param for '%s'", req.Method)
-		}
-		var label, description string
-		if len(req.Params) >= 2 {
-			label, _ = req.Params[1].(string)
-		}
-		if len(req.Params) >= 3 {
-			description, _ = req.Params[2].(string)
-		}
-		var color, order int
-		if len(req.Params) >= 4 {
-			color = coerceInt(req.Params[3])
-		}
-		if len(req.Params) >= 5 {
-			order = coerceInt(req.Params[4])
-		}
-		return EditRole{id, label, description, color, order}, nil
-	case "deleterole":
-		if len(req.Params) == 0 {
-			return nil, fmt.Errorf("invalid number of params for '%s'", req.Method)
-		}
-		id, ok := req.Params[0].(string)
-		if !ok {
-			return nil, fmt.Errorf("missing id param for '%s'", req.Method)
-		}
-		return DeleteRole{id}, nil
-	case "assignrole":
-		if len(req.Params) < 2 {
-			return nil, fmt.Errorf("invalid number of params for '%s'", req.Method)
-		}
-		pkh, ok := req.Params[0].(string)
-		if !ok {
-			return nil, fmt.Errorf("missing pubkey param for '%s'", req.Method)
-		}
-		pk, err := nostr.PubKeyFromHex(pkh)
-		if err != nil {
-			return nil, fmt.Errorf("invalid pubkey param for '%s'", req.Method)
-		}
-		roleID, ok := req.Params[1].(string)
-		if !ok {
-			return nil, fmt.Errorf("missing role id param for '%s'", req.Method)
-		}
-		return AssignRole{pk, roleID}, nil
-	case "unassignrole":
-		if len(req.Params) < 2 {
-			return nil, fmt.Errorf("invalid number of params for '%s'", req.Method)
-		}
-		pkh, ok := req.Params[0].(string)
-		if !ok {
-			return nil, fmt.Errorf("missing pubkey param for '%s'", req.Method)
-		}
-		pk, err := nostr.PubKeyFromHex(pkh)
-		if err != nil {
-			return nil, fmt.Errorf("invalid pubkey param for '%s'", req.Method)
-		}
-		roleID, ok := req.Params[1].(string)
-		if !ok {
-			return nil, fmt.Errorf("missing role id param for '%s'", req.Method)
-		}
-		return UnassignRole{pk, roleID}, nil
-	case "signevent":
-		if len(req.Params) == 0 {
-			return nil, fmt.Errorf("invalid number of params for '%s'", req.Method)
-		}
-		tmpl, ok := req.Params[0].(map[string]any)
-		if !ok {
-			return nil, fmt.Errorf("missing event param for '%s'", req.Method)
-		}
-		kind, ok := tmpl["kind"].(float64)
-		if !ok || math.Trunc(kind) != kind {
-			return nil, fmt.Errorf("invalid kind '%v' for '%s'", tmpl["kind"], req.Method)
-		}
-		var createdAt nostr.Timestamp
-		if ca, ok := tmpl["created_at"]; ok {
-			caf, ok := ca.(float64)
-			if !ok || math.Trunc(caf) != caf {
-				return nil, fmt.Errorf("invalid created_at '%v' for '%s'", ca, req.Method)
-			}
-			createdAt = nostr.Timestamp(caf)
-		}
-		tags, err := coerceTags(tmpl["tags"])
-		if err != nil {
-			return nil, fmt.Errorf("invalid tags for '%s': %w", req.Method, err)
-		}
-		content, _ := tmpl["content"].(string)
-		return SignEvent{nostr.Kind(kind), createdAt, tags, content}, nil
 	case "stats":
 		return Stats{}, nil
 	default:
@@ -363,48 +247,6 @@ func DecodeRequest(req Request) (MethodParams, error) {
 	}
 }
 
-// coerceInt converts a decoded JSON param (a float64 number or a numeric
-// string) into an int, returning 0 when the value is neither.
-func coerceInt(v any) int {
-	switch n := v.(type) {
-	case float64:
-		return int(n)
-	case string:
-		i, _ := strconv.Atoi(n)
-		return i
-	}
-	return 0
-}
-
-// coerceTags converts a decoded JSON value (an array of arrays of strings) into
-// nostr.Tags. A nil value yields nil tags; any other shape is an error.
-func coerceTags(v any) (nostr.Tags, error) {
-	if v == nil {
-		return nil, nil
-	}
-	rawTags, ok := v.([]any)
-	if !ok {
-		return nil, fmt.Errorf("tags must be an array")
-	}
-	tags := make(nostr.Tags, len(rawTags))
-	for i, rt := range rawTags {
-		rawTag, ok := rt.([]any)
-		if !ok {
-			return nil, fmt.Errorf("tag %d must be an array", i)
-		}
-		tag := make(nostr.Tag, len(rawTag))
-		for j, el := range rawTag {
-			s, ok := el.(string)
-			if !ok {
-				return nil, fmt.Errorf("tag %d element %d must be a string", i, j)
-			}
-			tag[j] = s
-		}
-		tags[i] = tag
-	}
-	return tags, nil
-}
-
 type MethodParams interface {
 	MethodName() string
 }
@@ -434,12 +276,6 @@ var (
 	_ MethodParams = (*ListDisallowedKinds)(nil)
 	_ MethodParams = (*GrantAdmin)(nil)
 	_ MethodParams = (*RevokeAdmin)(nil)
-	_ MethodParams = (*CreateRole)(nil)
-	_ MethodParams = (*EditRole)(nil)
-	_ MethodParams = (*DeleteRole)(nil)
-	_ MethodParams = (*AssignRole)(nil)
-	_ MethodParams = (*UnassignRole)(nil)
-	_ MethodParams = (*SignEvent)(nil)
 	_ MethodParams = (*Stats)(nil)
 )
 
@@ -579,55 +415,6 @@ type RevokeAdmin struct {
 
 func (RevokeAdmin) MethodName() string { return "revokeadmin" }
 
-type CreateRole struct {
-	ID          string
-	Label       string
-	Description string
-	Color       int
-	Order       int
-}
-
-func (CreateRole) MethodName() string { return "createrole" }
-
-type EditRole struct {
-	ID          string
-	Label       string
-	Description string
-	Color       int
-	Order       int
-}
-
-func (EditRole) MethodName() string { return "editrole" }
-
-type DeleteRole struct {
-	ID string
-}
-
-func (DeleteRole) MethodName() string { return "deleterole" }
-
-type AssignRole struct {
-	PubKey nostr.PubKey
-	RoleID string
-}
-
-func (AssignRole) MethodName() string { return "assignrole" }
-
-type UnassignRole struct {
-	PubKey nostr.PubKey
-	RoleID string
-}
-
-func (UnassignRole) MethodName() string { return "unassignrole" }
-
-type SignEvent struct {
-	Kind      nostr.Kind
-	CreatedAt nostr.Timestamp
-	Tags      nostr.Tags
-	Content   string
-}
-
-func (SignEvent) MethodName() string { return "signevent" }
-
 type Stats struct{}
 
 func (Stats) MethodName() string { return "stats" }

nipb0/blossom/blossom_test.go

@@ -3,8 +3,6 @@ package blossom_test
 import (
 	"bytes"
 	"context"
-	"encoding/hex"
-	"errors"
 	"fmt"
 	"io"
 	"net/http/httptest"
@@ -20,18 +18,6 @@ import (
 	blossomclient "fiatjaf.com/nostr/nipb0/blossom"
 )
 
-func hexTo32(s string) (h [32]byte, err error) {
-	b, err := hex.DecodeString(s)
-	if err != nil {
-		return h, err
-	}
-	if len(b) != 32 {
-		return h, errors.New("not 32 bytes")
-	}
-	copy(h[:], b)
-	return h, nil
-}
-
 func TestBlossomBasicOperations(t *testing.T) {
 	// setup two test servers
 	server1 := setupTestServer(t, ":38081")
@@ -92,10 +78,7 @@ func TestBlossomBasicOperations(t *testing.T) {
 			t.Fatalf("Expected 1 blob, got %d", len(blobs))
 		}
 
-		hash, err := hexTo32(blobs[0].SHA256)
+		hash := blobs[0].SHA256
-		if err != nil {
-			t.Fatalf("Failed to parse hash: %v", err)
-		}
 		downloaded, err := client1.Download(ctx, hash)
 		if err != nil {
 			t.Fatalf("Failed to download blob: %v", err)
@@ -190,12 +173,8 @@ func TestBlossomBasicOperations(t *testing.T) {
 			t.Errorf("Expected pubkey2 to still see 1 blob after pubkey1 delete, got %d", len(blobs2))
 		}
 
-		hash32, err := hexTo32(hash)
-		if err != nil {
-			t.Fatalf("Failed to parse hash: %v", err)
-		}
 		// download should still work
-		downloaded, err := client2.Download(ctx, hash32)
+		downloaded, err := client2.Download(ctx, hash)
 		if err != nil {
 			t.Fatalf("Failed to download blob after pubkey1 delete: %v", err)
 		}
@@ -224,12 +203,8 @@ func TestBlossomBasicOperations(t *testing.T) {
 			t.Errorf("Expected 1 blob on server2, got %d", len(blobs))
 		}
 
-		hash32, err := hexTo32(bd.SHA256)
-		if err != nil {
-			t.Fatalf("Failed to parse hash: %v", err)
-		}
 		// verify download
-		downloaded, err := client2Server.Download(ctx, hash32)
+		downloaded, err := client2Server.Download(ctx, bd.SHA256)
 		if err != nil {
 			t.Fatalf("Failed to download from server2: %v", err)
 		}
@@ -271,21 +246,13 @@ func TestBlossomBasicOperations(t *testing.T) {
 		}
 
 		// verify the mirrored blob can be downloaded
-		hash32, err := hexTo32(bd.SHA256)
+		downloaded, err := client2Server.Download(ctx, bd.SHA256)
-		if err != nil {
-			t.Fatalf("Failed to parse hash: %v", err)
-		}
-		downloaded, err := client2Server.Download(ctx, hash32)
 		if err != nil {
 			t.Fatalf("Failed to download mirrored blob: %v", err)
 		}
 
-		hash32, err = hexTo32(blobs1[0].SHA256)
-		if err != nil {
-			t.Fatalf("Failed to parse hash: %v", err)
-		}
 		// should match the original content
-		originalDownloaded, err := client2.Download(ctx, hash32)
+		originalDownloaded, err := client2.Download(ctx, blobs1[0].SHA256)
 		if err != nil {
 			t.Fatalf("Failed to download original blob for comparison: %v", err)
 		}

nipb0/blossom/client.go

@@ -6,7 +6,6 @@ import (
 
 	"fiatjaf.com/nostr"
 	"github.com/valyala/fasthttp"
-	"github.com/valyala/fasthttp/fasthttpproxy"
 )
 
 // Client represents a Blossom client for interacting with a media server
@@ -29,18 +28,6 @@ func NewClient(mediaserver string, signer nostr.Signer) *Client {
 
 // createHTTPClient creates a properly configured HTTP client
 func createHTTPClient() *fasthttp.Client {
-	d := fasthttpproxy.Dialer{
-		Timeout:        10 * time.Second,
-		ConnectTimeout: 10 * time.Second,
-		TCPDialer: fasthttp.TCPDialer{
-			// increase DNS cache time to an hour instead of default minute
-			Concurrency:      4096,
-			DNSCacheDuration: time.Hour,
-		},
-		DialDualStack: true,
-	}
-	dialFunc, _ := d.GetDialFunc(true)
-
 	return &fasthttp.Client{
 		MaxIdleConnDuration:           time.Hour,
 		DisableHeaderNamesNormalizing: true, // because our headers are properly constructed
@@ -48,7 +35,11 @@ func createHTTPClient() *fasthttp.Client {
 
 		Name: "nl-b", // user-agent
 
-		Dial: dialFunc,
+		// increase DNS cache time to an hour instead of default minute
+		Dial: (&fasthttp.TCPDialer{
+			Concurrency:      4096,
+			DNSCacheDuration: time.Hour,
+		}).Dial,
 	}
 }
 

nipb0/blossom/download.go

@@ -15,7 +15,7 @@ import (
 func (c *Client) Download(ctx context.Context, hash [32]byte) ([]byte, error) {
 	hhash := hex.EncodeToString(hash[:])
 
-	req, err := http.NewRequestWithContext(ctx, "GET", c.mediaserver+hhash, nil)
+	req, err := http.NewRequestWithContext(ctx, "GET", c.mediaserver+"/"+hhash, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
@@ -43,7 +43,7 @@ func (c *Client) Download(ctx context.Context, hash [32]byte) ([]byte, error) {
 func (c *Client) DownloadToFile(ctx context.Context, hash [32]byte, filePath string) error {
 	hhash := hex.EncodeToString(hash[:])
 
-	req, err := http.NewRequestWithContext(ctx, "GET", c.mediaserver+hhash, nil)
+	req, err := http.NewRequestWithContext(ctx, "GET", c.mediaserver+"/"+hhash, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}

nipb0/blossom/utils.go

@@ -2,109 +2,37 @@ package blossom
 
 import (
 	"mime"
-	"strings"
 )
 
-var commonMimeExtensions = map[string]string{
-	"application/json":                        ".json",
-	"application/pdf":                         ".pdf",
-	"application/vnd.android.package-archive": ".apk",
-	"application/vnd.sqlite3":                 ".sqlite3",
-	"application/xml":                         ".xml",
-	"audio/aac":                               ".aac",
-	"audio/flac":                              ".flac",
-	"audio/midi":                              ".midi",
-	"audio/mp3":                               ".mp3",
-	"audio/mpeg":                              ".mp3",
-	"audio/mp4":                               ".m4a",
-	"audio/ogg":                               ".ogg",
-	"audio/wav":                               ".wav",
-	"audio/webm":                              ".weba",
-	"audio/x-aiff":                            ".aiff",
-	"audio/x-m4a":                             ".m4a",
-	"image/avif":                              ".avif",
-	"image/gif":                               ".gif",
-	"image/jpeg":                              ".jpg",
-	"image/png":                               ".png",
-	"image/svg+xml":                           ".svg",
-	"image/webp":                              ".webp",
-	"text/css":                                ".css",
-	"text/csv":                                ".csv",
-	"text/html":                               ".html",
-	"text/javascript":                         ".js",
-	"text/markdown":                           ".md",
-	"text/plain":                              ".txt",
-	"text/xml":                                ".xml",
-	"video/mp2t":                              ".ts",
-	"video/mp4":                               ".mp4",
-	"video/ogg":                               ".ogv",
-	"video/quicktime":                         ".mov",
-	"video/webm":                              ".webm",
-	"video/x-matroska":                        ".mkv",
-}
-
-var commonExtensionMimes = map[string]string{
-	".aac":     "audio/aac",
-	".aiff":    "audio/x-aiff",
-	".apk":     "application/vnd.android.package-archive",
-	".avif":    "image/avif",
-	".css":     "text/css; charset=utf-8",
-	".csv":     "text/csv; charset=utf-8",
-	".flac":    "audio/flac",
-	".gif":     "image/gif",
-	".html":    "text/html; charset=utf-8",
-	".jpeg":    "image/jpeg",
-	".jpg":     "image/jpeg",
-	".js":      "text/javascript; charset=utf-8",
-	".json":    "application/json",
-	".m4a":     "audio/mp4",
-	".md":      "text/markdown; charset=utf-8",
-	".midi":    "audio/midi",
-	".mkv":     "video/x-matroska",
-	".mov":     "video/quicktime",
-	".mp3":     "audio/mpeg",
-	".mp4":     "video/mp4",
-	".oga":     "audio/ogg",
-	".ogg":     "audio/ogg",
-	".ogv":     "video/ogg",
-	".pdf":     "application/pdf",
-	".png":     "image/png",
-	".sqlite3": "application/vnd.sqlite3",
-	".svg":     "image/svg+xml",
-	".ts":      "video/mp2t",
-	".txt":     "text/plain; charset=utf-8",
-	".wav":     "audio/wav",
-	".weba":    "audio/webm",
-	".webm":    "video/webm",
-	".webp":    "image/webp",
-	".xml":     "application/xml",
-}
-
-func normalizeMIMEType(mimetype string) string {
-	if mimetype == "" {
-		return ""
-	}
-
-	base, _, err := mime.ParseMediaType(mimetype)
-	if err == nil {
-		return strings.ToLower(base)
-	}
-
-	if idx := strings.IndexByte(mimetype, ';'); idx >= 0 {
-		mimetype = mimetype[:idx]
-	}
-
-	return strings.ToLower(strings.TrimSpace(mimetype))
-}
-
 func GetExtension(mimetype string) string {
-	mimetype = normalizeMIMEType(mimetype)
 	if mimetype == "" {
 		return ""
 	}
 
-	if ext, ok := commonMimeExtensions[mimetype]; ok {
+	// hardcode some common cases (abd jbiwb oribkenatuc cases kuje ,ogg/.oga or .mov/.moov)
-		return ext
+	switch mimetype {
+	case "image/jpeg":
+		return ".jpg"
+	case "image/gif":
+		return ".gif"
+	case "image/png":
+		return ".png"
+	case "image/webp":
+		return ".webp"
+	case "video/mp4":
+		return ".mp4"
+	case "application/vnd.android.package-archive":
+		return ".apk"
+	case "video/quicktime":
+		return ".mov"
+	case "application/vnd.sqlite3":
+		return "sqlite3"
+	case "text/markdown":
+		return "md"
+	case "audio/midi":
+		return "midi"
+	case "audio/x-aiff":
+		return "aiff"
 	}
 
 	exts, _ := mime.ExtensionsByType(mimetype)
@@ -114,20 +42,3 @@ func GetExtension(mimetype string) string {
 
 	return ""
 }
-
-func GetMIMEType(ext string) string {
-	if ext == "" {
-		return ""
-	}
-
-	ext = strings.ToLower(strings.TrimSpace(ext))
-	if ext != "" && ext[0] != '.' {
-		ext = "." + ext
-	}
-
-	if mimetype, ok := commonExtensionMimes[ext]; ok {
-		return mimetype
-	}
-
-	return mime.TypeByExtension(ext)
-}

pointers_easyjson.go

@@ -313,7 +313,7 @@ func easyjson33014d6eEncodeFiatjafComNostr2(out *jwriter.Writer, in EntityPointe
 		out.RawString(prefix)
 		out.Uint(uint(in.Kind))
 	}
-	if in.Identifier != "" || in.Kind.IsAddressable() {
+	if in.Identifier == "" && in.Kind.IsReplaceable() {
 		// this is expected, no identifiers in replaceable events, so don't print
 		// but we do print in case there is an identifier, incorrectly, to assist debug
 		const prefix string = ",\"identifier\":"

pool.go

@@ -46,8 +46,7 @@ type Pool struct {
 	RelayOptions RelayOptions
 
 	// custom things not often used
-	penaltyBox       *xsync.MapOf[string, [2]float64]
+	penaltyBox *xsync.MapOf[string, [2]float64]
-	penaltyBoxCancel context.CancelFunc
 }
 
 // DirectedFilter combines a Filter with a specific relay URL.
@@ -75,19 +74,13 @@ func NewPool() *Pool {
 }
 
 func (pool *Pool) StartPenaltyBox() {
-	if pool.penaltyBoxCancel != nil {
-		pool.penaltyBoxCancel()
-	}
-
-	ctx, cancel := context.WithCancel(pool.Context)
-	pool.penaltyBoxCancel = cancel
 	pool.penaltyBox = xsync.NewMapOf[string, [2]float64]()
 
 	go func() {
 		sleep := 30.0
 		for {
 			select {
-			case <-ctx.Done():
+			case <-pool.Context.Done():
 				return
 			case <-time.After(time.Duration(sleep) * time.Second):
 
@@ -113,15 +106,6 @@ func (pool *Pool) StartPenaltyBox() {
 	}()
 }
 
-func (pool *Pool) StopPenaltyBox() {
-	if pool.penaltyBoxCancel != nil {
-		pool.penaltyBoxCancel()
-		pool.penaltyBoxCancel = nil
-	}
-
-	pool.penaltyBox = nil
-}
-
 // AddToPenaltyBox manually adds a relay to the penalty box for the specified duration.
 // This prevents EnsureRelay from attempting to connect to the relay until the duration expires.
 func (pool *Pool) AddToPenaltyBox(url string, duration time.Duration) {
@@ -159,7 +143,7 @@ func (pool *Pool) EnsureRelay(url string) (*Relay, error) {
 		if pool.penaltyBox != nil {
 			// putting relay in penalty box
 			pool.penaltyBox.Compute(nm, func(v [2]float64, loaded bool) (newV [2]float64, delete bool) {
-				return [2]float64{v[0] + 1, math.Min(600.0, 30.0*math.Pow(1.5, v[0]+1))}, false
+				return [2]float64{v[0] + 1, 30.0 + math.Pow(2, v[0]+1)}, false
 			})
 			pool.Relays.Store(nm, nil) // this is important for penalty box detection on EnsureRelay
 		}

relay.go

@@ -494,11 +494,11 @@ func (r *Relay) Auth(ctx context.Context, sign func(context.Context, *Event) err
 			},
 			Content: "",
 		}
-		if err = sign(ctx, &authEvent); err != nil {
+		if err := sign(ctx, &authEvent); err != nil {
 			err = fmt.Errorf("error signing auth event: %w", err)
-		} else {
-			err = r.publish(ctx, authEvent.ID, &AuthEnvelope{Event: authEvent})
 		}
+
+		err = r.publish(ctx, authEvent.ID, &AuthEnvelope{Event: authEvent})
 	})
 
 	if err == nil {

schema/schema.go

@@ -18,7 +18,7 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-const DefaultSchemaURL = "https://raw.githubusercontent.com/nostr-protocol/registry-of-kinds/refs/heads/master/schema.yaml"
+const DefaultSchemaURL = "https://raw.githubusercontent.com/nostr-protocol/registry-of-kinds/ffa18bf6fb5496d755b465b062e18c676df1a5d4/schema.yaml"
 
 // this is used by hex.Decode in the "hex" validator -- we don't care about data races
 var hexdummydecoder = make([]byte, 128)
@@ -39,72 +39,62 @@ func FetchSchemaFromURL(schemaURL string) (Schema, error) {
 		return Schema{}, fmt.Errorf("failed to read schema response: %w", err)
 	}
 
-	return NewSchemaFromBytes(body)
+	var schema Schema
-}
+	if err := yaml.Unmarshal(body, &schema); err != nil {
-
-type Schema struct {
-	GenericTags map[string]ContentSpec `yaml:"generic_tags" json:"generic_tags,omitempty"`
-	Kinds       map[string]*KindSchema `yaml:"kinds" json:"kinds,omitempty"`
-}
-
-type KindSchema struct {
-	Kind        nostr.Kind  `yaml:"-" json:"kind"`
-	Description string      `yaml:"description" json:"description,omitempty"`
-	InUse       bool        `yaml:"in_use" json:"in_use,omitempty"`
-	Content     ContentSpec `yaml:"content" json:"content,omitempty"`
-	Required    []string    `yaml:"required" json:"required,omitempty"`
-	Multiple    []string    `yaml:"multiple" json:"multiple,omitempty"`
-	Tags        []TagSpec   `yaml:"tags" json:"tags,omitempty"`
-}
-
-type TagSpec struct {
-	Name   string       `yaml:"name" json:"name,omitempty"`
-	Prefix string       `yaml:"prefix" json:"prefix,omitempty"`
-	Next   *ContentSpec `yaml:"next" json:"next,omitempty"`
-}
-
-type ContentSpec struct {
-	Type     string       `yaml:"type" json:"type,omitempty"`
-	Required bool         `yaml:"required" json:"required,omitempty"`
-	Min      int          `yaml:"min" json:"min,omitempty"`
-	Max      int          `yaml:"max" json:"max,omitempty"`
-	Either   []string     `yaml:"either" json:"either,omitempty"`
-	Next     *ContentSpec `yaml:"next" json:"next,omitempty"`
-	Variadic bool         `yaml:"variadic" json:"variadic,omitempty"`
-}
-
-type Validator struct {
-	Schema            Schema                                                 `json:"schema,omitempty"`
-	FailOnUnknownKind bool                                                   `json:"fail_on_unknown_kind,omitempty"`
-	FailOnUnknownType bool                                                   `json:"fail_on_unknown_type,omitempty"`
-	TypeValidators    map[string]func(value string, spec *ContentSpec) error `json:"type_validators,omitempty"`
-	UnknownTypes      []string                                               `json:"unknown_types,omitempty"`
-}
-
-func NewValidatorFromBytes(schemaData []byte) (Validator, error) {
-	schema, err := NewSchemaFromBytes(schemaData)
-	if err != nil {
-		return Validator{}, err
-	}
-
-	return NewValidatorFromSchema(schema), nil
-}
-
-func NewSchemaFromBytes(schemaData []byte) (Schema, error) {
-	schema := Schema{
-		GenericTags: make(map[string]ContentSpec),
-		Kinds:       make(map[string]*KindSchema),
-	}
-	if err := yaml.Unmarshal(schemaData, &schema); err != nil {
 		return Schema{}, fmt.Errorf("failed to parse schema: %w", err)
 	}
 
-	for k := range schema.Kinds {
+	return schema, nil
-		kn, _ := strconv.ParseUint(k, 10, 16)
+}
-		schema.Kinds[k].Kind = nostr.Kind(kn)
+
+type Schema struct {
+	GenericTags map[string]ContentSpec `yaml:"generic_tags"`
+	Kinds       map[string]KindSchema  `yaml:"kinds"`
+}
+
+type KindSchema struct {
+	Description string      `yaml:"description"`
+	InUse       bool        `yaml:"in_use"`
+	Content     ContentSpec `yaml:"content"`
+	Required    []string    `yaml:"required"`
+	Multiple    []string    `yaml:"multiple"`
+	Tags        []TagSpec   `yaml:"tags"`
+}
+
+type TagSpec struct {
+	Name   string       `yaml:"name"`
+	Prefix string       `yaml:"prefix"`
+	Next   *ContentSpec `yaml:"next"`
+}
+
+type ContentSpec struct {
+	Type     string       `yaml:"type"`
+	Required bool         `yaml:"required"`
+	Min      int          `yaml:"min"`
+	Max      int          `yaml:"max"`
+	Either   []string     `yaml:"either"`
+	Next     *ContentSpec `yaml:"next"`
+	Variadic bool         `yaml:"variadic"`
+}
+
+type Validator struct {
+	Schema            Schema
+	FailOnUnknownKind bool
+	FailOnUnknownType bool
+	TypeValidators    map[string]func(value string, spec *ContentSpec) error
+	UnknownTypes      []string
+}
+
+func NewValidatorFromBytes(schemaData []byte) (Validator, error) {
+	schema := Schema{
+		GenericTags: make(map[string]ContentSpec),
+		Kinds:       make(map[string]KindSchema),
+	}
+	if err := yaml.Unmarshal(schemaData, &schema); err != nil {
+		return Validator{}, fmt.Errorf("failed to parse schema: %w", err)
 	}
 
-	return schema, nil
+	return NewValidatorFromSchema(schema), nil
 }
 
 func NewValidatorFromSchema(sch Schema) Validator {
@@ -195,19 +185,11 @@ func NewValidatorFromSchema(sch Schema) Validator {
 }
 
 func NewValidatorFromFile(filename string) (Validator, error) {
-	schema, err := NewSchemaFromFile(filename)
-	if err != nil {
-		return Validator{}, err
-	}
-	return NewValidatorFromSchema(schema), nil
-}
-
-func NewSchemaFromFile(filename string) (Schema, error) {
 	data, err := os.ReadFile(filename)
 	if err != nil {
-		return Schema{}, fmt.Errorf("failed to read schema file: %w", err)
+		return Validator{}, fmt.Errorf("failed to read schema file: %w", err)
 	}
-	return NewSchemaFromBytes(data)
+	return NewValidatorFromBytes(data)
 }
 
 func NewValidatorFromURL(schemaURL string) (Validator, error) {
@@ -230,7 +212,7 @@ var (
 )
 
 type UnknownTypes struct {
-	Types []string `json:"types,omitempty"`
+	Types []string
 }
 
 func (ut UnknownTypes) Error() string {
@@ -238,7 +220,7 @@ func (ut UnknownTypes) Error() string {
 }
 
 type ContentError struct {
-	Err error `json:"err,omitempty"`
+	Err error
 }
 
 func (ce ContentError) Error() string {
@@ -246,9 +228,9 @@ func (ce ContentError) Error() string {
 }
 
 type TagError struct {
-	Tag  int   `json:"tag,omitempty"`
+	Tag  int
-	Item int   `json:"item,omitempty"`
+	Item int
-	Err  error `json:"err,omitempty"`
+	Err  error
 }
 
 func (te TagError) Error() string {
@@ -256,7 +238,7 @@ func (te TagError) Error() string {
 }
 
 type RequiredTagError struct {
-	Missing []string `json:"missing,omitempty"`
+	Missing []string
 }
 
 func (rte RequiredTagError) Error() string {
@@ -403,9 +385,7 @@ func (v *Validator) validateNext(tag nostr.Tag, index int, this *ContentSpec) (f
 		return index, ErrDanglingSpace
 	}
 
-	if tag[index] == "" && !this.Required {
+	if validator, ok := v.TypeValidators[this.Type]; ok {
-		// empty string ok for non-required items
-	} else if validator, ok := v.TypeValidators[this.Type]; ok {
 		if err := validator(tag[index], this); err != nil {
 			return index, fmt.Errorf("invalid %s value '%s' at tag '%s', index %d: %w",
 				this.Type, tag[index], tag[0], index, err)

sdk/list.go

@@ -94,7 +94,7 @@ func fetchGenericList[V comparable, I TagItemWithValue[V]](
 		// we'll only save this if we got something which means we found at least one event
 		lastFetchKey := makeLastFetchKey(actualKind, pubkey)
 		sys.KVStore.Set(lastFetchKey, encodeTimestamp(nostr.Now()))
-		sys.Store.ReplaceEvent(*v.Event)
+		sys.Store.SaveEvent(*v.Event)
 	}
 
 	// save cache even if we didn't get anything

sdk/metadata.go

@@ -142,7 +142,7 @@ func (sys *System) FetchProfileMetadata(ctx context.Context, pubkey nostr.PubKey
 	if newM := sys.tryFetchMetadataFromNetwork(ctx, pubkey); newM != nil {
 		pm = *newM
 
-		sys.Store.ReplaceEvent(*pm.Event)
+		sys.Store.SaveEvent(*pm.Event)
 
 		// we'll only save this if we got something which means we found at least one event
 		lastFetchKey := makeLastFetchKey(0, pubkey)

sdk/utils.go

@@ -22,7 +22,9 @@ func IsVirtualRelay(url string) bool {
 		return true
 	}
 
-	if !testing.Testing() && (strings.HasPrefix(url, "ws://localhost") || strings.HasPrefix(url, "ws://127.0.0.1")) {
+	if !testing.Testing() &&
+		strings.HasPrefix(url, "ws://localhost") ||
+		strings.HasPrefix(url, "ws://127.0.0.1") {
 		return true
 	}
 

sdk/wot.go

@@ -92,7 +92,7 @@ func (sys *System) loadWoT(ctx context.Context, pubkey nostr.PubKey) chan nostr.
 
 	res := make(chan nostr.PubKey)
 
-	g.Go(func() error {
+	go func() {
 		for _, f := range sys.FetchFollowList(ctx, pubkey).Items {
 			g.Go(func() error {
 				res <- f.Pubkey
@@ -107,9 +107,7 @@ func (sys *System) loadWoT(ctx context.Context, pubkey nostr.PubKey) chan nostr.
 				return nil
 			})
 		}
-
+	}()
-		return nil
-	})
 
 	go func() {
 		g.Wait()

sdk/wot_test.go

@@ -14,7 +14,8 @@ func TestLoadWoT(t *testing.T) {
 	ctx := t.Context()
 
 	// test with fiatjaf's pubkey
-	wotch := sys.loadWoT(ctx, nostr.MustPubKeyFromHex("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"))
+	wotch, err := sys.loadWoT(ctx, nostr.MustPubKeyFromHex("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"))
+	require.NoError(t, err)
 
 	wot := make([]nostr.PubKey, 0, 100000)
 	wotch2 := make(chan nostr.PubKey)
@@ -59,7 +60,8 @@ func TestLoadWoTManyPeople(t *testing.T) {
 
 	// these are the same pubkey
 	go func() {
-		rabble := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa"))
+		rabble, err := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa"))
+		require.NoError(t, err)
 		diffs[0] = nostr.Now()
 		rabble1 = rabble
 		wg.Done()
@@ -67,7 +69,8 @@ func TestLoadWoTManyPeople(t *testing.T) {
 
 	time.Sleep(time.Millisecond * 20)
 	go func() {
-		rabble := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa"))
+		rabble, err := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa"))
+		require.NoError(t, err)
 		diffs[1] = nostr.Now()
 		rabble2 = rabble
 		wg.Done()
@@ -75,7 +78,8 @@ func TestLoadWoTManyPeople(t *testing.T) {
 
 	time.Sleep(time.Millisecond * 20)
 	go func() {
-		rabble := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa"))
+		rabble, err := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa"))
+		require.NoError(t, err)
 		diffs[2] = nostr.Now()
 		rabble3 = rabble
 		wg.Done()
@@ -84,7 +88,8 @@ func TestLoadWoTManyPeople(t *testing.T) {
 	// these should map to the same pos
 	time.Sleep(time.Millisecond * 20)
 	go func() {
-		alex := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("9ce71f1506ccf4b99f234af49bd6202be883a80f95a155c6e9a1c36fd7e780c7"))
+		alex, err := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("9ce71f1506ccf4b99f234af49bd6202be883a80f95a155c6e9a1c36fd7e780c7"))
+		require.NoError(t, err)
 		diffs[3] = nostr.Now()
 		alex1 = alex
 		wg.Done()
@@ -92,7 +97,8 @@ func TestLoadWoTManyPeople(t *testing.T) {
 
 	time.Sleep(time.Millisecond * 20)
 	go func() {
-		alex := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("9ce71f1506ccf4b99f234af49bd6202be883a80f95a155c6e9a1c36fd7e780c7"))
+		alex, err := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("9ce71f1506ccf4b99f234af49bd6202be883a80f95a155c6e9a1c36fd7e780c7"))
+		require.NoError(t, err)
 		diffs[4] = nostr.Now()
 		alex2 = alex
 		wg.Done()
@@ -100,14 +106,16 @@ func TestLoadWoTManyPeople(t *testing.T) {
 
 	// these are independent
 	go func() {
-		hodlbod := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322"))
+		hodlbod, err := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322"))
+		require.NoError(t, err)
 		require.True(t, hodlbod.Contains(nostr.MustPubKeyFromHex("ee11a5dff40c19a555f41fe42b48f00e618c91225622ae37b6c2bb67b76c4e49")))
 		require.True(t, hodlbod.Contains(nostr.MustPubKeyFromHex("76c71aae3a491f1d9eec47cba17e229cda4113a0bbb6e6ae1776d7643e29cafa")))
 		require.True(t, hodlbod.Contains(nostr.MustPubKeyFromHex("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")))
 		wg.Done()
 	}()
 	go func() {
-		mikedilger := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("ee11a5dff40c19a555f41fe42b48f00e618c91225622ae37b6c2bb67b76c4e49"))
+		mikedilger, err := sys.LoadWoTFilter(ctx, nostr.MustPubKeyFromHex("ee11a5dff40c19a555f41fe42b48f00e618c91225622ae37b6c2bb67b76c4e49"))
+		require.NoError(t, err)
 		require.True(t, mikedilger.Contains(nostr.MustPubKeyFromHex("97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322")))
 		require.True(t, mikedilger.Contains(nostr.MustPubKeyFromHex("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")))
 		wg.Done()