get rid of badger everywhere, including as an sdk/hints backend.

sdk/hints/bbolth/db.go

@@ -0,0 +1,196 @@
+package bbolth
+
+import (
+	"fmt"
+	"math"
+	"slices"
+
+	"fiatjaf.com/nostr"
+	"fiatjaf.com/nostr/sdk/hints"
+	"go.etcd.io/bbolt"
+)
+
+var _ hints.HintsDB = (*BoltHints)(nil)
+
+var (
+	hintsBucket = []byte("hints")
+)
+
+type BoltHints struct {
+	db *bbolt.DB
+}
+
+func NewBoltHints(path string) (*BoltHints, error) {
+	db, err := bbolt.Open(path, 0600, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open bbolt db: %w", err)
+	}
+
+	// Create the hints bucket
+	err = db.Update(func(tx *bbolt.Tx) error {
+		_, err := tx.CreateBucketIfNotExists(hintsBucket)
+		return err
+	})
+	if err != nil {
+		db.Close()
+		return nil, err
+	}
+
+	return &BoltHints{db: db}, nil
+}
+
+func (bh *BoltHints) Close() {
+	bh.db.Close()
+}
+
+func (bh *BoltHints) Save(pubkey nostr.PubKey, relay string, hintkey hints.HintKey, ts nostr.Timestamp) {
+	if now := nostr.Now(); ts > now {
+		ts = now
+	}
+
+	err := bh.db.Update(func(tx *bbolt.Tx) error {
+		b := tx.Bucket(hintsBucket)
+		k := encodeKey(pubkey, relay)
+		var tss timestamps
+
+		if v := b.Get(k); v != nil {
+			tss = parseValue(v)
+		}
+
+		if tss[hintkey] < ts {
+			tss[hintkey] = ts
+			return b.Put(k, encodeValue(tss))
+		}
+
+		return nil
+	})
+	if err != nil {
+		nostr.InfoLogger.Printf("[sdk/hints/bbolt] unexpected error on save: %s\n", err)
+	}
+}
+
+func (bh *BoltHints) TopN(pubkey nostr.PubKey, n int) []string {
+	type relayScore struct {
+		relay string
+		score int64
+	}
+
+	scores := make([]relayScore, 0, n)
+	err := bh.db.View(func(tx *bbolt.Tx) error {
+		b := tx.Bucket(hintsBucket)
+		c := b.Cursor()
+
+		prefix := pubkey[:]
+		for k, v := c.Seek(prefix); k != nil && len(k) >= 32 && string(k[:32]) == string(prefix); k, v = c.Next() {
+			relay := string(k[32:])
+			tss := parseValue(v)
+			scores = append(scores, relayScore{relay, tss.sum()})
+		}
+		return nil
+	})
+	if err != nil {
+		nostr.InfoLogger.Printf("[sdk/hints/bbolt] unexpected error on topn: %s\n", err)
+		return nil
+	}
+
+	slices.SortFunc(scores, func(a, b relayScore) int {
+		return int(b.score - a.score)
+	})
+
+	result := make([]string, 0, n)
+	for i, rs := range scores {
+		if i >= n {
+			break
+		}
+		result = append(result, rs.relay)
+	}
+	return result
+}
+
+func (bh *BoltHints) GetDetailedScores(pubkey nostr.PubKey, n int) []hints.RelayScores {
+	type relayScore struct {
+		relay string
+		tss   timestamps
+		score int64
+	}
+
+	scores := make([]relayScore, 0, n)
+	err := bh.db.View(func(tx *bbolt.Tx) error {
+		b := tx.Bucket(hintsBucket)
+		c := b.Cursor()
+
+		prefix := pubkey[:]
+		for k, v := c.Seek(prefix); k != nil && len(k) >= 32 && string(k[:32]) == string(prefix); k, v = c.Next() {
+			relay := string(k[32:])
+			tss := parseValue(v)
+			scores = append(scores, relayScore{relay, tss, tss.sum()})
+		}
+		return nil
+	})
+	if err != nil {
+		return nil
+	}
+
+	slices.SortFunc(scores, func(a, b relayScore) int {
+		return int(b.score - a.score)
+	})
+
+	result := make([]hints.RelayScores, 0, n)
+	for i, rs := range scores {
+		if i >= n {
+			break
+		}
+		result = append(result, hints.RelayScores{
+			Relay:  rs.relay,
+			Scores: rs.tss,
+			Sum:    rs.score,
+		})
+	}
+	return result
+}
+
+func (bh *BoltHints) PrintScores() {
+	fmt.Println("= print scores")
+
+	err := bh.db.View(func(tx *bbolt.Tx) error {
+		b := tx.Bucket(hintsBucket)
+		c := b.Cursor()
+
+		var lastPubkey nostr.PubKey
+		i := 0
+
+		for k, v := c.First(); k != nil; k, v = c.Next() {
+			pubkey, relay := parseKey(k)
+			tss := parseValue(v)
+
+			if pubkey != lastPubkey {
+				fmt.Println("== relay scores for", pubkey)
+				lastPubkey = pubkey
+				i = 0
+			} else {
+				i++
+			}
+
+			fmt.Printf("  %3d :: %30s ::> %12d\n", i, relay, tss.sum())
+		}
+		return nil
+	})
+	if err != nil {
+		nostr.InfoLogger.Printf("[sdk/hints/bbolt] unexpected error on print: %s\n", err)
+	}
+}
+
+type timestamps [4]nostr.Timestamp
+
+func (tss timestamps) sum() int64 {
+	now := nostr.Now() + 24*60*60
+	var sum int64
+	for i, ts := range tss {
+		if ts == 0 {
+			continue
+		}
+		value := float64(hints.HintKey(i).BasePoints()) * 10000000000 / math.Pow(float64(max(now-ts, 1)), 1.3)
+		sum += int64(value)
+	}
+	return sum
+}