relayinfo

Documentation

Index

• Variables
• func Fetch(c Ctx, u B) (info *T, err E)
• func GetList(items ...NIP) (n number.List)
• type Admission
• type B
• type Ctx
• type E
• type Fees
• type Limits
• type N
• type NIP
  • func (n NIP) N() N
• type Payment
• type Pub
• type Publication
• type S
• type Sub
• type Subscription
• type T
  • func NewInfo(inf *T) (info *T)
  • func (ri *T) AddNIPs(n ...int)
  • func (ri *T) AddSupportedNIP(n int)
  • func (ri *T) Clone() (r2 *T, err E)
  • func (ri *T) HasNIP(n int) (ok bool)
  • func (ri *T) Load(filename string) (err error)
  • func (ri *T) Save(filename string) (err error)

Variables

var (
	BasicProtocol = NIP{
		"Basic protocol flow description", 1,
	}
	NIP1       = BasicProtocol
	FollowList = NIP{
		"Follow List", 2,
	}
	NIP2                       = FollowList
	OpenTimestampsAttestations = NIP{
		"OpenTimestamps Attestations for Events", 3,
	}
	NIP3                   = OpenTimestampsAttestations
	EncryptedDirectMessage = NIP{
		"Encrypted Direct Message --- unrecommended: deprecated in favor o," +
			"f NIP-44",
		4}
	NIP4                  = EncryptedDirectMessage
	MappingNostrKeysToDNS = NIP{
		"Mapping Nostr keys to DNS-based internet identifiers",
		5}
	NIP5             = MappingNostrKeysToDNS
	HandlingMentions = NIP{
		"Handling Mentions --- unrecommended: deprecated in favor of NIP-27",
		8}
	NIP8          = HandlingMentions
	EventDeletion = NIP{
		"Event Deletion", 9,
	}
	NIP9                     = EventDeletion
	RelayInformationDocument = NIP{
		"Relay Information Document", 11,
	}
	NIP11             = RelayInformationDocument
	GenericTagQueries = NIP{
		"Generic Tag Queries", 12,
	}
	NIP12      = GenericTagQueries
	SubjectTag = NIP{
		"Subject tag in text events", 14,
	}
	NIP14            = SubjectTag
	NostrMarketplace = NIP{
		"Nostr Marketplace (for resilient marketplaces)", 15,
	}
	NIP15          = NostrMarketplace
	EventTreatment = NIP{
		"EVent Treatment", 16,
	}
	NIP16   = EventTreatment
	Reposts = NIP{
		"Reposts", 18,
	}
	NIP18                 = Reposts
	Bech32EncodedEntities = NIP{
		"bech32-encoded entities", 19,
	}
	NIP19          = Bech32EncodedEntities
	CommandResults = NIP{
		"Command Results", 20,
	}
	NIP20          = CommandResults
	NostrURIScheme = NIP{
		"nostr: URI scheme", 21,
	}
	NIP21           = NostrURIScheme
	CreatedAtLimits = NIP{
		"Something Something", 22,
	}
	NIP22           = CreatedAtLimits
	LongFormContent = NIP{
		"Long-form Content", 23,
	}
	NIP23         = LongFormContent
	ExtraMetadata = NIP{
		"Extra metadata fields and tags", 24,
	}
	NIP24     = ExtraMetadata
	Reactions = NIP{
		"Reactions", 25,
	}
	NIP25                 = Reactions
	DelegatedEventSigning = NIP{
		"Delegated Event Signing", 26,
	}
	NIP26              = DelegatedEventSigning
	TextNoteReferences = NIP{
		"Text Note References", 27,
	}
	NIP27      = TextNoteReferences
	PublicChat = NIP{
		"Public Chat", 28,
	}
	NIP28       = PublicChat
	CustomEmoji = NIP{
		"Custom Emoji", 30,
	}
	NIP30    = CustomEmoji
	Labeling = NIP{
		"Labeling", 32,
	}
	NIP32                          = Labeling
	ParameterizedReplaceableEvents = NIP{
		"Parameterized Replaceable Events", 33,
	}
	NIP33            = ParameterizedReplaceableEvents
	SensitiveContent = NIP{
		"Sensitive Content", 36,
	}
	NIP36        = SensitiveContent
	UserStatuses = NIP{
		"User Statuses", 38,
	}
	NIP38                        = UserStatuses
	ExternalIdentitiesInProfiles = NIP{
		"External Identities in Profiles", 39,
	}
	NIP39               = ExternalIdentitiesInProfiles
	ExpirationTimestamp = NIP{
		"Expiration Timestamp", 40,
	}
	NIP40          = ExpirationTimestamp
	Authentication = NIP{
		"Authentication of clients to relays", 42,
	}
	NIP42               = Authentication
	VersionedEncryption = NIP{
		"Versioned Encryption", 44,
	}
	NIP44           = VersionedEncryption
	CountingResults = NIP{
		"Counting results", 45,
	}
	NIP45        = CountingResults
	NostrConnect = NIP{
		"Nostr Connect", 46,
	}
	NIP46         = NostrConnect
	WalletConnect = NIP{
		"Wallet Connect", 47,
	}
	NIP47     = WalletConnect
	ProxyTags = NIP{
		"Proxy Tags", 48,
	}
	NIP48            = ProxyTags
	SearchCapability = NIP{
		"Search Capability", 50,
	}
	NIP50 = SearchCapability
	Lists = NIP{
		"Lists", 51,
	}
	NIP51          = Lists
	CalendarEvents = NIP{
		"Calendar Events", 52,
	}
	NIP52          = CalendarEvents
	LiveActivities = NIP{
		"Live Activities", 53,
	}
	NIP53     = LiveActivities
	Reporting = NIP{
		"Reporting", 56,
	}
	NIP56         = Reporting
	LightningZaps = NIP{
		"Lightning Zaps", 57,
	}
	NIP57  = LightningZaps
	Badges = NIP{
		"Badges", 58,
	}
	NIP58             = Badges
	RelayListMetadata = NIP{
		"Relay List Metadata", 65,
	}
	NIP65                = RelayListMetadata
	ModeratedCommunities = NIP{
		"Moderated Communities", 72,
	}
	NIP72    = ModeratedCommunities
	ZapGoals = NIP{
		"Zap Goals", 75,
	}
	NIP75                   = ZapGoals
	ApplicationSpecificData = NIP{
		"Application-specific data", 78,
	}
	NIP78      = ApplicationSpecificData
	Highlights = NIP{
		"Highlights", 84,
	}
	NIP84                          = Highlights
	RecommendedApplicationHandlers = NIP{
		"Recommended Application Handlers", 89,
	}
	NIP89               = RecommendedApplicationHandlers
	DataVendingMachines = NIP{
		"Data Vending Machines", 90,
	}
	NIP90        = DataVendingMachines
	FileMetadata = NIP{
		"File Metadata", 94,
	}
	NIP94                      = FileMetadata
	HTTPFileStorageIntegration = NIP{
		"HTTP File Storage Integration", 96,
	}
	NIP96    = HTTPFileStorageIntegration
	HTTPAuth = NIP{
		"HTTP IsAuthed", 98,
	}
	NIP98              = HTTPAuth
	ClassifiedListings = NIP{
		"Classified Listings", 99,
	}
	NIP99 = ClassifiedListings
)

this is the list of all nips and their titles for use in supported_nips field

var NIPMap = map[int]NIP{1: NIP1, 2: NIP2, 3: NIP3, 4: NIP4, 5: NIP5, 8: NIP8, 9: NIP9,
	11: NIP11, 12: NIP12, 14: NIP14,
	15: NIP15, 16: NIP16, 18: NIP18, 19: NIP19, 20: NIP20, 21: NIP21, 22: NIP22, 23: NIP23,
	24: NIP24, 25: NIP25,
	26: NIP26, 27: NIP27, 28: NIP28, 30: NIP30, 32: NIP32, 33: NIP33, 36: NIP36, 38: NIP38,
	39: NIP39, 40: NIP40,
	42: NIP42, 44: NIP44, 45: NIP45, 46: NIP46, 47: NIP47, 48: NIP48, 50: NIP50, 51: NIP51,
	52: NIP52, 53: NIP53,
	56: NIP56, 57: NIP57, 58: NIP58, 65: NIP65, 72: NIP72, 75: NIP75, 78: NIP78, 84: NIP84,
	89: NIP89, 90: NIP90,
	94: NIP94, 96: NIP96, 98: NIP98, 99: NIP99}

Functions

func Fetch

func Fetch(c Ctx, u B) (info *T, err E)

Fetch fetches the NIP-11 Info.

func GetList

func GetList(items ...NIP) (n number.List)

Types

type Admission

type Admission struct {
	Amount int    `json:"amount"`
	Unit   string `json:"unit"`
}

type B

type B = []byte

type Ctx

type Ctx = context.T

type E

type E = error

type Fees

type Fees struct {
	Admission    []Admission    `json:"admission,omitempty"`
	Subscription []Subscription `json:"subscription,omitempty"`
	Publication  []Publication  `json:"publication,omitempty"`
}

Fees defines the fee structure used for a paid relay.

type Limits

type Limits struct {
	// MaxMessageLength is the maximum number of bytes for incoming JSON
	// that the relay will attempt to decode and act upon. When you send large
	// subscriptions, you will be limited by this value. It also effectively
	// limits the maximum size of any event. Value is calculated from [ to ] and
	// is after UTF-8 serialization (so some unicode characters will cost 2-3
	// bytes). It is equal to the maximum size of the WebSocket message frame.
	MaxMessageLength int `json:"max_message_length,omitempty"`
	// MaxSubscriptions is total number of subscriptions that may be active on a
	// single websocket connection to this relay. It's possible that
	// authenticated clients with a (paid) relationship to the relay may have
	// higher limits.
	MaxSubscriptions int `json:"max_subscriptions,omitempty"`
	// MaxFilter is maximum number of filter values in each subscription. Must
	// be one or higher.
	MaxFilters int `json:"max_filters,omitempty"`
	// MaxLimit is the relay server will clamp each filter's limit value to this
	// number. This means the client won't be able to get more than this number
	// of events from a single subscription filter. This clamping is typically
	// done silently by the relay, but with this number, you can know that there
	// are additional results if you narrowed your filter's time range or other
	// parameters.
	MaxLimit int `json:"max_limit,omitempty"`
	// MaxSubidLength is the maximum length of subscription id as a string.
	MaxSubidLength int `json:"max_subid_length,omitempty"`
	// MaxEventTags in any event, this is the maximum number of elements in the
	// tags list.
	MaxEventTags int `json:"max_event_tags,omitempty"`
	// MaxContentLength maximum number of characters in the content field of any
	// event. This is a count of unicode characters. After serializing into JSON
	// it may be larger (in bytes), and is still subject to the
	// max_message_length, if defined.
	MaxContentLength int `json:"max_content_length,omitempty"`
	// MinPowDifficulty new events will require at least this difficulty of PoW,
	// based on NIP-13, or they will be rejected by this server.
	MinPowDifficulty int `json:"min_pow_difficulty,omitempty"`
	// AuthRequired means the realy requires NIP-42 authentication to happen
	// before a new connection may perform any other action. Even if set to
	// False, authentication may be required for specific actions.
	AuthRequired bool `json:"auth_required"`
	// PaymentRequired this realy requires payment before a new connection may
	// perform any action.
	PaymentRequired bool `json:"payment_required"`
	// RestrictedWrites this realy requires some kind of condition to be
	// fulfilled in order to accept events (not necessarily, but including
	// payment_required and min_pow_difficulty). This should only be set to true
	// when users are expected to know the realy policy before trying to write
	// to it -- like belonging to a special pubkey-based whitelist or writing
	// only events of a specific niche kind or content. Normal anti-spam
	// heuristics, for example, do not qualify.q
	RestrictedWrites bool        `json:"restricted_writes"`
	Oldest           timestamp.T `json:"created_at_lower_limit,omitempty"`
	Newest           timestamp.T `json:"created_at_upper_limit,omitempty"`
}

type N

type N = int

type NIP

type NIP struct {
	Description string
	Number      int
}

func (NIP) N

func (n NIP) N() N

type Payment

type Payment struct {
	Amount int    `json:"amount"`
	Unit   string `json:"unit"`
}

type Pub

type Pub struct {
	Kinds kinds.T `json:"kinds"`
	Payment
}

type Publication

type Publication []struct {
	Kinds  []int  `json:"kinds"`
	Amount int    `json:"amount"`
	Unit   string `json:"unit"`
}

type S

type S = string

type Sub

type Sub struct {
	Payment
	Period int `json:"period"`
}

type Subscription

type Subscription struct {
	Amount int    `json:"amount"`
	Unit   string `json:"unit"`
	Period int    `json:"period"`
}

type T

type T struct {
	Name           string      `json:"name"`
	Description    string      `json:"description"`
	PubKey         string      `json:"pubkey"`
	Contact        string      `json:"contact,omitempty"`
	Nips           number.List `json:"supported_nips"`
	Software       string      `json:"software"`
	Version        string      `json:"version"`
	Limitation     Limits      `json:"limitation"`
	Retention      any         `json:"retention"`
	RelayCountries []string    `json:"relay_countries"`
	LanguageTags   []string    `json:"language_tags"`
	Tags           []string    `json:"tags"`
	PostingPolicy  string      `json:"posting_policy"`
	PaymentsURL    string      `json:"payments_url"`
	Fees           Fees        `json:"fees"`
	Icon           string      `json:"icon"`
	sync.Mutex
}

T is the realy information document.

func NewInfo

func NewInfo(inf *T) (info *T)

NewInfo populates the nips map and if an Info structure is provided it is used and its nips map is populated if it isn't already.

func (*T) AddNIPs

func (ri *T) AddNIPs(n ...int)

AddNIPs adds one or more numbers to the list of NIPs.

func (*T) AddSupportedNIP

func (ri *T) AddSupportedNIP(n int)

AddSupportedNIP appends a supported NIP number to a RelayInfo.

func (*T) Clone

func (ri *T) Clone() (r2 *T, err E)

func (*T) HasNIP

func (ri *T) HasNIP(n int) (ok bool)

HasNIP returns true if the given number is found in the list.

func (*T) Load

func (ri *T) Load(filename string) (err error)

Load a given file and decode the JSON relayinfo.T encoded in it.

func (*T) Save

func (ri *T) Save(filename string) (err error)

Save the relayinfo.T to a given file as JSON.