protocol

type Config struct {
	// Worker pools
	Workers         int // CPU cores * 2 by default
	PriorityWorkers int // 4 by default

	// Channels
	BufferSize     int // 10000 by default
	PriorityBuffer int // 1000 by default

	// Timeouts
	MessageTimeout  time.Duration // 30s by default
	RoundTimeout    time.Duration // 60s by default
	ProtocolTimeout time.Duration // 5m by default

	// Performance
	EnableBatching       bool          // true by default
	BatchSize            int           // 100 by default
	BatchTimeout         time.Duration // 10ms by default
	EnableCompression    bool          // true for large messages
	CompressionThreshold int           // 1KB by default

	// Memory
	EnablePooling  bool // true by default
	MaxMessageSize int  // 10MB by default

	// Reliability
	RetryAttempts int           // 3 by default
	RetryBackoff  time.Duration // 1s by default
}

type Context = context.Context

type Error struct {
	// Culprit is empty if the identity of the misbehaving party cannot be known.
	Culprits []party.ID
	// Err is the underlying error.
	Err error
}

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

type KeyID struct {
	// ProtocolID identifies the protocol (e.g., "cmp/keygen", "frost/keygen")
	ProtocolID string
	// Group is the elliptic curve group being used
	Group curve.Curve
	// PublicKey is the shared public key (if available)
	PublicKey curve.Point
	// PartyIDs is the canonical ordered list of all parties
	PartyIDs []party.ID
	// Threshold is the threshold parameter
	Threshold int
	// Generation is an optional generation counter for key refresh
	Generation uint32
}

type Message struct {
	// SSID is a byte string which uniquely identifies the session this message belongs to.
	SSID []byte
	// From is the party.ID of the sender
	From party.ID
	// To is the intended recipient for this message. If To == "", then the message should be sent to all.
	To party.ID
	// Protocol identifies the protocol this message belongs to
	Protocol string
	// RoundNumber is the index of the round this message belongs to
	RoundNumber round.Number
	// Data is the actual content consumed by the round.
	Data []byte
	// Broadcast indicates whether this message should be reliably broadcast to all participants.
	Broadcast bool
	// BroadcastVerification is the hash of all messages broadcast by the parties,
	// and is included in all messages in the round following a broadcast round.
	BroadcastVerification []byte
	// Compressed indicates whether the Data field is compressed
	Compressed bool
}

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

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

type MultiHandler = Handler

type ProtocolAdapter[C ThresholdConfig] struct {
	// contains filtered or unexported fields
}

type ReshareableProtocol interface {
	ThresholdProtocol

	// Reshare changes the participant set
	Reshare(config ThresholdConfig, newParticipants []party.ID, newThreshold int) (StartFunc, error)

	// AddParties adds new participants
	AddParties(config ThresholdConfig, newParties []party.ID) (StartFunc, error)

	// RemoveParties removes participants
	RemoveParties(config ThresholdConfig, partiesToRemove []party.ID) (StartFunc, error)
}

type SessionInfo struct {
	SessionID []byte
	SelfID    party.ID
	PartyIDs  []party.ID
	Threshold int
	Group     curve.Curve
	Protocol  string // "cmp", "frost", "lss", etc.
}

type SignatureScheme int

type StartFunc func(sessionID []byte) (round.Session, error)

type ThresholdConfig interface {
	// Core identity and parameters
	GetID() party.ID
	GetThreshold() int
	GetGroup() curve.Curve

	// Key material
	GetPrivateShare() curve.Scalar
	GetPublicKey() (curve.Point, error)
	GetPublicShare(id party.ID) (curve.Point, error)

	// Protocol-specific data
	GetChainKey() []byte
	GetRID() []byte

	// Validation
	Validate() error
	IsCompatible(other ThresholdConfig) bool
}

type ThresholdProtocol interface {
	// Keygen creates a new distributed key
	Keygen(group curve.Curve, selfID party.ID, participants []party.ID, threshold int) (StartFunc, error)

	// Sign creates a signature with the given signers
	Sign(config ThresholdConfig, signers []party.ID, message []byte) (StartFunc, error)

	// Refresh updates shares without changing the key
	Refresh(config ThresholdConfig) (StartFunc, error)

	// GetScheme returns the signature scheme this protocol implements
	GetScheme() SignatureScheme

	// SupportsResharing indicates if the protocol supports dynamic resharing
	SupportsResharing() bool
}

type ThresholdSigner[S any] interface {
	// Sign produces a signature of type S
	Sign(config ThresholdConfig, signers []party.ID, message []byte) (S, error)

	// Verify checks if a signature is valid
	Verify(signature S, publicKey curve.Point, message []byte) bool
}

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