realy

README

realy.lol

nostr relay built from a heavily modified fork of nbd-wtf/go-nostr and fiatjaf/relayer aimed at maximum performance, simplicity and memory efficiency.

includes:

• a lot of other bits and pieces accumulated from nearly 8 years of working with Go, logging and run control, user data directories (windows, mac, linux, android)
• a cleaned up and unified fork of the btcd/dcred BIP-340 signatures, including the use of bitcoin core's BIP-340 implementation (more than 4x faster than btcd)
• AVX/AVX2 optimized SHA256 and SIMD hex encoder
• a bespoke, mutable byte slice based hash/pubkey/signature encoding in memory and the fastest nostr binary codec that exists
• custom badger based database with a garbage collector that prunes off data with least recent access
• vanity npub generator that can mine a 5 letter prefix in around 15 minutes on a 6 core Ryzen 5 processor
• reverse proxy tool with support for Go vanity imports and nip-05 npub DNS verification and own TLS certificates

Documentation

Index

• type B
• type Binary
• type Ctx
• type E
• type Generator
• type I
• type JSON
• type N
• type S
• type Signer

Types

type B

type B = []byte

type Binary

type Binary interface {
	// MarshalBinary converts the data of the type into binary form, appending
	// it to the provided slice.
	MarshalBinary(dst B) (b B, err E)
	// UnmarshalBinary decodes a binary form of a type back into the runtime
	// form, and returns whatever remains after the type has been decoded out.
	UnmarshalBinary(b B) (r B, err E)
}

type Ctx

type Ctx = context.T

type E

type E = error

type Generator

type Generator interface {
	// Generate gathers entropy and derives pubkey bytes for matching, this returns the 33 byte
	// compressed form for checking the oddness of the Y coordinate.
	Generate() (pubBytes B, err E)
	// Negate flips the public key Y coordinate between odd and even.
	Negate()
	// KeyPairBytes returns the raw bytes of the secret and public key, this returns the 32 byte
	// X-only pubkey.
	KeyPairBytes() (secBytes, cmprPubBytes B)
}

Generator is an interface for nostr BIP-340 key generation.

type I

type I interface {
	Label() string
	Write(w io.Writer) (err E)
	JSON
}

type JSON

type JSON interface {
	// MarshalJSON converts the data of the type into JSON, appending it to the
	// provided slice and returning the extended slice.
	MarshalJSON(dst B) (b B, err E)
	// UnmarshalJSON decodes a JSON form of a type back into the runtime form,
	// and returns whatever remains after the type has been decoded out.
	UnmarshalJSON(b B) (r B, err E)
}

type N

type N = int

type S

type S = string

type Signer

type Signer interface {
	// Generate creates a fresh new key pair from system entropy, and ensures it is even (so
	// ECDH works).
	Generate() (err E)
	// InitSec initialises the secret (signing) key from the raw bytes, and also
	// derives the public key because it can.
	InitSec(sec B) (err E)
	// InitPub initializes the public (verification) key from raw bytes.
	InitPub(pub B) (err E)
	// Sec returns the secret key bytes.
	Sec() B
	// Pub returns the public key bytes (x-only schnorr pubkey).
	Pub() B
	// ECPub returns the public key bytes (33 byte ecdsa pubkey). The first byte is always 2 due
	// to ECDH and X-only keys.
	ECPub() B
	// Sign creates a signature using the stored secret key.
	Sign(msg B) (sig B, err E)
	// Verify checks a message hash and signature match the stored public key.
	Verify(msg, sig B) (valid bool, err E)
	// Zero wipes the secret key to prevent memory leaks.
	Zero()
	// ECDH returns a shared secret derived using Elliptic Curve Diffie Hellman on the Signer
	// secret and provided pubkey.
	ECDH(pub B) (secret B, err E)
	// Negate flips the the secret key to change between odd and even compressed public key.
	Negate()
}