networking

type BinaryNetworkEndpointLimits struct {
	MaxMessageLength          int
	MessagesRatePerOracle     float64
	MessagesCapacityPerOracle int
	BytesRatePerOracle        float64
	BytesCapacityPerOracle    int
}

type EndpointConfigV2 struct {
	// IncomingMessageBufferSize is the per-remote number of incoming
	// messages to buffer. Any additional messages received on top of those
	// already in the queue will be dropped.
	IncomingMessageBufferSize int

	// OutgoingMessageBufferSize is the per-remote number of outgoing
	// messages to buffer. Any additional messages send on top of those
	// already in the queue will displace the oldest.
	// NOTE: OutgoingMessageBufferSize should be comfortably smaller than remote's
	// IncomingMessageBufferSize to give the remote enough space to process
	// them all in case we regained connection and now send a bunch at once
	OutgoingMessageBufferSize int
}

type NewStreamArgs interface {
	// contains filtered or unexported methods
}

type NewStreamArgs1 struct {
	StreamName         string
	OutgoingBufferSize int // number of messages that fit in the outgoing buffer
	IncomingBufferSize int // number of messages that fit in the incoming buffer
	MaxMessageLength   int
	MessagesLimit      ragetypes.TokenBucketParams // rate limit for incoming messages
	BytesLimit         ragetypes.TokenBucketParams // rate limit for incoming messages
}

type PeerConfig struct {
	// Exactly one of PrivKey (deprecated) or PeerKeyring must be provided.
	//
	// Deprecated: Use PeerKeyring instead. This field is maintained for
	// backwards compatibility and will be removed in a future release.
	PrivKey ed25519.PrivateKey
	// Exactly one of PrivKey (deprecated) or PeerKeyring must be provided.
	PeerKeyring ragetypes.PeerKeyring

	Logger commontypes.Logger

	// V2ListenAddresses contains the addresses the peer will listen to on the network in <ip>:<port> form as
	// accepted by net.Listen.
	V2ListenAddresses []string

	// V2AnnounceAddresses contains the addresses the peer will advertise on the network in <ip>:<port> form as
	// accepted by net.Dial. The addresses should be reachable by peers of interest.
	// May be left unspecified, in which case the announce addresses are auto-detected based on V2ListenAddresses.
	V2AnnounceAddresses []string

	// Every V2DeltaReconcile a Reconcile message is sent to every peer.
	V2DeltaReconcile time.Duration

	// Dial attempts will be at least V2DeltaDial apart.
	V2DeltaDial time.Duration

	V2DiscovererDatabase nettypes.DiscovererDatabase

	V2EndpointConfig EndpointConfigV2

	MetricsRegisterer prometheus.Registerer

	LatencyMetricsServiceConfigs []*rageping.LatencyMetricsServiceConfig

	// Set this to DangerDangerEnableExperimentalRageP2P to use the experimental ragep2p stack.
	// If set to any other value, the default production ragep2p stack is used.
	// Note that the experimental ragep2p stack is not yet ready for production use, but should
	// in principle be backwards compatible with the current ragep2p stack.
	EnableExperimentalRageP2P string
}

type PeerGroup interface {
	// See ragep2p.Host NewStream for details on the parameters. The stream will
	// be automatically closed upon closure of the peer group. The
	// streamName must be prefixed as dictated by the config digest prefix used
	// in NewPeerGroup.
	NewStream(remotePeerID string, newStreamArgs NewStreamArgs) (Stream, error)

	// Close closes all opened streams, and stops peer discovery for the group.
	// Future calls to NewStream will error.
	Close() error
}

type PeerGroupFactory interface {
	// This call is necessary for peer discovery to work among the group
	// configured in the parameters. Once the peer group is closed, peer
	// discovery will cease, and all streams created under the peer group
	// will be automatically closed. For pure bootstrapping, it is expected to
	// invoke NewPeerGroup and never create any streams using NewStream.
	NewPeerGroup(
		configDigest ocr2types.ConfigDigest,
		peerIDs []string,
		bootstrappers []commontypes.BootstrapperLocator,
	) (PeerGroup, error)
}

type Stream interface {
	SendMessage(data []byte)
	ReceiveMessages() <-chan []byte
	Close() error
}