invalidated filters just return nothing instead of erroring.

i.e. if there has been an auth and for some reason the client tried to auth again
after RequestAuth() has been called again.

.github/workflows/test.yml

@@ -0,0 +1,14 @@
+name: test every commit
+on:
+  - push
+  - pull_request
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v3
+        with:
+          go-version-file: ./go.mod
+      - run: go test ./...

README.md

@@ -1 +1,121 @@
-khatru
+# khatru, a relay framework [![docs badge](https://img.shields.io/badge/docs-reference-blue)](https://pkg.go.dev/github.com/fiatjaf/khatru#Relay)
+
+[![Run Tests](https://github.com/fiatjaf/khatru/actions/workflows/test.yml/badge.svg)](https://github.com/fiatjaf/khatru/actions/workflows/test.yml)
+[![Go Reference](https://pkg.go.dev/badge/github.com/fiatjaf/khatru.svg)](https://pkg.go.dev/github.com/fiatjaf/khatru)
+[![Go Report Card](https://goreportcard.com/badge/github.com/fiatjaf/khatru)](https://goreportcard.com/report/github.com/fiatjaf/khatru)
+
+Khatru makes it easy to write very very custom relays:
+
+  - custom event or filter acceptance policies
+  - custom `AUTH` handlers
+  - custom storage and pluggable databases
+  - custom webpages and other HTTP handlers
+
+Here's a sample:
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/fiatjaf/khatru"
+	"github.com/nbd-wtf/go-nostr"
+)
+
+func main() {
+	// create the relay instance
+	relay := khatru.NewRelay()
+
+	// set up some basic properties (will be returned on the NIP-11 endpoint)
+	relay.Info.Name = "my relay"
+	relay.Info.PubKey = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
+	relay.Info.Description = "this is my custom relay"
+	relay.Info.Icon = "https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fliquipedia.net%2Fcommons%2Fimages%2F3%2F35%2FSCProbe.jpg&f=1&nofb=1&ipt=0cbbfef25bce41da63d910e86c3c343e6c3b9d63194ca9755351bb7c2efa3359&ipo=images"
+
+	// you must bring your own storage scheme -- if you want to have any
+	store := make(map[string]*nostr.Event, 120)
+
+	// set up the basic relay functions
+	relay.StoreEvent = append(relay.StoreEvent,
+		func(ctx context.Context, event *nostr.Event) error {
+			store[event.ID] = event
+			return nil
+		},
+	)
+	relay.QueryEvents = append(relay.QueryEvents,
+		func(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error) {
+			ch := make(chan *nostr.Event)
+			go func() {
+				for _, evt := range store {
+					if filter.Matches(evt) {
+						ch <- evt
+					}
+				}
+				close(ch)
+			}()
+			return ch, nil
+		},
+	)
+	relay.DeleteEvent = append(relay.DeleteEvent,
+		func(ctx context.Context, event *nostr.Event) error {
+			delete(store, event.ID)
+			return nil
+		},
+	)
+
+	// there are many other configurable things you can set
+	relay.RejectEvent = append(relay.RejectEvent,
+		func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
+			if event.PubKey == "fa984bd7dbb282f07e16e7ae87b26a2a7b9b90b7246a44771f0cf5ae58018f52" {
+				return true, "we don't allow this person to write here"
+			}
+			return false, "" // anyone else can
+		},
+	)
+
+	// you can request auth by rejecting an event or a request with the prefix "auth-required: "
+	relay.RejectFilter = append(relay.RejectFilter,
+		func(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
+			if pubkey := khatru.GetAuthed(ctx); pubkey != "" {
+				log.Printf("request from %s\n", pubkey)
+				return false, ""
+			}
+			return true, "auth-required: only authenticated users can read from this relay"
+			// (this will cause an AUTH message to be sent and then a CLOSED message such that clients can
+			//  authenticate and then request again)
+		},
+	)
+	// check the docs for more goodies!
+
+	mux := relay.Router()
+	// set up other http handlers
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("content-type", "text/html")
+		fmt.Fprintf(w, `<b>welcome</b> to my relay!`)
+	})
+
+	// start the server
+	fmt.Println("running on :3334")
+	http.ListenAndServe(":3334", relay)
+}
+```
+
+### But I don't want to write my own database!
+
+Fear no more. Using the https://github.com/fiatjaf/eventstore module you get a bunch of compatible databases out of the box and you can just plug them into your relay. For example, [sqlite](https://pkg.go.dev/github.com/fiatjaf/eventstore/sqlite3):
+
+```go
+	db := sqlite3.SQLite3Backend{DatabaseURL: "/tmp/khatru-sqlite-tmp"}
+	if err := db.Init(); err != nil {
+		panic(err)
+	}
+
+	relay.StoreEvent = append(relay.StoreEvent, db.SaveEvent)
+	relay.QueryEvents = append(relay.QueryEvents, db.QueryEvents)
+	relay.CountEvents = append(relay.CountEvents, db.CountEvents)
+	relay.DeleteEvent = append(relay.DeleteEvent, db.DeleteEvent)
+```

add-event.go

@@ -1,134 +0,0 @@
-package khatru
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func (rl *Relay) AddEvent(ctx context.Context, evt *nostr.Event) error {
-	if evt == nil {
-		return fmt.Errorf("event is nil")
-	}
-
-	msg := ""
-	rejecting := false
-	for _, reject := range rl.RejectEvent {
-		rejecting, msg = reject(ctx, evt)
-		if rejecting {
-			break
-		}
-	}
-
-	if rejecting {
-		if msg == "" {
-			msg = "no reason"
-		}
-		return fmt.Errorf(msg)
-	}
-
-	if 20000 <= evt.Kind && evt.Kind < 30000 {
-		// do not store ephemeral events
-	} else {
-		if evt.Kind == 0 || evt.Kind == 3 || (10000 <= evt.Kind && evt.Kind < 20000) {
-			// replaceable event, delete before storing
-			for _, query := range rl.QueryEvents {
-				ch, err := query(ctx, nostr.Filter{Authors: []string{evt.PubKey}, Kinds: []int{evt.Kind}})
-				if err != nil {
-					continue
-				}
-				previous := <-ch
-				if previous != nil {
-					for _, del := range rl.DeleteEvent {
-						del(ctx, previous)
-					}
-				}
-			}
-		} else if 30000 <= evt.Kind && evt.Kind < 40000 {
-			// parameterized replaceable event, delete before storing
-			d := evt.Tags.GetFirst([]string{"d", ""})
-			if d != nil {
-				for _, query := range rl.QueryEvents {
-					ch, err := query(ctx, nostr.Filter{Authors: []string{evt.PubKey}, Kinds: []int{evt.Kind}, Tags: nostr.TagMap{"d": []string{d.Value()}}})
-					if err != nil {
-						continue
-					}
-					previous := <-ch
-					if previous != nil {
-						for _, del := range rl.DeleteEvent {
-							del(ctx, previous)
-						}
-					}
-				}
-			}
-		}
-
-		// store
-		for _, store := range rl.StoreEvent {
-			if saveErr := store(ctx, evt); saveErr != nil {
-				switch saveErr {
-				case ErrDupEvent:
-					return nil
-				default:
-					errmsg := saveErr.Error()
-					if nip20prefixmatcher.MatchString(errmsg) {
-						return saveErr
-					} else {
-						return fmt.Errorf("error: failed to save (%s)", errmsg)
-					}
-				}
-			}
-		}
-
-		for _, ons := range rl.OnEventSaved {
-			ons(ctx, evt)
-		}
-	}
-
-	notifyListeners(evt)
-	return nil
-}
-
-func (rl *Relay) handleDeleteRequest(ctx context.Context, evt *nostr.Event) error {
-	// event deletion -- nip09
-	for _, tag := range evt.Tags {
-		if len(tag) >= 2 && tag[0] == "e" {
-			// first we fetch the event
-			for _, query := range rl.QueryEvents {
-				ch, err := query(ctx, nostr.Filter{IDs: []string{tag[1]}})
-				if err != nil {
-					continue
-				}
-				target := <-ch
-				if target == nil {
-					continue
-				}
-				// got the event, now check if the user can delete it
-				acceptDeletion := target.PubKey == evt.PubKey
-				var msg string
-				if acceptDeletion == false {
-					msg = "you are not the author of this event"
-				}
-				// but if we have a function to overwrite this outcome, use that instead
-				for _, odo := range rl.OverwriteDeletionOutcome {
-					acceptDeletion, msg = odo(ctx, target, evt)
-				}
-				if acceptDeletion {
-					// delete it
-					for _, del := range rl.DeleteEvent {
-						del(ctx, target)
-					}
-				} else {
-					// fail and stop here
-					return fmt.Errorf("blocked: %s", msg)
-				}
-
-				// don't try to query this same event again
-				break
-			}
-		}
-	}
-
-	return nil
-}

adding.go

@@ -0,0 +1,85 @@
+package khatru
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/fiatjaf/eventstore"
+	"github.com/nbd-wtf/go-nostr"
+)
+
+// AddEvent sends an event through then normal add pipeline, as if it was received from a websocket.
+func (rl *Relay) AddEvent(ctx context.Context, evt *nostr.Event) error {
+	if evt == nil {
+		return errors.New("error: event is nil")
+	}
+
+	for _, reject := range rl.RejectEvent {
+		if reject, msg := reject(ctx, evt); reject {
+			if msg == "" {
+				return errors.New("blocked: no reason")
+			} else {
+				return errors.New(nostr.NormalizeOKMessage(msg, "blocked"))
+			}
+		}
+	}
+
+	if 20000 <= evt.Kind && evt.Kind < 30000 {
+		// do not store ephemeral events
+	} else {
+		if evt.Kind == 0 || evt.Kind == 3 || (10000 <= evt.Kind && evt.Kind < 20000) {
+			// replaceable event, delete before storing
+			for _, query := range rl.QueryEvents {
+				ch, err := query(ctx, nostr.Filter{Authors: []string{evt.PubKey}, Kinds: []int{evt.Kind}})
+				if err != nil {
+					continue
+				}
+				if previous := <-ch; previous != nil && isOlder(previous, evt) {
+					for _, del := range rl.DeleteEvent {
+						del(ctx, previous)
+					}
+				}
+			}
+		} else if 30000 <= evt.Kind && evt.Kind < 40000 {
+			// parameterized replaceable event, delete before storing
+			d := evt.Tags.GetFirst([]string{"d", ""})
+			if d != nil {
+				for _, query := range rl.QueryEvents {
+					ch, err := query(ctx, nostr.Filter{Authors: []string{evt.PubKey}, Kinds: []int{evt.Kind}, Tags: nostr.TagMap{"d": []string{d.Value()}}})
+					if err != nil {
+						continue
+					}
+					if previous := <-ch; previous != nil && isOlder(previous, evt) {
+						for _, del := range rl.DeleteEvent {
+							del(ctx, previous)
+						}
+					}
+				}
+			}
+		}
+
+		// store
+		for _, store := range rl.StoreEvent {
+			if saveErr := store(ctx, evt); saveErr != nil {
+				switch saveErr {
+				case eventstore.ErrDupEvent:
+					return nil
+				default:
+					return fmt.Errorf(nostr.NormalizeOKMessage(saveErr.Error(), "error"))
+				}
+			}
+		}
+
+		for _, ons := range rl.OnEventSaved {
+			ons(ctx, evt)
+		}
+	}
+
+	for _, ovw := range rl.OverwriteResponseEvent {
+		ovw(ctx, evt)
+	}
+	notifyListeners(evt)
+
+	return nil
+}

broadcasting.go

@@ -0,0 +1,11 @@
+package khatru
+
+import (
+	"github.com/nbd-wtf/go-nostr"
+)
+
+// BroadcastEvent emits an event to all listeners whose filters' match, skipping all filters and actions
+// it also doesn't attempt to store the event or trigger any reactions or callbacks
+func (rl *Relay) BroadcastEvent(evt *nostr.Event) {
+	notifyListeners(evt)
+}

deleting.go

@@ -0,0 +1,51 @@
+package khatru
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/nbd-wtf/go-nostr"
+)
+
+func (rl *Relay) handleDeleteRequest(ctx context.Context, evt *nostr.Event) error {
+	// event deletion -- nip09
+	for _, tag := range evt.Tags {
+		if len(tag) >= 2 && tag[0] == "e" {
+			// first we fetch the event
+			for _, query := range rl.QueryEvents {
+				ch, err := query(ctx, nostr.Filter{IDs: []string{tag[1]}})
+				if err != nil {
+					continue
+				}
+				target := <-ch
+				if target == nil {
+					continue
+				}
+				// got the event, now check if the user can delete it
+				acceptDeletion := target.PubKey == evt.PubKey
+				var msg string
+				if acceptDeletion == false {
+					msg = "you are not the author of this event"
+				}
+				// but if we have a function to overwrite this outcome, use that instead
+				for _, odo := range rl.OverwriteDeletionOutcome {
+					acceptDeletion, msg = odo(ctx, target, evt)
+				}
+				if acceptDeletion {
+					// delete it
+					for _, del := range rl.DeleteEvent {
+						del(ctx, target)
+					}
+				} else {
+					// fail and stop here
+					return fmt.Errorf("blocked: %s", msg)
+				}
+
+				// don't try to query this same event again
+				break
+			}
+		}
+	}
+
+	return nil
+}

errors.go

@@ -1,5 +0,0 @@
-package khatru
-
-import "fmt"
-
-var ErrDupEvent = fmt.Errorf("duplicate: event already exists")

examples/basic-badger/main.go

@@ -4,14 +4,14 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/fiatjaf/eventstore/badger"
 	"github.com/fiatjaf/khatru"
-	"github.com/fiatjaf/khatru/plugins/storage/badgern"
 )
 
 func main() {
 	relay := khatru.NewRelay()
 
-	db := badgern.BadgerBackend{Path: "/tmp/khatru-badgern-tmp"}
+	db := badger.BadgerBackend{Path: "/tmp/khatru-badgern-tmp"}
 	if err := db.Init(); err != nil {
 		panic(err)
 	}

examples/basic-elasticsearch/main.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 
 	"github.com/fiatjaf/khatru"
-	"github.com/fiatjaf/khatru/plugins/storage/elasticsearch"
+	"github.com/fiatjaf/eventstore/elasticsearch"
 )
 
 func main() {

examples/basic-lmdb/main.go

@@ -5,14 +5,14 @@ import (
 	"net/http"
 	"os"
 
+	"github.com/fiatjaf/eventstore/lmdb"
 	"github.com/fiatjaf/khatru"
-	"github.com/fiatjaf/khatru/plugins/storage/lmdbn"
 )
 
 func main() {
 	relay := khatru.NewRelay()
 
-	db := lmdbn.LMDBBackend{Path: "/tmp/khatru-lmdbn-tmp"}
+	db := lmdb.LMDBBackend{Path: "/tmp/khatru-lmdb-tmp"}
 	os.MkdirAll(db.Path, 0755)
 	if err := db.Init(); err != nil {
 		panic(err)

examples/basic-postgres/main.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 
 	"github.com/fiatjaf/khatru"
-	"github.com/fiatjaf/khatru/plugins/storage/postgresql"
+	"github.com/fiatjaf/eventstore/postgresql"
 )
 
 func main() {

examples/basic-sqlite3/main.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 
 	"github.com/fiatjaf/khatru"
-	"github.com/fiatjaf/khatru/plugins/storage/sqlite3"
+	"github.com/fiatjaf/eventstore/sqlite3"
 )
 
 func main() {

examples/exclusive/main.go

@@ -6,16 +6,16 @@ import (
 	"net/http"
 	"os"
 
+	"github.com/fiatjaf/eventstore/lmdb"
 	"github.com/fiatjaf/khatru"
-	"github.com/fiatjaf/khatru/plugins"
-	"github.com/fiatjaf/khatru/plugins/storage/lmdbn"
+	"github.com/fiatjaf/khatru/policies"
 	"github.com/nbd-wtf/go-nostr"
 )
 
 func main() {
 	relay := khatru.NewRelay()
 
-	db := lmdbn.LMDBBackend{Path: "/tmp/exclusive"}
+	db := lmdb.LMDBBackend{Path: "/tmp/exclusive"}
 	os.MkdirAll(db.Path, 0755)
 	if err := db.Init(); err != nil {
 		panic(err)
@@ -26,8 +26,8 @@ func main() {
 	relay.CountEvents = append(relay.CountEvents, db.CountEvents)
 	relay.DeleteEvent = append(relay.DeleteEvent, db.DeleteEvent)
 
-	relay.RejectEvent = append(relay.RejectEvent, plugins.PreventTooManyIndexableTags(10))
-	relay.RejectFilter = append(relay.RejectFilter, plugins.NoPrefixFilters, plugins.NoComplexFilters)
+	relay.RejectEvent = append(relay.RejectEvent, policies.PreventTooManyIndexableTags(10, nil, nil))
+	relay.RejectFilter = append(relay.RejectFilter, policies.NoComplexFilters)
 
 	relay.OnEventSaved = append(relay.OnEventSaved, func(ctx context.Context, event *nostr.Event) {
 	})

examples/readme-demo/main.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/fiatjaf/khatru"
+	"github.com/nbd-wtf/go-nostr"
+)
+
+func main() {
+	// create the relay instance
+	relay := khatru.NewRelay()
+
+	// set up some basic properties (will be returned on the NIP-11 endpoint)
+	relay.Info.Name = "my relay"
+	relay.Info.PubKey = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
+	relay.Info.Description = "this is my custom relay"
+	relay.Info.Icon = "https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fliquipedia.net%2Fcommons%2Fimages%2F3%2F35%2FSCProbe.jpg&f=1&nofb=1&ipt=0cbbfef25bce41da63d910e86c3c343e6c3b9d63194ca9755351bb7c2efa3359&ipo=images"
+
+	// you must bring your own storage scheme -- if you want to have any
+	store := make(map[string]*nostr.Event, 120)
+
+	// set up the basic relay functions
+	relay.StoreEvent = append(relay.StoreEvent,
+		func(ctx context.Context, event *nostr.Event) error {
+			store[event.ID] = event
+			return nil
+		},
+	)
+	relay.QueryEvents = append(relay.QueryEvents,
+		func(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error) {
+			ch := make(chan *nostr.Event)
+			go func() {
+				for _, evt := range store {
+					if filter.Matches(evt) {
+						ch <- evt
+					}
+				}
+				close(ch)
+			}()
+			return ch, nil
+		},
+	)
+	relay.DeleteEvent = append(relay.DeleteEvent,
+		func(ctx context.Context, event *nostr.Event) error {
+			delete(store, event.ID)
+			return nil
+		},
+	)
+
+	// there are many other configurable things you can set
+	relay.RejectEvent = append(relay.RejectEvent,
+		func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
+			if event.PubKey == "fa984bd7dbb282f07e16e7ae87b26a2a7b9b90b7246a44771f0cf5ae58018f52" {
+				return true, "we don't allow this person to write here"
+			}
+			return false, "" // anyone else can
+		},
+	)
+
+	// you can request auth by rejecting an event or a request with the prefix "auth-required: "
+	relay.RejectFilter = append(relay.RejectFilter,
+		func(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
+			if pubkey := khatru.GetAuthed(ctx); pubkey != "" {
+				log.Printf("request from %s\n", pubkey)
+				return false, ""
+			}
+			return true, "auth-required: only authenticated users can read from this relay"
+			// (this will cause an AUTH message to be sent and then a CLOSED message such that clients can
+			//  authenticate and then request again)
+		},
+	)
+	// check the docs for more goodies!
+
+	mux := relay.Router()
+	// set up other http handlers
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("content-type", "text/html")
+		fmt.Fprintf(w, `<b>welcome</b> to my relay!`)
+	})
+
+	// start the server
+	fmt.Println("running on :3334")
+	http.ListenAndServe(":3334", relay)
+}

go.mod

@@ -1,61 +1,57 @@
 module github.com/fiatjaf/khatru
 
-go 1.20
+go 1.21.0
 
 require (
-	github.com/aquasecurity/esquery v0.2.0
-	github.com/bmatsuo/lmdb-go v1.8.0
-	github.com/dgraph-io/badger/v4 v4.1.0
-	github.com/elastic/go-elasticsearch/v8 v8.6.0
 	github.com/fasthttp/websocket v1.5.3
-	github.com/gobwas/ws v1.2.0
-	github.com/jmoiron/sqlx v1.3.1
-	github.com/lib/pq v1.10.3
-	github.com/mattn/go-sqlite3 v1.14.6
-	github.com/nbd-wtf/go-nostr v0.20.0
+	github.com/fiatjaf/eventstore v0.3.1
+	github.com/nbd-wtf/go-nostr v0.27.1
 	github.com/puzpuzpuz/xsync/v2 v2.5.1
 	github.com/rs/cors v1.7.0
-	github.com/stretchr/testify v1.8.2
-	golang.org/x/exp v0.0.0-20230425010034-47ecfdc1ba53
+	github.com/sebest/xff v0.0.0-20210106013422-671bd2870b3a
+	golang.org/x/exp v0.0.0-20231006140011-7918f672742d
 )
 
 require (
+	github.com/PowerDNS/lmdb-go v1.9.2 // indirect
 	github.com/andybalholm/brotli v1.0.5 // indirect
+	github.com/aquasecurity/esquery v0.2.0 // indirect
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/decred/dcrd/crypto/blake256 v1.0.1 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
+	github.com/dgraph-io/badger/v4 v4.2.0 // indirect
 	github.com/dgraph-io/ristretto v0.1.1 // indirect
-	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/elastic/elastic-transport-go/v8 v8.0.0-20211216131617-bbee439d559c // indirect
-	github.com/elastic/go-elasticsearch/v7 v7.6.0 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/elastic/elastic-transport-go/v8 v8.3.0 // indirect
+	github.com/elastic/go-elasticsearch/v7 v7.17.10 // indirect
+	github.com/elastic/go-elasticsearch/v8 v8.10.1 // indirect
 	github.com/fatih/structs v1.1.0 // indirect
 	github.com/gobwas/httphead v0.1.0 // indirect
 	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.3.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
-	github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 // indirect
-	github.com/golang/protobuf v1.3.1 // indirect
-	github.com/golang/snappy v0.0.3 // indirect
-	github.com/google/flatbuffers v1.12.1 // indirect
+	github.com/golang/glog v1.1.2 // indirect
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/flatbuffers v23.5.26+incompatible // indirect
+	github.com/jmoiron/sqlx v1.3.5 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
-	github.com/klauspost/compress v1.16.5 // indirect
-	github.com/kr/text v0.2.0 // indirect
+	github.com/klauspost/compress v1.17.2 // indirect
+	github.com/lib/pq v1.10.9 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-sqlite3 v1.14.18 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/puzpuzpuz/xsync v1.5.2 // indirect
 	github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee // indirect
-	github.com/tidwall/gjson v1.14.4 // indirect
+	github.com/tidwall/gjson v1.17.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/pretty v1.2.0 // indirect
+	github.com/tidwall/pretty v1.2.1 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasthttp v1.47.0 // indirect
-	go.opencensus.io v0.22.5 // indirect
-	golang.org/x/net v0.8.0 // indirect
-	golang.org/x/sys v0.8.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	go.opencensus.io v0.24.0 // indirect
+	golang.org/x/net v0.17.0 // indirect
+	golang.org/x/sys v0.14.0 // indirect
+	google.golang.org/protobuf v1.31.0 // indirect
 )

go.sum

@@ -1,20 +1,21 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/PowerDNS/lmdb-go v1.9.2 h1:Cmgerh9y3ZKBZGz1irxSShhfmFyRUh+Zdk4cZk7ZJvU=
+github.com/PowerDNS/lmdb-go v1.9.2/go.mod h1:TE0l+EZK8Z1B4dx070ZxkWTlp8RG1mjN0/+FkFRQMtU=
 github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
 github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
 github.com/aquasecurity/esquery v0.2.0 h1:9WWXve95TE8hbm3736WB7nS6Owl8UGDeu+0jiyE9ttA=
 github.com/aquasecurity/esquery v0.2.0/go.mod h1:VU+CIFR6C+H142HHZf9RUkp4Eedpo9UrEKeCQHWf9ao=
-github.com/bmatsuo/lmdb-go v1.8.0 h1:ohf3Q4xjXZBKh4AayUY4bb2CXuhRAI8BYGlJq08EfNA=
-github.com/bmatsuo/lmdb-go v1.8.0/go.mod h1:wWPZmKdOAZsl4qOqkowQ1aCrFie1HU8gWloHMCeAUdM=
 github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
 github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 h1:KdUfX2zKommPRa+PD0sWZUyXe9w277ABlgELO7H04IM=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
-github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -22,114 +23,141 @@ github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5il
 github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
-github.com/dgraph-io/badger/v4 v4.1.0 h1:E38jc0f+RATYrycSUf9LMv/t47XAy+3CApyYSq4APOQ=
-github.com/dgraph-io/badger/v4 v4.1.0/go.mod h1:P50u28d39ibBRmIJuQC/NSdBOg46HnHw7al2SW5QRHg=
+github.com/dgraph-io/badger/v4 v4.2.0 h1:kJrlajbXXL9DFTNuhhu9yCx7JJa4qpYWxtE8BzuWsEs=
+github.com/dgraph-io/badger/v4 v4.2.0/go.mod h1:qfCqhPoWDFJRx1gp5QwwyGo8xk1lbHUxvK9nK0OGAak=
 github.com/dgraph-io/ristretto v0.1.1 h1:6CWw5tJNgpegArSHpNHJKldNeq03FQCwYvfMVWajOK8=
 github.com/dgraph-io/ristretto v0.1.1/go.mod h1:S1GPSBCYCIhmVNfcth17y2zZtQT6wzkzgwUve0VDWWA=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
-github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-github.com/elastic/elastic-transport-go/v8 v8.0.0-20211216131617-bbee439d559c h1:onA2RpIyeCPvYAj1LFYiiMTrSpqVINWMfYFRS7lofJs=
-github.com/elastic/elastic-transport-go/v8 v8.0.0-20211216131617-bbee439d559c/go.mod h1:87Tcz8IVNe6rVSLdBux1o/PEItLtyabHU3naC7IoqKI=
-github.com/elastic/go-elasticsearch/v7 v7.6.0 h1:sYpGLpEFHgLUKLsZUBfuaVI9QgHjS3JdH9fX4/z8QI8=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/elastic/elastic-transport-go/v8 v8.3.0 h1:DJGxovyQLXGr62e9nDMPSxRyWION0Bh6d9eCFBriiHo=
+github.com/elastic/elastic-transport-go/v8 v8.3.0/go.mod h1:87Tcz8IVNe6rVSLdBux1o/PEItLtyabHU3naC7IoqKI=
 github.com/elastic/go-elasticsearch/v7 v7.6.0/go.mod h1:OJ4wdbtDNk5g503kvlHLyErCgQwwzmDtaFC4XyOxXA4=
-github.com/elastic/go-elasticsearch/v8 v8.6.0 h1:xMaSe8jIh7NHzmNo9YBkewmaD2Pr+tX+zLkXxhieny4=
-github.com/elastic/go-elasticsearch/v8 v8.6.0/go.mod h1:Usvydt+x0dv9a1TzEUaovqbJor8rmOHy5dSmPeMAE2k=
+github.com/elastic/go-elasticsearch/v7 v7.17.10 h1:TCQ8i4PmIJuBunvBS6bwT2ybzVFxxUhhltAs3Gyu1yo=
+github.com/elastic/go-elasticsearch/v7 v7.17.10/go.mod h1:OJ4wdbtDNk5g503kvlHLyErCgQwwzmDtaFC4XyOxXA4=
+github.com/elastic/go-elasticsearch/v8 v8.10.1 h1:JJ3i2DimYTsJcUoEGbg6tNB0eehTNdid9c5kTR1TGuI=
+github.com/elastic/go-elasticsearch/v8 v8.10.1/go.mod h1:GU1BJHO7WeamP7UhuElYwzzHtvf9SDmeVpSSy9+o6Qg=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fasthttp/websocket v1.5.3 h1:TPpQuLwJYfd4LJPXvHDYPMFWbLjsT91n3GpWtCQtdek=
 github.com/fasthttp/websocket v1.5.3/go.mod h1:46gg/UBmTU1kUaTcwQXpUxtRwG2PvIZYeA8oL6vF3Fs=
 github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
-github.com/go-sql-driver/mysql v1.5.0 h1:ozyZYNQW3x3HtqT1jira07DN2PArx2v7/mN66gGcHOs=
-github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/fiatjaf/eventstore v0.3.1 h1:GDuF8RxBNL6km9Y7qEucDQbkzKfkPJqoA/YiiIE0wao=
+github.com/fiatjaf/eventstore v0.3.1/go.mod h1:q3r6SuNhCxaSwfnK++2BratEVUcwK2NNr004hLOpz7Q=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
+github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
 github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.2.0 h1:u0p9s3xLYpZCA1z5JgCkMeB34CKCMMQbM+G8Ii7YD0I=
-github.com/gobwas/ws v1.2.0/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
+github.com/gobwas/ws v1.3.1 h1:Qi34dfLMWJbiKaNbDVzM9x27nZBjmkaW6i4+Ku+pGVU=
+github.com/gobwas/ws v1.3.1/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 h1:ZgQEtGgCBiWRM39fZuwSd1LwSqqSW0hOdXCYYDX0R3I=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/glog v1.1.2 h1:DVjP2PbBOzHyzA+dn3WhHIq4NdVu3Q+pvivFICf/7fo=
+github.com/golang/glog v1.1.2/go.mod h1:zR+okUeTbrL6EL3xHUDxZuEtGv04p5shwip1+mL/rLQ=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA=
-github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/flatbuffers v1.12.1 h1:MVlul7pQNoDzWRLTw5imwYsl+usrS1TXG2H4jg6ImGw=
-github.com/google/flatbuffers v1.12.1/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/flatbuffers v23.5.26+incompatible h1:M9dgRyhJemaM4Sw8+66GHBu8ioaQmyPLg1b8VwK5WJg=
+github.com/google/flatbuffers v23.5.26+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/jgroeneveld/schema v1.0.0 h1:J0E10CrOkiSEsw6dfb1IfrDJD14pf6QLVJ3tRPl/syI=
 github.com/jgroeneveld/schema v1.0.0/go.mod h1:M14lv7sNMtGvo3ops1MwslaSYgDYxrSmbzWIQ0Mr5rs=
 github.com/jgroeneveld/trial v2.0.0+incompatible h1:d59ctdgor+VqdZCAiUfVN8K13s0ALDioG5DWwZNtRuQ=
 github.com/jgroeneveld/trial v2.0.0+incompatible/go.mod h1:I6INLW96EN8WysNBXUFI3M4RIC8ePg9ntAc/Wy+U/+M=
-github.com/jmoiron/sqlx v1.3.1 h1:aLN7YINNZ7cYOPK3QC83dbM6KT0NMqVMw961TqrejlE=
-github.com/jmoiron/sqlx v1.3.1/go.mod h1:2BljVx/86SuTyjE+aPYlHCTNvZrnJXghYGpNiXLBMCQ=
+github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
+github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.16.5 h1:IFV2oUNUzZaz+XyusxpLzpzS8Pt5rh0Z16For/djlyI=
-github.com/klauspost/compress v1.16.5/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
+github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.10.3 h1:v9QZf2Sn6AmjXtQeFpdoq/eaNtYP6IN+7lcrygsIAtg=
-github.com/lib/pq v1.10.3/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
-github.com/mattn/go-sqlite3 v1.14.6 h1:dNPt6NO46WmLVt2DLNpwczCmdV5boIZ6g/tlDrlRUbg=
 github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
-github.com/nbd-wtf/go-nostr v0.20.0 h1:97SYhg68jWh5G1bW1g454hA0dTV7btwtPg836n4no0o=
-github.com/nbd-wtf/go-nostr v0.20.0/go.mod h1:iFfiZr8YYSC1vmdUei0VfDB7GH/RjS3cbmiD1I5BKyo=
+github.com/mattn/go-sqlite3 v1.14.18 h1:JL0eqdCOq6DJVNPSvArO/bIV9/P7fbGrV00LZHc+5aI=
+github.com/mattn/go-sqlite3 v1.14.18/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
+github.com/nbd-wtf/go-nostr v0.27.1 h1:DAwXpAUGxq3/B8KZIWlZmJIoDNkMvlKqQwB/OM/49xk=
+github.com/nbd-wtf/go-nostr v0.27.1/go.mod h1:bkffJI+x914sPQWum9ZRUn66D7NpDnAoWo1yICvj3/0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/puzpuzpuz/xsync v1.5.2 h1:yRAP4wqSOZG+/4pxJ08fPTwrfL0IzE/LKQ/cw509qGY=
-github.com/puzpuzpuz/xsync v1.5.2/go.mod h1:K98BYhX3k1dQ2M63t1YNVDanbwUPmBCAhNmVrrxfiGg=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/puzpuzpuz/xsync/v2 v2.5.1 h1:mVGYAvzDSu52+zaGyNjC+24Xw2bQi3kTr4QJ6N9pIIU=
 github.com/puzpuzpuz/xsync/v2 v2.5.1/go.mod h1:gD2H2krq/w52MfPLE+Uy64TzJDVY7lP2znR9qmR35kU=
 github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee h1:8Iv5m6xEo1NR1AvpV+7XmhI4r39LGNzwUL4YpMuL5vk=
 github.com/savsgio/gotils v0.0.0-20230208104028-c358bd845dee/go.mod h1:qwtSXrKuJh/zsFQ12yEE89xfCrGKK63Rr7ctU/uCo4g=
+github.com/sebest/xff v0.0.0-20210106013422-671bd2870b3a h1:iLcLb5Fwwz7g/DLK89F+uQBDeAhHhwdzB5fSlVdhGcM=
+github.com/sebest/xff v0.0.0-20210106013422-671bd2870b3a/go.mod h1:wozgYq9WEBQBaIJe4YZ0qTSFAMxmcwBhQH0fO0R34Z0=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/tidwall/gjson v1.14.4 h1:uo0p8EbA09J7RQaflQ1aBRffTR7xedD2bcIVSYxLnkM=
-github.com/tidwall/gjson v1.14.4/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/tidwall/gjson v1.17.0 h1:/Jocvlh98kcTfpN2+JzGQWQcqrPQwDrVEMApx/M5ZwM=
+github.com/tidwall/gjson v1.17.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
 github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
 github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
-github.com/tidwall/pretty v1.2.0 h1:RWIZEg2iJ8/g6fDDYzMpobmaoGh5OLl4AXtGUGPcqCs=
 github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasthttp v1.47.0 h1:y7moDoxYzMooFpT5aHgNgVOQDrS3qlkfiP9mDtGGK9c=
 github.com/valyala/fasthttp v1.47.0/go.mod h1:k2zXd82h/7UZc3VOdJ2WaUqt1uZ/XpXAfE9i+HBC3lA=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.opencensus.io v0.22.5 h1:dntmOdLpSpHlVqbW5Eay97DelsZHe+55D+xC6i0dDS0=
-go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
+go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
+go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20230425010034-47ecfdc1ba53 h1:5llv2sWeaMSnA3w2kS57ouQQ4pudlXrR0dCgw51QK9o=
-golang.org/x/exp v0.0.0-20230425010034-47ecfdc1ba53/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
@@ -143,30 +171,30 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
+golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=
+golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
@@ -177,14 +205,30 @@ golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8T
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

handlers.go

@@ -6,30 +6,34 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"net/http"
+	"strings"
 	"sync"
 	"time"
 
 	"github.com/fasthttp/websocket"
 	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nip11"
 	"github.com/nbd-wtf/go-nostr/nip42"
+	"github.com/rs/cors"
 )
 
 // ServeHTTP implements http.Handler interface.
 func (rl *Relay) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if rl.ServiceURL == "" {
+		rl.ServiceURL = getServiceBaseURL(r)
+	}
+
 	if r.Header.Get("Upgrade") == "websocket" {
 		rl.HandleWebsocket(w, r)
 	} else if r.Header.Get("Accept") == "application/nostr+json" {
-		rl.HandleNIP11(w, r)
+		cors.AllowAll().Handler(http.HandlerFunc(rl.HandleNIP11)).ServeHTTP(w, r)
 	} else {
 		rl.serveMux.ServeHTTP(w, r)
 	}
 }
 
 func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
 	conn, err := rl.upgrader.Upgrade(w, r, nil)
 	if err != nil {
 		rl.Log.Printf("failed to upgrade websocket: %v\n", err)
@@ -43,21 +47,34 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 	rand.Read(challenge)
 
 	ws := &WebSocket{
-		conn:           conn,
-		Challenge:      hex.EncodeToString(challenge),
-		WaitingForAuth: make(chan struct{}),
+		conn:      conn,
+		Request:   r,
+		Challenge: hex.EncodeToString(challenge),
+	}
+
+	ctx, cancel := context.WithCancel(
+		context.WithValue(
+			context.Background(),
+			wsKey, ws,
+		),
+	)
+
+	kill := func() {
+		for _, ondisconnect := range rl.OnDisconnect {
+			ondisconnect(ctx)
+		}
+
+		ticker.Stop()
+		cancel()
+		if _, ok := rl.clients.Load(conn); ok {
+			conn.Close()
+			rl.clients.Delete(conn)
+			removeListener(ws)
+		}
 	}
 
-	// reader
 	go func() {
-		defer func() {
-			ticker.Stop()
-			if _, ok := rl.clients.Load(conn); ok {
-				conn.Close()
-				rl.clients.Delete(conn)
-				removeListener(ws)
-			}
-		}()
+		defer kill()
 
 		conn.SetReadLimit(rl.MaxMessageSize)
 		conn.SetReadDeadline(time.Now().Add(rl.PongWait))
@@ -75,13 +92,14 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 			if err != nil {
 				if websocket.IsUnexpectedCloseError(
 					err,
+					websocket.CloseNormalClosure,    // 1000
 					websocket.CloseGoingAway,        // 1001
 					websocket.CloseNoStatusReceived, // 1005
 					websocket.CloseAbnormalClosure,  // 1006
 				) {
 					rl.Log.Printf("unexpected close error from %s: %v\n", r.Header.Get("X-Forwarded-For"), err)
 				}
-				break
+				return
 			}
 
 			if typ == websocket.PingMessage {
@@ -90,211 +108,129 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 			}
 
 			go func(message []byte) {
-				ctx = context.Background()
-
-				var request []json.RawMessage
-				if err := json.Unmarshal(message, &request); err != nil {
+				envelope := nostr.ParseMessage(message)
+				if envelope == nil {
 					// stop silently
 					return
 				}
 
-				if len(request) < 2 {
-					ws.WriteJSON(nostr.NoticeEnvelope("request has less than 2 parameters"))
-					return
-				}
-
-				var typ string
-				json.Unmarshal(request[0], &typ)
-
-				switch typ {
-				case "EVENT":
-					// it's a new event
-					var evt nostr.Event
-					if err := json.Unmarshal(request[1], &evt); err != nil {
-						ws.WriteJSON(nostr.NoticeEnvelope("failed to decode event: " + err.Error()))
+				switch env := envelope.(type) {
+				case *nostr.EventEnvelope:
+					// check id
+					hash := sha256.Sum256(env.Event.Serialize())
+					id := hex.EncodeToString(hash[:])
+					if id != env.Event.ID {
+						ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: false, Reason: "invalid: id is computed incorrectly"})
 						return
 					}
 
-					// check serialization
-					serialized := evt.Serialize()
-
-					// assign ID
-					hash := sha256.Sum256(serialized)
-					evt.ID = hex.EncodeToString(hash[:])
-
-					// check signature (requires the ID to be set)
-					if ok, err := evt.CheckSignature(); err != nil {
-						reason := "error: failed to verify signature"
-						ws.WriteJSON(nostr.OKEnvelope{EventID: evt.ID, OK: false, Reason: &reason})
+					// check signature
+					if ok, err := env.Event.CheckSignature(); err != nil {
+						ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: false, Reason: "error: failed to verify signature"})
 						return
 					} else if !ok {
-						reason := "invalid: signature is invalid"
-						ws.WriteJSON(nostr.OKEnvelope{EventID: evt.ID, OK: false, Reason: &reason})
+						ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: false, Reason: "invalid: signature is invalid"})
 						return
 					}
 
 					var ok bool
-					if evt.Kind == 5 {
-						err = rl.handleDeleteRequest(ctx, &evt)
+					var writeErr error
+					if env.Event.Kind == 5 {
+						// this always returns "blocked: " whenever it returns an error
+						writeErr = rl.handleDeleteRequest(ctx, &env.Event)
 					} else {
-						err = rl.AddEvent(ctx, &evt)
+						// this will also always return a prefixed reason
+						writeErr = rl.AddEvent(ctx, &env.Event)
 					}
-					var reason *string
-					if err == nil {
+
+					var reason string
+					if writeErr == nil {
 						ok = true
 					} else {
-						msg := err.Error()
-						reason = &msg
+						reason = writeErr.Error()
+						if strings.HasPrefix(reason, "auth-required:") {
+							RequestAuth(ctx)
+						}
 					}
-					ws.WriteJSON(nostr.OKEnvelope{EventID: evt.ID, OK: ok, Reason: reason})
-				case "COUNT":
+					ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: ok, Reason: reason})
+				case *nostr.CountEnvelope:
 					if rl.CountEvents == nil {
-						ws.WriteJSON(nostr.NoticeEnvelope("this relay does not support NIP-45"))
+						ws.WriteJSON(nostr.ClosedEnvelope{SubscriptionID: env.SubscriptionID, Reason: "unsupported: this relay does not support NIP-45"})
 						return
 					}
-
-					var id string
-					json.Unmarshal(request[1], &id)
-					if id == "" {
-						ws.WriteJSON(nostr.NoticeEnvelope("COUNT has no <id>"))
-						return
-					}
-
 					var total int64
-					filters := make(nostr.Filters, len(request)-2)
-					for i, filterReq := range request[2:] {
-						if err := json.Unmarshal(filterReq, &filters[i]); err != nil {
-							ws.WriteJSON(nostr.NoticeEnvelope("failed to decode filter"))
-							continue
-						}
-
-						filter := filters[i]
-
-						for _, reject := range rl.RejectFilter {
-							if rejecting, msg := reject(ctx, filter); rejecting {
-								ws.WriteJSON(nostr.NoticeEnvelope(msg))
-								continue
-							}
-						}
-						for _, reject := range rl.RejectCountFilter {
-							if rejecting, msg := reject(ctx, filter); rejecting {
-								ws.WriteJSON(nostr.NoticeEnvelope(msg))
-								continue
-							}
-						}
-
-						for _, count := range rl.CountEvents {
-							res, err := count(ctx, filter)
-							if err != nil {
-								ws.WriteJSON(nostr.NoticeEnvelope(err.Error()))
-							}
-							total += res
-						}
+					for _, filter := range env.Filters {
+						total += rl.handleCountRequest(ctx, ws, filter)
 					}
-
-					ws.WriteJSON([]interface{}{"COUNT", id, map[string]int64{"count": total}})
-				case "REQ":
-					var id string
-					json.Unmarshal(request[1], &id)
-					if id == "" {
-						ws.WriteJSON(nostr.NoticeEnvelope("REQ has no <id>"))
-						return
-					}
-
-					filters := make(nostr.Filters, len(request)-2)
+					ws.WriteJSON(nostr.CountEnvelope{SubscriptionID: env.SubscriptionID, Count: &total})
+				case *nostr.ReqEnvelope:
 					eose := sync.WaitGroup{}
-					eose.Add(len(request[2:]))
+					eose.Add(len(env.Filters))
 
-					for i, filterReq := range request[2:] {
-						if err := json.Unmarshal(
-							filterReq,
-							&filters[i],
-						); err != nil {
-							ws.WriteJSON(nostr.NoticeEnvelope("failed to decode filter"))
-							eose.Done()
-							continue
-						}
+					// a context just for the "stored events" request handler
+					reqCtx, cancelReqCtx := context.WithCancelCause(ctx)
 
-						filter := filters[i]
+					// expose subscription id in the context
+					reqCtx = context.WithValue(reqCtx, subscriptionIdKey, env.SubscriptionID)
 
-						for _, reject := range rl.RejectCountFilter {
-							if rejecting, msg := reject(ctx, filter); rejecting {
-								ws.WriteJSON(nostr.NoticeEnvelope(msg))
-								eose.Done()
-								continue
+					// handle each filter separately -- dispatching events as they're loaded from databases
+					for _, filter := range env.Filters {
+						err := rl.handleRequest(reqCtx, env.SubscriptionID, &eose, ws, filter)
+						if err != nil {
+							// fail everything if any filter is rejected
+							reason := err.Error()
+							if strings.HasPrefix(reason, "auth-required:") {
+								RequestAuth(ctx)
 							}
+							ws.WriteJSON(nostr.ClosedEnvelope{SubscriptionID: env.SubscriptionID, Reason: reason})
+							cancelReqCtx(errors.New("filter rejected"))
+							return
 						}
-
-						eose.Add(len(rl.QueryEvents))
-						for _, query := range rl.QueryEvents {
-							ch, err := query(ctx, filter)
-							if err != nil {
-								ws.WriteJSON(nostr.NoticeEnvelope(err.Error()))
-								eose.Done()
-								continue
-							}
-
-							go func(ch chan *nostr.Event) {
-								for event := range ch {
-									ws.WriteJSON(nostr.EventEnvelope{SubscriptionID: &id, Event: *event})
-								}
-								eose.Done()
-							}(ch)
-						}
-
-						eose.Done()
 					}
 
 					go func() {
+						// when all events have been loaded from databases and dispatched
+						// we can cancel the context and fire the EOSE message
 						eose.Wait()
-						ws.WriteJSON(nostr.EOSEEnvelope(id))
+						cancelReqCtx(nil)
+						ws.WriteJSON(nostr.EOSEEnvelope(env.SubscriptionID))
 					}()
 
-					setListener(id, ws, filters)
-				case "CLOSE":
-					var id string
-					json.Unmarshal(request[1], &id)
-					if id == "" {
-						ws.WriteJSON(nostr.NoticeEnvelope("CLOSE has no <id>"))
-						return
-					}
-
-					removeListenerId(ws, id)
-				case "AUTH":
-					if rl.ServiceURL != "" {
-						var evt nostr.Event
-						if err := json.Unmarshal(request[1], &evt); err != nil {
-							ws.WriteJSON(nostr.NoticeEnvelope("failed to decode auth event: " + err.Error()))
-							return
-						}
-						if pubkey, ok := nip42.ValidateAuthEvent(&evt, ws.Challenge, rl.ServiceURL); ok {
-							ws.Authed = pubkey
-							close(ws.WaitingForAuth)
-							ctx = context.WithValue(ctx, AUTH_CONTEXT_KEY, pubkey)
-							ws.WriteJSON(nostr.OKEnvelope{EventID: evt.ID, OK: true})
-						} else {
-							reason := "error: failed to authenticate"
-							ws.WriteJSON(nostr.OKEnvelope{EventID: evt.ID, OK: false, Reason: &reason})
+					setListener(env.SubscriptionID, ws, env.Filters, cancelReqCtx)
+				case *nostr.CloseEnvelope:
+					removeListenerId(ws, string(*env))
+				case *nostr.AuthEnvelope:
+					wsBaseUrl := strings.Replace(rl.ServiceURL, "http", "ws", 1)
+					if pubkey, ok := nip42.ValidateAuthEvent(&env.Event, ws.Challenge, wsBaseUrl); ok {
+						ws.AuthedPublicKey = pubkey
+						ws.authLock.Lock()
+						if ws.Authed != nil {
+							close(ws.Authed)
+							ws.Authed = nil
 						}
+						ws.authLock.Unlock()
+						ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: true})
+					} else {
+						ws.WriteJSON(nostr.OKEnvelope{EventID: env.Event.ID, OK: false, Reason: "error: failed to authenticate"})
 					}
 				}
 			}(message)
 		}
 	}()
 
-	// writer
 	go func() {
-		defer func() {
-			ticker.Stop()
-			conn.Close()
-		}()
+		defer kill()
 
 		for {
 			select {
+			case <-ctx.Done():
+				return
 			case <-ticker.C:
 				err := ws.WriteMessage(websocket.PingMessage, nil)
 				if err != nil {
-					rl.Log.Printf("error writing ping: %v; closing websocket\n", err)
+					if !strings.HasSuffix(err.Error(), "use of closed network connection") {
+						rl.Log.Printf("error writing ping: %v; closing websocket\n", err)
+					}
 					return
 				}
 			}
@@ -303,28 +239,11 @@ func (rl *Relay) HandleWebsocket(w http.ResponseWriter, r *http.Request) {
 }
 
 func (rl *Relay) HandleNIP11(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Content-Type", "application/nostr+json")
 
-	supportedNIPs := []int{9, 11, 12, 15, 16, 20, 33}
-	if rl.ServiceURL != "" {
-		supportedNIPs = append(supportedNIPs, 42)
-	}
-	if rl.CountEvents != nil {
-		supportedNIPs = append(supportedNIPs, 45)
-	}
-
-	info := nip11.RelayInformationDocument{
-		Name:          rl.Name,
-		Description:   rl.Description,
-		PubKey:        rl.PubKey,
-		Contact:       rl.Contact,
-		SupportedNIPs: supportedNIPs,
-		Software:      "https://github.com/trailriver/khatru",
-		Version:       "n/a",
-	}
-
-	for _, edit := range rl.EditInformation {
-		edit(r.Context(), &info)
+	info := *rl.Info
+	for _, ovw := range rl.OverwriteRelayInformation {
+		info = ovw(r.Context(), r, info)
 	}
 
 	json.NewEncoder(w).Encode(info)

helpers.go

@@ -0,0 +1,42 @@
+package khatru
+
+import (
+	"hash/maphash"
+	"net/http"
+	"strconv"
+	"strings"
+	"unsafe"
+
+	"github.com/nbd-wtf/go-nostr"
+)
+
+func pointerHasher[V any](_ maphash.Seed, k *V) uint64 {
+	return uint64(uintptr(unsafe.Pointer(k)))
+}
+
+func isOlder(previous, next *nostr.Event) bool {
+	return previous.CreatedAt < next.CreatedAt ||
+		(previous.CreatedAt == next.CreatedAt && previous.ID > next.ID)
+}
+
+func getServiceBaseURL(r *http.Request) string {
+	host := r.Header.Get("X-Forwarded-Host")
+	if host == "" {
+		host = r.Host
+	}
+	proto := r.Header.Get("X-Forwarded-Proto")
+	if proto == "" {
+		if host == "localhost" {
+			proto = "http"
+		} else if strings.Index(host, ":") != -1 {
+			// has a port number
+			proto = "http"
+		} else if _, err := strconv.Atoi(strings.ReplaceAll(host, ".", "")); err == nil {
+			// it's a naked IP
+			proto = "http"
+		} else {
+			proto = "https"
+		}
+	}
+	return proto + "://" + host
+}

listener.go

@@ -1,22 +1,26 @@
 package khatru
 
 import (
+	"context"
+	"fmt"
+
 	"github.com/nbd-wtf/go-nostr"
 	"github.com/puzpuzpuz/xsync/v2"
 )
 
 type Listener struct {
 	filters nostr.Filters
+	cancel  context.CancelCauseFunc
 }
 
-var listeners = xsync.NewTypedMapOf[*WebSocket, map[string]*Listener](pointerHasher[WebSocket])
+var listeners = xsync.NewTypedMapOf[*WebSocket, *xsync.MapOf[string, *Listener]](pointerHasher[WebSocket])
 
 func GetListeningFilters() nostr.Filters {
 	respfilters := make(nostr.Filters, 0, listeners.Size()*2)
 
 	// here we go through all the existing listeners
-	listeners.Range(func(_ *WebSocket, subs map[string]*Listener) bool {
-		for _, listener := range subs {
+	listeners.Range(func(_ *WebSocket, subs *xsync.MapOf[string, *Listener]) bool {
+		subs.Range(func(_ string, listener *Listener) bool {
 			for _, listenerfilter := range listener.filters {
 				for _, respfilter := range respfilters {
 					// check if this filter specifically is already added to respfilters
@@ -32,7 +36,9 @@ func GetListeningFilters() nostr.Filters {
 			nextconn:
 				continue
 			}
-		}
+
+			return true
+		})
 
 		return true
 	})
@@ -41,34 +47,41 @@ func GetListeningFilters() nostr.Filters {
 	return respfilters
 }
 
-func setListener(id string, ws *WebSocket, filters nostr.Filters) {
-	subs, _ := listeners.LoadOrCompute(ws, func() map[string]*Listener { return make(map[string]*Listener) })
-	subs[id] = &Listener{filters: filters}
+func setListener(id string, ws *WebSocket, filters nostr.Filters, cancel context.CancelCauseFunc) {
+	subs, _ := listeners.LoadOrCompute(ws, func() *xsync.MapOf[string, *Listener] {
+		return xsync.NewMapOf[*Listener]()
+	})
+	subs.Store(id, &Listener{filters: filters, cancel: cancel})
 }
 
-// Remove a specific subscription id from listeners for a given ws client
+// remove a specific subscription id from listeners for a given ws client
+// and cancel its specific context
 func removeListenerId(ws *WebSocket, id string) {
 	if subs, ok := listeners.Load(ws); ok {
-		delete(subs, id)
-		if len(subs) == 0 {
+		if listener, ok := subs.LoadAndDelete(id); ok {
+			listener.cancel(fmt.Errorf("subscription closed by client"))
+		}
+		if subs.Size() == 0 {
 			listeners.Delete(ws)
 		}
 	}
 }
 
-// Remove WebSocket conn from listeners
+// remove WebSocket conn from listeners
+// (no need to cancel contexts as they are all inherited from the main connection context)
 func removeListener(ws *WebSocket) {
 	listeners.Delete(ws)
 }
 
 func notifyListeners(event *nostr.Event) {
-	listeners.Range(func(ws *WebSocket, subs map[string]*Listener) bool {
-		for id, listener := range subs {
+	listeners.Range(func(ws *WebSocket, subs *xsync.MapOf[string, *Listener]) bool {
+		subs.Range(func(id string, listener *Listener) bool {
 			if !listener.filters.Match(event) {
-				continue
+				return true
 			}
 			ws.WriteJSON(nostr.EventEnvelope{SubscriptionID: &id, Event: *event})
-		}
+			return true
+		})
 		return true
 	})
 }

plugins/events.go

@@ -1,22 +0,0 @@
-package plugins
-
-import (
-	"context"
-
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func PreventTooManyIndexableTags(max int) func(context.Context, *nostr.Event) (bool, string) {
-	return func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
-		ntags := 0
-		for _, tag := range event.Tags {
-			if len(tag) > 0 && len(tag[0]) == 1 {
-				ntags++
-			}
-		}
-		if ntags > max {
-			return true, "too many indexable tags"
-		}
-		return false, ""
-	}
-}

plugins/filters.go

@@ -1,33 +0,0 @@
-package plugins
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func NoPrefixFilters(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
-	for _, id := range filter.IDs {
-		if len(id) != 64 {
-			return true, fmt.Sprintf("filters can only contain full ids")
-		}
-	}
-	for _, pk := range filter.Authors {
-		if len(pk) != 64 {
-			return true, fmt.Sprintf("filters can only contain full pubkeys")
-		}
-	}
-
-	return false, ""
-}
-
-func NoComplexFilters(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
-	items := len(filter.Tags) + len(filter.Kinds)
-
-	if items > 4 && len(filter.Tags) > 2 {
-		return true, "too many things to filter for"
-	}
-
-	return false, ""
-}

plugins/storage/badgern/count.go

@@ -1,83 +0,0 @@
-package badgern
-
-import (
-	"context"
-	"encoding/binary"
-
-	"github.com/dgraph-io/badger/v4"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-func (b BadgerBackend) CountEvents(ctx context.Context, filter nostr.Filter) (int64, error) {
-	var count int64 = 0
-
-	queries, extraFilter, since, prefixLen, idxOffset, err := prepareQueries(filter)
-	if err != nil {
-		return 0, err
-	}
-
-	err = b.View(func(txn *badger.Txn) error {
-		// iterate only through keys and in reverse order
-		opts := badger.DefaultIteratorOptions
-		opts.PrefetchValues = false
-		opts.Reverse = true
-
-		// actually iterate
-		for _, q := range queries {
-			it := txn.NewIterator(opts)
-			defer it.Close()
-
-			for it.Seek(q.startingPoint); it.ValidForPrefix(q.prefix); it.Next() {
-				item := it.Item()
-				key := item.Key()
-
-				if !q.skipTimestamp {
-					createdAt := binary.BigEndian.Uint32(key[prefixLen:idxOffset])
-					if createdAt < since {
-						break
-					}
-				}
-
-				idx := make([]byte, 5)
-				idx[0] = rawEventStorePrefix
-				copy(idx[1:], key[idxOffset:])
-
-				// fetch actual event
-				item, err := txn.Get(idx)
-				if err != nil {
-					if err == badger.ErrDiscardedTxn {
-						return err
-					}
-
-					panic(err)
-				}
-
-				if extraFilter == nil {
-					count++
-				} else {
-					err = item.Value(func(val []byte) error {
-						evt := &nostr.Event{}
-						if err := nson.Unmarshal(string(val), evt); err != nil {
-							return err
-						}
-
-						// check if this matches the other filters that were not part of the index
-						if extraFilter == nil || extraFilter.Matches(evt) {
-							count++
-						}
-
-						return nil
-					})
-					if err != nil {
-						panic(err)
-					}
-				}
-			}
-		}
-
-		return nil
-	})
-
-	return count, err
-}

plugins/storage/badgern/delete.go

@@ -1,78 +0,0 @@
-package badgern
-
-import (
-	"context"
-	"encoding/hex"
-
-	"github.com/dgraph-io/badger/v4"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-func (b *BadgerBackend) DeleteEvent(ctx context.Context, evt *nostr.Event) error {
-	deletionHappened := false
-
-	err := b.Update(func(txn *badger.Txn) error {
-		idx := make([]byte, 1, 5)
-		idx[0] = rawEventStorePrefix
-
-		// query event by id to get its idx
-		id, _ := hex.DecodeString(evt.ID)
-		prefix := make([]byte, 1+32)
-		copy(prefix[1:], id)
-		opts := badger.DefaultIteratorOptions
-		opts.PrefetchValues = false
-		it := txn.NewIterator(opts)
-		it.Seek(prefix)
-		if it.ValidForPrefix(prefix) {
-			// the key is the last 32 bytes
-			idx = append(idx, it.Item().Key()[1+32:]...)
-		}
-		it.Close()
-
-		// if no idx was found, end here, this event doesn't exist
-		if len(idx) == 1 {
-			return nil
-		}
-
-		// fetch the event
-		item, err := txn.Get(idx)
-		if err != nil {
-			return err
-		}
-
-		item.Value(func(val []byte) error {
-			evt := &nostr.Event{}
-			if err := nson.Unmarshal(string(val), evt); err != nil {
-				return err
-			}
-
-			// set this so we'll run the GC later
-			deletionHappened = true
-
-			// calculate all index keys we have for this event and delete them
-			for _, k := range getIndexKeysForEvent(evt, idx[1:]) {
-				if err := txn.Delete(k); err != nil {
-					return err
-				}
-			}
-
-			// delete the raw event
-			return txn.Delete(idx)
-		})
-
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	// after deleting, run garbage collector
-	if deletionHappened {
-		if err := b.RunValueLogGC(0.8); err != nil {
-			panic(err)
-		}
-	}
-
-	return nil
-}

plugins/storage/badgern/lib.go

@@ -1,159 +0,0 @@
-package badgern
-
-import (
-	"encoding/binary"
-	"encoding/hex"
-
-	"github.com/dgraph-io/badger/v4"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-const (
-	rawEventStorePrefix   byte = 0
-	indexCreatedAtPrefix  byte = 1
-	indexIdPrefix         byte = 2
-	indexKindPrefix       byte = 3
-	indexPubkeyPrefix     byte = 4
-	indexPubkeyKindPrefix byte = 5
-	indexTagPrefix        byte = 6
-)
-
-type BadgerBackend struct {
-	Path     string
-	MaxLimit int
-
-	*badger.DB
-	seq *badger.Sequence
-}
-
-func (b *BadgerBackend) Init() error {
-	db, err := badger.Open(badger.DefaultOptions(b.Path))
-	if err != nil {
-		return err
-	}
-	b.DB = db
-	b.seq, err = db.GetSequence([]byte("events"), 1000)
-	if err != nil {
-		return err
-	}
-
-	if b.MaxLimit == 0 {
-		b.MaxLimit = 500
-	}
-
-	// DEBUG: inspecting keys on startup
-	// db.View(func(txn *badger.Txn) error {
-	// 	opts := badger.DefaultIteratorOptions
-	// 	opts.PrefetchSize = 10
-	// 	it := txn.NewIterator(opts)
-	// 	defer it.Close()
-	// 	for it.Rewind(); it.Valid(); it.Next() {
-	// 		item := it.Item()
-	// 		k := item.Key()
-	// 		err := item.Value(func(v []byte) error {
-	// 			fmt.Println("key:", k)
-	// 			return nil
-	// 		})
-	// 		if err != nil {
-	// 			return err
-	// 		}
-	// 	}
-	// 	return nil
-	// })
-
-	return nil
-}
-
-func (b BadgerBackend) Close() {
-	b.DB.Close()
-	b.seq.Release()
-}
-
-func (b BadgerBackend) Serial() []byte {
-	v, _ := b.seq.Next()
-	vb := make([]byte, 5)
-	vb[0] = rawEventStorePrefix
-	binary.BigEndian.PutUint32(vb[1:], uint32(v))
-	return vb
-}
-
-func getIndexKeysForEvent(evt *nostr.Event, idx []byte) [][]byte {
-	keys := make([][]byte, 0, 18)
-
-	// indexes
-	{
-		// ~ by id
-		id, _ := hex.DecodeString(evt.ID)
-		k := make([]byte, 1+32+4)
-		k[0] = indexIdPrefix
-		copy(k[1:], id)
-		copy(k[1+32:], idx)
-		keys = append(keys, k)
-	}
-
-	{
-		// ~ by pubkey+date
-		pubkey, _ := hex.DecodeString(evt.PubKey)
-		k := make([]byte, 1+32+4+4)
-		k[0] = indexPubkeyPrefix
-		copy(k[1:], pubkey)
-		binary.BigEndian.PutUint32(k[1+32:], uint32(evt.CreatedAt))
-		copy(k[1+32+4:], idx)
-		keys = append(keys, k)
-	}
-
-	{
-		// ~ by kind+date
-		k := make([]byte, 1+2+4+4)
-		k[0] = indexKindPrefix
-		binary.BigEndian.PutUint16(k[1:], uint16(evt.Kind))
-		binary.BigEndian.PutUint32(k[1+2:], uint32(evt.CreatedAt))
-		copy(k[1+2+4:], idx)
-		keys = append(keys, k)
-	}
-
-	{
-		// ~ by pubkey+kind+date
-		pubkey, _ := hex.DecodeString(evt.PubKey)
-		k := make([]byte, 1+32+2+4+4)
-		k[0] = indexPubkeyKindPrefix
-		copy(k[1:], pubkey)
-		binary.BigEndian.PutUint16(k[1+32:], uint16(evt.Kind))
-		binary.BigEndian.PutUint32(k[1+32+2:], uint32(evt.CreatedAt))
-		copy(k[1+32+2+4:], idx)
-		keys = append(keys, k)
-	}
-
-	// ~ by tagvalue+date
-	for _, tag := range evt.Tags {
-		if len(tag) < 2 || len(tag[0]) != 1 || len(tag[1]) == 0 || len(tag[1]) > 100 {
-			continue
-		}
-
-		var v []byte
-		if vb, _ := hex.DecodeString(tag[1]); len(vb) == 32 {
-			// store value as bytes
-			v = vb
-		} else {
-			v = []byte(tag[1])
-		}
-
-		k := make([]byte, 1+len(v)+4+4)
-		k[0] = indexTagPrefix
-		copy(k[1:], v)
-		binary.BigEndian.PutUint32(k[1+len(v):], uint32(evt.CreatedAt))
-		copy(k[1+len(v)+4:], idx)
-		keys = append(keys, k)
-	}
-
-	{
-		// ~ by date only
-		k := make([]byte, 1+4+4)
-		k[0] = indexCreatedAtPrefix
-		binary.BigEndian.PutUint32(k[1:], uint32(evt.CreatedAt))
-		copy(k[1+4:], idx)
-		keys = append(keys, k)
-	}
-
-	return keys
-}

plugins/storage/badgern/query.go

@@ -1,325 +0,0 @@
-package badgern
-
-import (
-	"container/heap"
-	"context"
-	"encoding/binary"
-	"encoding/hex"
-	"fmt"
-
-	"github.com/dgraph-io/badger/v4"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-type query struct {
-	i             int
-	prefix        []byte
-	startingPoint []byte
-	results       chan *nostr.Event
-	skipTimestamp bool
-}
-
-type queryEvent struct {
-	*nostr.Event
-	query int
-}
-
-func (b BadgerBackend) QueryEvents(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error) {
-	ch := make(chan *nostr.Event)
-
-	queries, extraFilter, since, prefixLen, idxOffset, err := prepareQueries(filter)
-	if err != nil {
-		return nil, err
-	}
-
-	go func() {
-		err := b.View(func(txn *badger.Txn) error {
-			// iterate only through keys and in reverse order
-			opts := badger.DefaultIteratorOptions
-			opts.PrefetchValues = false
-			opts.Reverse = true
-
-			// actually iterate
-			iteratorClosers := make([]func(), len(queries))
-			for i, q := range queries {
-				go func(i int, q query) {
-					it := txn.NewIterator(opts)
-					iteratorClosers[i] = it.Close
-
-					defer close(q.results)
-
-					for it.Seek(q.startingPoint); it.ValidForPrefix(q.prefix); it.Next() {
-						item := it.Item()
-						key := item.Key()
-
-						if !q.skipTimestamp {
-							createdAt := binary.BigEndian.Uint32(key[prefixLen:idxOffset])
-							if createdAt < since {
-								break
-							}
-						}
-
-						idx := make([]byte, 5)
-						idx[0] = rawEventStorePrefix
-						copy(idx[1:], key[idxOffset:])
-
-						// fetch actual event
-						item, err := txn.Get(idx)
-						if err != nil {
-							if err == badger.ErrDiscardedTxn {
-								return
-							}
-
-							panic(err)
-						}
-						err = item.Value(func(val []byte) error {
-							evt := &nostr.Event{}
-							if err := nson.Unmarshal(string(val), evt); err != nil {
-								return err
-							}
-
-							// check if this matches the other filters that were not part of the index
-							if extraFilter == nil || extraFilter.Matches(evt) {
-								q.results <- evt
-							}
-
-							return nil
-						})
-						if err != nil {
-							panic(err)
-						}
-					}
-				}(i, q)
-			}
-
-			// max number of events we'll return
-			limit := b.MaxLimit
-			if filter.Limit > 0 && filter.Limit < limit {
-				limit = filter.Limit
-			}
-
-			// receive results and ensure we only return the most recent ones always
-			emittedEvents := 0
-
-			// first pass
-			emitQueue := make(priorityQueue, 0, len(queries)+limit)
-			for _, q := range queries {
-				evt, ok := <-q.results
-				if ok {
-					emitQueue = append(emitQueue, &queryEvent{Event: evt, query: q.i})
-				}
-			}
-
-			// now it's a good time to schedule this
-			defer func() {
-				close(ch)
-				for _, itclose := range iteratorClosers {
-					itclose()
-				}
-			}()
-
-			// queue may be empty here if we have literally nothing
-			if len(emitQueue) == 0 {
-				return nil
-			}
-
-			heap.Init(&emitQueue)
-
-			// iterate until we've emitted all events required
-			for {
-				// emit latest event in queue
-				latest := emitQueue[0]
-				ch <- latest.Event
-
-				// stop when reaching limit
-				emittedEvents++
-				if emittedEvents == limit {
-					break
-				}
-
-				// fetch a new one from query results and replace the previous one with it
-				if evt, ok := <-queries[latest.query].results; ok {
-					emitQueue[0].Event = evt
-					heap.Fix(&emitQueue, 0)
-				} else {
-					// if this query has no more events we just remove this and proceed normally
-					heap.Remove(&emitQueue, 0)
-
-					// check if the list is empty and end
-					if len(emitQueue) == 0 {
-						break
-					}
-				}
-			}
-
-			return nil
-		})
-		if err != nil {
-			panic(err)
-		}
-	}()
-
-	return ch, nil
-}
-
-type priorityQueue []*queryEvent
-
-func (pq priorityQueue) Len() int { return len(pq) }
-
-func (pq priorityQueue) Less(i, j int) bool {
-	return pq[i].CreatedAt > pq[j].CreatedAt
-}
-
-func (pq priorityQueue) Swap(i, j int) {
-	pq[i], pq[j] = pq[j], pq[i]
-}
-
-func (pq *priorityQueue) Push(x any) {
-	item := x.(*queryEvent)
-	*pq = append(*pq, item)
-}
-
-func (pq *priorityQueue) Pop() any {
-	old := *pq
-	n := len(old)
-	item := old[n-1]
-	old[n-1] = nil // avoid memory leak
-	*pq = old[0 : n-1]
-	return item
-}
-
-func prepareQueries(filter nostr.Filter) (
-	queries []query,
-	extraFilter *nostr.Filter,
-	since uint32,
-	prefixLen int,
-	idxOffset int,
-	err error,
-) {
-	var index byte
-
-	if len(filter.IDs) > 0 {
-		index = indexIdPrefix
-		queries = make([]query, len(filter.IDs))
-		for i, idHex := range filter.IDs {
-			prefix := make([]byte, 1+32)
-			prefix[0] = index
-			id, _ := hex.DecodeString(idHex)
-			if len(id) != 32 {
-				return nil, nil, 0, 0, 0, fmt.Errorf("invalid id '%s'", idHex)
-			}
-			copy(prefix[1:], id)
-			queries[i] = query{i: i, prefix: prefix, skipTimestamp: true}
-		}
-	} else if len(filter.Authors) > 0 {
-		if len(filter.Kinds) == 0 {
-			index = indexPubkeyPrefix
-			queries = make([]query, len(filter.Authors))
-			for i, pubkeyHex := range filter.Authors {
-				pubkey, _ := hex.DecodeString(pubkeyHex)
-				if len(pubkey) != 32 {
-					continue
-				}
-				prefix := make([]byte, 1+32)
-				prefix[0] = index
-				copy(prefix[1:], pubkey)
-				queries[i] = query{i: i, prefix: prefix}
-			}
-		} else {
-			index = indexPubkeyKindPrefix
-			queries = make([]query, len(filter.Authors)*len(filter.Kinds))
-			i := 0
-			for _, pubkeyHex := range filter.Authors {
-				for _, kind := range filter.Kinds {
-					pubkey, _ := hex.DecodeString(pubkeyHex)
-					if len(pubkey) != 32 {
-						return nil, nil, 0, 0, 0, fmt.Errorf("invalid pubkey '%s'", pubkeyHex)
-					}
-					prefix := make([]byte, 1+32+2)
-					prefix[0] = index
-					copy(prefix[1:], pubkey)
-					binary.BigEndian.PutUint16(prefix[1+32:], uint16(kind))
-					queries[i] = query{i: i, prefix: prefix}
-					i++
-				}
-			}
-		}
-		extraFilter = &nostr.Filter{Tags: filter.Tags}
-	} else if len(filter.Tags) > 0 {
-		index = indexTagPrefix
-
-		// determine the size of the queries array by inspecting all tags sizes
-		size := 0
-		for _, values := range filter.Tags {
-			size += len(values)
-		}
-		queries = make([]query, size)
-
-		extraFilter = &nostr.Filter{Kinds: filter.Kinds}
-		i := 0
-		for _, values := range filter.Tags {
-			for _, value := range values {
-				bv, _ := hex.DecodeString(value)
-				var size int
-				if len(bv) == 32 {
-					// hex tag
-					size = 32
-				} else {
-					// string tag
-					bv = []byte(value)
-					size = len(bv)
-				}
-				prefix := make([]byte, 1+size)
-				prefix[0] = index
-				copy(prefix[1:], bv)
-				queries[i] = query{i: i, prefix: prefix}
-				i++
-			}
-		}
-	} else if len(filter.Kinds) > 0 {
-		index = indexKindPrefix
-		queries = make([]query, len(filter.Kinds))
-		for i, kind := range filter.Kinds {
-			prefix := make([]byte, 1+2)
-			prefix[0] = index
-			binary.BigEndian.PutUint16(prefix[1:], uint16(kind))
-			queries[i] = query{i: i, prefix: prefix}
-		}
-	} else {
-		index = indexCreatedAtPrefix
-		queries = make([]query, 1)
-		prefix := make([]byte, 1)
-		prefix[0] = index
-		queries[0] = query{i: 0, prefix: prefix}
-		extraFilter = nil
-	}
-
-	prefixLen = len(queries[0].prefix)
-
-	if index == indexIdPrefix {
-		idxOffset = prefixLen
-	} else {
-		idxOffset = prefixLen + 4
-	}
-
-	var until uint32 = 4294967295
-	if filter.Until != nil {
-		if fu := uint32(*filter.Until); fu < until {
-			until = fu + 1
-		}
-	}
-	for i, q := range queries {
-		queries[i].startingPoint = binary.BigEndian.AppendUint32(q.prefix, uint32(until))
-		queries[i].results = make(chan *nostr.Event, 12)
-	}
-
-	// this is where we'll end the iteration
-	if filter.Since != nil {
-		if fs := uint32(*filter.Since); fs > since {
-			since = fs
-		}
-	}
-
-	return queries, extraFilter, since, prefixLen, idxOffset, nil
-}

plugins/storage/badgern/save.go

@@ -1,32 +0,0 @@
-package badgern
-
-import (
-	"context"
-
-	"github.com/dgraph-io/badger/v4"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-func (b *BadgerBackend) SaveEvent(ctx context.Context, evt *nostr.Event) error {
-	return b.Update(func(txn *badger.Txn) error {
-		nson, err := nson.Marshal(evt)
-		if err != nil {
-			return err
-		}
-
-		idx := b.Serial()
-		// raw event store
-		if err := txn.Set(idx, []byte(nson)); err != nil {
-			return err
-		}
-
-		for _, k := range getIndexKeysForEvent(evt, idx[1:]) {
-			if err := txn.Set(k, nil); err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-}

plugins/storage/elasticsearch/elasticsearch.go

@@ -1,182 +0,0 @@
-package elasticsearch
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"strings"
-	"time"
-
-	"github.com/elastic/go-elasticsearch/v8"
-	"github.com/elastic/go-elasticsearch/v8/esutil"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-type IndexedEvent struct {
-	Event         nostr.Event `json:"event"`
-	ContentSearch string      `json:"content_search"`
-}
-
-var indexMapping = `
-{
-	"settings": {
-		"number_of_shards": 1,
-		"number_of_replicas": 0
-	},
-	"mappings": {
-		"dynamic": false,
-		"properties": {
-			"event": {
-				"dynamic": false,
-				"properties": {
-					"id": {"type": "keyword"},
-					"pubkey": {"type": "keyword"},
-					"kind": {"type": "integer"},
-					"tags": {"type": "keyword"},
-					"created_at": {"type": "date"}
-				}
-			},
-			"content_search": {"type": "text"}
-		}
-	}
-}
-`
-
-type ElasticsearchStorage struct {
-	URL       string
-	IndexName string
-
-	es *elasticsearch.Client
-	bi esutil.BulkIndexer
-}
-
-func (ess *ElasticsearchStorage) Init() error {
-	if ess.IndexName == "" {
-		ess.IndexName = "events"
-	}
-
-	cfg := elasticsearch.Config{}
-	if ess.URL != "" {
-		cfg.Addresses = strings.Split(ess.URL, ",")
-	}
-	es, err := elasticsearch.NewClient(cfg)
-	if err != nil {
-		return err
-	}
-
-	res, err := es.Indices.Create(ess.IndexName, es.Indices.Create.WithBody(strings.NewReader(indexMapping)))
-	if err != nil {
-		return err
-	}
-	if res.IsError() {
-		body, _ := io.ReadAll(res.Body)
-		txt := string(body)
-		if !strings.Contains(txt, "resource_already_exists_exception") {
-			return fmt.Errorf("%s", txt)
-		}
-	}
-
-	// bulk indexer
-	bi, err := esutil.NewBulkIndexer(esutil.BulkIndexerConfig{
-		Index:         ess.IndexName,
-		Client:        es,
-		NumWorkers:    2,
-		FlushInterval: 3 * time.Second,
-	})
-	if err != nil {
-		return fmt.Errorf("error creating the indexer: %s", err)
-	}
-
-	ess.es = es
-	ess.bi = bi
-
-	return nil
-}
-
-func (ess *ElasticsearchStorage) DeleteEvent(ctx context.Context, evt *nostr.Event) error {
-	done := make(chan error)
-	err := ess.bi.Add(
-		ctx,
-		esutil.BulkIndexerItem{
-			Action:     "delete",
-			DocumentID: evt.ID,
-			OnSuccess: func(ctx context.Context, item esutil.BulkIndexerItem, res esutil.BulkIndexerResponseItem) {
-				close(done)
-			},
-			OnFailure: func(ctx context.Context, item esutil.BulkIndexerItem, res esutil.BulkIndexerResponseItem, err error) {
-				if err != nil {
-					done <- err
-				} else {
-					// ok if deleted item not found
-					if res.Status == 404 {
-						close(done)
-						return
-					}
-					txt, _ := json.Marshal(res)
-					err := fmt.Errorf("ERROR: %s", txt)
-					done <- err
-				}
-			},
-		},
-	)
-	if err != nil {
-		return err
-	}
-
-	err = <-done
-	return err
-}
-
-func (ess *ElasticsearchStorage) SaveEvent(ctx context.Context, evt *nostr.Event) error {
-	ie := &IndexedEvent{
-		Event: *evt,
-	}
-
-	// post processing: index for FTS
-	// some ideas:
-	// - index kind=0 fields a set of dedicated mapped fields
-	//   (or use a separate index for profiles with a dedicated mapping)
-	// - if it's valid JSON just index the "values" and not the keys
-	// - more content introspection: language detection
-	// - denormalization... attach profile + ranking signals to events
-	if evt.Kind != 4 {
-		ie.ContentSearch = evt.Content
-	}
-
-	data, err := json.Marshal(ie)
-	if err != nil {
-		return err
-	}
-
-	done := make(chan error)
-
-	// adapted from:
-	// https://github.com/elastic/go-elasticsearch/blob/main/_examples/bulk/indexer.go#L196
-	err = ess.bi.Add(
-		ctx,
-		esutil.BulkIndexerItem{
-			Action:     "index",
-			DocumentID: evt.ID,
-			Body:       bytes.NewReader(data),
-			OnSuccess: func(ctx context.Context, item esutil.BulkIndexerItem, res esutil.BulkIndexerResponseItem) {
-				close(done)
-			},
-			OnFailure: func(ctx context.Context, item esutil.BulkIndexerItem, res esutil.BulkIndexerResponseItem, err error) {
-				if err != nil {
-					done <- err
-				} else {
-					err := fmt.Errorf("ERROR: %s: %s", res.Error.Type, res.Error.Reason)
-					done <- err
-				}
-			},
-		},
-	)
-	if err != nil {
-		return err
-	}
-
-	err = <-done
-	return err
-}

plugins/storage/elasticsearch/query.go

@@ -1,261 +0,0 @@
-package elasticsearch
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"reflect"
-
-	"github.com/aquasecurity/esquery"
-	"github.com/elastic/go-elasticsearch/v8/esutil"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-type EsSearchResult struct {
-	Took     int
-	TimedOut bool `json:"timed_out"`
-	Hits     struct {
-		Total struct {
-			Value    int
-			Relation string
-		}
-		Hits []struct {
-			Source IndexedEvent `json:"_source"`
-		}
-	}
-}
-
-type EsCountResult struct {
-	Count int64
-}
-
-func buildDsl(filter nostr.Filter) ([]byte, error) {
-	dsl := esquery.Bool()
-
-	prefixFilter := func(fieldName string, values []string) {
-		if len(values) == 0 {
-			return
-		}
-		prefixQ := esquery.Bool()
-		for _, v := range values {
-			if len(v) < 64 {
-				prefixQ.Should(esquery.Prefix(fieldName, v))
-			} else {
-				prefixQ.Should(esquery.Term(fieldName, v))
-			}
-		}
-		dsl.Must(prefixQ)
-	}
-
-	// ids
-	prefixFilter("event.id", filter.IDs)
-
-	// authors
-	prefixFilter("event.pubkey", filter.Authors)
-
-	// kinds
-	if len(filter.Kinds) > 0 {
-		dsl.Must(esquery.Terms("event.kind", toInterfaceSlice(filter.Kinds)...))
-	}
-
-	// tags
-	if len(filter.Tags) > 0 {
-		tagQ := esquery.Bool()
-		for char, terms := range filter.Tags {
-			vs := toInterfaceSlice(append(terms, char))
-			tagQ.Should(esquery.Terms("event.tags", vs...))
-		}
-		dsl.Must(tagQ)
-	}
-
-	// since
-	if filter.Since != nil {
-		dsl.Must(esquery.Range("event.created_at").Gt(filter.Since))
-	}
-
-	// until
-	if filter.Until != nil {
-		dsl.Must(esquery.Range("event.created_at").Lt(filter.Until))
-	}
-
-	// search
-	if filter.Search != "" {
-		dsl.Must(esquery.Match("content_search", filter.Search))
-	}
-
-	return json.Marshal(esquery.Query(dsl))
-}
-
-func (ess *ElasticsearchStorage) getByID(filter nostr.Filter) ([]*nostr.Event, error) {
-	got, err := ess.es.Mget(
-		esutil.NewJSONReader(filter),
-		ess.es.Mget.WithIndex(ess.IndexName))
-	if err != nil {
-		return nil, err
-	}
-
-	var mgetResponse struct {
-		Docs []struct {
-			Found  bool
-			Source IndexedEvent `json:"_source"`
-		}
-	}
-	if err := json.NewDecoder(got.Body).Decode(&mgetResponse); err != nil {
-		return nil, err
-	}
-
-	events := make([]*nostr.Event, 0, len(mgetResponse.Docs))
-	for _, e := range mgetResponse.Docs {
-		if e.Found {
-			events = append(events, &e.Source.Event)
-		}
-	}
-
-	return events, nil
-}
-
-func (ess *ElasticsearchStorage) QueryEvents(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error) {
-	ch := make(chan *nostr.Event)
-
-	// optimization: get by id
-	if isGetByID(filter) {
-		if evts, err := ess.getByID(filter); err == nil {
-			for _, evt := range evts {
-				ch <- evt
-			}
-			close(ch)
-		} else {
-			return nil, fmt.Errorf("error getting by id: %w", err)
-		}
-	}
-
-	dsl, err := buildDsl(filter)
-	if err != nil {
-		return nil, err
-	}
-
-	limit := 1000
-	if filter.Limit > 0 && filter.Limit < limit {
-		limit = filter.Limit
-	}
-
-	es := ess.es
-	res, err := es.Search(
-		es.Search.WithContext(ctx),
-		es.Search.WithIndex(ess.IndexName),
-
-		es.Search.WithBody(bytes.NewReader(dsl)),
-		es.Search.WithSize(limit),
-		es.Search.WithSort("event.created_at:desc"),
-	)
-	if err != nil {
-		log.Fatalf("Error getting response: %s", err)
-	}
-	defer res.Body.Close()
-
-	if res.IsError() {
-		txt, _ := io.ReadAll(res.Body)
-		fmt.Println("oh no", string(txt))
-		return nil, fmt.Errorf("%s", txt)
-	}
-
-	var r EsSearchResult
-	if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
-		return nil, err
-	}
-
-	go func() {
-		for _, e := range r.Hits.Hits {
-			ch <- &e.Source.Event
-		}
-		close(ch)
-	}()
-
-	return ch, nil
-}
-
-func isGetByID(filter nostr.Filter) bool {
-	isGetById := len(filter.IDs) > 0 &&
-		len(filter.Authors) == 0 &&
-		len(filter.Kinds) == 0 &&
-		len(filter.Tags) == 0 &&
-		len(filter.Search) == 0 &&
-		filter.Since == nil &&
-		filter.Until == nil
-
-	if isGetById {
-		for _, id := range filter.IDs {
-			if len(id) != 64 {
-				return false
-			}
-		}
-	}
-	return isGetById
-}
-
-// from: https://stackoverflow.com/a/12754757
-func toInterfaceSlice(slice interface{}) []interface{} {
-	s := reflect.ValueOf(slice)
-	if s.Kind() != reflect.Slice {
-		panic("InterfaceSlice() given a non-slice type")
-	}
-
-	// Keep the distinction between nil and empty slice input
-	if s.IsNil() {
-		return nil
-	}
-
-	ret := make([]interface{}, s.Len())
-
-	for i := 0; i < s.Len(); i++ {
-		ret[i] = s.Index(i).Interface()
-	}
-
-	return ret
-}
-
-func (ess *ElasticsearchStorage) CountEvents(ctx context.Context, filter nostr.Filter) (int64, error) {
-	count := int64(0)
-
-	// optimization: get by id
-	if isGetByID(filter) {
-		if evts, err := ess.getByID(filter); err == nil {
-			count += int64(len(evts))
-		} else {
-			return 0, fmt.Errorf("error getting by id: %w", err)
-		}
-	}
-
-	dsl, err := buildDsl(filter)
-	if err != nil {
-		return 0, err
-	}
-
-	es := ess.es
-	res, err := es.Count(
-		es.Count.WithContext(ctx),
-		es.Count.WithIndex(ess.IndexName),
-
-		es.Count.WithBody(bytes.NewReader(dsl)),
-	)
-	if err != nil {
-		log.Fatalf("Error getting response: %s", err)
-	}
-	defer res.Body.Close()
-
-	if res.IsError() {
-		txt, _ := io.ReadAll(res.Body)
-		fmt.Println("oh no", string(txt))
-		return 0, fmt.Errorf("%s", txt)
-	}
-
-	var r EsCountResult
-	if err := json.NewDecoder(res.Body).Decode(&r); err != nil {
-		return 0, err
-	}
-
-	return r.Count + count, nil
-}

plugins/storage/elasticsearch/query_test.go

@@ -1,43 +0,0 @@
-package elasticsearch
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func TestQuery(t *testing.T) {
-	now := nostr.Now()
-	yesterday := now - 60*60*24
-	filter := &nostr.Filter{
-		IDs:   []string{"abc", "123", "971b9489b4fd4e41a85951607922b982d981fa9d55318bc304f21f390721404c"},
-		Kinds: []int{0, 1},
-		Tags: nostr.TagMap{
-			"e": []string{"abc"},
-			"p": []string{"aaa", "bbb"},
-		},
-		Since:  &yesterday,
-		Until:  &now,
-		Limit:  100,
-		Search: "other stuff",
-	}
-
-	dsl, err := buildDsl(filter)
-	if err != nil {
-		t.Fatal(err)
-	}
-	pprint(dsl)
-}
-
-func pprint(j []byte) {
-	var dst bytes.Buffer
-	err := json.Indent(&dst, j, "", "    ")
-	if err != nil {
-		fmt.Println("invalid JSON", err, string(j))
-	} else {
-		fmt.Println(dst.String())
-	}
-}

plugins/storage/lmdbn/count.go

@@ -1,91 +0,0 @@
-package lmdbn
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-
-	"github.com/bmatsuo/lmdb-go/lmdb"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-func (b *LMDBBackend) CountEvents(ctx context.Context, filter nostr.Filter) (int64, error) {
-	var count int64 = 0
-
-	dbi, queries, extraFilter, since, prefixLen, err := b.prepareQueries(filter)
-	if err != nil {
-		return 0, err
-	}
-
-	err = b.lmdbEnv.View(func(txn *lmdb.Txn) error {
-		// actually iterate
-		for _, q := range queries {
-			cursor, err := txn.OpenCursor(dbi)
-			if err != nil {
-				continue
-			}
-
-			var k []byte
-			var idx []byte
-			var iterr error
-
-			if _, _, errsr := cursor.Get(q.startingPoint, nil, lmdb.SetRange); errsr != nil {
-				if operr, ok := errsr.(*lmdb.OpError); !ok || operr.Errno != lmdb.NotFound {
-					// in this case it's really an error
-					panic(err)
-				} else {
-					// we're at the end and we just want notes before this,
-					// so we just need to set the cursor the last key, this is not a real error
-					k, idx, iterr = cursor.Get(nil, nil, lmdb.Last)
-				}
-			} else {
-				// move one back as the first step
-				k, idx, iterr = cursor.Get(nil, nil, lmdb.Prev)
-			}
-
-			for {
-				// we already have a k and a v and an err from the cursor setup, so check and use these
-				if iterr != nil || !bytes.Equal(q.prefix, k[0:prefixLen]) {
-					break
-				}
-
-				if !q.skipTimestamp {
-					createdAt := binary.BigEndian.Uint32(k[prefixLen:])
-					if createdAt < since {
-						break
-					}
-				}
-
-				// fetch actual event
-				val, err := txn.Get(b.rawEventStore, idx)
-				if err != nil {
-					panic(err)
-				}
-
-				if extraFilter == nil {
-					count++
-				} else {
-					evt := &nostr.Event{}
-					if err := nson.Unmarshal(string(val), evt); err != nil {
-						return err
-					}
-
-					// check if this matches the other filters that were not part of the index
-					if extraFilter == nil || extraFilter.Matches(evt) {
-						count++
-					}
-
-					return nil
-				}
-
-				// move one back (we'll look into k and v and err in the next iteration)
-				k, idx, iterr = cursor.Get(nil, nil, lmdb.Prev)
-			}
-		}
-
-		return nil
-	})
-
-	return count, err
-}

plugins/storage/lmdbn/delete.go

@@ -1,50 +0,0 @@
-package lmdbn
-
-import (
-	"context"
-	"encoding/hex"
-
-	"github.com/bmatsuo/lmdb-go/lmdb"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-func (b *LMDBBackend) DeleteEvent(ctx context.Context, evt *nostr.Event) error {
-	err := b.lmdbEnv.Update(func(txn *lmdb.Txn) error {
-		id, _ := hex.DecodeString(evt.ID)
-		idx, err := txn.Get(b.indexId, id)
-		if operr, ok := err.(*lmdb.OpError); ok && operr.Errno == lmdb.NotFound {
-			// we already do not have this
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-
-		// fetch the event
-		val, err := txn.Get(b.rawEventStore, idx)
-		if err != nil {
-			return err
-		}
-
-		evt := &nostr.Event{}
-		if err := nson.Unmarshal(string(val), evt); err != nil {
-			return err
-		}
-
-		// calculate all index keys we have for this event and delete them
-		for _, k := range b.getIndexKeysForEvent(evt) {
-			if err := txn.Del(k.dbi, k.key, nil); err != nil {
-				return err
-			}
-		}
-
-		// delete the raw event
-		return txn.Del(b.rawEventStore, idx, nil)
-	})
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

plugins/storage/lmdbn/lib.go

@@ -1,208 +0,0 @@
-package lmdbn
-
-import (
-	"encoding/binary"
-	"encoding/hex"
-	"sync/atomic"
-
-	"github.com/bmatsuo/lmdb-go/lmdb"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-const (
-	maxuint16 = 65535
-	maxuint32 = 4294967295
-)
-
-type LMDBBackend struct {
-	Path     string
-	MaxLimit int
-
-	lmdbEnv *lmdb.Env
-
-	rawEventStore   lmdb.DBI
-	indexCreatedAt  lmdb.DBI
-	indexId         lmdb.DBI
-	indexKind       lmdb.DBI
-	indexPubkey     lmdb.DBI
-	indexPubkeyKind lmdb.DBI
-	indexTag        lmdb.DBI
-
-	lastId atomic.Uint32
-}
-
-func (b *LMDBBackend) Init() error {
-	if b.MaxLimit == 0 {
-		b.MaxLimit = 500
-	}
-
-	// open lmdb
-	env, err := lmdb.NewEnv()
-	if err != nil {
-		return err
-	}
-
-	env.SetMaxDBs(7)
-	env.SetMaxReaders(500)
-	env.SetMapSize(1 << 38) // ~273GB
-
-	err = env.Open(b.Path, lmdb.NoTLS, 0644)
-	if err != nil {
-		return err
-	}
-	b.lmdbEnv = env
-
-	// open each db
-	if err := b.lmdbEnv.Update(func(txn *lmdb.Txn) error {
-		if dbi, err := txn.OpenDBI("raw", lmdb.Create); err != nil {
-			return err
-		} else {
-			b.rawEventStore = dbi
-			return nil
-		}
-	}); err != nil {
-		return err
-	}
-	if err := b.lmdbEnv.Update(func(txn *lmdb.Txn) error {
-		if dbi, err := txn.OpenDBI("created_at", lmdb.Create); err != nil {
-			return err
-		} else {
-			b.indexCreatedAt = dbi
-		}
-		if dbi, err := txn.OpenDBI("id", lmdb.Create); err != nil {
-			return err
-		} else {
-			b.indexId = dbi
-		}
-		if dbi, err := txn.OpenDBI("kind", lmdb.Create); err != nil {
-			return err
-		} else {
-			b.indexKind = dbi
-		}
-		if dbi, err := txn.OpenDBI("pubkey", lmdb.Create); err != nil {
-			return err
-		} else {
-			b.indexPubkey = dbi
-		}
-		if dbi, err := txn.OpenDBI("pubkeyKind", lmdb.Create); err != nil {
-			return err
-		} else {
-			b.indexPubkeyKind = dbi
-		}
-		if dbi, err := txn.OpenDBI("tag", lmdb.Create); err != nil {
-			return err
-		} else {
-			b.indexTag = dbi
-		}
-		return nil
-	}); err != nil {
-		return err
-	}
-
-	// get lastId
-	if err := b.lmdbEnv.View(func(txn *lmdb.Txn) error {
-		txn.RawRead = true
-		cursor, err := txn.OpenCursor(b.rawEventStore)
-		if err != nil {
-			return err
-		}
-		defer cursor.Close()
-		k, _, err := cursor.Get(nil, nil, lmdb.Last)
-		if operr, ok := err.(*lmdb.OpError); ok && operr.Errno == lmdb.NotFound {
-			// nothing found, so we're at zero
-			return nil
-		}
-		if err != nil {
-		}
-		b.lastId.Store(binary.BigEndian.Uint32(k))
-
-		return nil
-	}); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (b *LMDBBackend) Close() {
-	b.lmdbEnv.Close()
-}
-
-func (b *LMDBBackend) Serial() []byte {
-	v := b.lastId.Add(1)
-	vb := make([]byte, 4)
-	binary.BigEndian.PutUint32(vb[:], uint32(v))
-	return vb
-}
-
-type key struct {
-	dbi lmdb.DBI
-	key []byte
-}
-
-func (b *LMDBBackend) getIndexKeysForEvent(evt *nostr.Event) []key {
-	keys := make([]key, 0, 18)
-
-	// indexes
-	{
-		// ~ by id
-		k, _ := hex.DecodeString(evt.ID)
-		keys = append(keys, key{dbi: b.indexId, key: k})
-	}
-
-	{
-		// ~ by pubkey+date
-		pubkey, _ := hex.DecodeString(evt.PubKey)
-		k := make([]byte, 32+4)
-		copy(k[:], pubkey)
-		binary.BigEndian.PutUint32(k[32:], uint32(evt.CreatedAt))
-		keys = append(keys, key{dbi: b.indexPubkey, key: k})
-	}
-
-	{
-		// ~ by kind+date
-		k := make([]byte, 2+4)
-		binary.BigEndian.PutUint16(k[:], uint16(evt.Kind))
-		binary.BigEndian.PutUint32(k[2:], uint32(evt.CreatedAt))
-		keys = append(keys, key{dbi: b.indexKind, key: k})
-	}
-
-	{
-		// ~ by pubkey+kind+date
-		pubkey, _ := hex.DecodeString(evt.PubKey)
-		k := make([]byte, 32+2+4)
-		copy(k[:], pubkey)
-		binary.BigEndian.PutUint16(k[32:], uint16(evt.Kind))
-		binary.BigEndian.PutUint32(k[32+2:], uint32(evt.CreatedAt))
-		keys = append(keys, key{dbi: b.indexPubkeyKind, key: k})
-	}
-
-	// ~ by tagvalue+date
-	for _, tag := range evt.Tags {
-		if len(tag) < 2 || len(tag[0]) != 1 || len(tag[1]) == 0 || len(tag[1]) > 100 {
-			continue
-		}
-
-		var v []byte
-		if vb, _ := hex.DecodeString(tag[1]); len(vb) == 32 {
-			// store value as bytes
-			v = vb
-		} else {
-			v = []byte(tag[1])
-		}
-
-		k := make([]byte, len(v)+4)
-		copy(k[:], v)
-		binary.BigEndian.PutUint32(k[len(v):], uint32(evt.CreatedAt))
-		keys = append(keys, key{dbi: b.indexTag, key: k})
-	}
-
-	{
-		// ~ by date only
-		k := make([]byte, 4)
-		binary.BigEndian.PutUint32(k[:], uint32(evt.CreatedAt))
-		keys = append(keys, key{dbi: b.indexCreatedAt, key: k})
-	}
-
-	return keys
-}

plugins/storage/lmdbn/query.go

@@ -1,321 +0,0 @@
-package lmdbn
-
-import (
-	"bytes"
-	"container/heap"
-	"context"
-	"encoding/binary"
-	"encoding/hex"
-	"fmt"
-
-	"github.com/bmatsuo/lmdb-go/lmdb"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-type query struct {
-	i             int
-	prefix        []byte
-	startingPoint []byte
-	results       chan *nostr.Event
-	skipTimestamp bool
-}
-
-type queryEvent struct {
-	*nostr.Event
-	query int
-}
-
-func (b *LMDBBackend) QueryEvents(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error) {
-	ch := make(chan *nostr.Event)
-
-	dbi, queries, extraFilter, since, prefixLen, err := b.prepareQueries(filter)
-	if err != nil {
-		return nil, err
-	}
-
-	go func() {
-		err := b.lmdbEnv.View(func(txn *lmdb.Txn) error {
-			// actually iterate
-			cursorClosers := make([]func(), len(queries))
-			for i, q := range queries {
-				go func(i int, q query) {
-					defer close(q.results)
-
-					cursor, err := txn.OpenCursor(dbi)
-					if err != nil {
-						return
-					}
-					cursorClosers[i] = cursor.Close
-
-					var k []byte
-					var idx []byte
-					var iterr error
-
-					if _, _, errsr := cursor.Get(q.startingPoint, nil, lmdb.SetRange); errsr != nil {
-						if operr, ok := errsr.(*lmdb.OpError); !ok || operr.Errno != lmdb.NotFound {
-							// in this case it's really an error
-							panic(err)
-						} else {
-							// we're at the end and we just want notes before this,
-							// so we just need to set the cursor the last key, this is not a real error
-							k, idx, iterr = cursor.Get(nil, nil, lmdb.Last)
-						}
-					} else {
-						// move one back as the first step
-						k, idx, iterr = cursor.Get(nil, nil, lmdb.Prev)
-					}
-
-					for {
-						select {
-						case <-ctx.Done():
-							break
-						default:
-						}
-
-						// we already have a k and a v and an err from the cursor setup, so check and use these
-						if iterr != nil || !bytes.Equal(q.prefix, k[0:prefixLen]) {
-							return
-						}
-
-						if !q.skipTimestamp {
-							createdAt := binary.BigEndian.Uint32(k[prefixLen:])
-							if createdAt < since {
-								break
-							}
-						}
-
-						// fetch actual event
-						val, err := txn.Get(b.rawEventStore, idx)
-						if err != nil {
-							panic(err)
-						}
-
-						evt := &nostr.Event{}
-						if err := nson.Unmarshal(string(val), evt); err != nil {
-							panic(err)
-						}
-
-						// check if this matches the other filters that were not part of the index
-						if extraFilter == nil || extraFilter.Matches(evt) {
-							q.results <- evt
-						}
-
-						// move one back (we'll look into k and v and err in the next iteration)
-						k, idx, iterr = cursor.Get(nil, nil, lmdb.Prev)
-					}
-				}(i, q)
-			}
-
-			// max number of events we'll return
-			limit := b.MaxLimit
-			if filter.Limit > 0 && filter.Limit < limit {
-				limit = filter.Limit
-			}
-
-			// receive results and ensure we only return the most recent ones always
-			emittedEvents := 0
-
-			// first pass
-			emitQueue := make(priorityQueue, 0, len(queries)+limit)
-			for _, q := range queries {
-				evt, ok := <-q.results
-				if ok {
-					emitQueue = append(emitQueue, &queryEvent{Event: evt, query: q.i})
-				}
-			}
-
-			// now it's a good time to schedule this
-			defer func() {
-				close(ch)
-				for _, cclose := range cursorClosers {
-					cclose()
-				}
-			}()
-
-			// queue may be empty here if we have literally nothing
-			if len(emitQueue) == 0 {
-				return nil
-			}
-
-			heap.Init(&emitQueue)
-
-			// iterate until we've emitted all events required
-			for {
-				// emit latest event in queue
-				latest := emitQueue[0]
-				ch <- latest.Event
-
-				// stop when reaching limit
-				emittedEvents++
-				if emittedEvents >= limit {
-					break
-				}
-
-				// fetch a new one from query results and replace the previous one with it
-				if evt, ok := <-queries[latest.query].results; ok {
-					emitQueue[0].Event = evt
-					heap.Fix(&emitQueue, 0)
-				} else {
-					// if this query has no more events we just remove this and proceed normally
-					heap.Remove(&emitQueue, 0)
-
-					// check if the list is empty and end
-					if len(emitQueue) == 0 {
-						break
-					}
-				}
-			}
-
-			return nil
-		})
-		if err != nil {
-			panic(err)
-		}
-	}()
-
-	return ch, nil
-}
-
-type priorityQueue []*queryEvent
-
-func (pq priorityQueue) Len() int { return len(pq) }
-
-func (pq priorityQueue) Less(i, j int) bool {
-	return pq[i].CreatedAt > pq[j].CreatedAt
-}
-
-func (pq priorityQueue) Swap(i, j int) {
-	pq[i], pq[j] = pq[j], pq[i]
-}
-
-func (pq *priorityQueue) Push(x any) {
-	item := x.(*queryEvent)
-	*pq = append(*pq, item)
-}
-
-func (pq *priorityQueue) Pop() any {
-	old := *pq
-	n := len(old)
-	item := old[n-1]
-	old[n-1] = nil // avoid memory leak
-	*pq = old[0 : n-1]
-	return item
-}
-
-func (b *LMDBBackend) prepareQueries(filter nostr.Filter) (
-	dbi lmdb.DBI,
-	queries []query,
-	extraFilter *nostr.Filter,
-	since uint32,
-	prefixLen int,
-	err error,
-) {
-	if len(filter.IDs) > 0 {
-		dbi = b.indexId
-		queries = make([]query, len(filter.IDs))
-		for i, idHex := range filter.IDs {
-			prefix, _ := hex.DecodeString(idHex)
-			if len(prefix) != 32 {
-				return dbi, nil, nil, 0, 0, fmt.Errorf("invalid id '%s'", idHex)
-			}
-			queries[i] = query{i: i, prefix: prefix, skipTimestamp: true}
-		}
-	} else if len(filter.Authors) > 0 {
-		if len(filter.Kinds) == 0 {
-			dbi = b.indexPubkey
-			queries = make([]query, len(filter.Authors))
-			for i, pubkeyHex := range filter.Authors {
-				prefix, _ := hex.DecodeString(pubkeyHex)
-				if len(prefix) != 32 {
-					return dbi, nil, nil, 0, 0, fmt.Errorf("invalid pubkey '%s'", pubkeyHex)
-				}
-				queries[i] = query{i: i, prefix: prefix}
-			}
-		} else {
-			dbi = b.indexPubkeyKind
-			queries = make([]query, len(filter.Authors)*len(filter.Kinds))
-			i := 0
-			for _, pubkeyHex := range filter.Authors {
-				for _, kind := range filter.Kinds {
-					pubkey, _ := hex.DecodeString(pubkeyHex)
-					if len(pubkey) != 32 {
-						return dbi, nil, nil, 0, 0, fmt.Errorf("invalid pubkey '%s'", pubkeyHex)
-					}
-					prefix := make([]byte, 32+2)
-					copy(prefix[:], pubkey)
-					binary.BigEndian.PutUint16(prefix[+32:], uint16(kind))
-					queries[i] = query{i: i, prefix: prefix}
-					i++
-				}
-			}
-		}
-		extraFilter = &nostr.Filter{Tags: filter.Tags}
-	} else if len(filter.Tags) > 0 {
-		dbi = b.indexTag
-
-		// determine the size of the queries array by inspecting all tags sizes
-		size := 0
-		for _, values := range filter.Tags {
-			size += len(values)
-		}
-		queries = make([]query, size)
-
-		extraFilter = &nostr.Filter{Kinds: filter.Kinds}
-		i := 0
-		for _, values := range filter.Tags {
-			for _, value := range values {
-				bv, _ := hex.DecodeString(value)
-				var size int
-				if len(bv) == 32 {
-					// hex tag
-					size = 32
-				} else {
-					// string tag
-					bv = []byte(value)
-					size = len(bv)
-				}
-				prefix := make([]byte, size)
-				copy(prefix[:], bv)
-				queries[i] = query{i: i, prefix: prefix}
-				i++
-			}
-		}
-	} else if len(filter.Kinds) > 0 {
-		dbi = b.indexKind
-		queries = make([]query, len(filter.Kinds))
-		for i, kind := range filter.Kinds {
-			prefix := make([]byte, 2)
-			binary.BigEndian.PutUint16(prefix[:], uint16(kind))
-			queries[i] = query{i: i, prefix: prefix}
-		}
-	} else {
-		dbi = b.indexCreatedAt
-		queries = make([]query, 1)
-		prefix := make([]byte, 0)
-		queries[0] = query{i: 0, prefix: prefix}
-		extraFilter = nil
-	}
-
-	prefixLen = len(queries[0].prefix)
-
-	var until uint32 = 4294967295
-	if filter.Until != nil {
-		if fu := uint32(*filter.Until); fu < until {
-			until = fu + 1
-		}
-	}
-	for i, q := range queries {
-		queries[i].startingPoint = binary.BigEndian.AppendUint32(q.prefix, uint32(until))
-		queries[i].results = make(chan *nostr.Event, 12)
-	}
-
-	// this is where we'll end the iteration
-	if filter.Since != nil {
-		if fs := uint32(*filter.Since); fs > since {
-			since = fs
-		}
-	}
-
-	return dbi, queries, extraFilter, since, prefixLen, nil
-}

plugins/storage/lmdbn/save.go

@@ -1,38 +0,0 @@
-package lmdbn
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/bmatsuo/lmdb-go/lmdb"
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/nbd-wtf/go-nostr/nson"
-)
-
-func (b *LMDBBackend) SaveEvent(ctx context.Context, evt *nostr.Event) error {
-	// sanity checking
-	if evt.CreatedAt > maxuint32 || evt.Kind > maxuint16 {
-		return fmt.Errorf("event with values out of expected boundaries")
-	}
-
-	return b.lmdbEnv.Update(func(txn *lmdb.Txn) error {
-		nson, err := nson.Marshal(evt)
-		if err != nil {
-			return err
-		}
-
-		idx := b.Serial()
-		// raw event store
-		if err := txn.Put(b.rawEventStore, idx, []byte(nson), 0); err != nil {
-			return err
-		}
-
-		for _, k := range b.getIndexKeysForEvent(evt) {
-			if err := txn.Put(k.dbi, k.key, idx, 0); err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
-}

plugins/storage/postgresql/delete.go

@@ -1,12 +0,0 @@
-package postgresql
-
-import (
-	"context"
-
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func (b PostgresBackend) DeleteEvent(ctx context.Context, evt *nostr.Event) error {
-	_, err := b.DB.ExecContext(ctx, "DELETE FROM event WHERE id = $1", evt.ID)
-	return err
-}

plugins/storage/postgresql/init.go

@@ -1,71 +0,0 @@
-package postgresql
-
-import (
-	"github.com/jmoiron/sqlx"
-	"github.com/jmoiron/sqlx/reflectx"
-	_ "github.com/lib/pq"
-)
-
-const (
-	queryLimit        = 100
-	queryIDsLimit     = 500
-	queryAuthorsLimit = 500
-	queryKindsLimit   = 10
-	queryTagsLimit    = 10
-)
-
-func (b *PostgresBackend) Init() error {
-	db, err := sqlx.Connect("postgres", b.DatabaseURL)
-	if err != nil {
-		return err
-	}
-
-	// sqlx default is 0 (unlimited), while postgresql by default accepts up to 100 connections
-	db.SetMaxOpenConns(80)
-
-	db.Mapper = reflectx.NewMapperFunc("json", sqlx.NameMapper)
-	b.DB = db
-
-	_, err = b.DB.Exec(`
-CREATE OR REPLACE FUNCTION tags_to_tagvalues(jsonb) RETURNS text[]
-    AS 'SELECT array_agg(t->>1) FROM (SELECT jsonb_array_elements($1) AS t)s WHERE length(t->>0) = 1;'
-    LANGUAGE SQL
-    IMMUTABLE
-    RETURNS NULL ON NULL INPUT;
-
-CREATE TABLE IF NOT EXISTS event (
-  id text NOT NULL,
-  pubkey text NOT NULL,
-  created_at integer NOT NULL,
-  kind integer NOT NULL,
-  tags jsonb NOT NULL,
-  content text NOT NULL,
-  sig text NOT NULL,
-
-  tagvalues text[] GENERATED ALWAYS AS (tags_to_tagvalues(tags)) STORED
-);
-
-CREATE UNIQUE INDEX IF NOT EXISTS ididx ON event USING btree (id text_pattern_ops);
-CREATE INDEX IF NOT EXISTS pubkeyprefix ON event USING btree (pubkey text_pattern_ops);
-CREATE INDEX IF NOT EXISTS timeidx ON event (created_at DESC);
-CREATE INDEX IF NOT EXISTS kindidx ON event (kind);
-CREATE INDEX IF NOT EXISTS arbitrarytagvalues ON event USING gin (tagvalues);
-    `)
-
-	if b.QueryLimit == 0 {
-		b.QueryLimit = queryLimit
-	}
-	if b.QueryIDsLimit == 0 {
-		b.QueryIDsLimit = queryIDsLimit
-	}
-	if b.QueryAuthorsLimit == 0 {
-		b.QueryAuthorsLimit = queryAuthorsLimit
-	}
-	if b.QueryKindsLimit == 0 {
-		b.QueryKindsLimit = queryKindsLimit
-	}
-	if b.QueryTagsLimit == 0 {
-		b.QueryTagsLimit = queryTagsLimit
-	}
-	return err
-}

plugins/storage/postgresql/postgresql.go

@@ -1,15 +0,0 @@
-package postgresql
-
-import (
-	"github.com/jmoiron/sqlx"
-)
-
-type PostgresBackend struct {
-	*sqlx.DB
-	DatabaseURL       string
-	QueryLimit        int
-	QueryIDsLimit     int
-	QueryAuthorsLimit int
-	QueryKindsLimit   int
-	QueryTagsLimit    int
-}

plugins/storage/postgresql/query.go

@@ -1,193 +0,0 @@
-package postgresql
-
-import (
-	"context"
-	"database/sql"
-	"encoding/hex"
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/jmoiron/sqlx"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func (b PostgresBackend) QueryEvents(ctx context.Context, filter nostr.Filter) (ch chan *nostr.Event, err error) {
-	ch = make(chan *nostr.Event)
-
-	query, params, err := b.queryEventsSql(filter, false)
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := b.DB.Query(query, params...)
-	if err != nil && err != sql.ErrNoRows {
-		return nil, fmt.Errorf("failed to fetch events using query %q: %w", query, err)
-	}
-
-	go func() {
-		defer rows.Close()
-		defer close(ch)
-		for rows.Next() {
-			var evt nostr.Event
-			var timestamp int64
-			err := rows.Scan(&evt.ID, &evt.PubKey, &timestamp,
-				&evt.Kind, &evt.Tags, &evt.Content, &evt.Sig)
-			if err != nil {
-				return
-			}
-			evt.CreatedAt = nostr.Timestamp(timestamp)
-			ch <- &evt
-		}
-	}()
-
-	return ch, nil
-}
-
-func (b PostgresBackend) CountEvents(ctx context.Context, filter nostr.Filter) (int64, error) {
-	query, params, err := b.queryEventsSql(filter, true)
-	if err != nil {
-		return 0, err
-	}
-
-	var count int64
-	if err = b.DB.QueryRow(query, params...).Scan(&count); err != nil && err != sql.ErrNoRows {
-		return 0, fmt.Errorf("failed to fetch events using query %q: %w", query, err)
-	}
-	return count, nil
-}
-
-func (b PostgresBackend) queryEventsSql(filter nostr.Filter, doCount bool) (string, []any, error) {
-	var conditions []string
-	var params []any
-
-	if filter.IDs != nil {
-		if len(filter.IDs) > b.QueryIDsLimit {
-			// too many ids, fail everything
-			return "", nil, nil
-		}
-
-		likeids := make([]string, 0, len(filter.IDs))
-		for _, id := range filter.IDs {
-			// to prevent sql attack here we will check if
-			// these ids are valid 32byte hex
-			parsed, err := hex.DecodeString(id)
-			if err != nil || len(parsed) != 32 {
-				continue
-			}
-			likeids = append(likeids, fmt.Sprintf("id LIKE '%x%%'", parsed))
-		}
-		if len(likeids) == 0 {
-			// ids being [] mean you won't get anything
-			return "", nil, nil
-		}
-		conditions = append(conditions, "("+strings.Join(likeids, " OR ")+")")
-	}
-
-	if filter.Authors != nil {
-		if len(filter.Authors) > b.QueryAuthorsLimit {
-			// too many authors, fail everything
-			return "", nil, nil
-		}
-
-		likekeys := make([]string, 0, len(filter.Authors))
-		for _, key := range filter.Authors {
-			// to prevent sql attack here we will check if
-			// these keys are valid 32byte hex
-			parsed, err := hex.DecodeString(key)
-			if err != nil || len(parsed) != 32 {
-				continue
-			}
-			likekeys = append(likekeys, fmt.Sprintf("pubkey LIKE '%x%%'", parsed))
-		}
-		if len(likekeys) == 0 {
-			// authors being [] mean you won't get anything
-			return "", nil, nil
-		}
-		conditions = append(conditions, "("+strings.Join(likekeys, " OR ")+")")
-	}
-
-	if filter.Kinds != nil {
-		if len(filter.Kinds) > b.QueryKindsLimit {
-			// too many kinds, fail everything
-			return "", nil, nil
-		}
-
-		if len(filter.Kinds) == 0 {
-			// kinds being [] mean you won't get anything
-			return "", nil, nil
-		}
-		// no sql injection issues since these are ints
-		inkinds := make([]string, len(filter.Kinds))
-		for i, kind := range filter.Kinds {
-			inkinds[i] = strconv.Itoa(kind)
-		}
-		conditions = append(conditions, `kind IN (`+strings.Join(inkinds, ",")+`)`)
-	}
-
-	tagQuery := make([]string, 0, 1)
-	for _, values := range filter.Tags {
-		if len(values) == 0 {
-			// any tag set to [] is wrong
-			return "", nil, nil
-		}
-
-		// add these tags to the query
-		tagQuery = append(tagQuery, values...)
-
-		if len(tagQuery) > b.QueryTagsLimit {
-			// too many tags, fail everything
-			return "", nil, nil
-		}
-	}
-
-	if len(tagQuery) > 0 {
-		arrayBuild := make([]string, len(tagQuery))
-		for i, tagValue := range tagQuery {
-			arrayBuild[i] = "?"
-			params = append(params, tagValue)
-		}
-
-		// we use a very bad implementation in which we only check the tag values and
-		// ignore the tag names
-		conditions = append(conditions,
-			"tagvalues && ARRAY["+strings.Join(arrayBuild, ",")+"]")
-	}
-
-	if filter.Since != nil {
-		conditions = append(conditions, "created_at > ?")
-		params = append(params, filter.Since)
-	}
-	if filter.Until != nil {
-		conditions = append(conditions, "created_at < ?")
-		params = append(params, filter.Until)
-	}
-
-	if len(conditions) == 0 {
-		// fallback
-		conditions = append(conditions, "true")
-	}
-
-	if filter.Limit < 1 || filter.Limit > b.QueryLimit {
-		params = append(params, b.QueryLimit)
-	} else {
-		params = append(params, filter.Limit)
-	}
-
-	var query string
-	if doCount {
-		query = sqlx.Rebind(sqlx.BindType("postgres"), `SELECT
-          COUNT(*)
-        FROM event WHERE `+
-			strings.Join(conditions, " AND ")+
-			" ORDER BY created_at DESC LIMIT ?")
-	} else {
-		query = sqlx.Rebind(sqlx.BindType("postgres"), `SELECT
-          id, pubkey, created_at, kind, tags, content, sig
-        FROM event WHERE `+
-			strings.Join(conditions, " AND ")+
-			" ORDER BY created_at DESC LIMIT ?")
-	}
-
-	return query, params, nil
-}

plugins/storage/postgresql/query_test.go

@@ -1,405 +0,0 @@
-package postgresql
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/stretchr/testify/assert"
-)
-
-var defaultBackend = PostgresBackend{
-	QueryLimit:        queryLimit,
-	QueryIDsLimit:     queryIDsLimit,
-	QueryAuthorsLimit: queryAuthorsLimit,
-	QueryKindsLimit:   queryKindsLimit,
-	QueryTagsLimit:    queryTagsLimit,
-}
-
-func TestQueryEventsSql(t *testing.T) {
-	var tests = []struct {
-		name    string
-		backend PostgresBackend
-		filter  *nostr.Filter
-		query   string
-		params  []any
-		err     error
-	}{
-		{
-			name:    "empty filter",
-			backend: defaultBackend,
-			filter:  &nostr.Filter{},
-			query:   "SELECT id, pubkey, created_at, kind, tags, content, sig FROM event WHERE true ORDER BY created_at DESC LIMIT $1",
-			params:  []any{100},
-			err:     nil,
-		},
-		{
-			name:    "valid filter limit",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Limit: 50,
-			},
-			query:  "SELECT id, pubkey, created_at, kind, tags, content, sig FROM event WHERE true ORDER BY created_at DESC LIMIT $1",
-			params: []any{50},
-			err:    nil,
-		},
-		{
-			name:    "too large filter limit",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Limit: 2000,
-			},
-			query:  "SELECT id, pubkey, created_at, kind, tags, content, sig FROM event WHERE true ORDER BY created_at DESC LIMIT $1",
-			params: []any{100},
-			err:    nil,
-		},
-		{
-			name:    "ids filter",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				IDs: []string{"083ec57f36a7b39ab98a57bedab4f85355b2ee89e4b205bed58d7c3ef9edd294"},
-			},
-			query: `SELECT id, pubkey, created_at, kind, tags, content, sig 
-			FROM event 
-			WHERE (id LIKE '083ec57f36a7b39ab98a57bedab4f85355b2ee89e4b205bed58d7c3ef9edd294%') 
-			ORDER BY created_at DESC LIMIT $1`,
-			params: []any{100},
-			err:    nil,
-		},
-		{
-			name:    "kind filter",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Kinds: []int{1, 2, 3},
-			},
-			query: `SELECT id, pubkey, created_at, kind, tags, content, sig 
-			FROM event 
-			WHERE kind IN(1,2,3) 
-			ORDER BY created_at DESC LIMIT $1`,
-			params: []any{100},
-			err:    nil,
-		},
-		{
-			name:    "authors filter",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Authors: []string{"7bdef7bdebb8721f77927d0e77c66059360fa62371fdf15f3add93923a613229"},
-			},
-			query: `SELECT id, pubkey, created_at, kind, tags, content, sig 
-			FROM event 
-			WHERE (pubkey LIKE '7bdef7bdebb8721f77927d0e77c66059360fa62371fdf15f3add93923a613229%') 
-			ORDER BY created_at DESC LIMIT $1`,
-			params: []any{100},
-			err:    nil,
-		},
-		// errors
-		{
-			name:    "nil filter",
-			backend: defaultBackend,
-			filter:  nil,
-			query:   "",
-			params:  nil,
-			err:     fmt.Errorf("filter cannot be null"),
-		},
-		{
-			name:    "too many ids",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				IDs: strSlice(501),
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "invalid ids",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				IDs: []string{"stuff"},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "too many authors",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Authors: strSlice(501),
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "invalid authors",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Authors: []string{"stuff"},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "too many kinds",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Kinds: intSlice(11),
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "no kinds",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Kinds: []int{},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "tags of empty array",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Tags: nostr.TagMap{
-					"#e": []string{},
-				},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "too many tag values",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Tags: nostr.TagMap{
-					"#e": strSlice(11),
-				},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			query, params, err := tt.backend.queryEventsSql(tt.filter, false)
-			assert.Equal(t, tt.err, err)
-			if err != nil {
-				return
-			}
-
-			assert.Equal(t, clean(tt.query), clean(query))
-			assert.Equal(t, tt.params, params)
-		})
-	}
-}
-
-func clean(s string) string {
-	return strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(s, "\t", ""), "\n", ""), " ", "")
-}
-
-func intSlice(n int) []int {
-	slice := make([]int, 0, n)
-	for i := 0; i < n; i++ {
-		slice = append(slice, i)
-	}
-	return slice
-}
-
-func strSlice(n int) []string {
-	slice := make([]string, 0, n)
-	for i := 0; i < n; i++ {
-		slice = append(slice, strconv.Itoa(i))
-	}
-	return slice
-}
-
-func TestCountEventsSql(t *testing.T) {
-	var tests = []struct {
-		name    string
-		backend PostgresBackend
-		filter  *nostr.Filter
-		query   string
-		params  []any
-		err     error
-	}{
-		{
-			name:    "empty filter",
-			backend: defaultBackend,
-			filter:  &nostr.Filter{},
-			query:   "SELECT COUNT(*) FROM event WHERE true ORDER BY created_at DESC LIMIT $1",
-			params:  []any{100},
-			err:     nil,
-		},
-		{
-			name:    "ids filter",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				IDs: []string{"083ec57f36a7b39ab98a57bedab4f85355b2ee89e4b205bed58d7c3ef9edd294"},
-			},
-			query: `SELECT COUNT(*)
-			FROM event 
-			WHERE (id LIKE '083ec57f36a7b39ab98a57bedab4f85355b2ee89e4b205bed58d7c3ef9edd294%') 
-			ORDER BY created_at DESC LIMIT $1`,
-			params: []any{100},
-			err:    nil,
-		},
-		{
-			name:    "kind filter",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Kinds: []int{1, 2, 3},
-			},
-			query: `SELECT COUNT(*)
-			FROM event 
-			WHERE kind IN(1,2,3) 
-			ORDER BY created_at DESC LIMIT $1`,
-			params: []any{100},
-			err:    nil,
-		},
-		{
-			name:    "authors filter",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Authors: []string{"7bdef7bdebb8721f77927d0e77c66059360fa62371fdf15f3add93923a613229"},
-			},
-			query: `SELECT COUNT(*)
-			FROM event 
-			WHERE (pubkey LIKE '7bdef7bdebb8721f77927d0e77c66059360fa62371fdf15f3add93923a613229%') 
-			ORDER BY created_at DESC LIMIT $1`,
-			params: []any{100},
-			err:    nil,
-		},
-		// errors
-		{
-			name:    "nil filter",
-			backend: defaultBackend,
-			filter:  nil,
-			query:   "",
-			params:  nil,
-			err:     fmt.Errorf("filter cannot be null"),
-		},
-		{
-			name:    "too many ids",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				IDs: strSlice(501),
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "invalid ids",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				IDs: []string{"stuff"},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "too many authors",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Authors: strSlice(501),
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "invalid authors",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Authors: []string{"stuff"},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "too many kinds",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Kinds: intSlice(11),
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "no kinds",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Kinds: []int{},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "tags of empty array",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Tags: nostr.TagMap{
-					"#e": []string{},
-				},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-		{
-			name:    "too many tag values",
-			backend: defaultBackend,
-			filter: &nostr.Filter{
-				Tags: nostr.TagMap{
-					"#e": strSlice(11),
-				},
-			},
-			query:  "",
-			params: nil,
-			// REVIEW: should return error
-			err: nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			query, params, err := tt.backend.queryEventsSql(tt.filter, true)
-			assert.Equal(t, tt.err, err)
-			if err != nil {
-				return
-			}
-
-			assert.Equal(t, clean(tt.query), clean(query))
-			assert.Equal(t, tt.params, params)
-		})
-	}
-}

plugins/storage/postgresql/save.go

@@ -1,54 +0,0 @@
-package postgresql
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/fiatjaf/khatru"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func (b *PostgresBackend) SaveEvent(ctx context.Context, evt *nostr.Event) error {
-	sql, params, _ := saveEventSql(evt)
-	res, err := b.DB.ExecContext(ctx, sql, params...)
-	if err != nil {
-		return err
-	}
-
-	nr, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-
-	if nr == 0 {
-		return khatru.ErrDupEvent
-	}
-
-	return nil
-}
-
-func (b *PostgresBackend) BeforeSave(ctx context.Context, evt *nostr.Event) {
-	// do nothing
-}
-
-func (b *PostgresBackend) AfterSave(evt *nostr.Event) {
-	// delete all but the 100 most recent ones for each key
-	b.DB.Exec(`DELETE FROM event WHERE pubkey = $1 AND kind = $2 AND created_at < (
-      SELECT created_at FROM event WHERE pubkey = $1
-      ORDER BY created_at DESC OFFSET 100 LIMIT 1
-    )`, evt.PubKey, evt.Kind)
-}
-
-func saveEventSql(evt *nostr.Event) (string, []any, error) {
-	const query = `INSERT INTO event (
-	id, pubkey, created_at, kind, tags, content, sig)
-	VALUES ($1, $2, $3, $4, $5, $6, $7)
-	ON CONFLICT (id) DO NOTHING`
-
-	var (
-		tagsj, _ = json.Marshal(evt.Tags)
-		params   = []any{evt.ID, evt.PubKey, evt.CreatedAt, evt.Kind, tagsj, evt.Content, evt.Sig}
-	)
-
-	return query, params, nil
-}

plugins/storage/postgresql/save_test.go

@@ -1,64 +0,0 @@
-package postgresql
-
-import (
-	"testing"
-
-	"github.com/nbd-wtf/go-nostr"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSaveEventSql(t *testing.T) {
-	now := nostr.Now()
-	tests := []struct {
-		name   string
-		event  *nostr.Event
-		query  string
-		params []any
-		err    error
-	}{
-		{
-			name: "basic",
-			event: &nostr.Event{
-				ID:        "id",
-				PubKey:    "pk",
-				CreatedAt: now,
-				Kind:      nostr.KindTextNote,
-				Content:   "test",
-				Sig:       "sig",
-			},
-			query: `INSERT INTO event (
-	id, pubkey, created_at, kind, tags, content, sig)
-	VALUES ($1, $2, $3, $4, $5, $6, $7)
-	ON CONFLICT (id) DO NOTHING`,
-			params: []any{"id", "pk", now, nostr.KindTextNote, []byte("null"), "test", "sig"},
-			err:    nil,
-		},
-		{
-			name: "tags",
-			event: &nostr.Event{
-				ID:        "id",
-				PubKey:    "pk",
-				CreatedAt: now,
-				Kind:      nostr.KindTextNote,
-				Tags:      nostr.Tags{nostr.Tag{"foo", "bar"}},
-				Content:   "test",
-				Sig:       "sig",
-			},
-			query: `INSERT INTO event (
-	id, pubkey, created_at, kind, tags, content, sig)
-	VALUES ($1, $2, $3, $4, $5, $6, $7)
-	ON CONFLICT (id) DO NOTHING`,
-			params: []any{"id", "pk", now, nostr.KindTextNote, []byte("[[\"foo\",\"bar\"]]"), "test", "sig"},
-			err:    nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			query, params, err := saveEventSql(tt.event)
-			assert.Equal(t, clean(tt.query), clean(query))
-			assert.Equal(t, tt.params, params)
-			assert.Equal(t, tt.err, err)
-		})
-	}
-}

plugins/storage/sqlite3/delete.go

@@ -1,12 +0,0 @@
-package sqlite3
-
-import (
-	"context"
-
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func (b SQLite3Backend) DeleteEvent(ctx context.Context, evt *nostr.Event) error {
-	_, err := b.DB.ExecContext(ctx, "DELETE FROM event WHERE id = $1", evt.ID)
-	return err
-}

plugins/storage/sqlite3/init.go

@@ -1,33 +0,0 @@
-package sqlite3
-
-import (
-	"github.com/jmoiron/sqlx"
-	"github.com/jmoiron/sqlx/reflectx"
-	_ "github.com/mattn/go-sqlite3"
-)
-
-func (b *SQLite3Backend) Init() error {
-	db, err := sqlx.Connect("sqlite3", b.DatabaseURL)
-	if err != nil {
-		return err
-	}
-
-	// sqlx default is 0 (unlimited), while sqlite3 by default accepts up to 100 connections
-	db.SetMaxOpenConns(80)
-
-	db.Mapper = reflectx.NewMapperFunc("json", sqlx.NameMapper)
-	b.DB = db
-
-	_, err = b.DB.Exec(`
-CREATE TABLE IF NOT EXISTS event (
-  id text NOT NULL,
-  pubkey text NOT NULL,
-  created_at integer NOT NULL,
-  kind integer NOT NULL,
-  tags jsonb NOT NULL,
-  content text NOT NULL,
-  sig text NOT NULL
-);
-    `)
-	return err
-}

plugins/storage/sqlite3/query.go

@@ -1,192 +0,0 @@
-package sqlite3
-
-import (
-	"context"
-	"database/sql"
-	"encoding/hex"
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/jmoiron/sqlx"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func (b SQLite3Backend) QueryEvents(ctx context.Context, filter nostr.Filter) (ch chan *nostr.Event, err error) {
-	ch = make(chan *nostr.Event)
-
-	query, params, err := queryEventsSql(filter, false)
-	if err != nil {
-		return nil, err
-	}
-
-	rows, err := b.DB.Query(query, params...)
-	if err != nil && err != sql.ErrNoRows {
-		return nil, fmt.Errorf("failed to fetch events using query %q: %w", query, err)
-	}
-
-	go func() {
-		defer rows.Close()
-		defer close(ch)
-		for rows.Next() {
-			var evt nostr.Event
-			var timestamp int64
-			err := rows.Scan(&evt.ID, &evt.PubKey, &timestamp,
-				&evt.Kind, &evt.Tags, &evt.Content, &evt.Sig)
-			if err != nil {
-				return
-			}
-			evt.CreatedAt = nostr.Timestamp(timestamp)
-			ch <- &evt
-		}
-	}()
-
-	return ch, nil
-}
-
-func (b SQLite3Backend) CountEvents(ctx context.Context, filter nostr.Filter) (int64, error) {
-	query, params, err := queryEventsSql(filter, true)
-	if err != nil {
-		return 0, err
-	}
-
-	var count int64
-	err = b.DB.QueryRow(query, params...).Scan(&count)
-	if err != nil && err != sql.ErrNoRows {
-		return 0, fmt.Errorf("failed to fetch events using query %q: %w", query, err)
-	}
-	return count, nil
-}
-
-func queryEventsSql(filter nostr.Filter, doCount bool) (string, []any, error) {
-	var conditions []string
-	var params []any
-
-	if filter.IDs != nil {
-		if len(filter.IDs) > 500 {
-			// too many ids, fail everything
-			return "", nil, nil
-		}
-
-		likeids := make([]string, 0, len(filter.IDs))
-		for _, id := range filter.IDs {
-			// to prevent sql attack here we will check if
-			// these ids are valid 32byte hex
-			parsed, err := hex.DecodeString(id)
-			if err != nil || len(parsed) != 32 {
-				continue
-			}
-			likeids = append(likeids, fmt.Sprintf("id LIKE '%x%%'", parsed))
-		}
-		if len(likeids) == 0 {
-			// ids being [] mean you won't get anything
-			return "", nil, nil
-		}
-		conditions = append(conditions, "("+strings.Join(likeids, " OR ")+")")
-	}
-
-	if filter.Authors != nil {
-		if len(filter.Authors) > 500 {
-			// too many authors, fail everything
-			return "", nil, nil
-		}
-
-		likekeys := make([]string, 0, len(filter.Authors))
-		for _, key := range filter.Authors {
-			// to prevent sql attack here we will check if
-			// these keys are valid 32byte hex
-			parsed, err := hex.DecodeString(key)
-			if err != nil || len(parsed) != 32 {
-				continue
-			}
-			likekeys = append(likekeys, fmt.Sprintf("pubkey LIKE '%x%%'", parsed))
-		}
-		if len(likekeys) == 0 {
-			// authors being [] mean you won't get anything
-			return "", nil, nil
-		}
-		conditions = append(conditions, "("+strings.Join(likekeys, " OR ")+")")
-	}
-
-	if filter.Kinds != nil {
-		if len(filter.Kinds) > 10 {
-			// too many kinds, fail everything
-			return "", nil, nil
-		}
-
-		if len(filter.Kinds) == 0 {
-			// kinds being [] mean you won't get anything
-			return "", nil, nil
-		}
-		// no sql injection issues since these are ints
-		inkinds := make([]string, len(filter.Kinds))
-		for i, kind := range filter.Kinds {
-			inkinds[i] = strconv.Itoa(kind)
-		}
-		conditions = append(conditions, `kind IN (`+strings.Join(inkinds, ",")+`)`)
-	}
-
-	tagQuery := make([]string, 0, 1)
-	for _, values := range filter.Tags {
-		if len(values) == 0 {
-			// any tag set to [] is wrong
-			return "", nil, nil
-		}
-
-		// add these tags to the query
-		tagQuery = append(tagQuery, values...)
-
-		if len(tagQuery) > 10 {
-			// too many tags, fail everything
-			return "", nil, nil
-		}
-	}
-
-	// we use a very bad implementation in which we only check the tag values and
-	// ignore the tag names
-	for _, tagValue := range tagQuery {
-		params = append(params, "%"+tagValue+"%")
-		conditions = append(conditions, "tags LIKE ?")
-	}
-
-	if filter.Since != nil {
-		conditions = append(conditions, "created_at > ?")
-		params = append(params, filter.Since)
-	}
-	if filter.Until != nil {
-		conditions = append(conditions, "created_at < ?")
-		params = append(params, filter.Until)
-	}
-	if filter.Search != "" {
-		conditions = append(conditions, "content LIKE ?")
-		params = append(params, "%"+filter.Search+"%")
-	}
-
-	if len(conditions) == 0 {
-		// fallback
-		conditions = append(conditions, "true")
-	}
-
-	if filter.Limit < 1 || filter.Limit > 100 {
-		params = append(params, 100)
-	} else {
-		params = append(params, filter.Limit)
-	}
-
-	var query string
-	if doCount {
-		query = sqlx.Rebind(sqlx.BindType("sqlite3"), `SELECT
-          COUNT(*)
-        FROM event WHERE `+
-			strings.Join(conditions, " AND ")+
-			" ORDER BY created_at DESC LIMIT ?")
-	} else {
-		query = sqlx.Rebind(sqlx.BindType("sqlite3"), `SELECT
-          id, pubkey, created_at, kind, tags, content, sig
-        FROM event WHERE `+
-			strings.Join(conditions, " AND ")+
-			" ORDER BY created_at DESC LIMIT ?")
-	}
-
-	return query, params, nil
-}

plugins/storage/sqlite3/save.go

@@ -1,44 +0,0 @@
-package sqlite3
-
-import (
-	"context"
-	"encoding/json"
-
-	"github.com/fiatjaf/khatru"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func (b *SQLite3Backend) SaveEvent(ctx context.Context, evt *nostr.Event) error {
-	// insert
-	tagsj, _ := json.Marshal(evt.Tags)
-	res, err := b.DB.ExecContext(ctx, `
-        INSERT INTO event (id, pubkey, created_at, kind, tags, content, sig)
-        VALUES ($1, $2, $3, $4, $5, $6, $7)
-    `, evt.ID, evt.PubKey, evt.CreatedAt, evt.Kind, tagsj, evt.Content, evt.Sig)
-	if err != nil {
-		return err
-	}
-
-	nr, err := res.RowsAffected()
-	if err != nil {
-		return err
-	}
-
-	if nr == 0 {
-		return khatru.ErrDupEvent
-	}
-
-	return nil
-}
-
-func (b *SQLite3Backend) BeforeSave(ctx context.Context, evt *nostr.Event) {
-	// do nothing
-}
-
-func (b *SQLite3Backend) AfterSave(evt *nostr.Event) {
-	// delete all but the 100 most recent ones for each key
-	b.DB.Exec(`DELETE FROM event WHERE pubkey = $1 AND kind = $2 AND created_at < (
-      SELECT created_at FROM event WHERE pubkey = $1
-      ORDER BY created_at DESC OFFSET 100 LIMIT 1
-    )`, evt.PubKey, evt.Kind)
-}

plugins/storage/sqlite3/sqlite3.go

@@ -1,10 +0,0 @@
-package sqlite3
-
-import (
-	"github.com/jmoiron/sqlx"
-)
-
-type SQLite3Backend struct {
-	*sqlx.DB
-	DatabaseURL string
-}

policies/events.go

@@ -0,0 +1,110 @@
+package policies
+
+import (
+	"context"
+
+	"github.com/nbd-wtf/go-nostr"
+	"golang.org/x/exp/slices"
+)
+
+// PreventTooManyIndexableTags returns a function that can be used as a RejectFilter that will reject
+// events with more indexable (single-character) tags than the specified number.
+//
+// If ignoreKinds is given this restriction will not apply to these kinds (useful for allowing a bigger).
+// If onlyKinds is given then all other kinds will be ignored.
+func PreventTooManyIndexableTags(max int, ignoreKinds []int, onlyKinds []int) func(context.Context, *nostr.Event) (bool, string) {
+	ignore := func(kind int) bool { return false }
+	if len(ignoreKinds) > 0 {
+		ignore = func(kind int) bool {
+			_, isIgnored := slices.BinarySearch(ignoreKinds, kind)
+			return isIgnored
+		}
+	}
+	if len(onlyKinds) > 0 {
+		ignore = func(kind int) bool {
+			_, isApplicable := slices.BinarySearch(onlyKinds, kind)
+			return !isApplicable
+		}
+	}
+
+	return func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
+		if ignore(event.Kind) {
+			return false, ""
+		}
+
+		ntags := 0
+		for _, tag := range event.Tags {
+			if len(tag) > 0 && len(tag[0]) == 1 {
+				ntags++
+			}
+		}
+		if ntags > max {
+			return true, "too many indexable tags"
+		}
+		return false, ""
+	}
+}
+
+// PreventLargeTags rejects events that have indexable tag values greater than maxTagValueLen.
+func PreventLargeTags(maxTagValueLen int) func(context.Context, *nostr.Event) (bool, string) {
+	return func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
+		for _, tag := range event.Tags {
+			if len(tag) > 1 && len(tag[0]) == 1 {
+				if len(tag[1]) > maxTagValueLen {
+					return true, "event contains too large tags"
+				}
+			}
+		}
+		return false, ""
+	}
+}
+
+// RestrictToSpecifiedKinds returns a function that can be used as a RejectFilter that will reject
+// any events with kinds different than the specified ones.
+func RestrictToSpecifiedKinds(kinds ...uint16) func(context.Context, *nostr.Event) (bool, string) {
+	max := 0
+	min := 0
+	for _, kind := range kinds {
+		if int(kind) > max {
+			max = int(kind)
+		}
+		if int(kind) < min {
+			min = int(kind)
+		}
+	}
+
+	return func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
+		// these are cheap and very questionable optimizations, but they exist for a reason:
+		// we would have to ensure that the kind number is within the bounds of a uint16 anyway
+		if event.Kind > max {
+			return true, "event kind not allowed"
+		}
+		if event.Kind < min {
+			return true, "event kind not allowed"
+		}
+
+		// hopefully this map of uint16s is very fast
+		if _, allowed := slices.BinarySearch(kinds, uint16(event.Kind)); allowed {
+			return false, ""
+		}
+		return true, "event kind not allowed"
+	}
+}
+
+func PreventTimestampsInThePast(thresholdSeconds nostr.Timestamp) func(context.Context, *nostr.Event) (bool, string) {
+	return func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
+		if nostr.Now()-event.CreatedAt > thresholdSeconds {
+			return true, "event too old"
+		}
+		return false, ""
+	}
+}
+
+func PreventTimestampsInTheFuture(thresholdSeconds nostr.Timestamp) func(context.Context, *nostr.Event) (bool, string) {
+	return func(ctx context.Context, event *nostr.Event) (reject bool, msg string) {
+		if event.CreatedAt-nostr.Now() > thresholdSeconds {
+			return true, "event too much in the future"
+		}
+		return false, ""
+	}
+}

policies/filters.go

@@ -0,0 +1,73 @@
+package policies
+
+import (
+	"context"
+
+	"github.com/nbd-wtf/go-nostr"
+	"golang.org/x/exp/slices"
+)
+
+// NoComplexFilters disallows filters with more than 2 tags.
+func NoComplexFilters(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
+	items := len(filter.Tags) + len(filter.Kinds)
+
+	if items > 4 && len(filter.Tags) > 2 {
+		return true, "too many things to filter for"
+	}
+
+	return false, ""
+}
+
+// NoEmptyFilters disallows filters that don't have at least a tag, a kind, an author or an id.
+func NoEmptyFilters(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
+	c := len(filter.Kinds) + len(filter.IDs) + len(filter.Authors)
+	for _, tagItems := range filter.Tags {
+		c += len(tagItems)
+	}
+	if c == 0 {
+		return true, "can't handle empty filters"
+	}
+	return false, ""
+}
+
+// AntiSyncBots tries to prevent people from syncing kind:1s from this relay to else by always
+// requiring an author parameter at least.
+func AntiSyncBots(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
+	return (len(filter.Kinds) == 0 || slices.Contains(filter.Kinds, 1)) &&
+		len(filter.Authors) == 0, "an author must be specified to get their kind:1 notes"
+}
+
+func NoSearchQueries(ctx context.Context, filter nostr.Filter) (reject bool, msg string) {
+	if filter.Search != "" {
+		return true, "search is not supported"
+	}
+	return false, ""
+}
+
+func RemoveSearchQueries(ctx context.Context, filter *nostr.Filter) {
+	filter.Search = ""
+}
+
+func RemoveAllButKinds(kinds ...uint16) func(context.Context, *nostr.Filter) {
+	return func(ctx context.Context, filter *nostr.Filter) {
+		if n := len(filter.Kinds); n > 0 {
+			newKinds := make([]int, 0, n)
+			for i := 0; i < n; i++ {
+				if k := filter.Kinds[i]; slices.Contains(kinds, uint16(k)) {
+					newKinds = append(newKinds, k)
+				}
+			}
+			filter.Kinds = newKinds
+		}
+	}
+}
+
+func RemoveAllButTags(tagNames ...string) func(context.Context, *nostr.Filter) {
+	return func(ctx context.Context, filter *nostr.Filter) {
+		for tagName := range filter.Tags {
+			if !slices.Contains(tagNames, tagName) {
+				delete(filter.Tags, tagName)
+			}
+		}
+	}
+}

policies/nip04.go

@@ -1,4 +1,4 @@
-package plugins
+package policies
 
 import (
 	"context"
@@ -8,7 +8,8 @@ import (
 	"golang.org/x/exp/slices"
 )
 
-func rejectKind04Snoopers(ctx context.Context, filter nostr.Filter) (bool, string) {
+// RejectKind04Snoopers prevents reading NIP-04 messages from people not involved in the conversation.
+func RejectKind04Snoopers(ctx context.Context, filter nostr.Filter) (bool, string) {
 	// prevent kind-4 events from being returned to unauthed users,
 	//   only when authentication is a thing
 	if !slices.Contains(filter.Kinds, 4) {
@@ -19,13 +20,13 @@ func rejectKind04Snoopers(ctx context.Context, filter nostr.Filter) (bool, strin
 	senders := filter.Authors
 	receivers, _ := filter.Tags["p"]
 	switch {
-	case ws.Authed == "":
+	case ws.AuthedPublicKey == "":
 		// not authenticated
 		return true, "restricted: this relay does not serve kind-4 to unauthenticated users, does your client implement NIP-42?"
-	case len(senders) == 1 && len(receivers) < 2 && (senders[0] == ws.Authed):
+	case len(senders) == 1 && len(receivers) < 2 && (senders[0] == ws.AuthedPublicKey):
 		// allowed filter: ws.authed is sole sender (filter specifies one or all receivers)
 		return false, ""
-	case len(receivers) == 1 && len(senders) < 2 && (receivers[0] == ws.Authed):
+	case len(receivers) == 1 && len(senders) < 2 && (receivers[0] == ws.AuthedPublicKey):
 		// allowed filter: ws.authed is sole receiver (filter specifies one or all senders)
 		return false, ""
 	default:

relay.go

@@ -17,6 +17,12 @@ func NewRelay() *Relay {
 	return &Relay{
 		Log: log.New(os.Stderr, "[khatru-relay] ", log.LstdFlags),
 
+		Info: &nip11.RelayInformationDocument{
+			Software:      "https://github.com/fiatjaf/khatru",
+			Version:       "n/a",
+			SupportedNIPs: make([]int, 0),
+		},
+
 		upgrader: websocket.Upgrader{
 			ReadBufferSize:  1024,
 			WriteBufferSize: 1024,
@@ -34,24 +40,26 @@ func NewRelay() *Relay {
 }
 
 type Relay struct {
-	Name        string
-	Description string
-	PubKey      string
-	Contact     string
-	ServiceURL  string // required for nip-42
+	ServiceURL string
 
-	RejectEvent              []func(ctx context.Context, event *nostr.Event) (reject bool, msg string)
-	RejectFilter             []func(ctx context.Context, filter nostr.Filter) (reject bool, msg string)
-	RejectCountFilter        []func(ctx context.Context, filter nostr.Filter) (reject bool, msg string)
-	OverwriteDeletionOutcome []func(ctx context.Context, target *nostr.Event, deletion *nostr.Event) (acceptDeletion bool, msg string)
-	StoreEvent               []func(ctx context.Context, event *nostr.Event) error
-	DeleteEvent              []func(ctx context.Context, event *nostr.Event) error
-	QueryEvents              []func(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error)
-	CountEvents              []func(ctx context.Context, filter nostr.Filter) (int64, error)
-	EditInformation          []func(ctx context.Context, info *nip11.RelayInformationDocument)
-	OnAuth                   []func(ctx context.Context, pubkey string)
-	OnConnect                []func(ctx context.Context)
-	OnEventSaved             []func(ctx context.Context, event *nostr.Event)
+	RejectEvent               []func(ctx context.Context, event *nostr.Event) (reject bool, msg string)
+	RejectFilter              []func(ctx context.Context, filter nostr.Filter) (reject bool, msg string)
+	RejectCountFilter         []func(ctx context.Context, filter nostr.Filter) (reject bool, msg string)
+	OverwriteDeletionOutcome  []func(ctx context.Context, target *nostr.Event, deletion *nostr.Event) (acceptDeletion bool, msg string)
+	OverwriteResponseEvent    []func(ctx context.Context, event *nostr.Event)
+	OverwriteFilter           []func(ctx context.Context, filter *nostr.Filter)
+	OverwriteCountFilter      []func(ctx context.Context, filter *nostr.Filter)
+	OverwriteRelayInformation []func(ctx context.Context, r *http.Request, info nip11.RelayInformationDocument) nip11.RelayInformationDocument
+	StoreEvent                []func(ctx context.Context, event *nostr.Event) error
+	DeleteEvent               []func(ctx context.Context, event *nostr.Event) error
+	QueryEvents               []func(ctx context.Context, filter nostr.Filter) (chan *nostr.Event, error)
+	CountEvents               []func(ctx context.Context, filter nostr.Filter) (int64, error)
+	OnConnect                 []func(ctx context.Context)
+	OnDisconnect              []func(ctx context.Context)
+	OnEventSaved              []func(ctx context.Context, event *nostr.Event)
+
+	// editing info will affect
+	Info *nip11.RelayInformationDocument
 
 	// Default logger, as set by NewServer, is a stdlib logger prefixed with "[khatru-relay] ",
 	// outputting to stderr.
@@ -74,8 +82,3 @@ type Relay struct {
 	PingPeriod     time.Duration // Send pings to peer with this period. Must be less than pongWait.
 	MaxMessageSize int64         // Maximum message size allowed from peer.
 }
-
-func (rl *Relay) RequestAuth(ctx context.Context) {
-	ws := GetConnection(ctx)
-	ws.WriteJSON(nostr.AuthEnvelope{Challenge: &ws.Challenge})
-}

responding.go

@@ -0,0 +1,87 @@
+package khatru
+
+import (
+	"context"
+	"errors"
+	"sync"
+
+	"github.com/nbd-wtf/go-nostr"
+)
+
+func (rl *Relay) handleRequest(ctx context.Context, id string, eose *sync.WaitGroup, ws *WebSocket, filter nostr.Filter) error {
+	defer eose.Done()
+
+	// overwrite the filter (for example, to eliminate some kinds or
+	// that we know we don't support)
+	for _, ovw := range rl.OverwriteFilter {
+		ovw(ctx, &filter)
+	}
+
+	if filter.Limit < 0 {
+		// this is a special situation through which the implementor signals to us that it doesn't want
+		// to event perform any queries whatsoever
+		return nil
+	}
+
+	// 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
+	// filter we can just reject it)
+	for _, reject := range rl.RejectFilter {
+		if reject, msg := reject(ctx, filter); reject {
+			ws.WriteJSON(nostr.NoticeEnvelope(msg))
+			return errors.New(nostr.NormalizeOKMessage(msg, "blocked"))
+		}
+	}
+
+	// run the functions to query events (generally just one,
+	// but we might be fetching stuff from multiple places)
+	eose.Add(len(rl.QueryEvents))
+	for _, query := range rl.QueryEvents {
+		ch, err := query(ctx, filter)
+		if err != nil {
+			ws.WriteJSON(nostr.NoticeEnvelope(err.Error()))
+			eose.Done()
+			continue
+		}
+
+		go func(ch chan *nostr.Event) {
+			for event := range ch {
+				for _, ovw := range rl.OverwriteResponseEvent {
+					ovw(ctx, event)
+				}
+				ws.WriteJSON(nostr.EventEnvelope{SubscriptionID: &id, Event: *event})
+			}
+			eose.Done()
+		}(ch)
+	}
+
+	return nil
+}
+
+func (rl *Relay) handleCountRequest(ctx context.Context, ws *WebSocket, filter nostr.Filter) int64 {
+	// overwrite the filter (for example, to eliminate some kinds or tags that we know we don't support)
+	for _, ovw := range rl.OverwriteCountFilter {
+		ovw(ctx, &filter)
+	}
+
+	// then check if we'll reject this filter
+	for _, reject := range rl.RejectCountFilter {
+		if rejecting, msg := reject(ctx, filter); rejecting {
+			ws.WriteJSON(nostr.NoticeEnvelope(msg))
+			return 0
+		}
+	}
+
+	// run the functions to count (generally it will be just one)
+	var subtotal int64 = 0
+	for _, count := range rl.CountEvents {
+		res, err := count(ctx, filter)
+		if err != nil {
+			ws.WriteJSON(nostr.NoticeEnvelope(err.Error()))
+		}
+		subtotal += res
+	}
+
+	return subtotal
+}

start_test.go

@@ -1,93 +0,0 @@
-package khatru
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/gobwas/ws/wsutil"
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func TestServerStartShutdown(t *testing.T) {
-	var (
-		inited      bool
-		storeInited bool
-		shutdown    bool
-	)
-	rl := &testRelay{
-		name: "test server start",
-		init: func() error {
-			inited = true
-			return nil
-		},
-		onShutdown: func(context.Context) { shutdown = true },
-		storage: &testStorage{
-			init: func() error { storeInited = true; return nil },
-		},
-	}
-	srv, _ := NewServer(rl)
-	ready := make(chan bool)
-	done := make(chan error)
-	go func() { done <- srv.Start("127.0.0.1", 0, ready); close(done) }()
-	<-ready
-
-	// verify everything's initialized
-	if !inited {
-		t.Error("didn't call testRelay.init")
-	}
-	if !storeInited {
-		t.Error("didn't call testStorage.init")
-	}
-
-	// check that http requests are served
-	if _, err := http.Get("http://" + srv.Addr); err != nil {
-		t.Errorf("GET %s: %v", srv.Addr, err)
-	}
-
-	// verify server shuts down
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
-	srv.Shutdown(ctx)
-	if !shutdown {
-		t.Error("didn't call testRelay.onShutdown")
-	}
-	select {
-	case err := <-done:
-		if err != nil {
-			t.Errorf("srv.Start: %v", err)
-		}
-	case <-time.After(time.Second):
-		t.Error("srv.Start too long to return")
-	}
-}
-
-func TestServerShutdownWebsocket(t *testing.T) {
-	// set up a new relay server
-	srv := startTestRelay(t, &testRelay{storage: &testStorage{}})
-
-	// connect a client to it
-	ctx1, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-	client, err := nostr.RelayConnect(ctx1, "ws://"+srv.Addr)
-	if err != nil {
-		t.Fatalf("nostr.RelayConnectContext: %v", err)
-	}
-
-	// now, shut down the server
-	ctx2, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-	srv.Shutdown(ctx2)
-
-	// wait for the client to receive a "connection close"
-	time.Sleep(1 * time.Second)
-	err = client.ConnectionError
-	if e := errors.Unwrap(err); e != nil {
-		err = e
-	}
-	if _, ok := err.(wsutil.ClosedError); !ok {
-		t.Errorf("client.ConnextionError: %v (%T); want wsutil.ClosedError", err, err)
-	}
-}

util_test.go

@@ -1,91 +0,0 @@
-package khatru
-
-import (
-	"context"
-	"testing"
-
-	"github.com/nbd-wtf/go-nostr"
-)
-
-func startTestRelay(t *testing.T, tr *testRelay) *Server {
-	t.Helper()
-	srv, _ := NewServer(tr)
-	started := make(chan bool)
-	go srv.Start("127.0.0.1", 0, started)
-	<-started
-	return srv
-}
-
-type testRelay struct {
-	name        string
-	storage     Storage
-	init        func() error
-	onShutdown  func(context.Context)
-	acceptEvent func(*nostr.Event) bool
-}
-
-func (tr *testRelay) Name() string                    { return tr.name }
-func (tr *testRelay) Storage(context.Context) Storage { return tr.storage }
-
-func (tr *testRelay) Init() error {
-	if fn := tr.init; fn != nil {
-		return fn()
-	}
-	return nil
-}
-
-func (tr *testRelay) OnShutdown(ctx context.Context) {
-	if fn := tr.onShutdown; fn != nil {
-		fn(ctx)
-	}
-}
-
-func (tr *testRelay) AcceptEvent(ctx context.Context, e *nostr.Event) bool {
-	if fn := tr.acceptEvent; fn != nil {
-		return fn(e)
-	}
-	return true
-}
-
-type testStorage struct {
-	init        func() error
-	queryEvents func(context.Context, *nostr.Filter) (chan *nostr.Event, error)
-	deleteEvent func(ctx context.Context, id string, pubkey string) error
-	saveEvent   func(context.Context, *nostr.Event) error
-	countEvents func(context.Context, *nostr.Filter) (int64, error)
-}
-
-func (st *testStorage) Init() error {
-	if fn := st.init; fn != nil {
-		return fn()
-	}
-	return nil
-}
-
-func (st *testStorage) QueryEvents(ctx context.Context, f *nostr.Filter) (chan *nostr.Event, error) {
-	if fn := st.queryEvents; fn != nil {
-		return fn(ctx, f)
-	}
-	return nil, nil
-}
-
-func (st *testStorage) DeleteEvent(ctx context.Context, id string, pubkey string) error {
-	if fn := st.deleteEvent; fn != nil {
-		return fn(ctx, id, pubkey)
-	}
-	return nil
-}
-
-func (st *testStorage) SaveEvent(ctx context.Context, e *nostr.Event) error {
-	if fn := st.saveEvent; fn != nil {
-		return fn(ctx, e)
-	}
-	return nil
-}
-
-func (st *testStorage) CountEvents(ctx context.Context, f *nostr.Filter) (int64, error) {
-	if fn := st.countEvents; fn != nil {
-		return fn(ctx, f)
-	}
-	return 0, nil
-}

utils.go

@@ -2,28 +2,50 @@ package khatru
 
 import (
 	"context"
-	"hash/maphash"
-	"regexp"
-	"unsafe"
+
+	"github.com/nbd-wtf/go-nostr"
+	"github.com/sebest/xff"
 )
 
 const (
-	AUTH_CONTEXT_KEY = iota
-	WS_KEY           = iota
+	wsKey = iota
+	subscriptionIdKey
 )
 
-var nip20prefixmatcher = regexp.MustCompile(`^\w+: `)
+func RequestAuth(ctx context.Context) {
+	ws := GetConnection(ctx)
+	ws.authLock.Lock()
+	if ws.Authed == nil {
+		ws.Authed = make(chan struct{})
+	}
+	ws.authLock.Unlock()
+	ws.WriteJSON(nostr.AuthEnvelope{Challenge: &ws.Challenge})
+}
 
 func GetConnection(ctx context.Context) *WebSocket {
-	return ctx.Value(WS_KEY).(*WebSocket)
+	return ctx.Value(wsKey).(*WebSocket)
 }
 
 func GetAuthed(ctx context.Context) string {
-	authedPubkey := ctx.Value(AUTH_CONTEXT_KEY)
-	if authedPubkey == nil {
-		return ""
-	}
-	return authedPubkey.(string)
+	return GetConnection(ctx).AuthedPublicKey
 }
 
-func pointerHasher[V any](_ maphash.Seed, k *V) uint64 { return uint64(uintptr(unsafe.Pointer(k))) }
+func GetIP(ctx context.Context) string {
+	return xff.GetRemoteAddr(GetConnection(ctx).Request)
+}
+
+func GetSubscriptionID(ctx context.Context) string {
+	return ctx.Value(subscriptionIdKey).(string)
+}
+
+func GetOpenSubscriptions(ctx context.Context) []nostr.Filter {
+	if subs, ok := listeners.Load(GetConnection(ctx)); ok {
+		res := make([]nostr.Filter, 0, listeners.Size()*2)
+		subs.Range(func(_ string, sub *Listener) bool {
+			res = append(res, sub.filters...)
+			return true
+		})
+		return res
+	}
+	return nil
+}

websocket.go

@@ -1,6 +1,7 @@
 package khatru
 
 import (
+	"net/http"
 	"sync"
 
 	"github.com/fasthttp/websocket"
@@ -10,10 +11,15 @@ type WebSocket struct {
 	conn  *websocket.Conn
 	mutex sync.Mutex
 
+	// original request
+	Request *http.Request
+
 	// nip42
-	Challenge      string
-	Authed         string
-	WaitingForAuth chan struct{}
+	Challenge       string
+	AuthedPublicKey string
+	Authed          chan struct{}
+
+	authLock sync.Mutex
 }
 
 func (ws *WebSocket) WriteJSON(any any) error {