node

type AliasesProvider interface {
	GetAliases() (aliases []domain.Alias, err error)
	SetAlias(alias domain.Alias) error
	DeleteAlias(nodeId string) error
	GetNodeIDs() (ids []string, err error)
}

type AuthProvider interface {
	GetOwner() domain.Owner
	SessionToken() string
}

type BlocksProvider interface {
	Block(blockerId string, blockeeId string) error
	List(blockerId string, limit *uint64, cursor *string) ([]string, string, error)
	Unblock(blockerId string, blockeeId string) error
}

type BookmarkProvider interface {
	Bookmark(userId string, tweetId string, ownerUserId string) error
	List(userId string, limit *uint64, cursor *string) ([]domain.Bookmark, string, error)
	Unbookmark(userId string, tweetId string) error
}

type ChatProvider interface {
	CreateChat(chatId *string, ownerId string, otherUserId string) (domain.Chat, error)
	CreateMessage(msg domain.ChatMessage) (domain.ChatMessage, error)
	DeleteChat(chatId string) error
	DeleteMessage(chatId string, id string) error
	GetChat(chatId string) (chat domain.Chat, err error)
	GetMessage(chatId string, id string) (domain.ChatMessage, error)
	GetUserChats(userId string, limit *uint64, cursor *string) ([]domain.Chat, string, error)
	ListMessages(chatId string, limit *uint64, cursor *string) ([]domain.ChatMessage, string, error)
	IsParticipants(ownerId string, otherUserId string) bool
}

type ClientNodeStreamer interface {
	ClientStream(nodeId string, path string, data any) (_ []byte, err error)
	IsRunning() bool
}

type DiscoveryHandler interface {
	DiscoveryHandlerStream(pi warpnet.WarpAddrInfo)
	Run(n discovery.DiscoveryInfoStorer) error
	Event() <-chan warpnet.PeerEvent
	Close()
}

type DistributedHashTableCloser interface {
	FindProvidersAsync(ctx context.Context, key cid.Cid, count int) (ch <-chan peer.AddrInfo)
	BootstrapNodes() []warpnet.WarpAddrInfo
	Close()
}

type FilterProvider interface {
	AddKeyword(userId string, filterId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
	Create(userId string, f domain.Filter) (domain.Filter, error)
	Delete(userId string, filterId string) error
	DeleteKeyword(userId string, keywordId string) error
	Get(userId string, filterId string) (domain.Filter, error)
	List(userId string, limit *uint64, cursor *string) ([]domain.Filter, string, error)
	Update(userId string, f domain.Filter) (domain.Filter, error)
	UpdateKeyword(userId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
}

type FollowStorer interface {
	GetFollowersCount(userId string) (uint64, error)
	GetFollowingsCount(userId string) (uint64, error)
	Follow(fromUserId, toUserId string) error
	Unfollow(fromUserId, toUserId string) error
	GetFollowers(userId string, limit *uint64, cursor *string) ([]domain.ID, string, error)
	GetFollowings(userId string, limit *uint64, cursor *string) ([]domain.ID, string, error)
	IsFollowing(ownerId, otherUserId string) bool
	IsFollower(ownerId, otherUserId string) bool
	AddFollowRequest(targetUserId, followerId string) error
	RemoveFollowRequest(targetUserId, followerId string) error
	ListFollowRequests(targetUserId string, limit *uint64, cursor *string) ([]domain.ID, string, error)
}

type MDNSStarterCloser interface {
	Start(n mdns.NodeConnector)
	Close()
}

type MediaProvider interface {
	GetImage(userId string, key string) (domain.Base64Image, error)
	GetVideo(userId string, key string) (domain.Base64Video, error)
	SetForeignImageWithTTL(userId string, key string, img domain.Base64Image) error
	SetForeignVideoWithTTL(userId string, key string, video domain.Base64Video) error
	SetImage(userId string, img domain.Base64Image) (_ domain.ImageKey, err error)
	SetVideo(userId string, video domain.Base64Video) (_ domain.VideoKey, err error)
	DeleteImage(userId string, key string) error
	DeleteVideo(userId string, key string) error
	GetCopy(userId string, key string) (domain.MediaCopy, error)
	SetCopy(userId string, key string, c domain.MediaCopy) error
	ListCopies(userId string, originalKey string) ([]domain.MediaCopy, error)
	SetImageHashes(h domain.TweetImageHashes) error
	ListImageHashes() ([]domain.TweetImageHashes, error)
}

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

type MutesProvider interface {
	List(muterId string, limit *uint64, cursor *string) ([]string, string, error)
	Mute(muterId string, muteeId string) error
	Unmute(muterId string, muteeId string) error
}

type NodeProvider interface {
	datastore.Datastore
	BlocklistExponential(peerId string) error
	BlocklistPermanent(peerId string) error
	BlocklistRemove(peerId string) error
}

type NotificationProvider interface {
	Get(userId string, notificationId string) (domain.Notification, error)
	List(userId string, limit *uint64, cursor *string) ([]domain.Notification, string, error)
	MarkAllRead(userId string) error
	MarkRead(userId string, notificationId string) error
	ReverseList(userId string, cursor *string, limit *uint64) ([]domain.Notification, string, error)
	UnreadCount(userId string) (uint64, error)
}

type OrderProvider interface {
	Get(tweetId, buyerId string) (domain.Order, error)
	Save(o domain.Order) error
	CountConfirmed(buyerId string, from, to time.Time) (int, error)
	Delete(tweetId, buyerId string) error
	IsPayerTaken(payer, buyerNodeId string) (bool, error)
}

type PeerRater interface {
	Listen(sources ...<-chan warpnet.PeerEvent)
	View(peerID warpnet.WarpPeerID) (domain.NodeRating, error)
	Own() (domain.NodeRating, error)
	Close() error
}

type PeersRatings interface {
	Rate(peerID warpnet.WarpPeerID, tier rating.Tier)
	ConnTag(peerID warpnet.WarpPeerID) int
	GossipScore(peerID warpnet.WarpPeerID) float64
	RateMultiplier(peerID warpnet.WarpPeerID) float64
	IsAllowedInDHT(peerID warpnet.WarpPeerID) bool
	IsMediaAllowed(peerID warpnet.WarpPeerID) bool
}

type PollProvider interface {
	Results(tweetId string, optionsNum int) (votes []uint64, err error)
	Vote(tweetId string, userId string, option int, isTransitive bool) error
	Voted(tweetId string, userId string) (option int, ok bool, err error)
}

type PubSubProvider interface {
	SubscribeUserUpdate(userId string) (err error)
	UnsubscribeUserUpdate(userId string) (err error)
	Run(m pubsub.PubsubServerNodeConnector)
	PublishUpdateToFollowers(ownerId, dest string, bt []byte) (err error)
	PublishReport(ev event.ReportEvent) error
	Close() error
	Gossip() *corePubsub.Gossip
}

type RatingProvider interface {
	Get(ctx context.Context, key datastore.Key) ([]byte, error)
	Has(ctx context.Context, key datastore.Key) (bool, error)
	GetSize(ctx context.Context, key datastore.Key) (int, error)
	Query(ctx context.Context, q datastore.Query) (datastore.Results, error)
	Put(ctx context.Context, key datastore.Key, value []byte) error
	Delete(ctx context.Context, key datastore.Key) error
	Sync(ctx context.Context, prefix datastore.Key) error
	Close() error
}

type RatingStorer interface {
	Put(rec domain.RatingRecord) error
	List(peerID string) ([]domain.RatingRecord, error)
	PeerIDs() ([]string, error)
	DeleteExpired(dimension string, beforeBucket int64) error
	OnPut(hook func(domain.RatingRecord))
	OnDelete(hook func(domain.RatingRecord))
	Close() error
}

type ReactionsProvider interface {
	React(tweetId string, userId string, emoji string, isTransitive bool) (reactionsNum uint64, err error)
	Reacted(userId string, limit *uint64, cursor *string) ([]domain.ReactedTweet, string, error)
	Reactors(tweetId string, limit *uint64, cursor *string) (reactors []string, cur string, err error)
	ReactionsCount(tweetId string) (reactionsNum uint64, err error)
	Reaction(tweetId string, userId string) (emoji string, err error)
	Reactions(tweetId string) (reactions map[string]uint64, err error)
	RemoveReacted(userId string, tweetId string) error
	SetReacted(userId string, tweetId string, ownerUserId string) error
	Unreact(tweetId string, userId string, isTransitive bool) (reactionsNum uint64, err error)
}

type SettingsProvider interface {
	GetGatewaySettings(userId string) (domain.GatewaySettings, error)
	GetNotificationSettings(userId string) (domain.NotificationSettings, error)
	GetRateLimitSettings(userId string) (ratelimit.Settings, error)
	GetSponsoredSettings(userId string) (domain.SponsoredSettings, error)
	SetGatewaySettings(userId string, s domain.GatewaySettings) error
	SetNotificationSettings(userId string, s domain.NotificationSettings) error
	SetRateLimitSettings(userId string, s ratelimit.Settings) error
	SetSponsoredSettings(userId string, s domain.SponsoredSettings) error
}

type StatsProvider interface {
	datastore.Datastore
}

type StatsStorer interface {
	Increment(key ds.Key) error
	Decrement(key ds.Key) error
	GetAggregatedStat(key ds.Key) (uint64, error)
	Close() error
}

type Storer interface {
	NewTxn() (local_store.WarpTransactioner, error)
	NewReadTxn() (local_store.WarpTransactioner, error)
	Get(key local_store.DatabaseKey) ([]byte, error)
	GetExpiration(key local_store.DatabaseKey) (uint64, error)
	GetSize(key local_store.DatabaseKey) (int64, error)
	Sync() error
	IsClosed() bool
	InnerDB() *local_store.WarpDB
	SetWithTTL(key local_store.DatabaseKey, value []byte, ttl time.Duration) error
	Set(key local_store.DatabaseKey, value []byte) error
	Delete(key local_store.DatabaseKey) error
	Path() string
	Stats() map[string]string
	IsFirstRun() bool
}

type SubscriptionProvider interface {
	Subscribe(selfId string, targetUserId string) error
	Unsubscribe(selfId string, targetUserId string) error
}

type TimelineProvider interface {
	AddTweetToTimeline(userId string, tweet domain.Tweet) error
	DeleteTweetFromTimeline(userID string, tweetID string) error
	GetTimeline(string, *uint64, *string) ([]domain.Tweet, string, error)
}

type TweetsProvider interface {
	AddReply(reply domain.Tweet, isTransitive bool) (domain.Tweet, error)
	AppendEdit(edit domain.TweetEdit) (domain.TweetEdit, error)
	Blocklist(tweetId string) error
	Create(_ string, tweet domain.Tweet) (domain.Tweet, error)
	CreateWithTTL(userId string, tweet domain.Tweet, duration time.Duration) (domain.Tweet, error)
	Delete(userID string, tweetID string) error
	DeleteReply(parentID string, replyID string, isTransitive bool) (domain.Tweet, error)
	Get(userID string, tweetID string) (tweet domain.Tweet, err error)
	GetReplies(parentID string, limit *uint64, cursor *string) ([]domain.Tweet, string, error)
	GetReply(parentID string, replyID string) (domain.Tweet, error)
	GetViewsCount(tweetId string) (uint64, error)
	IsBlocklisted(tweetId string) bool
	List(string, *uint64, *string) ([]domain.Tweet, string, error)
	NewRetweet(tweet domain.Tweet, isTransitive bool) (_ domain.Tweet, err error)
	Pin(userId string, tweetId string) (domain.Tweet, error)
	RecordView(tweetId string, viewerId string) (uint64, error)
	RepliesCount(tweetId string) (reactionsNum uint64, err error)
	Retweeters(tweetId string, limit *uint64, cursor *string) (_ []string, cur string, err error)
	RetweetsCount(tweetId string) (uint64, error)
	TweetsCount(userId string) (uint64, error)
	UnRetweet(retweetedByUserID string, tweetId string, isTransitive bool) error
	Unpin(userId string, tweetId string) (domain.Tweet, error)
	Update(tweet domain.Tweet) error
}

type UserFetcher interface {
	Get(userId string) (user domain.User, err error)
	Update(userId string, newUser domain.User) (domain.User, error)
	GetByNodeID(nodeID string) (user domain.User, err error)
}

type UserProvider interface {
	Create(user domain.User) (domain.User, error)
	GetByNodeID(nodeID string) (user domain.User, err error)
	Get(userId string) (user domain.User, err error)
	List(limit *uint64, cursor *string) ([]domain.User, string, error)
	Search(query string, limit *uint64, cursor *string) ([]domain.User, string, error)
	Update(userId string, newUser domain.User) (updatedUser domain.User, err error)
	GetBatch(userIds ...string) (users []domain.User, err error)
	CreateWithTTL(user domain.User, ttl time.Duration) (domain.User, error)
	WhoToFollow(limit *uint64, cursor *string) ([]domain.User, string, error)
}

type WalletAddressProvider interface {
	SetAddress(chain, userId, address string) error
	ListAddresses(chain string, limit *uint64, cursor *string) ([]domain.WalletAddress, string, error)
}

type WalletProvider interface {
	Address(ctx context.Context, seed string) (string, error)
	Balance(ctx context.Context, address string) (wallet.Account, error)
	Transfer(ctx context.Context, seed, asset, to, amount string) (string, error)
	Export(ctx context.Context, seed string) (address, privateKey string, err error)
	History(ctx context.Context, address, asset string, limit int) ([]wallet.Transfer, error)
	Stake(ctx context.Context, seed, amount string) (string, error)
	Unstake(ctx context.Context, seed, amount string) (string, error)
	Withdraw(ctx context.Context, seed string) (string, error)
	Pay(ctx context.Context, seed string, s wallet.Sponsorship) (wallet.Payment, error)
	Payment(ctx context.Context, s wallet.Sponsorship, since time.Time) (wallet.PaymentState, error)
	Quote(ctx context.Context, seed string, s wallet.Sponsorship) (wallet.Quote, error)
	IsPaid(ctx context.Context, txId string, s wallet.Sponsorship) (wallet.Receipt, error)
	IsAvailable(ctx context.Context) bool
	Token() string
	Decimals() uint8
	Network() string
	Splitter() string
	Splitters() []string
	MaxFeePercent() uint64
	Close()
}