feat: add SQLite storage layer with binary-first event persistence

Storage implementation:
- Concrete type with constructor (consumer-side interfaces)
- Event storage: protobuf + zstd-compressed canonical JSON
- Schema: events, deletions, replaceable_events, auth_challenges, rate_limits
- WAL mode, STRICT typing, optimized indexes
- Methods: StoreEvent, GetEvent, GetEventWithCanonical, DeleteEvent

Dependencies:
- modernc.org/sqlite v1.45.0 (pure Go SQLite driver)
- github.com/klauspost/compress v1.18.4 (zstd compression)

366 lines, 10 tests passing

1 files changed, 264 insertions, 0 deletions

diff --git a/internal/storage/events_test.go b/internal/storage/events_test.go
new file mode 100644
index 0000000..4393404
--- /dev/null
+++ b/internal/storage/events_test.go
@@ -0,0 +1,264 @@
+package storage
+
+import (
+        "context"
+        "testing"
+
+        pb "northwest.io/nostr-grpc/api/nostr/v1"
+)
+
+func TestStoreEvent(t *testing.T) {
+        store, err := New(":memory:")
+        if err != nil {
+                t.Fatalf("failed to create storage: %v", err)
+        }
+        defer store.Close()
+
+        ctx := context.Background()
+
+        // Create test event
+        event := &pb.Event{
+                Id:        "test123",
+                Pubkey:    "pubkey123",
+                CreatedAt: 1234567890,
+                Kind:      1,
+                Tags:      []*pb.Tag{{Values: []string{"e", "event1"}}},
+                Content:   "Hello, Nostr!",
+                Sig:       "sig123",
+        }
+
+        canonicalJSON := []byte(`[0,"pubkey123",1234567890,1,[["e","event1"]],"Hello, Nostr!"]`)
+
+        data := &EventData{
+                Event:         event,
+                CanonicalJSON: canonicalJSON,
+        }
+
+        // Store event
+        err = store.StoreEvent(ctx, data)
+        if err != nil {
+                t.Fatalf("failed to store event: %v", err)
+        }
+
+        // Verify event was stored
+        retrieved, err := store.GetEvent(ctx, "test123")
+        if err != nil {
+                t.Fatalf("failed to retrieve event: %v", err)
+        }
+
+        if retrieved.Id != event.Id {
+                t.Errorf("expected ID %s, got %s", event.Id, retrieved.Id)
+        }
+        if retrieved.Content != event.Content {
+                t.Errorf("expected content %s, got %s", event.Content, retrieved.Content)
+        }
+}
+
+func TestStoreEventDuplicate(t *testing.T) {
+        store, err := New(":memory:")
+        if err != nil {
+                t.Fatalf("failed to create storage: %v", err)
+        }
+        defer store.Close()
+
+        ctx := context.Background()
+
+        event := &pb.Event{
+                Id:        "duplicate123",
+                Pubkey:    "pubkey123",
+                CreatedAt: 1234567890,
+                Kind:      1,
+                Content:   "test",
+                Sig:       "sig123",
+        }
+
+        data := &EventData{
+                Event:         event,
+                CanonicalJSON: []byte(`[0,"pubkey123",1234567890,1,[],"test"]`),
+        }
+
+        // Store first time
+        err = store.StoreEvent(ctx, data)
+        if err != nil {
+                t.Fatalf("failed to store event first time: %v", err)
+        }
+
+        // Try to store again
+        err = store.StoreEvent(ctx, data)
+        if err != ErrEventExists {
+                t.Errorf("expected ErrEventExists, got %v", err)
+        }
+}
+
+func TestGetEvent(t *testing.T) {
+        store, err := New(":memory:")
+        if err != nil {
+                t.Fatalf("failed to create storage: %v", err)
+        }
+        defer store.Close()
+
+        ctx := context.Background()
+
+        // Test non-existent event
+        _, err = store.GetEvent(ctx, "nonexistent")
+        if err != ErrEventNotFound {
+                t.Errorf("expected ErrEventNotFound, got %v", err)
+        }
+}
+
+func TestGetEventWithCanonical(t *testing.T) {
+        store, err := New(":memory:")
+        if err != nil {
+                t.Fatalf("failed to create storage: %v", err)
+        }
+        defer store.Close()
+
+        ctx := context.Background()
+
+        canonicalJSON := []byte(`[0,"pubkey123",1234567890,1,[],"test"]`)
+
+        event := &pb.Event{
+                Id:        "canonical123",
+                Pubkey:    "pubkey123",
+                CreatedAt: 1234567890,
+                Kind:      1,
+                Content:   "test",
+                Sig:       "sig123",
+        }
+
+        data := &EventData{
+                Event:         event,
+                CanonicalJSON: canonicalJSON,
+        }
+
+        err = store.StoreEvent(ctx, data)
+        if err != nil {
+                t.Fatalf("failed to store event: %v", err)
+        }
+
+        // Retrieve with canonical JSON
+        retrieved, err := store.GetEventWithCanonical(ctx, "canonical123")
+        if err != nil {
+                t.Fatalf("failed to retrieve event: %v", err)
+        }
+
+        if string(retrieved.CanonicalJson) != string(canonicalJSON) {
+                t.Errorf("canonical JSON mismatch:\nexpected: %s\ngot: %s",
+                        canonicalJSON, retrieved.CanonicalJson)
+        }
+}
+
+func TestDeleteEvent(t *testing.T) {
+        store, err := New(":memory:")
+        if err != nil {
+                t.Fatalf("failed to create storage: %v", err)
+        }
+        defer store.Close()
+
+        ctx := context.Background()
+
+        event := &pb.Event{
+                Id:        "delete123",
+                Pubkey:    "pubkey123",
+                CreatedAt: 1234567890,
+                Kind:      1,
+                Content:   "to be deleted",
+                Sig:       "sig123",
+        }
+
+        data := &EventData{
+                Event:         event,
+                CanonicalJSON: []byte(`[0,"pubkey123",1234567890,1,[],"to be deleted"]`),
+        }
+
+        // Store event
+        err = store.StoreEvent(ctx, data)
+        if err != nil {
+                t.Fatalf("failed to store event: %v", err)
+        }
+
+        // Delete event
+        err = store.DeleteEvent(ctx, "delete123")
+        if err != nil {
+                t.Fatalf("failed to delete event: %v", err)
+        }
+
+        // Verify event is no longer retrievable
+        _, err = store.GetEvent(ctx, "delete123")
+        if err != ErrEventNotFound {
+                t.Errorf("expected ErrEventNotFound after deletion, got %v", err)
+        }
+
+        // Try deleting non-existent event
+        err = store.DeleteEvent(ctx, "nonexistent")
+        if err != ErrEventNotFound {
+                t.Errorf("expected ErrEventNotFound, got %v", err)
+        }
+}
+
+func TestCompressDecompressJSON(t *testing.T) {
+        original := []byte(`{"key":"value","array":[1,2,3],"nested":{"a":"b"}}`)
+
+        compressed, err := compressJSON(original)
+        if err != nil {
+                t.Fatalf("compression failed: %v", err)
+        }
+
+        // Verify compression reduces size (for larger data)
+        if len(compressed) >= len(original) {
+                t.Logf("Note: compressed size (%d) >= original (%d) - normal for small data",
+                        len(compressed), len(original))
+        }
+
+        decompressed, err := decompressJSON(compressed)
+        if err != nil {
+                t.Fatalf("decompression failed: %v", err)
+        }
+
+        if string(decompressed) != string(original) {
+                t.Errorf("decompressed data doesn't match original:\nexpected: %s\ngot: %s",
+                        original, decompressed)
+        }
+}
+
+func TestMarshalTags(t *testing.T) {
+        tests := []struct {
+                name     string
+                tags     []*pb.Tag
+                expected string
+        }{
+                {
+                        name:     "empty tags",
+                        tags:     nil,
+                        expected: "[]",
+                },
+                {
+                        name: "single tag",
+                        tags: []*pb.Tag{
+                                {Values: []string{"e", "event123"}},
+                        },
+                        expected: `[["e","event123"]]`,
+                },
+                {
+                        name: "multiple tags",
+                        tags: []*pb.Tag{
+                                {Values: []string{"e", "event123", "wss://relay.example.com"}},
+                                {Values: []string{"p", "pubkey456"}},
+                        },
+                        expected: `[["e","event123","wss://relay.example.com"],["p","pubkey456"]]`,
+                },
+        }
+
+        for _, tt := range tests {
+                t.Run(tt.name, func(t *testing.T) {
+                        result, err := marshalTags(tt.tags)
+                        if err != nil {
+                                t.Fatalf("marshalTags failed: %v", err)
+                        }
+
+                        if result != tt.expected {
+                                t.Errorf("expected %s, got %s", tt.expected, result)
+                        }
+                })
+        }
+}