mocrelay

type CacheHandler struct {
	// contains filtered or unexported fields
}

type ClientAuthMsg struct {
	Event *Event
}

type ClientCloseMsg struct {
	SubscriptionID string
}

type ClientCountMsg struct {
	SubscriptionID string
	ReqFilters     []*ReqFilter
}

type ClientEventMsg struct {
	Event *Event
}

type ClientMsg interface {
	ClientMsgLabel() string
}

type ClientReqMsg struct {
	SubscriptionID string
	ReqFilters     []*ReqFilter
}

type Config struct {
	// Server settings
	ServerAddr         string
	ServerSendTimeout  time.Duration
	ServerPingDuration time.Duration

	// Relay settings
	RelayMaxMessageLength   int64
	RelayRecvRateLimitRate  float64
	RelayRecvRateLimitBurst int

	// Handler settings
	CacheSize  int
	RouterSize int

	// SQLite plugin settings
	SQLiteEnabled            bool
	SQLitePath               string
	SQLiteBulkInsertNum      int
	SQLiteBulkInsertDuration time.Duration
	SQLiteMaxLimit           int

	// Prometheus plugin settings
	PrometheusEnabled bool

	// NIP-11
	NIP11 *NIP11
}

type CreatedAtLowerLimitMiddleware Middleware

type CreatedAtUpperLimitMiddleware Middleware

type DefaultSimpleHandlerBase struct{}

type Event struct {
	ID        string `json:"id"`
	Pubkey    string `json:"pubkey"`
	CreatedAt int64  `json:"created_at"`
	Kind      int64  `json:"kind"`
	Tags      []Tag  `json:"tags"`
	Content   string `json:"content"`
	Sig       string `json:"sig"`
}

type EventCache struct {
	Cap int
	// contains filtered or unexported fields
}

type EventCreatedAtMiddleware Middleware

type EventInvalidIDError struct {
	Correct, Actual string
}

type EventInvalidSigError struct {
	Correct, Actual string
}

type EventLimitMatcher interface {
	EventMatcher
	LimitMatch(*Event) bool
	Done() bool
}

type EventLimitMatchers[T EventLimitMatcher] []T

type EventMatcher interface {
	Match(*Event) bool
}

type EventType int

type Handler interface {
	ServeNostr(ctx context.Context, send chan<- ServerMsg, recv <-chan ClientMsg) error
}

type HandlerFunc func(ctx context.Context, send chan<- ServerMsg, recv <-chan ClientMsg) error

type LoggingMiddleware Middleware

type MaxContentLengthMiddleware Middleware

type MaxEventTagsMiddleware Middleware

type MaxLimitMiddleware Middleware

type MaxReqFiltersMiddleware Middleware

type MaxSubIDLengthMiddleware Middleware

type MaxSubscriptionsMiddleware Middleware

type MergeHandler struct {
	// contains filtered or unexported fields
}

type Middleware func(Handler) Handler

type NIP11 struct {
	Name          string           `json:"name,omitempty" yaml:"name,omitempty"`
	Description   string           `json:"description,omitempty" yaml:"description,omitempty"`
	Pubkey        string           `json:"pubkey,omitempty" yaml:"pubkey,omitempty"`
	Contact       string           `json:"contact,omitempty" yaml:"contact,omitempty"`
	SupportedNIPs []int            `json:"supported_nips,omitempty" yaml:"supported_nips,omitempty"`
	Software      string           `json:"software,omitempty" yaml:"software,omitempty"`
	Version       string           `json:"version,omitempty" yaml:"version,omitempty"`
	Limitation    *NIP11Limitation `json:"limitation,omitempty" yaml:"limitation,omitempty"`
	Retention     *NIP11Retention  `json:"retention,omitempty" yaml:"retention,omitempty"`
	RelayContries []string         `json:"relay_countries,omitempty" yaml:"relay_countries,omitempty"`
	LanguageTags  []string         `json:"language_tags,omitempty" yaml:"language_tags,omitempty"`
	Tags          []string         `json:"tags,omitempty" yaml:"tags,omitempty"`
	PostingPolicy string           `json:"posting_policy,omitempty" yaml:"posting_policy,omitempty"`
	PaymentsURL   string           `json:"payments_url,omitempty" yaml:"payments_url,omitempty"`
	Fees          *NIP11Fees       `json:"fees,omitempty" yaml:"fees,omitempty"`
	Icon          string           `json:"icon,omitempty" yaml:"icon,omitempty"`
}

type NIP11Fees struct {
	Admission    []*Nip11Fee `json:"admission,omitempty" yaml:"admission,omitempty"`
	Subscription []*Nip11Fee `json:"subscription,omitempty" yaml:"subscription,omitempty"`
	Publication  []*Nip11Fee `json:"publication,omitempty" yaml:"publication,omitempty"`
}

type NIP11Limitation struct {
	MaxMessageLength    int   `json:"max_message_length,omitempty" yaml:"max_message_length,omitempty"`
	MaxSubscriptions    int   `json:"max_subscriptions,omitempty" yaml:"max_subscriptions,omitempty"`
	MaxFilters          int   `json:"max_filters,omitempty" yaml:"max_filters,omitempty"`
	MaxLimit            int   `json:"max_limit,omitempty" yaml:"max_limit,omitempty"`
	MaxSubIDLength      int   `json:"max_subid_length,omitempty" yaml:"max_subid_length,omitempty"`
	MaxEventTags        int   `json:"max_event_tags,omitempty" yaml:"max_event_tags,omitempty"`
	MaxContentLength    int   `json:"max_content_length,omitempty" yaml:"max_content_length,omitempty"`
	MinPoWDifficulty    int   `json:"min_pow_difficulty,omitempty" yaml:"min_pow_difficulty,omitempty"`
	AuthRequired        bool  `json:"auth_required,omitempty" yaml:"auth_required,omitempty"`
	PaymentRequired     bool  `json:"payment_required,omitempty" yaml:"payment_required,omitempty"`
	CreatedAtLowerLimit int64 `json:"created_at_lower_limit,omitempty" yaml:"created_at_lower_limit,omitempty"`
	CreatedAtUpperLimit int64 `json:"created_at_upper_limit,omitempty" yaml:"created_at_upper_limit,omitempty"`
}

type NIP11Retention struct {
	Kinds []*Nip11Kind `json:"kinds,omitempty" yaml:"kinds,omitempty"`
	Time  *int         `json:"time,omitempty" yaml:"time,omitempty"`
	Count *int         `json:"count,omitempty" yaml:"count,omitempty"`
}

type NeoHandler interface {
	NeoServeNostr(ctx context.Context, send chan<- ServerMsg, recv <-chan ClientMsg) error
}

type NeoHandlerFunc func(ctx context.Context, send chan<- ServerMsg, recv <-chan ClientMsg) error

type NeoSimpleHandler NeoHandlerFunc

type NeoSimpleHandlerBase interface {
	NeoServeNostrOnStart(ctx context.Context) (newCtx context.Context, err error)
	NeoServeNostrClientMsg(ctx context.Context, msg ClientMsg) (<-chan ServerMsg, error)
	NeoServeNostrOnEnd(ctx context.Context, serveErr error) error
}

type Nip11Fee struct {
	Kinds  []*Nip11Kind `json:"kinds,omitempty" yaml:"kinds,omitempty"`
	Amount int          `json:"amount" yaml:"amount"`
	Unit   string       `json:"unit,omitempty" yaml:"unit,omitempty"`
	Period *int         `json:"period,omitempty" yaml:"period,omitempty"`
}

type Nip11Kind struct {
	From, To int
}

type RecvEventAllowFilterMiddleware Middleware

type RecvEventDenyFilterMiddleware Middleware

type RecvEventUniqueFilterMiddleware Middleware

type Relay struct {
	Handler Handler
	// contains filtered or unexported fields
}

type RelayOption struct {
	Logger *slog.Logger

	SendTimeout time.Duration

	RecvRateLimitRate  float64
	RecvRateLimitBurst int

	MaxMessageLength int64

	PingDuration time.Duration
}

type ReqFilter struct {
	IDs     []string
	Authors []string
	Kinds   []int64
	Tags    map[string][]string
	Since   *int64
	Until   *int64
	Limit   *int64
}

type ReqFilterEventLimitMatcher struct {
	// contains filtered or unexported fields
}

type ReqFiltersLimitMatcher []*ReqFilterEventLimitMatcher

type RouterHandler struct {
	// contains filtered or unexported fields
}

type SendEventUniqueFilterMiddleware Middleware

type ServeMux struct {
	Relay   *Relay
	NIP11   *NIP11
	Default http.Handler
	Logger  *slog.Logger
}

type ServerAuthMsg struct {
	Challenge string
}

type ServerClosedMsg struct {
	SubscriptionID string
	Msg            string
	MsgPrefix      string
}

type ServerCountMsg struct {
	SubscriptionID string
	Count          uint64
	Approximate    *bool
}

type ServerEOSEMsg struct {
	SubscriptionID string
}

type ServerEventMsg struct {
	SubscriptionID string
	Event          *Event
}

type ServerMsg interface {
	ServerMsgLabel() string
}

type ServerNoticeMsg struct {
	Message string
}

type ServerOKMsg struct {
	EventID   string
	Accepted  bool
	Msg       string
	MsgPrefix string
}

type SimpleHandler struct {
	// contains filtered or unexported fields
}

type SimpleHandlerBase interface {
	ServeNostrStart(context.Context) (context.Context, error)
	ServeNostrEnd(context.Context) error
	ServeNostrClientMsg(context.Context, ClientMsg) (<-chan ServerMsg, error)
}

type SimpleMiddlewareBase interface {
	ServeNostrStart(context.Context) (context.Context, error)
	ServeNostrEnd(context.Context) error
	ServeNostrClientMsg(context.Context, ClientMsg) (<-chan ClientMsg, <-chan ServerMsg, error)
	ServeNostrServerMsg(context.Context, ServerMsg) (<-chan ServerMsg, error)
}

type Tag []string