go-nostr/event.go

113 lines
2.6 KiB
Go

package nostr
import (
"crypto/rand"
"crypto/sha256"
"encoding/hex"
"fmt"
"time"
"github.com/fiatjaf/bip340"
"github.com/valyala/fastjson"
)
type Event struct {
ID string
PubKey string
CreatedAt time.Time
Kind int
Tags Tags
Content string
Sig string
}
const (
KindSetMetadata int = 0
KindTextNote int = 1
KindRecommendServer int = 2
KindContactList int = 3
KindEncryptedDirectMessage int = 4
KindDeletion int = 5
)
// GetID serializes and returns the event ID as a string
func (evt *Event) GetID() string {
h := sha256.Sum256(evt.Serialize())
return hex.EncodeToString(h[:])
}
// Serialize outputs a byte array that can be hashed/signed to identify/authenticate
func (evt *Event) Serialize() []byte {
// the serialization process is just putting everything into a JSON array
// so the order is kept
var arena fastjson.Arena
arr := arena.NewArray()
// version: 0
arr.SetArrayItem(0, arena.NewNumberInt(0))
// pubkey
arr.SetArrayItem(1, arena.NewString(evt.PubKey))
// created_at
arr.SetArrayItem(2, arena.NewNumberInt(int(evt.CreatedAt.Unix())))
// kind
arr.SetArrayItem(3, arena.NewNumberInt(evt.Kind))
// tags
arr.SetArrayItem(4, tagsToFastjsonArray(&arena, evt.Tags))
// content
arr.SetArrayItem(5, arena.NewString(evt.Content))
return arr.MarshalTo(nil)
}
// CheckSignature checks if the signature is valid for the id
// (which is a hash of the serialized event content).
// returns an error if the signature itself is invalid.
func (evt Event) CheckSignature() (bool, error) {
// read and check pubkey
pubkey, err := bip340.ParsePublicKey(evt.PubKey)
if err != nil {
return false, fmt.Errorf("Event has invalid pubkey '%s': %w", evt.PubKey, err)
}
s, err := hex.DecodeString(evt.Sig)
if err != nil {
return false, fmt.Errorf("signature is invalid hex: %w", err)
}
if len(s) != 64 {
return false, fmt.Errorf("signature must be 64 bytes, not %d", len(s))
}
var sig [64]byte
copy(sig[:], s)
hash := sha256.Sum256(evt.Serialize())
return bip340.Verify(pubkey, hash, sig)
}
// Sign signs an event with a given privateKey
func (evt *Event) Sign(privateKey string) error {
h := sha256.Sum256(evt.Serialize())
s, err := bip340.ParsePrivateKey(privateKey)
if err != nil {
return fmt.Errorf("Sign called with invalid private key '%s': %w", privateKey, err)
}
aux := make([]byte, 32)
rand.Read(aux)
sig, err := bip340.Sign(s, h, aux)
if err != nil {
return err
}
evt.ID = hex.EncodeToString(h[:])
evt.Sig = hex.EncodeToString(sig[:])
return nil
}