Refactored into namespaced packages.

events/event.go

@@ -0,0 +1,35 @@
+// Roots is a purposefully minimal Nostr protocol library that provides only
+// the primitives that define protocol compliance: event structure,
+// serialization, cryptographic signatures, and subscription filters.
+package events
+
+import (
+	"regexp"
+)
+
+// Tag represents a single tag within an event as an array of strings.
+// The first element identifies the tag name, the second contains the value,
+// and subsequent elements are optional.
+type Tag []string
+
+// Event represents a Nostr protocol event, with its seven required fields.
+// All fields must be present for a valid event.
+type Event struct {
+	ID        string `json:"id"`
+	PubKey    string `json:"pubkey"`
+	CreatedAt int    `json:"created_at"`
+	Kind      int    `json:"kind"`
+	Tags      []Tag  `json:"tags"`
+	Content   string `json:"content"`
+	Sig       string `json:"sig"`
+}
+
+var (
+	// Hex64Pattern matches 64-character, lowercase, hexadecimal strings.
+	// Used for validating event IDs and cryptographic keys.
+	Hex64Pattern = regexp.MustCompile("^[a-f0-9]{64}$")
+
+	// Hex128Pattern matches 128-character, lowercase, hexadecimal strings.
+	// Used for validating signatures.
+	Hex128Pattern = regexp.MustCompile("^[a-f0-9]{128}$")
+)

events/event_json_test.go

@@ -0,0 +1,54 @@
+package events
+
+import (
+	"encoding/json"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestUnmarshalEventJSON(t *testing.T) {
+	event := Event{}
+	json.Unmarshal(testEventJSONBytes, &event)
+	if err := event.Validate(); err != nil {
+		t.Error("unmarshalled event is invalid")
+	}
+	expectEqualEvents(t, event, testEvent)
+}
+
+func TestMarshalEventJSON(t *testing.T) {
+	eventJSONBytes, err := json.Marshal(testEvent)
+	assert.NoError(t, err)
+	assert.Equal(t, testEventJSON, string(eventJSONBytes))
+}
+
+func TestEventJSONRoundTrip(t *testing.T) {
+	event := Event{
+		ID:        "86e856d0527dd08527498cd8afd8a7d296bde37e4757a8921f034f0b344df3ad",
+		PubKey:    testEvent.PubKey,
+		CreatedAt: testEvent.CreatedAt,
+		Kind:      testEvent.Kind,
+		Tags: []Tag{
+			{"a", "value"},
+			{"b", "value", "optional"},
+			{"name", "value", "optional", "optional"},
+		},
+		Content: testEvent.Content,
+		Sig:     "c05fe02a9c082ff56aad2b16b5347498a21665f02f050ba086dbe6bd593c8cd448505d2831d1c0340acc1793eaf89b7c0cb21bb696c71da6b8d6b857702bb557",
+	}
+	expectedJSON := `{"id":"86e856d0527dd08527498cd8afd8a7d296bde37e4757a8921f034f0b344df3ad","pubkey":"cfa87f35acbde29ba1ab3ee42de527b2cad33ac487e80cf2d6405ea0042c8fef","created_at":1760740551,"kind":1,"tags":[["a","value"],["b","value","optional"],["name","value","optional","optional"]],"content":"hello world","sig":"c05fe02a9c082ff56aad2b16b5347498a21665f02f050ba086dbe6bd593c8cd448505d2831d1c0340acc1793eaf89b7c0cb21bb696c71da6b8d6b857702bb557"}`
+
+	if err := event.Validate(); err != nil {
+		t.Error("test event is invalid")
+	}
+	eventJSON, err := json.Marshal(event)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedJSON, string(eventJSON))
+
+	unmarshalledEvent := Event{}
+	json.Unmarshal(eventJSON, &unmarshalledEvent)
+
+	if err := unmarshalledEvent.Validate(); err != nil {
+		t.Error("unmarshalled event is invalid")
+	}
+	expectEqualEvents(t, unmarshalledEvent, event)
+}

events/event_test.go

@@ -0,0 +1,32 @@
+package events
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+const testSK = "f43a0435f69529f310bbd1d6263d2fbf0977f54bfe2310cc37ae5904b83bb167"
+const testPK = "cfa87f35acbde29ba1ab3ee42de527b2cad33ac487e80cf2d6405ea0042c8fef"
+
+var testEvent = Event{
+	ID:        "c7a702e6158744ca03508bbb4c90f9dbb0d6e88fefbfaa511d5ab24b4e3c48ad",
+	PubKey:    testPK,
+	CreatedAt: 1760740551,
+	Kind:      1,
+	Tags:      []Tag{},
+	Content:   "hello world",
+	Sig:       "83b71e15649c9e9da362c175f988c36404cabf357a976d869102a74451cfb8af486f6088b5631033b4927bd46cad7a0d90d7f624aefc0ac260364aa65c36071a",
+}
+
+var testEventJSON = `{"id":"c7a702e6158744ca03508bbb4c90f9dbb0d6e88fefbfaa511d5ab24b4e3c48ad","pubkey":"cfa87f35acbde29ba1ab3ee42de527b2cad33ac487e80cf2d6405ea0042c8fef","created_at":1760740551,"kind":1,"tags":[],"content":"hello world","sig":"83b71e15649c9e9da362c175f988c36404cabf357a976d869102a74451cfb8af486f6088b5631033b4927bd46cad7a0d90d7f624aefc0ac260364aa65c36071a"}`
+var testEventJSONBytes = []byte(testEventJSON)
+
+func expectEqualEvents(t *testing.T, got, want Event) {
+	assert.Equal(t, want.ID, got.ID)
+	assert.Equal(t, want.PubKey, got.PubKey)
+	assert.Equal(t, want.CreatedAt, got.CreatedAt)
+	assert.Equal(t, want.Kind, got.Kind)
+	assert.Equal(t, want.Content, got.Content)
+	assert.Equal(t, want.Sig, got.Sig)
+	assert.Equal(t, want.Tags, got.Tags)
+}

events/id.go

@@ -0,0 +1,37 @@
+package events
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+)
+
+// Serialize returns the canonical JSON array representation of the event.
+// used for ID computation: [0, pubkey, created_at, kind, tags, content].
+func (e *Event) Serialize() ([]byte, error) {
+	serialized := []interface{}{
+		0,
+		e.PubKey,
+		e.CreatedAt,
+		e.Kind,
+		e.Tags,
+		e.Content,
+	}
+
+	bytes, err := json.Marshal(serialized)
+	if err != nil {
+		return []byte{}, err
+	}
+	return bytes, nil
+}
+
+// GetID computes and returns the event ID as a lowercase, hex-encoded SHA-256 hash
+// of the serialized event.
+func (e *Event) GetID() (string, error) {
+	bytes, err := e.Serialize()
+	if err != nil {
+		return "", err
+	}
+	hash := sha256.Sum256(bytes)
+	return hex.EncodeToString(hash[:]), nil
+}

events/id_test.go

@@ -0,0 +1,204 @@
+package events
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+type IDTestCase struct {
+	name     string
+	event    Event
+	expected string
+}
+
+var idTestCases = []IDTestCase{
+	{
+		name: "minimal event",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "",
+		},
+		expected: "13a55672a600398894592f4cb338652d4936caffe5d3718d11597582bb030c39",
+	},
+
+	{
+		name: "alphanumeric content",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "hello world",
+		},
+		expected: "c7a702e6158744ca03508bbb4c90f9dbb0d6e88fefbfaa511d5ab24b4e3c48ad",
+	},
+
+	{
+		name: "unicode content",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "hello world 😀",
+		},
+		expected: "e42083fafbf9a39f97914fd9a27cedb38c429ac3ca8814288414eaad1f472fe8",
+	},
+
+	{
+		name: "escaped content",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "\"You say yes.\"\\n\\t\"I say no.\"",
+		},
+		expected: "343de133996a766bf00561945b6f2b2717d4905275976ca75c1d7096b7d1900c",
+	},
+
+	{
+		name: "json content",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "{\"field\": [\"value\",\"value\"],\"numeral\": 123}",
+		},
+		expected: "c6140190453ee947efb790e70541a9d37c41604d1f29e4185da4325621ed5270",
+	},
+
+	{
+		name: "empty tag",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags: []Tag{
+				{"a", ""},
+			},
+			Content: "",
+		},
+		expected: "7d3e394c75916362436f11c603b1a89b40b50817550cfe522a90d769655007a4",
+	},
+
+	{
+		name: "single tag",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags: []Tag{
+				{"a", "value"},
+			},
+			Content: "",
+		},
+		expected: "7db394e274fb893edbd9f4aa9ff189d4f3264bf1a29cef8f614e83ebf6fa19fe",
+	},
+
+	{
+		name: "optional tag values",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags: []Tag{
+				{"a", "value", "optional"},
+			},
+			Content: "",
+		},
+		expected: "656b47884200959e0c03054292c453cfc4beea00b592d92c0f557bff765e9d34",
+	},
+
+	{
+		name: "multiple tags",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags: []Tag{
+				{"a", "value", "optional"},
+				{"b", "another"},
+				{"c", "data"},
+			},
+			Content: "",
+		},
+		expected: "f7c27f2eacda7ece5123a4f82db56145ba59f7c9e6c5eeb88552763664506b06",
+	},
+
+	{
+		name: "unicode tag",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      1,
+			Tags: []Tag{
+				{"a", "😀"},
+			},
+			Content: "",
+		},
+		expected: "fd2798d165d9bf46acbe817735dc8cedacd4c42dfd9380792487d4902539e986",
+	},
+
+	{
+		name: "zero timestamp",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: 0,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "",
+		},
+		expected: "9ca742f2e2eea72ad6e0277a6287e2bb16a3e47d64b8468bc98474e266cf0ec2",
+	},
+
+	{
+		name: "negative timestamp",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: -1760740551,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "",
+		},
+		expected: "4740b027040bb4d0ee8e885f567a80277097da70cddd143d8a6dadf97f6faaa3",
+	},
+
+	{
+		name: "max int64 timestamp",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: 9223372036854775807,
+			Kind:      1,
+			Tags:      []Tag{},
+			Content:   "",
+		},
+		expected: "b28cdd44496acb49e36c25859f0f819122829a12dc57c07612d5f44cb121d2a7",
+	},
+
+	{
+		name: "different kind",
+		event: Event{
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      20021,
+			Tags:      []Tag{},
+			Content:   "",
+		},
+		expected: "995c4894c264e6b9558cb94b7b34008768d53801b99960b47298d4e3e23fadd3",
+	},
+}
+
+func TestEventGetId(t *testing.T) {
+	for _, tc := range idTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual, err := tc.event.GetID()
+			assert.NoError(t, err)
+			assert.Equal(t, tc.expected, actual)
+		})
+	}
+}

events/sign.go

@@ -0,0 +1,32 @@
+package events
+
+import (
+	"encoding/hex"
+	"fmt"
+	"git.wisehodl.dev/jay/go-roots/errors"
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcec/v2/schnorr"
+)
+
+// SignEvent generates a Schnorr signature for the given event ID using the
+// provided private key. Returns the signature as 128 lowercase hex characters.
+func SignEvent(eventID, privateKeyHex string) (string, error) {
+	skBytes, err := hex.DecodeString(privateKeyHex)
+	if err != nil {
+		return "", errors.MalformedPrivKey
+	}
+
+	idBytes, err := hex.DecodeString(eventID)
+	if err != nil {
+		return "", errors.MalformedID
+	}
+
+	// discard public key return value
+	sk, _ := btcec.PrivKeyFromBytes(skBytes)
+	sig, err := schnorr.Sign(sk, idBytes)
+	if err != nil {
+		return "", fmt.Errorf("schnorr signature error: %w", err)
+	}
+
+	return hex.EncodeToString(sig.Serialize()), nil
+}

events/sign_test.go

@@ -0,0 +1,34 @@
+package events
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestSignEvent(t *testing.T) {
+	eventID := testEvent.ID
+	expectedSig := testEvent.Sig
+	actualSig, err := SignEvent(eventID, testSK)
+
+	assert.NoError(t, err)
+	assert.Equal(t, expectedSig, actualSig)
+}
+
+func TestSignInvalidEventID(t *testing.T) {
+	badEventID := "thisisabadeventid"
+	expectedError := "event id must be 64 hex characters"
+
+	_, err := SignEvent(badEventID, testSK)
+
+	assert.ErrorContains(t, err, expectedError)
+}
+
+func TestSignInvalidPrivateKey(t *testing.T) {
+	eventID := testEvent.ID
+	badSK := "thisisabadsecretkey"
+	expectedError := "private key must be 64 lowercase hex characters"
+
+	_, err := SignEvent(eventID, badSK)
+
+	assert.ErrorContains(t, err, expectedError)
+}

events/util_test.go

@@ -0,0 +1,5 @@
+package events
+
+func intPtr(i int) *int {
+	return &i
+}

events/validate.go

@@ -0,0 +1,96 @@
+package events
+
+import (
+	"encoding/hex"
+	"fmt"
+	"git.wisehodl.dev/jay/go-roots/errors"
+	"github.com/btcsuite/btcd/btcec/v2/schnorr"
+)
+
+// Validate performs a complete event validation: structure, ID computation,
+// and signature verification. Returns the first error encountered.
+func (e *Event) Validate() error {
+	if err := e.ValidateStructure(); err != nil {
+		return err
+	}
+
+	if err := e.ValidateID(); err != nil {
+		return err
+	}
+
+	return e.ValidateSignature()
+}
+
+// ValidateStructure checks that all event fields conform to the protocol
+// specification: hex lengths, tag structure, and field formats.
+func (e *Event) ValidateStructure() error {
+	if !Hex64Pattern.MatchString(e.PubKey) {
+		return errors.MalformedPubKey
+	}
+
+	if !Hex64Pattern.MatchString(e.ID) {
+		return errors.MalformedID
+	}
+
+	if !Hex128Pattern.MatchString(e.Sig) {
+		return errors.MalformedSig
+	}
+
+	for _, tag := range e.Tags {
+		if len(tag) < 2 {
+			return errors.MalformedTag
+		}
+	}
+
+	return nil
+}
+
+// ValidateID recomputes the event ID and verifies it matches the stored ID field.
+func (e *Event) ValidateID() error {
+	computedID, err := e.GetID()
+	if err != nil {
+		return errors.FailedIDComp
+	}
+	if e.ID == "" {
+		return errors.NoEventID
+	}
+	if computedID != e.ID {
+		return fmt.Errorf("event id %q does not match computed id %q", e.ID, computedID)
+	}
+	return nil
+}
+
+// ValidateSignature verifies the event signature is cryptographically valid
+// for the event ID and public key using Schnorr verification.
+func (e *Event) ValidateSignature() error {
+	idBytes, err := hex.DecodeString(e.ID)
+	if err != nil {
+		return fmt.Errorf("invalid event id hex: %w", err)
+	}
+
+	sigBytes, err := hex.DecodeString(e.Sig)
+	if err != nil {
+		return fmt.Errorf("invalid event signature hex: %w", err)
+	}
+
+	pkBytes, err := hex.DecodeString(e.PubKey)
+	if err != nil {
+		return fmt.Errorf("invalid public key hex: %w", err)
+	}
+
+	signature, err := schnorr.ParseSignature(sigBytes)
+	if err != nil {
+		return fmt.Errorf("malformed signature: %w", err)
+	}
+
+	publicKey, err := schnorr.ParsePubKey(pkBytes)
+	if err != nil {
+		return fmt.Errorf("malformed public key: %w", err)
+	}
+
+	if signature.Verify(idBytes, publicKey) {
+		return nil
+	} else {
+		return errors.InvalidSig
+	}
+}

events/validate_test.go

@@ -0,0 +1,306 @@
+package events
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+type ValidateEventTestCase struct {
+	name          string
+	event         Event
+	expectedError string
+}
+
+var structureTestCases = []ValidateEventTestCase{
+	{
+		name: "empty pubkey",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    "",
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "public key must be 64 lowercase hex characters",
+	},
+
+	{
+		name: "short pubkey",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    "abc123",
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "public key must be 64 lowercase hex characters",
+	},
+
+	{
+		name: "long pubkey",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    "c7a702e6158744ca03508bbb4c90f9dbb0d6e88fefbfaa511d5ab24b4e3c48adabc",
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "public key must be 64 lowercase hex characters",
+	},
+
+	{
+		name: "non-hex pubkey",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    "zyx-!2e6158744ca03508bbb4c90f9dbb0d6e88fefbfaa511d5ab24b4e3c48ad",
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "public key must be 64 lowercase hex characters",
+	},
+
+	{
+		name: "uppercase pubkey",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    "C7A702E6158744CA03508BBB4C90F9DBB0D6E88FEFBFAA511D5AB24B4E3C48AD",
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "public key must be 64 lowercase hex characters",
+	},
+
+	{
+		name: "empty id",
+		event: Event{
+			ID:        "",
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "id must be 64 hex characters",
+	},
+
+	{
+		name: "short id",
+		event: Event{
+			ID:        "abc123",
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "id must be 64 hex characters",
+	},
+
+	{
+		name: "empty signature",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       "",
+		},
+		expectedError: "signature must be 128 hex characters",
+	},
+
+	{
+		name: "short signature",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      testEvent.Tags,
+			Content:   testEvent.Content,
+			Sig:       "abc123",
+		},
+		expectedError: "signature must be 128 hex characters",
+	},
+
+	{
+		name: "empty tag",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      []Tag{{}},
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "tags must contain at least two elements",
+	},
+
+	{
+		name: "single element tag",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      []Tag{{"a"}},
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "tags must contain at least two elements",
+	},
+
+	{
+		name: "one good tag, one single element tag",
+		event: Event{
+			ID:        testEvent.ID,
+			PubKey:    testEvent.PubKey,
+			CreatedAt: testEvent.CreatedAt,
+			Kind:      testEvent.Kind,
+			Tags:      []Tag{{"a", "value"}, {"b"}},
+			Content:   testEvent.Content,
+			Sig:       testEvent.Sig,
+		},
+		expectedError: "tags must contain at least two elements",
+	},
+}
+
+func TestValidateEventStructure(t *testing.T) {
+	for _, tc := range structureTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := tc.event.ValidateStructure()
+			assert.ErrorContains(t, err, tc.expectedError)
+		})
+	}
+}
+
+func TestValidateEventIDFailure(t *testing.T) {
+	event := Event{
+		ID:        "7f661c2a3c1ed67dc959d6cd968d743d5e6e334313df44724bca939e2aa42c9e",
+		PubKey:    testEvent.PubKey,
+		CreatedAt: testEvent.CreatedAt,
+		Kind:      testEvent.Kind,
+		Tags:      testEvent.Tags,
+		Content:   testEvent.Content,
+		Sig:       testEvent.Sig,
+	}
+
+	err := event.ValidateID()
+	assert.ErrorContains(t, err, "does not match computed id")
+}
+
+func TestValidateSignature(t *testing.T) {
+	event := Event{
+		ID:     testEvent.ID,
+		PubKey: testEvent.PubKey,
+		Sig:    testEvent.Sig,
+	}
+	err := event.ValidateSignature()
+
+	assert.NoError(t, err)
+}
+
+func TestValidateInvalidSignature(t *testing.T) {
+	event := Event{
+		ID:     testEvent.ID,
+		PubKey: testEvent.PubKey,
+		Sig:    "9e43cbcf7e828a21c53fa35371ee79bffbfd7a3063ae46fc05ec623dd3186667c57e3d006488015e19247df35eb41c61013e051aa87860e23fa5ffbd44120482",
+	}
+	err := event.ValidateSignature()
+
+	assert.ErrorContains(t, err, "event signature is invalid")
+}
+
+type ValidateSignatureTestCase struct {
+	name          string
+	id            string
+	sig           string
+	pubkey        string
+	expectedError string
+}
+
+var validateSignatureTestCases = []ValidateSignatureTestCase{
+	{
+		name:          "bad event id",
+		id:            "badeventid",
+		sig:           testEvent.Sig,
+		pubkey:        testEvent.PubKey,
+		expectedError: "invalid event id hex",
+	},
+
+	{
+		name:          "bad event signature",
+		id:            testEvent.ID,
+		sig:           "badeventsignature",
+		pubkey:        testEvent.PubKey,
+		expectedError: "invalid event signature hex",
+	},
+
+	{
+		name:          "bad public key",
+		id:            testEvent.ID,
+		sig:           testEvent.Sig,
+		pubkey:        "badpublickey",
+		expectedError: "invalid public key hex",
+	},
+
+	{
+		name:          "malformed event signature",
+		id:            testEvent.ID,
+		sig:           "abc123",
+		pubkey:        testEvent.PubKey,
+		expectedError: "malformed signature",
+	},
+
+	{
+		name:          "malformed public key",
+		id:            testEvent.ID,
+		sig:           testEvent.Sig,
+		pubkey:        "abc123",
+		expectedError: "malformed public key",
+	},
+}
+
+func TestValidateSignatureInvalidEventSignature(t *testing.T) {
+	for _, tc := range validateSignatureTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			event := Event{ID: tc.id, PubKey: tc.pubkey, Sig: tc.sig}
+			err := event.ValidateSignature()
+			assert.ErrorContains(t, err, tc.expectedError)
+		})
+	}
+}
+
+func TestValidateEvent(t *testing.T) {
+	event := Event{
+		ID:        "c9a0f84fcaa889654da8992105eb122eb210c8cbd58210609a5ef7e170b51400",
+		PubKey:    testEvent.PubKey,
+		CreatedAt: testEvent.CreatedAt,
+		Kind:      testEvent.Kind,
+		Tags: []Tag{
+			{"a", "value"},
+			{"b", "value", "optional"},
+		},
+		Content: "valid event",
+		Sig:     "668a715f1eb983172acf230d17bd283daedb2598adf8de4290bcc7eb0b802fdb60669d1e7d1104ac70393f4dbccd07e8abf897152af6ce6c0a75499874e27f14",
+	}
+
+	err := event.Validate()
+	assert.NoError(t, err)
+}