package pubsub

Import Path
	github.com/libp2p/go-libp2p-pubsub (on go.dev)

Dependency Relation
	imports 40 packages, and imported by one package

Involved Source Files

	    backoff.go
	    blacklist.go
	    comm.go
	    discovery.go
	  d doc.go
		The pubsub package provides facilities for the Publish/Subscribe pattern of message
		propagation, also known as overlay multicast.
		The implementation provides topic-based pubsub, with pluggable routing algorithms.
		
		The main interface to the library is the PubSub object.
		You can construct this object with the following constructors:
		
		- NewFloodSub creates an instance that uses the floodsub routing algorithm.
		
		- NewGossipSub creates an instance that uses the gossipsub routing algorithm.
		
		- NewRandomSub creates an instance that uses the randomsub routing algorithm.
		
		In addition, there is a generic constructor that creates a pubsub instance with
		a custom PubSubRouter interface. This procedure is currently reserved for internal
		use within the package.
		
		Once you have constructed a PubSub instance, you need to establish some connections
		to your peers; the implementation relies on ambient peer discovery, leaving bootstrap
		and active peer discovery up to the client.
		
		To publish a message to some topic, use Publish; you don't need to be subscribed
		to the topic in order to publish.
		
		To subscribe to a topic, use Subscribe; this will give you a subscription interface
		from which new messages can be pumped.

	    floodsub.go
	    gossip_tracer.go
	    gossipsub.go
	    gossipsub_feat.go
	    mcache.go
	    midgen.go
	    peer_gater.go
	    peer_notify.go
	    pubsub.go
	    randomsub.go
	    rpc_queue.go
	    score.go
	    score_params.go
	    sign.go
	    subscription.go
	    subscription_filter.go
	    tag_tracer.go
	    topic.go
	    trace.go
	    tracer.go
	    validation.go
	    validation_builtin.go
Package-Level Type Names (total 58)

	/* sort by: alphabet | popularity */
	 type AcceptStatus int (basic type)

		As Outputs Of (at least 4)
			func (*FloodSubRouter).AcceptFrom(peer.ID) AcceptStatus
			func (*GossipSubRouter).AcceptFrom(p peer.ID) AcceptStatus
			func PubSubRouter.AcceptFrom(peer.ID) AcceptStatus
			func (*RandomSubRouter).AcceptFrom(peer.ID) AcceptStatus
		As Types Of (total 3)
			const AcceptAll
			const AcceptControl
			const AcceptNone

	 type BackoffConnectorFactory (func)
		BackoffConnectorFactory creates a BackoffConnector that is attached to a given host

		As Inputs Of (at least one exported)
			func WithDiscoverConnector(connFactory BackoffConnectorFactory) DiscoverOpt

	 type BasicSeqnoValidator (struct)
		BasicSeqnoValidator is a basic validator, usable as a default validator, that ignores replayed
		messages outside the seen cache window. The validator uses the message seqno as a peer-specific
		nonce to decide whether the message should be propagated, comparing to the maximal nonce store
		in the peer metadata store. This is useful to ensure that there can be no infinitely propagating
		messages in the network regardless of the seen cache span and network diameter.
		It requires that pubsub is instantiated with a strict message signing policy and that seqnos
		are not disabled, ie it doesn't support anonymous mode.
		
		Warning: See https://github.com/libp2p/rust-libp2p/issues/3453
		TL;DR: rust is currently violating the spec by issuing a random seqno, which creates an
		interoperability hazard. We expect this issue to be addressed in the not so distant future,
		but keep this in mind if you are in a mixed environment with (older) rust nodes.

	 type Blacklist (interface)
		Blacklist is an interface for peer blacklisting.

		Methods (total 2)
			( Blacklist) Add(peer.ID) bool
			( Blacklist) Contains(peer.ID) bool
		Implemented By (at least 2)
			 MapBlacklist
			*TimeCachedBlacklist
		As Outputs Of (at least 2)
			func NewMapBlacklist() Blacklist
			func NewTimeCachedBlacklist(expiry time.Duration) (Blacklist, error)
		As Inputs Of (at least one exported)
			func WithBlacklist(b Blacklist) Option

	 type CacheEntry (struct)
	 type DiscoverOpt (func)

		As Outputs Of (at least 2)
			func WithDiscoverConnector(connFactory BackoffConnectorFactory) DiscoverOpt
			func WithDiscoveryOpts(opts ...discovery.Option) DiscoverOpt
		As Inputs Of (at least one exported)
			func WithDiscovery(d discovery.Discovery, opts ...DiscoverOpt) Option

	 type EventTracer (interface)
		EventTracer is a generic event tracer interface.
		This is a high level tracing interface which delivers tracing events, as defined by the protobuf
		schema in pb/trace.proto.

		Methods (only one)
			( EventTracer) Trace(evt *pb.TraceEvent)
		Implemented By (at least 3)
			*JSONTracer
			*PBTracer
			*RemoteTracer
		As Inputs Of (at least one exported)
			func WithEventTracer(tracer EventTracer) Option

	 type EventType int (basic type)

		As Types Of (total 2)
			const PeerJoin
			const PeerLeave

	 type ExtendedPeerScoreInspectFn = (func)
	 type FloodSubRouter (struct)

		Methods (total 11)
			(*FloodSubRouter) AcceptFrom(peer.ID) AcceptStatus
			(*FloodSubRouter) AddPeer(p peer.ID, proto protocol.ID)
			(*FloodSubRouter) Attach(p *PubSub)
			(*FloodSubRouter) EnoughPeers(topic string, suggested int) bool
			(*FloodSubRouter) HandleRPC(rpc *RPC)
			(*FloodSubRouter) Join(topic string)
			(*FloodSubRouter) Leave(topic string)
			(*FloodSubRouter) PreValidation([]*Message)
			(*FloodSubRouter) Protocols() []protocol.ID
			(*FloodSubRouter) Publish(msg *Message)
			(*FloodSubRouter) RemovePeer(p peer.ID)
		Implements (at least one exported)
			*FloodSubRouter : PubSubRouter

	 type GossipSubFeature int (basic type)
		GossipSubFeature is a feature discriminant enum

		As Inputs Of (at least one exported)
			func GossipSubDefaultFeatures(feat GossipSubFeature, proto protocol.ID) bool

	 type GossipSubFeatureTest = (func)
		GossipSubFeatureTest is a feature test function; it takes a feature and a protocol ID and
		should return true if the feature is supported by the protocol

	 type GossipSubParams (struct)
		GossipSubParams defines all the gossipsub specific parameters.

		Fields (total 32)
			ConnectionTimeout time.Duration
				ConnectionTimeout controls the timeout for connection attempts.

			Connectors int
				Connectors controls the number of active connection attempts for peers obtained through PX.

			D int
				D sets the optimal degree for a GossipSub topic mesh. For example, if D == 6,
				each peer will want to have about six peers in their mesh for each topic they're subscribed to.
				D should be set somewhere between Dlo and Dhi.

			Dhi int
				Dhi sets the upper bound on the number of peers we keep in a GossipSub topic mesh.
				If we have more than Dhi peers, we will select some to prune from the mesh at the next heartbeat.

			DirectConnectInitialDelay time.Duration
				DirectConnectInitialDelay is the initial delay before opening connections to direct peers

			DirectConnectTicks uint64
				DirectConnectTicks is the number of heartbeat ticks for attempting to reconnect direct peers
				that are not currently connected.

			Dlazy int
				Dlazy affects how many peers we will emit gossip to at each heartbeat.
				We will send gossip to at least Dlazy peers outside our mesh. The actual
				number may be more, depending on GossipFactor and how many peers we're
				connected to.

			Dlo int
				Dlo sets the lower bound on the number of peers we keep in a GossipSub topic mesh.
				If we have fewer than Dlo peers, we will attempt to graft some more into the mesh at
				the next heartbeat.

			Dout int
				Dout sets the quota for the number of outbound connections to maintain in a topic mesh.
				When the mesh is pruned due to over subscription, we make sure that we have outbound connections
				to at least Dout of the survivor peers. This prevents sybil attackers from overwhelming
				our mesh with incoming connections.
				
				Dout must be set below Dlo, and must not exceed D / 2.

			Dscore int
				Dscore affects how peers are selected when pruning a mesh due to over subscription.
				At least Dscore of the retained peers will be high-scoring, while the remainder are
				chosen randomly.

			FanoutTTL time.Duration
				FanoutTTL controls how long we keep track of the fanout state. If it's been
				FanoutTTL since we've published to a topic that we're not subscribed to,
				we'll delete the fanout map for that topic.

			GossipFactor float64
				GossipFactor affects how many peers we will emit gossip to at each heartbeat.
				We will send gossip to GossipFactor * (total number of non-mesh peers), or
				Dlazy, whichever is greater.

			GossipRetransmission int
				GossipRetransmission controls how many times we will allow a peer to request
				the same message id through IWANT gossip before we start ignoring them. This is designed
				to prevent peers from spamming us with requests and wasting our resources.

			GraftFloodThreshold time.Duration
				If a GRAFT comes before GraftFloodThreshold has elapsed since the last PRUNE,
				then there is an extra score penalty applied to the peer through P7.

			HeartbeatInitialDelay time.Duration
				HeartbeatInitialDelay is the short delay before the heartbeat timer begins
				after the router is initialized.

			HeartbeatInterval time.Duration
				HeartbeatInterval controls the time between heartbeats.

			HistoryGossip int
				HistoryGossip controls how many cached message ids we will advertise in
				IHAVE gossip messages. When asked for our seen message IDs, we will return
				only those from the most recent HistoryGossip heartbeats. The slack between
				HistoryGossip and HistoryLength allows us to avoid advertising messages
				that will be expired by the time they're requested.
				
				HistoryGossip must be less than or equal to HistoryLength to
				avoid a runtime panic.

			HistoryLength int
				HistoryLength controls the size of the message cache used for gossip.
				The message cache will remember messages for HistoryLength heartbeats.

			IDontWantMessageTTL int
				IDONTWANT is cleared when it's older than the TTL.

			IDontWantMessageThreshold int
				IDONTWANT is only sent for messages larger than the threshold. This should be greater than
				D_high * the size of the message id. Otherwise, the attacker can do the amplication attack by sending
				small messages while the receiver replies back with larger IDONTWANT messages.

			IWantFollowupTime time.Duration
				Time to wait for a message requested through IWANT following an IHAVE advertisement.
				If the message is not received within this window, a broken promise is declared and
				the router may apply bahavioural penalties.

			MaxIDontWantLength int
				MaxIDontWantLength is the maximum number of messages to include in an IDONTWANT message. Also controls
				the maximum number of IDONTWANT ids we will accept to protect against IDONTWANT floods. This value
				should be adjusted if your system anticipates a larger amount than specified per heartbeat.

			MaxIDontWantMessages int
				MaxIDontWantMessages is the maximum number of IDONTWANT messages to accept from a peer within a heartbeat.

			MaxIHaveLength int
				MaxIHaveLength is the maximum number of messages to include in an IHAVE message.
				Also controls the maximum number of IHAVE ids we will accept and request with IWANT from a
				peer within a heartbeat, to protect from IHAVE floods. You should adjust this value from the
				default if your system is pushing more than 5000 messages in HistoryGossip heartbeats;
				with the defaults this is 1666 messages/s.

			MaxIHaveMessages int
				MaxIHaveMessages is the maximum number of IHAVE messages to accept from a peer within a heartbeat.

			MaxPendingConnections int
				MaxPendingConnections sets the maximum number of pending connections for peers attempted through px.

			OpportunisticGraftPeers int
				OpportunisticGraftPeers is the number of peers to opportunistically graft.

			OpportunisticGraftTicks uint64
				OpportunisticGraftTicks is the number of heartbeat ticks for attempting to improve the mesh
				with opportunistic grafting. Every OpportunisticGraftTicks we will attempt to select some
				high-scoring mesh peers to replace lower-scoring ones, if the median score of our mesh peers falls
				below a threshold (see https://godoc.org/github.com/libp2p/go-libp2p-pubsub#PeerScoreThresholds).

			PruneBackoff time.Duration
				PruneBackoff controls the backoff time for pruned peers. This is how long
				a peer must wait before attempting to graft into our mesh again after being pruned.
				When pruning a peer, we send them our value of PruneBackoff so they know
				the minimum time to wait. Peers running older versions may not send a backoff time,
				so if we receive a prune message without one, we will wait at least PruneBackoff
				before attempting to re-graft.

			PrunePeers int
				PrunePeers controls the number of peers to include in prune Peer eXchange.
				When we prune a peer that's eligible for PX (has a good score, etc), we will try to
				send them signed peer records for up to PrunePeers other peers that we
				know of.

			SlowHeartbeatWarning float64
				SlowHeartbeatWarning is the duration threshold for heartbeat processing before emitting
				a warning; this would be indicative of an overloaded peer.

			UnsubscribeBackoff time.Duration
				UnsubscribeBackoff controls the backoff time to use when unsuscribing
				from a topic. A peer should not resubscribe to this topic before this
				duration.

		As Outputs Of (at least one exported)
			func DefaultGossipSubParams() GossipSubParams
		As Inputs Of (at least one exported)
			func WithGossipSubParams(cfg GossipSubParams) Option

	 type GossipSubRouter (struct)
		GossipSubRouter is a router that implements the gossipsub protocol.
		For each topic we have joined, we maintain an overlay through which
		messages flow; this is the mesh map.
		For each topic we publish to without joining, we maintain a list of peers
		to use for injecting our messages in the overlay with stable routes; this
		is the fanout map. Fanout peer lists are expired if we don't publish any
		messages to their topic for GossipSubFanoutTTL.

		Methods (total 13)
			(*GossipSubRouter) AcceptFrom(p peer.ID) AcceptStatus
			(*GossipSubRouter) AddPeer(p peer.ID, proto protocol.ID)
			(*GossipSubRouter) Attach(p *PubSub)
			(*GossipSubRouter) EnoughPeers(topic string, suggested int) bool
			(*GossipSubRouter) HandleRPC(rpc *RPC)
			(*GossipSubRouter) Join(topic string)
			(*GossipSubRouter) Leave(topic string)
			(*GossipSubRouter) PreValidation(msgs []*Message)
				PreValidation sends the IDONTWANT control messages to all the mesh
				peers. They need to be sent right before the validation because they
				should be seen by the peers as soon as possible.

			(*GossipSubRouter) Protocols() []protocol.ID
			(*GossipSubRouter) Publish(msg *Message)
			(*GossipSubRouter) RemovePeer(p peer.ID)
			(*GossipSubRouter) SendControl(p peer.ID, ctl *pb.ControlMessage, msgs ...*pb.Message)
				SendControl dispatches the given set of control messages to the given peer.
				The control messages are sent as a single RPC, with the given (optional) messages.
				Args:
				
					p: the peer to send the control messages to.
					ctl: the control messages to send.
					msgs: the messages to send in the same RPC (optional).
					The control messages are piggybacked on the messages.
				
				Returns:
				
					nothing.

			(*GossipSubRouter) WithDefaultTagTracer() Option
				WithDefaultTagTracer returns the tag tracer of the GossipSubRouter as a PubSub option.
				This is useful for cases where the GossipSubRouter is instantiated externally, and is
				injected into the GossipSub constructor as a dependency. This allows the tag tracer to be
				also injected into the GossipSub constructor as a PubSub option dependency.

		Implements (at least one exported)
			*GossipSubRouter : PubSubRouter
		As Outputs Of (at least one exported)
			func DefaultGossipSubRouter(h host.Host) *GossipSubRouter

	 type JSONTracer (struct)
		JSONTracer is a tracer that writes events to a file, encoded in ndjson.

		Methods (total 2)
			(*JSONTracer) Close()
			(*JSONTracer) Trace(evt *pb.TraceEvent)
		Implements (at least one exported)
			*JSONTracer : EventTracer
		As Outputs Of (at least 2)
			func NewJSONTracer(file string) (*JSONTracer, error)
			func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, error)

	 type MapBlacklist (map)
		MapBlacklist is a blacklist implementation using a perfect map

		Methods (total 2)
			( MapBlacklist) Add(p peer.ID) bool
			( MapBlacklist) Contains(p peer.ID) bool
		Implements (at least one exported)
			 MapBlacklist : Blacklist

	 type Message (struct)

		Fields (total 14)
			ID string
			Local bool
			Message *pb.Message
			Message.Data []byte
			Message.From []byte
			Message.Key []byte
			Message.Seqno []byte
			Message.Signature []byte
			Message.Topic *string
			Message.XXX_NoUnkeyedLiteral struct{}
			Message.XXX_sizecache int32
			Message.XXX_unrecognized []byte
			ReceivedFrom peer.ID
			ValidatorData interface{}
		Methods (total 20)
			( Message) Descriptor() ([]byte, []int)
			( Message) GetData() []byte
			(*Message) GetFrom() peer.ID
			( Message) GetKey() []byte
			( Message) GetSeqno() []byte
			( Message) GetSignature() []byte
			( Message) GetTopic() string
			( Message) Marshal() (dAtA []byte, err error)
			( Message) MarshalTo(dAtA []byte) (int, error)
			( Message) MarshalToSizedBuffer(dAtA []byte) (int, error)
			( Message) ProtoMessage()
			( Message) Reset()
			( Message) Size() (n int)
			( Message) String() string
			( Message) Unmarshal(dAtA []byte) error
			( Message) XXX_DiscardUnknown()
			( Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
			( Message) XXX_Merge(src proto.Message)
			( Message) XXX_Size() int
			( Message) XXX_Unmarshal(b []byte) error
		Implements (at least 10)
			 Message : github.com/gogo/protobuf/proto.Marshaler
			 Message : github.com/gogo/protobuf/proto.Message
			 Message : github.com/gogo/protobuf/proto.Sizer
			 Message : github.com/gogo/protobuf/proto.Unmarshaler
			 Message : github.com/golang/protobuf/proto.Marshaler
			 Message : github.com/golang/protobuf/proto.Unmarshaler
			 Message : github.com/pion/rtcp.PacketStatusChunk
			 Message : expvar.Var
			 Message : fmt.Stringer
			 Message : google.golang.org/protobuf/runtime/protoiface.MessageV1
		As Outputs Of (at least 3)
			func (*MessageCache).Get(mid string) (*Message, bool)
			func (*MessageCache).GetForPeer(mid string, p peer.ID) (*Message, int, bool)
			func (*Subscription).Next(ctx context.Context) (*Message, error)
		As Inputs Of (at least 14)
			func (*FloodSubRouter).PreValidation([]*Message)
			func (*FloodSubRouter).Publish(msg *Message)
			func (*GossipSubRouter).PreValidation(msgs []*Message)
			func (*GossipSubRouter).Publish(msg *Message)
			func (*MessageCache).Put(msg *Message)
			func PubSubRouter.PreValidation([]*Message)
			func PubSubRouter.Publish(*Message)
			func (*RandomSubRouter).PreValidation([]*Message)
			func (*RandomSubRouter).Publish(msg *Message)
			func RawTracer.DeliverMessage(msg *Message)
			func RawTracer.DuplicateMessage(msg *Message)
			func RawTracer.RejectMessage(msg *Message, reason string)
			func RawTracer.UndeliverableMessage(msg *Message)
			func RawTracer.ValidateMessage(msg *Message)

	 type MessageCache (struct)

		Methods (total 6)
			(*MessageCache) Get(mid string) (*Message, bool)
			(*MessageCache) GetForPeer(mid string, p peer.ID) (*Message, int, bool)
			(*MessageCache) GetGossipIDs(topic string) []string
			(*MessageCache) Put(msg *Message)
			(*MessageCache) SetMsgIdFn(msgID func(*Message) string)
			(*MessageCache) Shift()
		As Outputs Of (at least one exported)
			func NewMessageCache(gossip, history int) *MessageCache

	 type MessageSignaturePolicy uint8 (basic type)
		MessageSignaturePolicy describes if signatures are produced, expected, and/or verified.

		As Inputs Of (at least one exported)
			func WithMessageSignaturePolicy(policy MessageSignaturePolicy) Option
		As Types Of (total 3)
			const LaxSign
			const StrictNoSign
			const StrictSign

	 type MsgIdFunction (func)
		MsgIdFunction returns a unique ID for the passed Message, and PubSub can be customized to use any
		implementation of this function by configuring it with the Option from WithMessageIdFn.

		As Inputs Of (at least 2)
			func WithMessageIdFn(fn MsgIdFunction) Option
			func WithTopicMessageIdFn(msgId MsgIdFunction) TopicOpt

	 type Option (func)

		As Outputs Of (at least 32)
			func WithAppSpecificRpcInspector(inspector func(peer.ID, *RPC) error) Option
			func WithBlacklist(b Blacklist) Option
			func WithDefaultValidator(val interface{}, opts ...ValidatorOpt) Option
			func WithDirectConnectTicks(t uint64) Option
			func WithDirectPeers(pis []peer.AddrInfo) Option
			func WithDiscovery(d discovery.Discovery, opts ...DiscoverOpt) Option
			func WithEventTracer(tracer EventTracer) Option
			func WithFloodPublish(floodPublish bool) Option
			func WithGossipSubParams(cfg GossipSubParams) Option
			func WithGossipSubProtocols(protos []protocol.ID, feature GossipSubFeatureTest) Option
			func WithMaxMessageSize(maxMessageSize int) Option
			func WithMessageAuthor(author peer.ID) Option
			func WithMessageIdFn(fn MsgIdFunction) Option
			func WithMessageSignaturePolicy(policy MessageSignaturePolicy) Option
			func WithMessageSigning(enabled bool) Option
			func WithNoAuthor() Option
			func WithPeerExchange(doPX bool) Option
			func WithPeerFilter(filter PeerFilter) Option
			func WithPeerGater(params *PeerGaterParams) Option
			func WithPeerOutboundQueueSize(size int) Option
			func WithPeerScore(params *PeerScoreParams, thresholds *PeerScoreThresholds) Option
			func WithPeerScoreInspect(inspect interface{}, period time.Duration) Option
			func WithProtocolMatchFn(m ProtocolMatchFn) Option
			func WithRawTracer(tracer RawTracer) Option
			func WithSeenMessagesStrategy(strategy timecache.Strategy) Option
			func WithSeenMessagesTTL(ttl time.Duration) Option
			func WithStrictSignatureVerification(required bool) Option
			func WithSubscriptionFilter(subFilter SubscriptionFilter) Option
			func WithValidateQueueSize(n int) Option
			func WithValidateThrottle(n int) Option
			func WithValidateWorkers(n int) Option
			func (*GossipSubRouter).WithDefaultTagTracer() Option
		As Inputs Of (at least 6)
			func NewFloodSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error)
			func NewFloodsubWithProtocols(ctx context.Context, h host.Host, ps []protocol.ID, opts ...Option) (*PubSub, error)
			func NewGossipSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error)
			func NewGossipSubWithRouter(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)
			func NewPubSub(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)
			func NewRandomSub(ctx context.Context, h host.Host, size int, opts ...Option) (*PubSub, error)

	 type PBTracer (struct)
		PBTracer is a tracer that writes events to a file, as delimited protobufs.

		Methods (total 2)
			(*PBTracer) Close()
			(*PBTracer) Trace(evt *pb.TraceEvent)
		Implements (at least one exported)
			*PBTracer : EventTracer
		As Outputs Of (at least 2)
			func NewPBTracer(file string) (*PBTracer, error)
			func OpenPBTracer(file string, flags int, perm os.FileMode) (*PBTracer, error)

	 type PeerEvent (struct)

		Fields (total 2)
			Peer peer.ID
			Type EventType
		As Outputs Of (at least one exported)
			func (*TopicEventHandler).NextPeerEvent(ctx context.Context) (PeerEvent, error)

	 type PeerFilter (func)
		PeerFilter is used to filter pubsub peers. It should return true for peers that are accepted for
		a given topic. PubSub can be customized to use any implementation of this function by configuring
		it with the Option from WithPeerFilter.

		As Inputs Of (at least one exported)
			func WithPeerFilter(filter PeerFilter) Option

	 type PeerGaterParams (struct)
		PeerGaterParams groups together parameters that control the operation of the peer gater

		Fields (total 11)
			DecayInterval time.Duration
				decay interval

			DecayToZero float64
				counter zeroing threshold

			DuplicateWeight float64
				weight of duplicate message deliveries

			GlobalDecay float64
				(linear) decay parameter for gater counters
				// global counter decay

			IgnoreWeight float64
				weight of ignored messages

			Quiet time.Duration
				quiet interval before turning off the gater; if there are no validation throttle events
				for this interval, the gater turns off

			RejectWeight float64
				weight of rejected messages

			RetainStats time.Duration
				how long to retain stats

			SourceDecay float64
				// per IP counter decay

			Threshold float64
				when the ratio of throttled/validated messages exceeds this threshold, the gater turns on

			TopicDeliveryWeights map[string]float64
				priority topic delivery weights

		Methods (only one)
			(*PeerGaterParams) WithTopicDeliveryWeights(w map[string]float64) *PeerGaterParams
				WithTopicDeliveryWeights is a fluid setter for the priority topic delivery weights

		As Outputs Of (at least 3)
			func DefaultPeerGaterParams() *PeerGaterParams
			func NewPeerGaterParams(threshold, globalDecay, sourceDecay float64) *PeerGaterParams
			func (*PeerGaterParams).WithTopicDeliveryWeights(w map[string]float64) *PeerGaterParams
		As Inputs Of (at least one exported)
			func WithPeerGater(params *PeerGaterParams) Option

	 type PeerMetadataStore (interface)
		PeerMetadataStore is an interface for storing and retrieving per peer metadata

		Methods (total 2)
			( PeerMetadataStore) Get(context.Context, peer.ID) ([]byte, error)
				Get retrieves the metadata associated with a peer;
				It should return nil if there is no metadata associated with the peer and not an error.

			( PeerMetadataStore) Put(context.Context, peer.ID, []byte) error
				Put sets the metadata associated with a peer.

		As Inputs Of (at least one exported)
			func NewBasicSeqnoValidator(meta PeerMetadataStore) ValidatorEx

	 type PeerScoreInspectFn = (func)
	 type PeerScoreParams (struct)

		Fields (total 15)
			AppSpecificScore func(p peer.ID) float64
				P5: Application-specific peer scoring

			AppSpecificWeight float64
			BehaviourPenaltyDecay float64
				P7: behavioural pattern penalties.
				This parameter has an associated counter which tracks misbehaviour as detected by the
				router. The router currently applies penalties for the following behaviors:
				- attempting to re-graft before the prune backoff time has elapsed.
				- not following up in IWANT requests for messages advertised with IHAVE.
				
				The value of the parameter is the square of the counter over the threshold, which decays with
				BehaviourPenaltyDecay.
				The weight of the parameter MUST be negative (or zero to disable).

			BehaviourPenaltyThreshold float64
				P7: behavioural pattern penalties.
				This parameter has an associated counter which tracks misbehaviour as detected by the
				router. The router currently applies penalties for the following behaviors:
				- attempting to re-graft before the prune backoff time has elapsed.
				- not following up in IWANT requests for messages advertised with IHAVE.
				
				The value of the parameter is the square of the counter over the threshold, which decays with
				BehaviourPenaltyDecay.
				The weight of the parameter MUST be negative (or zero to disable).

			BehaviourPenaltyWeight float64
				P7: behavioural pattern penalties.
				This parameter has an associated counter which tracks misbehaviour as detected by the
				router. The router currently applies penalties for the following behaviors:
				- attempting to re-graft before the prune backoff time has elapsed.
				- not following up in IWANT requests for messages advertised with IHAVE.
				
				The value of the parameter is the square of the counter over the threshold, which decays with
				BehaviourPenaltyDecay.
				The weight of the parameter MUST be negative (or zero to disable).

			DecayInterval time.Duration
				the decay interval for parameter counters.

			DecayToZero float64
				counter value below which it is considered 0.

			IPColocationFactorThreshold int
			IPColocationFactorWeight float64
				P6: IP-colocation factor.
				The parameter has an associated counter which counts the number of peers with the same IP.
				If the number of peers in the same IP exceeds IPColocationFactorThreshold, then the value
				is the square of the difference, ie (PeersInSameIP - IPColocationThreshold)^2.
				If the number of peers in the same IP is less than the threshold, then the value is 0.
				The weight of the parameter MUST be negative, unless you want to disable for testing.
				Note: In order to simulate many IPs in a managable manner when testing, you can set the weight to 0
				      thus disabling the IP colocation penalty.

			IPColocationFactorWhitelist []*net.IPNet
			RetainScore time.Duration
				time to remember counters for a disconnected peer.

			SeenMsgTTL time.Duration
				time to remember a message delivery for. Default to global TimeCacheDuration if 0.

			SkipAtomicValidation bool
				whether it is allowed to just set some params and not all of them.

			TopicScoreCap float64
				Aggregate topic score cap; this limits the total contribution of topics towards a positive
				score. It must be positive (or 0 for no cap).

			Topics map[string]*TopicScoreParams
				Score parameters per topic.

		As Inputs Of (at least one exported)
			func WithPeerScore(params *PeerScoreParams, thresholds *PeerScoreThresholds) Option

	 type PeerScoreSnapshot (struct)

		Fields (total 5)
			AppSpecificScore float64
			BehaviourPenalty float64
			IPColocationFactor float64
			Score float64
			Topics map[string]*TopicScoreSnapshot

	 type PeerScoreThresholds (struct)

		Fields (total 6)
			AcceptPXThreshold float64
				AcceptPXThreshold is the score threshold below which PX will be ignored; this should be positive
				and limited to scores attainable by bootstrappers and other trusted nodes.

			GossipThreshold float64
				GossipThreshold is the score threshold below which gossip propagation is suppressed;
				should be negative.

			GraylistThreshold float64
				GraylistThreshold is the score threshold below which message processing is suppressed altogether,
				implementing an effective gray list according to peer score; should be negative and <= PublishThreshold.

			OpportunisticGraftThreshold float64
				OpportunisticGraftThreshold is the median mesh score threshold before triggering opportunistic
				grafting; this should have a small positive value.

			PublishThreshold float64
				PublishThreshold is the score threshold below which we shouldn't publish when using flood
				publishing (also applies to fanout and floodsub peers); should be negative and <= GossipThreshold.

			SkipAtomicValidation bool
				whether it is allowed to just set some params and not all of them.

		As Inputs Of (at least one exported)
			func WithPeerScore(params *PeerScoreParams, thresholds *PeerScoreThresholds) Option

	 type ProtocolMatchFn = (func)
	 type ProvideKey (func)
		ProvideKey is a function that provides a private key and its associated peer ID when publishing a new message

	 type PublishOptions (struct)
	 type PubOpt (func)

		As Outputs Of (at least 3)
			func WithLocalPublication(local bool) PubOpt
			func WithReadiness(ready RouterReady) PubOpt
			func WithSecretKeyAndPeerId(key crypto.PrivKey, pid peer.ID) PubOpt
		As Inputs Of (at least 2)
			func (*PubSub).Publish(topic string, data []byte, opts ...PubOpt) error
			func (*Topic).Publish(ctx context.Context, data []byte, opts ...PubOpt) error

	 type PubSub (struct)
		PubSub is the implementation of the pubsub system.

		Methods (total 8)
			(*PubSub) BlacklistPeer(pid peer.ID)
				BlacklistPeer blacklists a peer; all messages from this peer will be unconditionally dropped.

			(*PubSub) GetTopics() []string
				GetTopics returns the topics this node is subscribed to.

			(*PubSub) Join(topic string, opts ...TopicOpt) (*Topic, error)
				Join joins the topic and returns a Topic handle. Only one Topic handle should exist per topic, and Join will error if
				the Topic handle already exists.

			(*PubSub) ListPeers(topic string) []peer.ID
				ListPeers returns a list of peers we are connected to in the given topic.

			(*PubSub) Publish(topic string, data []byte, opts ...PubOpt) error
				Publish publishes data to the given topic.
				
				Deprecated: use pubsub.Join() and topic.Publish() instead

			(*PubSub) RegisterTopicValidator(topic string, val interface{}, opts ...ValidatorOpt) error
				RegisterTopicValidator registers a validator for topic.
				By default validators are asynchronous, which means they will run in a separate goroutine.
				The number of active goroutines is controlled by global and per topic validator
				throttles; if it exceeds the throttle threshold, messages will be dropped.

			(*PubSub) Subscribe(topic string, opts ...SubOpt) (*Subscription, error)
				Subscribe returns a new Subscription for the given topic.
				Note that subscription is not an instantaneous operation. It may take some time
				before the subscription is processed by the pubsub main loop and propagated to our peers.
				
				Deprecated: use pubsub.Join() and topic.Subscribe() instead

			(*PubSub) UnregisterTopicValidator(topic string) error
				UnregisterTopicValidator removes a validator from a topic.
				Returns an error if there was no validator registered with the topic.

		As Outputs Of (at least 6)
			func NewFloodSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error)
			func NewFloodsubWithProtocols(ctx context.Context, h host.Host, ps []protocol.ID, opts ...Option) (*PubSub, error)
			func NewGossipSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error)
			func NewGossipSubWithRouter(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)
			func NewPubSub(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)
			func NewRandomSub(ctx context.Context, h host.Host, size int, opts ...Option) (*PubSub, error)
		As Inputs Of (at least 4)
			func (*FloodSubRouter).Attach(p *PubSub)
			func (*GossipSubRouter).Attach(p *PubSub)
			func PubSubRouter.Attach(*PubSub)
			func (*RandomSubRouter).Attach(p *PubSub)

	 type PubSubRouter (interface)
		PubSubRouter is the message router component of PubSub.

		Methods (total 11)
			( PubSubRouter) AcceptFrom(peer.ID) AcceptStatus
				AcceptFrom is invoked on any RPC envelope before pushing it to the validation pipeline
				or processing control information.
				Allows routers with internal scoring to vet peers before committing any processing resources
				to the message and implement an effective graylist and react to validation queue overload.

			( PubSubRouter) AddPeer(peer.ID, protocol.ID)
				AddPeer notifies the router that a new peer has been connected.

			( PubSubRouter) Attach(*PubSub)
				Attach is invoked by the PubSub constructor to attach the router to a
				freshly initialized PubSub instance.

			( PubSubRouter) EnoughPeers(topic string, suggested int) bool
				EnoughPeers returns whether the router needs more peers before it's ready to publish new records.
				Suggested (if greater than 0) is a suggested number of peers that the router should need.

			( PubSubRouter) HandleRPC(*RPC)
				HandleRPC is invoked to process control messages in the RPC envelope.
				It is invoked after subscriptions and payload messages have been processed.

			( PubSubRouter) Join(topic string)
				Join notifies the router that we want to receive and forward messages in a topic.
				It is invoked after the subscription announcement.

			( PubSubRouter) Leave(topic string)
				Leave notifies the router that we are no longer interested in a topic.
				It is invoked after the unsubscription announcement.

			( PubSubRouter) PreValidation([]*Message)
				PreValidation is invoked on messages in the RPC envelope right before pushing it to
				the validation pipeline

			( PubSubRouter) Protocols() []protocol.ID
				Protocols returns the list of protocols supported by the router.

			( PubSubRouter) Publish(*Message)
				Publish is invoked to forward a new message that has been validated.

			( PubSubRouter) RemovePeer(peer.ID)
				RemovePeer notifies the router that a peer has been disconnected.

		Implemented By (at least 3)
			*FloodSubRouter
			*GossipSubRouter
			*RandomSubRouter
		As Inputs Of (at least 2)
			func NewGossipSubWithRouter(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)
			func NewPubSub(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)

	 type RandomSubRouter (struct)
		RandomSubRouter is a router that implements a random propagation strategy.
		For each message, it selects the square root of the network size peers, with a min of RandomSubD,
		and forwards the message to them.

		Methods (total 11)
			(*RandomSubRouter) AcceptFrom(peer.ID) AcceptStatus
			(*RandomSubRouter) AddPeer(p peer.ID, proto protocol.ID)
			(*RandomSubRouter) Attach(p *PubSub)
			(*RandomSubRouter) EnoughPeers(topic string, suggested int) bool
			(*RandomSubRouter) HandleRPC(rpc *RPC)
			(*RandomSubRouter) Join(topic string)
			(*RandomSubRouter) Leave(topic string)
			(*RandomSubRouter) PreValidation([]*Message)
			(*RandomSubRouter) Protocols() []protocol.ID
			(*RandomSubRouter) Publish(msg *Message)
			(*RandomSubRouter) RemovePeer(p peer.ID)
		Implements (at least one exported)
			*RandomSubRouter : PubSubRouter

	 type RawTracer (interface)
		RawTracer is a low level tracing interface that allows an application to trace the internal
		operation of the pubsub subsystem.
		
		Note that the tracers are invoked synchronously, which means that application tracers must
		take care to not block or modify arguments.
		
		Warning: this interface is not fixed, we may be adding new methods as necessitated by the system
		in the future.

		Methods (total 15)
			( RawTracer) AddPeer(p peer.ID, proto protocol.ID)
				AddPeer is invoked when a new peer is added.

			( RawTracer) DeliverMessage(msg *Message)
				DeliverMessage is invoked when a message is delivered

			( RawTracer) DropRPC(rpc *RPC, p peer.ID)
				DropRPC is invoked when an outbound RPC is dropped, typically because of a queue full.

			( RawTracer) DuplicateMessage(msg *Message)
				DuplicateMessage is invoked when a duplicate message is dropped.

			( RawTracer) Graft(p peer.ID, topic string)
				Graft is invoked when a new peer is grafted on the mesh (gossipsub)

			( RawTracer) Join(topic string)
				Join is invoked when a new topic is joined

			( RawTracer) Leave(topic string)
				Leave is invoked when a topic is abandoned

			( RawTracer) Prune(p peer.ID, topic string)
				Prune is invoked when a peer is pruned from the message (gossipsub)

			( RawTracer) RecvRPC(rpc *RPC)
				RecvRPC is invoked when an incoming RPC is received.

			( RawTracer) RejectMessage(msg *Message, reason string)
				RejectMessage is invoked when a message is Rejected or Ignored.
				The reason argument can be one of the named strings Reject*.

			( RawTracer) RemovePeer(p peer.ID)
				RemovePeer is invoked when a peer is removed.

			( RawTracer) SendRPC(rpc *RPC, p peer.ID)
				SendRPC is invoked when a RPC is sent.

			( RawTracer) ThrottlePeer(p peer.ID)
				ThrottlePeer is invoked when a peer is throttled by the peer gater.

			( RawTracer) UndeliverableMessage(msg *Message)
				UndeliverableMessage is invoked when the consumer of Subscribe is not reading messages fast enough and
				the pressure release mechanism trigger, dropping messages.

			( RawTracer) ValidateMessage(msg *Message)
				ValidateMessage is invoked when a message first enters the validation pipeline.

		As Inputs Of (at least one exported)
			func WithRawTracer(tracer RawTracer) Option

	 type RelayCancelFunc (func)

		As Outputs Of (at least one exported)
			func (*Topic).Relay() (RelayCancelFunc, error)

	 type RemoteTracer (struct)
		RemoteTracer is a tracer that sends trace events to a remote peer

		Methods (total 2)
			(*RemoteTracer) Close()
			(*RemoteTracer) Trace(evt *pb.TraceEvent)
		Implements (at least one exported)
			*RemoteTracer : EventTracer
		As Outputs Of (at least one exported)
			func NewRemoteTracer(ctx context.Context, host host.Host, pi peer.AddrInfo) (*RemoteTracer, error)

	 type RouterReady (func)
		RouterReady is a function that decides if a router is ready to publish

		As Outputs Of (at least one exported)
			func MinTopicSize(size int) RouterReady
		As Inputs Of (at least one exported)
			func WithReadiness(ready RouterReady) PubOpt

	 type RPC (struct)

		Fields (total 7)
			RPC pb.RPC
			RPC.Control *pubsub_pb.ControlMessage
			RPC.Publish []*pubsub_pb.Message
			RPC.Subscriptions []*pubsub_pb.RPC_SubOpts
			RPC.XXX_NoUnkeyedLiteral struct{}
			RPC.XXX_sizecache int32
			RPC.XXX_unrecognized []byte
		Methods (total 17)
			(*RPC) Descriptor() ([]byte, []int)
			(*RPC) GetControl() *pubsub_pb.ControlMessage
			(*RPC) GetPublish() []*pubsub_pb.Message
			(*RPC) GetSubscriptions() []*pubsub_pb.RPC_SubOpts
			(*RPC) Marshal() (dAtA []byte, err error)
			(*RPC) MarshalTo(dAtA []byte) (int, error)
			(*RPC) MarshalToSizedBuffer(dAtA []byte) (int, error)
			(*RPC) ProtoMessage()
			(*RPC) Reset()
			(*RPC) Size() (n int)
			(*RPC) String() string
			(*RPC) Unmarshal(dAtA []byte) error
			(*RPC) XXX_DiscardUnknown()
			(*RPC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
			(*RPC) XXX_Merge(src proto.Message)
			(*RPC) XXX_Size() int
			(*RPC) XXX_Unmarshal(b []byte) error
		Implements (at least 10)
			*RPC : github.com/gogo/protobuf/proto.Marshaler
			*RPC : github.com/gogo/protobuf/proto.Message
			*RPC : github.com/gogo/protobuf/proto.Sizer
			*RPC : github.com/gogo/protobuf/proto.Unmarshaler
			*RPC : github.com/golang/protobuf/proto.Marshaler
			*RPC : github.com/golang/protobuf/proto.Unmarshaler
			*RPC : github.com/pion/rtcp.PacketStatusChunk
			*RPC : expvar.Var
			*RPC : fmt.Stringer
			*RPC : google.golang.org/protobuf/runtime/protoiface.MessageV1
		As Inputs Of (at least 7)
			func (*FloodSubRouter).HandleRPC(rpc *RPC)
			func (*GossipSubRouter).HandleRPC(rpc *RPC)
			func PubSubRouter.HandleRPC(*RPC)
			func (*RandomSubRouter).HandleRPC(rpc *RPC)
			func RawTracer.DropRPC(rpc *RPC, p peer.ID)
			func RawTracer.RecvRPC(rpc *RPC)
			func RawTracer.SendRPC(rpc *RPC, p peer.ID)

	 type SubOpt (func)

		As Outputs Of (at least one exported)
			func WithBufferSize(size int) SubOpt
		As Inputs Of (at least 2)
			func (*PubSub).Subscribe(topic string, opts ...SubOpt) (*Subscription, error)
			func (*Topic).Subscribe(opts ...SubOpt) (*Subscription, error)

	 type Subscription (struct)
		Subscription handles the details of a particular Topic subscription.
		There may be many subscriptions for a given Topic.

		Methods (total 3)
			(*Subscription) Cancel()
				Cancel closes the subscription. If this is the last active subscription then pubsub will send an unsubscribe
				announcement to the network.

			(*Subscription) Next(ctx context.Context) (*Message, error)
				Next returns the next message in our subscription

			(*Subscription) Topic() string
				Topic returns the topic string associated with the Subscription

		As Outputs Of (at least 2)
			func (*PubSub).Subscribe(topic string, opts ...SubOpt) (*Subscription, error)
			func (*Topic).Subscribe(opts ...SubOpt) (*Subscription, error)

	 type SubscriptionFilter (interface)
		SubscriptionFilter is a function that tells us whether we are interested in allowing and tracking
		subscriptions for a given topic.
		
		The filter is consulted whenever a subscription notification is received by another peer; if the
		filter returns false, then the notification is ignored.
		
		The filter is also consulted when joining topics; if the filter returns false, then the Join
		operation will result in an error.

		Methods (total 2)
			( SubscriptionFilter) CanSubscribe(topic string) bool
				CanSubscribe returns true if the topic is of interest and we can subscribe to it

			( SubscriptionFilter) FilterIncomingSubscriptions(peer.ID, []*pb.RPC_SubOpts) ([]*pb.RPC_SubOpts, error)
				FilterIncomingSubscriptions is invoked for all RPCs containing subscription notifications.
				It should filter only the subscriptions of interest and my return an error if (for instance)
				there are too many subscriptions.

		As Outputs Of (at least 3)
			func NewAllowlistSubscriptionFilter(topics ...string) SubscriptionFilter
			func NewRegexpSubscriptionFilter(rx *regexp.Regexp) SubscriptionFilter
			func WrapLimitSubscriptionFilter(filter SubscriptionFilter, limit int) SubscriptionFilter
		As Inputs Of (at least 2)
			func WithSubscriptionFilter(subFilter SubscriptionFilter) Option
			func WrapLimitSubscriptionFilter(filter SubscriptionFilter, limit int) SubscriptionFilter

	 type TimeCachedBlacklist (struct)
		TimeCachedBlacklist is a blacklist implementation using a time cache

		Methods (total 2)
			(*TimeCachedBlacklist) Add(p peer.ID) bool
				Add returns a bool saying whether Add of peer was successful

			(*TimeCachedBlacklist) Contains(p peer.ID) bool
		Implements (at least one exported)
			*TimeCachedBlacklist : Blacklist

	 type Topic (struct)
		Topic is the handle for a pubsub topic

		Methods (total 8)
			(*Topic) Close() error
				Close closes down the topic. Will return an error unless there are no active event handlers or subscriptions.
				Does not error if the topic is already closed.

			(*Topic) EventHandler(opts ...TopicEventHandlerOpt) (*TopicEventHandler, error)
				EventHandler creates a handle for topic specific events
				Multiple event handlers may be created and will operate independently of each other

			(*Topic) ListPeers() []peer.ID
				ListPeers returns a list of peers we are connected to in the given topic.

			(*Topic) Publish(ctx context.Context, data []byte, opts ...PubOpt) error
				Publish publishes data to topic.

			(*Topic) Relay() (RelayCancelFunc, error)
				Relay enables message relaying for the topic and returns a reference
				cancel function. Subsequent calls increase the reference counter.
				To completely disable the relay, all references must be cancelled.

			(*Topic) SetScoreParams(p *TopicScoreParams) error
				SetScoreParams sets the topic score parameters if the pubsub router supports peer
				scoring

			(*Topic) String() string
				String returns the topic associated with t

			(*Topic) Subscribe(opts ...SubOpt) (*Subscription, error)
				Subscribe returns a new Subscription for the topic.
				Note that subscription is not an instantaneous operation. It may take some time
				before the subscription is processed by the pubsub main loop and propagated to our peers.

		Implements (at least 4)
			*Topic : github.com/prometheus/common/expfmt.Closer
			*Topic : expvar.Var
			*Topic : fmt.Stringer
			*Topic : io.Closer
		As Outputs Of (at least one exported)
			func (*PubSub).Join(topic string, opts ...TopicOpt) (*Topic, error)

	 type TopicEventHandler (struct)
		TopicEventHandler is used to manage topic specific events. No Subscription is required to receive events.

		Methods (total 2)
			(*TopicEventHandler) Cancel()
				Cancel closes the topic event handler

			(*TopicEventHandler) NextPeerEvent(ctx context.Context) (PeerEvent, error)
				NextPeerEvent returns the next event regarding subscribed peers
				Guarantees: Peer Join and Peer Leave events for a given peer will fire in order.
				Unless a peer both Joins and Leaves before NextPeerEvent emits either event
				all events will eventually be received from NextPeerEvent.

		As Outputs Of (at least one exported)
			func (*Topic).EventHandler(opts ...TopicEventHandlerOpt) (*TopicEventHandler, error)

	 type TopicEventHandlerOpt (func)

		As Inputs Of (at least one exported)
			func (*Topic).EventHandler(opts ...TopicEventHandlerOpt) (*TopicEventHandler, error)

	 type TopicOpt (func)

		As Outputs Of (at least one exported)
			func WithTopicMessageIdFn(msgId MsgIdFunction) TopicOpt
		As Inputs Of (at least one exported)
			func (*PubSub).Join(topic string, opts ...TopicOpt) (*Topic, error)

	 type TopicOptions (struct)
	 type TopicScoreParams (struct)

		Fields (total 18)
			FirstMessageDeliveriesCap float64
			FirstMessageDeliveriesDecay float64
				P2: first message deliveries
				This is the number of message deliveries in the topic.
				The value of the parameter is a counter, decaying with FirstMessageDeliveriesDecay, and capped
				by FirstMessageDeliveriesCap.
				The weight of the parameter MUST be positive (or zero to disable).

			FirstMessageDeliveriesWeight float64
				P2: first message deliveries
				This is the number of message deliveries in the topic.
				The value of the parameter is a counter, decaying with FirstMessageDeliveriesDecay, and capped
				by FirstMessageDeliveriesCap.
				The weight of the parameter MUST be positive (or zero to disable).

			InvalidMessageDeliveriesDecay float64
				P4: invalid messages
				This is the number of invalid messages in the topic.
				The value of the parameter is the square of the counter, decaying with
				InvalidMessageDeliveriesDecay.
				The weight of the parameter MUST be negative (or zero to disable).

			InvalidMessageDeliveriesWeight float64
				P4: invalid messages
				This is the number of invalid messages in the topic.
				The value of the parameter is the square of the counter, decaying with
				InvalidMessageDeliveriesDecay.
				The weight of the parameter MUST be negative (or zero to disable).

			MeshFailurePenaltyDecay float64
				P3b: sticky mesh propagation failures
				This is a sticky penalty that applies when a peer gets pruned from the mesh with an active
				mesh message delivery penalty.
				The weight of the parameter MUST be negative (or zero to disable)

			MeshFailurePenaltyWeight float64
				P3b: sticky mesh propagation failures
				This is a sticky penalty that applies when a peer gets pruned from the mesh with an active
				mesh message delivery penalty.
				The weight of the parameter MUST be negative (or zero to disable)

			MeshMessageDeliveriesActivation time.Duration
			MeshMessageDeliveriesCap float64
			MeshMessageDeliveriesDecay float64
				P3: mesh message deliveries
				This is the number of message deliveries in the mesh, within the MeshMessageDeliveriesWindow of
				message validation; deliveries during validation also count and are retroactively applied
				when validation succeeds.
				This window accounts for the minimum time before a hostile mesh peer trying to game the score
				could replay back a valid message we just sent them.
				It effectively tracks first and near-first deliveries, i.e., a message seen from a mesh peer
				before we have forwarded it to them.
				The parameter has an associated counter, decaying with MeshMessageDeliveriesDecay.
				If the counter exceeds the threshold, its value is 0.
				If the counter is below the MeshMessageDeliveriesThreshold, the value is the square of
				the deficit, ie (MessageDeliveriesThreshold - counter)^2
				The penalty is only activated after MeshMessageDeliveriesActivation time in the mesh.
				The weight of the parameter MUST be negative (or zero to disable).

			MeshMessageDeliveriesThreshold float64
			MeshMessageDeliveriesWeight float64
				P3: mesh message deliveries
				This is the number of message deliveries in the mesh, within the MeshMessageDeliveriesWindow of
				message validation; deliveries during validation also count and are retroactively applied
				when validation succeeds.
				This window accounts for the minimum time before a hostile mesh peer trying to game the score
				could replay back a valid message we just sent them.
				It effectively tracks first and near-first deliveries, i.e., a message seen from a mesh peer
				before we have forwarded it to them.
				The parameter has an associated counter, decaying with MeshMessageDeliveriesDecay.
				If the counter exceeds the threshold, its value is 0.
				If the counter is below the MeshMessageDeliveriesThreshold, the value is the square of
				the deficit, ie (MessageDeliveriesThreshold - counter)^2
				The penalty is only activated after MeshMessageDeliveriesActivation time in the mesh.
				The weight of the parameter MUST be negative (or zero to disable).

			MeshMessageDeliveriesWindow time.Duration
			SkipAtomicValidation bool
				whether it is allowed to just set some params and not all of them.

			TimeInMeshCap float64
			TimeInMeshQuantum time.Duration
			TimeInMeshWeight float64
				P1: time in the mesh
				This is the time the peer has been grafted in the mesh.
				The value of the parameter is the time/TimeInMeshQuantum, capped by TimeInMeshCap.
				The weight of the parameter MUST be positive (or zero to disable).

			TopicWeight float64
				The weight of the topic.

		As Inputs Of (at least one exported)
			func (*Topic).SetScoreParams(p *TopicScoreParams) error

	 type TopicScoreSnapshot (struct)

		Fields (total 4)
			FirstMessageDeliveries float64
			InvalidMessageDeliveries float64
			MeshMessageDeliveries float64
			TimeInMesh time.Duration

	 type ValidationError (struct)
		ValidationError is an error that may be signalled from message publication when the message
		fails validation

		Fields (only one)
			Reason string
		Methods (only one)
			( ValidationError) Error() string
		Implements (at least one exported)
			 ValidationError : error

	 type ValidationResult int (basic type)
		ValidationResult represents the decision of an extended validator

		As Types Of (total 3)
			const ValidationAccept
			const ValidationIgnore
			const ValidationReject

	 type Validator (func)
		Validator is a function that validates a message with a binary decision: accept or reject.

	 type ValidatorEx (func)
		ValidatorEx is an extended validation function that validates a message with an enumerated decision

		As Outputs Of (at least one exported)
			func NewBasicSeqnoValidator(meta PeerMetadataStore) ValidatorEx

	 type ValidatorOpt (func)
		ValidatorOpt is an option for RegisterTopicValidator.

		As Outputs Of (at least 3)
			func WithValidatorConcurrency(n int) ValidatorOpt
			func WithValidatorInline(inline bool) ValidatorOpt
			func WithValidatorTimeout(timeout time.Duration) ValidatorOpt
		As Inputs Of (at least 2)
			func WithDefaultValidator(val interface{}, opts ...ValidatorOpt) Option
			func (*PubSub).RegisterTopicValidator(topic string, val interface{}, opts ...ValidatorOpt) error


Package-Level Functions (total 70)

	 func DefaultGossipSubParams() GossipSubParams
		DefaultGossipSubParams returns the default gossip sub parameters
		as a config.

	 func DefaultGossipSubRouter(h host.Host) *GossipSubRouter
		DefaultGossipSubRouter returns a new GossipSubRouter with default parameters.

	 func DefaultMsgIdFn(pmsg *pb.Message) string
		DefaultMsgIdFn returns a unique ID of the passed Message

	 func DefaultPeerFilter(pid peer.ID, topic string) bool
		DefaultPeerFilter accepts all peers on all topics

	 func DefaultPeerGaterParams() *PeerGaterParams
		DefaultPeerGaterParams creates a new PeerGaterParams struct using default values

	 func FilterSubscriptions(subs []*pb.RPC_SubOpts, filter func(string) bool) []*pb.RPC_SubOpts
		FilterSubscriptions filters (and deduplicates) a list of subscriptions.
		filter should return true if a topic is of interest.

	 func GossipSubDefaultFeatures(feat GossipSubFeature, proto protocol.ID) bool
		GossipSubDefaultFeatures is the feature test function for the default gossipsub protocols

	 func MinTopicSize(size int) RouterReady
		MinTopicSize returns a function that checks if a router is ready for publishing based on the topic size.
		The router ultimately decides the whether it is ready or not, the given size is just a suggestion. Note
		that the topic size does not include the router in the count.

	 func NewAllowlistSubscriptionFilter(topics ...string) SubscriptionFilter
		NewAllowlistSubscriptionFilter creates a subscription filter that only allows explicitly
		specified topics for local subscriptions and incoming peer subscriptions.

	 func NewBasicSeqnoValidator(meta PeerMetadataStore) ValidatorEx
		NewBasicSeqnoValidator constructs a BasicSeqnoValidator using the givven PeerMetadataStore.

	 func NewFloodSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error)
		NewFloodSub returns a new PubSub object using the FloodSubRouter.

	 func NewFloodsubWithProtocols(ctx context.Context, h host.Host, ps []protocol.ID, opts ...Option) (*PubSub, error)
		NewFloodsubWithProtocols returns a new floodsub-enabled PubSub objecting using the protocols specified in ps.

	 func NewGossipSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error)
		NewGossipSub returns a new PubSub object using the default GossipSubRouter as the router.

	 func NewGossipSubWithRouter(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)
		NewGossipSubWithRouter returns a new PubSub object using the given router.

	 func NewJSONTracer(file string) (*JSONTracer, error)
		NewJsonTracer creates a new JSONTracer writing traces to file.

	 func NewMapBlacklist() Blacklist
		NewMapBlacklist creates a new MapBlacklist

	 func NewMessageCache(gossip, history int) *MessageCache
		NewMessageCache creates a sliding window cache that remembers messages for as
		long as `history` slots.
		
		When queried for messages to advertise, the cache only returns messages in
		the last `gossip` slots.
		
		The `gossip` parameter must be smaller or equal to `history`, or this
		function will panic.
		
		The slack between `gossip` and `history` accounts for the reaction time
		between when a message is advertised via IHAVE gossip, and the peer pulls it
		via an IWANT command.

	 func NewPBTracer(file string) (*PBTracer, error)
	 func NewPeerGaterParams(threshold, globalDecay, sourceDecay float64) *PeerGaterParams
		NewPeerGaterParams creates a new PeerGaterParams struct, using the specified threshold and decay
		parameters and default values for all other parameters.

	 func NewPubSub(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error)
		NewPubSub returns a new PubSub management object.

	 func NewRandomSub(ctx context.Context, h host.Host, size int, opts ...Option) (*PubSub, error)
		NewRandomSub returns a new PubSub object using RandomSubRouter as the router.

	 func NewRegexpSubscriptionFilter(rx *regexp.Regexp) SubscriptionFilter
		NewRegexpSubscriptionFilter creates a subscription filter that only allows topics that
		match a regular expression for local subscriptions and incoming peer subscriptions.
		
		Warning: the user should take care to match start/end of string in the supplied regular
		expression, otherwise the filter might match unwanted topics unexpectedly.

	 func NewRemoteTracer(ctx context.Context, host host.Host, pi peer.AddrInfo) (*RemoteTracer, error)
		NewRemoteTracer constructs a RemoteTracer, tracing to the peer identified by pi

	 func NewTimeCachedBlacklist(expiry time.Duration) (Blacklist, error)
		NewTimeCachedBlacklist creates a new TimeCachedBlacklist with the given expiry duration

	 func OpenJSONTracer(file string, flags int, perm os.FileMode) (*JSONTracer, error)
		OpenJSONTracer creates a new JSONTracer, with explicit control of OpenFile flags and permissions.

	 func OpenPBTracer(file string, flags int, perm os.FileMode) (*PBTracer, error)
		OpenPBTracer creates a new PBTracer, with explicit control of OpenFile flags and permissions.

	 func ScoreParameterDecay(decay time.Duration) float64
		ScoreParameterDecay computes the decay factor for a parameter, assuming the DecayInterval is 1s
		and that the value decays to zero if it drops below 0.01

	 func ScoreParameterDecayWithBase(decay time.Duration, base time.Duration, decayToZero float64) float64
		ScoreParameterDecayWithBase computes the decay factor for a parameter using base as the DecayInterval

	 func WithAppSpecificRpcInspector(inspector func(peer.ID, *RPC) error) Option
		WithAppSpecificRpcInspector sets a hook that inspect incomings RPCs prior to
		processing them.  The inspector is invoked on an accepted RPC just before it
		is handled.  If inspector's error is nil, the RPC is handled. Otherwise, it
		is dropped.

	 func WithBlacklist(b Blacklist) Option
		WithBlacklist provides an implementation of the blacklist; the default is a
		MapBlacklist

	 func WithBufferSize(size int) SubOpt
		WithBufferSize is a Subscribe option to customize the size of the subscribe output buffer.
		The default length is 32 but it can be configured to avoid dropping messages if the consumer is not reading fast
		enough.

	 func WithDefaultValidator(val interface{}, opts ...ValidatorOpt) Option
		/ Options
		WithDefaultValidator adds a validator that applies to all topics by default; it can be used
		more than once and add multiple validators. Having a defult validator does not inhibit registering
		a per topic validator.

	 func WithDirectConnectTicks(t uint64) Option
		WithDirectConnectTicks is a gossipsub router option that sets the number of
		heartbeat ticks between attempting to reconnect direct peers that are not
		currently connected. A "tick" is based on the heartbeat interval, which is
		1s by default. The default value for direct connect ticks is 300.

	 func WithDirectPeers(pis []peer.AddrInfo) Option
		WithDirectPeers is a gossipsub router option that specifies peers with direct
		peering agreements. These peers are connected outside of the mesh, with all (valid)
		message unconditionally forwarded to them. The router will maintain open connections
		to these peers. Note that the peering agreement should be reciprocal with direct peers
		symmetrically configured at both ends.

	 func WithDiscoverConnector(connFactory BackoffConnectorFactory) DiscoverOpt
		WithDiscoverConnector adds a custom connector that deals with how the discovery subsystem connects to peers

	 func WithDiscovery(d discovery.Discovery, opts ...DiscoverOpt) Option
		WithDiscovery provides a discovery mechanism used to bootstrap and provide peers into PubSub

	 func WithDiscoveryOpts(opts ...discovery.Option) DiscoverOpt
		WithDiscoveryOpts passes libp2p Discovery options into the PubSub discovery subsystem

	 func WithEventTracer(tracer EventTracer) Option
		WithEventTracer provides a tracer for the pubsub system

	 func WithFloodPublish(floodPublish bool) Option
		WithFloodPublish is a gossipsub router option that enables flood publishing.
		When this is enabled, published messages are forwarded to all peers with score >=
		to publishThreshold

	 func WithGossipSubParams(cfg GossipSubParams) Option
		WithGossipSubParams is a gossip sub router option that allows a custom
		config to be set when instantiating the gossipsub router.

	 func WithGossipSubProtocols(protos []protocol.ID, feature GossipSubFeatureTest) Option
		WithGossipSubProtocols is a gossipsub router option that configures a custom protocol list
		and feature test function

	 func WithLocalPublication(local bool) PubOpt
		WithLocalPublication returns a publishing option to notify in-process subscribers only.
		It prevents message publication to mesh peers.
		Useful in edge cases where the msg needs to be only delivered to the in-process subscribers,
		e.g. not to spam the network with outdated msgs.
		Should not be used specifically for in-process pubsubing.

	 func WithMaxMessageSize(maxMessageSize int) Option
		WithMaxMessageSize sets the global maximum message size for pubsub wire
		messages. The default value is 1MiB (DefaultMaxMessageSize).
		
		Observe the following warnings when setting this option.
		
		WARNING #1: Make sure to change the default protocol prefixes for floodsub
		(FloodSubID) and gossipsub (GossipSubID). This avoids accidentally joining
		the public default network, which uses the default max message size, and
		therefore will cause messages to be dropped.
		
		WARNING #2: Reducing the default max message limit is fine, if you are
		certain that your application messages will not exceed the new limit.
		However, be wary of increasing the limit, as pubsub networks are naturally
		write-amplifying, i.e. for every message we receive, we send D copies of the
		message to our peers. If those messages are large, the bandwidth requirements
		will grow linearly. Note that propagation is sent on the uplink, which
		traditionally is more constrained than the downlink. Instead, consider
		out-of-band retrieval for large messages, by sending a CID (Content-ID) or
		another type of locator, such that messages can be fetched on-demand, rather
		than being pushed proactively. Under this design, you'd use the pubsub layer
		as a signalling system, rather than a data delivery system.

	 func WithMessageAuthor(author peer.ID) Option
		WithMessageAuthor sets the author for outbound messages to the given peer ID
		(defaults to the host's ID). If message signing is enabled, the private key
		must be available in the host's peerstore.

	 func WithMessageIdFn(fn MsgIdFunction) Option
		WithMessageIdFn is an option to customize the way a message ID is computed for a pubsub message.
		The default ID function is DefaultMsgIdFn (concatenate source and seq nr.),
		but it can be customized to e.g. the hash of the message.

	 func WithMessageSignaturePolicy(policy MessageSignaturePolicy) Option
		WithMessageSignaturePolicy sets the mode of operation for producing and verifying message signatures.

	 func WithMessageSigning(enabled bool) Option
		WithMessageSigning enables or disables message signing (enabled by default).
		Deprecated: signature verification without message signing,
		or message signing without verification, are not recommended.

	 func WithNoAuthor() Option
		WithNoAuthor omits the author and seq-number data of messages, and disables the use of signatures.
		Not recommended to use with the default message ID function, see WithMessageIdFn.

	 func WithPeerExchange(doPX bool) Option
		WithPeerExchange is a gossipsub router option that enables Peer eXchange on PRUNE.
		This should generally be enabled in bootstrappers and well connected/trusted nodes
		used for bootstrapping.

	 func WithPeerFilter(filter PeerFilter) Option
		WithPeerFilter is an option to set a filter for pubsub peers.
		The default peer filter is DefaultPeerFilter (which always returns true), but it can be customized
		to any custom implementation.

	 func WithPeerGater(params *PeerGaterParams) Option
		WithPeerGater is a gossipsub router option that enables reactive validation queue
		management.
		The Gater is activated if the ratio of throttled/validated messages exceeds the specified
		threshold.
		Once active, the Gater probabilistically throttles peers _before_ they enter the validation
		queue, performing Random Early Drop.
		The throttle decision is randomized, with the probability of allowing messages to enter the
		validation queue controlled by the statistical observations of the performance of all peers
		in the IP address of the gated peer.
		The Gater deactivates if there is no validation throttlinc occurring for the specified quiet
		interval.

	 func WithPeerOutboundQueueSize(size int) Option
		WithPeerOutboundQueueSize is an option to set the buffer size for outbound messages to a peer
		We start dropping messages to a peer if the outbound queue if full

	 func WithPeerScore(params *PeerScoreParams, thresholds *PeerScoreThresholds) Option
		WithPeerScore is a gossipsub router option that enables peer scoring.

	 func WithPeerScoreInspect(inspect interface{}, period time.Duration) Option
		WithPeerScoreInspect is a gossipsub router option that enables peer score debugging.
		When this option is enabled, the supplied function will be invoked periodically to allow
		the application to inspect or dump the scores for connected peers.
		The supplied function can have one of two signatures:
		  - PeerScoreInspectFn, which takes a map of peer IDs to score.
		  - ExtendedPeerScoreInspectFn, which takes a map of peer IDs to
		    PeerScoreSnapshots and allows inspection of individual score
		    components for debugging peer scoring.
		
		This option must be passed _after_ the WithPeerScore option.

	 func WithProtocolMatchFn(m ProtocolMatchFn) Option
		WithProtocolMatchFn sets a custom matching function for protocol selection to
		be used by the protocol handler on the Host's Mux. Should be combined with
		WithGossipSubProtocols feature function for checking if certain protocol features
		are supported

	 func WithRawTracer(tracer RawTracer) Option
		WithRawTracer adds a raw tracer to the pubsub system.
		Multiple tracers can be added using multiple invocations of the option.

	 func WithReadiness(ready RouterReady) PubOpt
		WithReadiness returns a publishing option for only publishing when the router is ready.
		This option is not useful unless PubSub is also using WithDiscovery

	 func WithSecretKeyAndPeerId(key crypto.PrivKey, pid peer.ID) PubOpt
		WithSecretKeyAndPeerId returns a publishing option for providing a custom private key and its corresponding peer ID
		This option is useful when we want to send messages from "virtual", never-connectable peers in the network

	 func WithSeenMessagesStrategy(strategy timecache.Strategy) Option
		WithSeenMessagesStrategy configures which type of lookup/cleanup strategy is used by the seen messages cache

	 func WithSeenMessagesTTL(ttl time.Duration) Option
		WithSeenMessagesTTL configures when a previously seen message ID can be forgotten about

	 func WithStrictSignatureVerification(required bool) Option
		WithStrictSignatureVerification is an option to enable or disable strict message signing.
		When enabled (which is the default), unsigned messages will be discarded.
		Deprecated: signature verification without message signing,
		or message signing without verification, are not recommended.

	 func WithSubscriptionFilter(subFilter SubscriptionFilter) Option
		WithSubscriptionFilter is a pubsub option that specifies a filter for subscriptions
		in topics of interest.

	 func WithTopicMessageIdFn(msgId MsgIdFunction) TopicOpt
		WithTopicMessageIdFn sets custom MsgIdFunction for a Topic, enabling topics to have own msg id generation rules.

	 func WithValidateQueueSize(n int) Option
		WithValidateQueueSize sets the buffer of validate queue. Defaults to 32.
		When queue is full, validation is throttled and new messages are dropped.

	 func WithValidateThrottle(n int) Option
		WithValidateThrottle sets the upper bound on the number of active validation
		goroutines across all topics. The default is 8192.

	 func WithValidateWorkers(n int) Option
		WithValidateWorkers sets the number of synchronous validation worker goroutines.
		Defaults to NumCPU.
		
		The synchronous validation workers perform signature validation, apply inline
		user validators, and schedule asynchronous user validators.
		You can adjust this parameter to devote less cpu time to synchronous validation.

	 func WithValidatorConcurrency(n int) ValidatorOpt
		WithValidatorConcurrency is an option that sets the topic validator throttle.
		This controls the number of active validation goroutines for the topic; the default is 1024.

	 func WithValidatorInline(inline bool) ValidatorOpt
		WithValidatorInline is an option that sets the validation disposition to synchronous:
		it will be executed inline in validation front-end, without spawning a new goroutine.
		This is suitable for simple or cpu-bound validators that do not block.

	 func WithValidatorTimeout(timeout time.Duration) ValidatorOpt
		WithValidatorTimeout is an option that sets a timeout for an (asynchronous) topic validator.
		By default there is no timeout in asynchronous validators.

	 func WrapLimitSubscriptionFilter(filter SubscriptionFilter, limit int) SubscriptionFilter
		WrapLimitSubscriptionFilter wraps a subscription filter with a hard limit in the number of
		subscriptions allowed in an RPC message.


Package-Level Variables (total 60)

	  var DefaultPeerGaterDuplicateWeight float64
	  var DefaultPeerGaterGlobalDecay float64
	  var DefaultPeerGaterIgnoreWeight float64
	  var DefaultPeerGaterQuiet time.Duration
	  var DefaultPeerGaterRejectWeight float64
	  var DefaultPeerGaterRetainStats time.Duration
	  var DefaultPeerGaterSourceDecay float64
	  var DefaultPeerGaterThreshold float64
	  var DiscoveryPollInitialDelay time.Duration
		DiscoveryPollInitialDelay is how long the discovery system waits after it first starts before polling

	  var DiscoveryPollInterval time.Duration
		DiscoveryPollInterval is approximately how long the discovery system waits in between checks for whether the
		more peers are needed for any topic

	  var ErrEmptyPeerID error
		ErrEmptyPeerID is returned if an empty peer ID was provided

	  var ErrNilSignKey error
		ErrNilSignKey is returned if a nil private key was provided

	  var ErrQueueCancelled error
	  var ErrQueueClosed error
	  var ErrQueueFull error
	  var ErrQueuePushOnClosed error
	  var ErrSubscriptionCancelled error
		ErrSubscriptionCancelled may be returned when a subscription Next() is called after the
		subscription has been cancelled.

	  var ErrTooManySubscriptions error
		ErrTooManySubscriptions may be returned by a SubscriptionFilter to signal that there are too many
		subscriptions to process.

	  var ErrTopicClosed error
		ErrTopicClosed is returned if a Topic is utilized after it has been closed

	  var GossipSubConnectionTimeout time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubConnectors int
		Defines the default gossipsub parameters.

	  var GossipSubConnTagBumpMessageDelivery int
		GossipSubConnTagBumpMessageDelivery is the amount to add to the connection manager
		tag that tracks message deliveries. Each time a peer is the first to deliver a
		message within a topic, we "bump" a tag by this amount, up to a maximum
		of GossipSubConnTagMessageDeliveryCap.
		Note that the delivery tags decay over time, decreasing by GossipSubConnTagDecayAmount
		at every GossipSubConnTagDecayInterval.

	  var GossipSubConnTagDecayAmount int
		GossipSubConnTagDecayAmount is subtracted from decaying tag values at each decay interval.

	  var GossipSubConnTagDecayInterval time.Duration
		GossipSubConnTagDecayInterval is the decay interval for decaying connection manager tags.

	  var GossipSubConnTagMessageDeliveryCap int
		GossipSubConnTagMessageDeliveryCap is the maximum value for the connection manager tags that
		track message deliveries.

	  var GossipSubD int
		Defines the default gossipsub parameters.

	  var GossipSubDefaultProtocols []protocol.ID
		GossipSubDefaultProtocols is the default gossipsub router protocol list

	  var GossipSubDhi int
		Defines the default gossipsub parameters.

	  var GossipSubDirectConnectInitialDelay time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubDirectConnectTicks uint64
		Defines the default gossipsub parameters.

	  var GossipSubDlazy int
		Defines the default gossipsub parameters.

	  var GossipSubDlo int
		Defines the default gossipsub parameters.

	  var GossipSubDout int
		Defines the default gossipsub parameters.

	  var GossipSubDscore int
		Defines the default gossipsub parameters.

	  var GossipSubFanoutTTL time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubGossipFactor float64
		Defines the default gossipsub parameters.

	  var GossipSubGossipRetransmission int
		Defines the default gossipsub parameters.

	  var GossipSubGraftFloodThreshold time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubHeartbeatInitialDelay time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubHeartbeatInterval time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubHistoryGossip int
		Defines the default gossipsub parameters.

	  var GossipSubHistoryLength int
		Defines the default gossipsub parameters.

	  var GossipSubIDontWantMessageThreshold int // 1KB
		Defines the default gossipsub parameters.

	  var GossipSubIDontWantMessageTTL int // 3 heartbeats
		Defines the default gossipsub parameters.

	  var GossipSubIWantFollowupTime time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubMaxIDontWantLength int
		Defines the default gossipsub parameters.

	  var GossipSubMaxIDontWantMessages int
		Defines the default gossipsub parameters.

	  var GossipSubMaxIHaveLength int
		Defines the default gossipsub parameters.

	  var GossipSubMaxIHaveMessages int
		Defines the default gossipsub parameters.

	  var GossipSubMaxPendingConnections int
		Defines the default gossipsub parameters.

	  var GossipSubOpportunisticGraftPeers int
		Defines the default gossipsub parameters.

	  var GossipSubOpportunisticGraftTicks uint64
		Defines the default gossipsub parameters.

	  var GossipSubPruneBackoff time.Duration
		Defines the default gossipsub parameters.

	  var GossipSubPrunePeers int
		Defines the default gossipsub parameters.

	  var GossipSubUnsubscribeBackoff time.Duration
		Defines the default gossipsub parameters.

	  var MinTraceBatchSize int
	  var RandomSubD int
	  var TimeCacheDuration time.Duration
		TimeCacheDuration specifies how long a message ID will be remembered as seen.
		Use WithSeenMessagesTTL to configure this per pubsub instance, instead of overriding the global default.

	  var TimeCacheStrategy timecache.Strategy
		TimeCacheStrategy specifies which type of lookup/cleanup strategy is used by the seen messages cache.
		Use WithSeenMessagesStrategy to configure this per pubsub instance, instead of overriding the global default.

	  var TraceBufferSize int // 64K ought to be enough for everyone; famous last words.
Package-Level Constants (total 44)

	const AcceptAll AcceptStatus = 2
		AcceptAll signals to accept the incoming RPC for full processing

	const AcceptControl AcceptStatus = 1
		AcceptControl signals to accept the incoming RPC only for control message processing by
		the router. Included payload messages will _not_ be pushed to the validation queue.

	const AcceptNone AcceptStatus = 0
		AcceptNone signals to drop the incoming RPC

	const BackoffCleanupInterval time.Duration = 60000000000
	const BackoffMultiplier = 2
	const DefaultDecayInterval time.Duration = 1000000000
	const DefaultDecayToZero = 0.01
	const DefaultMaxMessageSize = 1048576
		DefaultMaximumMessageSize is 1mb.

	const FloodSubID protocol.ID = "/floodsub/1.0.0"
	const FloodSubTopicSearchSize = 5
	const GossipSubFeatureIdontwant = 2
		Protocol supports IDONTWANT -- gossipsub-v1.2 compatible

	const GossipSubFeatureMesh = 0
		Protocol supports basic GossipSub Mesh -- gossipsub-v1.0 compatible

	const GossipSubFeaturePX = 1
		Protocol supports Peer eXchange on prune -- gossipsub-v1.1 compatible

	const GossipSubID_v10 protocol.ID = "/meshsub/1.0.0"
		GossipSubID_v10 is the protocol ID for version 1.0.0 of the GossipSub protocol.
		It is advertised along with GossipSubID_v11 and GossipSubID_v12 for backwards compatibility.

	const GossipSubID_v11 protocol.ID = "/meshsub/1.1.0"
		GossipSubID_v11 is the protocol ID for version 1.1.0 of the GossipSub protocol.
		It is advertised along with GossipSubID_v12 for backwards compatibility.
		See the spec for details about how v1.1.0 compares to v1.0.0:
		https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.1.md

	const GossipSubID_v12 protocol.ID = "/meshsub/1.2.0"
		GossipSubID_v12 is the protocol ID for version 1.2.0 of the GossipSub protocol.
		See the spec for details about how v1.2.0 compares to v1.1.0:
		https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/gossipsub-v1.2.md

	const LaxNoSign = 0
		LaxNoSign does not produce signatures and validates incoming signatures iff one is present
		Deprecated: it is recommend to either strictly enable, or strictly disable, signatures.

	const LaxSign MessageSignaturePolicy = 1
		LaxSign produces signatures and validates incoming signatures iff one is present
		Deprecated: it is recommend to either strictly enable, or strictly disable, signatures.

	const MaxBackoffAttempts = 4
	const MaxBackoffDelay time.Duration = 10000000000
	const MaxBackoffJitterCoff = 100
	const MinBackoffDelay time.Duration = 100000000
	const PeerJoin EventType = 0
	const PeerLeave EventType = 1
	const RandomSubID protocol.ID = "/randomsub/1.0.0"
	const RejectBlacklistedSource = "blacklisted source"
		rejection reasons

	const RejectBlacklstedPeer = "blacklisted peer"
		rejection reasons

	const RejectInvalidSignature = "invalid signature"
		rejection reasons

	const RejectMissingSignature = "missing signature"
		rejection reasons

	const RejectSelfOrigin = "self originated message"
		rejection reasons

	const RejectUnexpectedAuthInfo = "unexpected auth info"
		rejection reasons

	const RejectUnexpectedSignature = "unexpected signature"
		rejection reasons

	const RejectValidationFailed = "validation failed"
		rejection reasons

	const RejectValidationIgnored = "validation ignored"
		rejection reasons

	const RejectValidationQueueFull = "validation queue full"
		rejection reasons

	const RejectValidationThrottled = "validation throttled"
		rejection reasons

	const RemoteTracerProtoID protocol.ID = "/libp2p/pubsub/tracer/1.0.0"
	const SignPrefix = "libp2p-pubsub:"
	const StrictNoSign MessageSignaturePolicy = 2
		StrictNoSign does not produce signatures and drops and penalises incoming messages that carry one

	const StrictSign MessageSignaturePolicy = 3
		StrictSign produces signatures and expects and verifies incoming signatures

	const TimeToLive time.Duration = 600000000000
	const ValidationAccept ValidationResult = 0
		ValidationAccept is a validation decision that indicates a valid message that should be accepted and
		delivered to the application and forwarded to the network.

	const ValidationIgnore ValidationResult = 2
		ValidationIgnore is a validation decision that indicates a message that should be ignored: it will
		be neither delivered to the application nor forwarded to the network. However, in contrast to
		ValidationReject, the peer that forwarded the message must not be penalized by peer scoring routers.

	const ValidationReject ValidationResult = 1
		ValidationReject is a validation decision that indicates an invalid message that should not be
		delivered to the application or forwarded to the application. Furthermore the peer that forwarded
		the message should be penalized by peer scoring routers.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.