threshold

type Aggregator interface {
	// Aggregate combines signature shares into a final signature.
	// For non-interactive schemes (BLS), this combines shares directly.
	// For interactive schemes, commitments from all signers may be required.
	Aggregate(ctx context.Context, message []byte, shares []SignatureShare, commitments []NonceCommitment) (Signature, error)

	// VerifyShare verifies a single signature share before aggregation.
	// Returns nil if the share is valid.
	VerifyShare(message []byte, share SignatureShare, publicShare []byte) error

	// GroupKey returns the group public key for this aggregator.
	GroupKey() PublicKey
}

type DKG interface {
	// Round1 generates the first round message to broadcast.
	// Returns the message to send to all other parties.
	Round1(ctx context.Context) (DKGMessage, error)

	// Round2 processes Round1 messages and generates Round2 messages.
	// The input map is keyed by party index.
	Round2(ctx context.Context, round1Messages map[int]DKGMessage) (DKGMessage, error)

	// Round3 processes Round2 messages and generates the final key share.
	// Some schemes may not require Round3; they return the key share from Round2.
	Round3(ctx context.Context, round2Messages map[int]DKGMessage) (KeyShare, error)

	// NumRounds returns the number of rounds required for this DKG protocol.
	NumRounds() int

	// GroupKey returns the group public key after DKG completes.
	// Returns nil if DKG has not completed.
	GroupKey() PublicKey
}

type DKGConfig struct {
	// Threshold is the minimum number of parties required to sign (t).
	// A valid signature requires at least Threshold+1 shares.
	Threshold int

	// TotalParties is the total number of parties (n).
	TotalParties int

	// PartyIndex is this party's index (0 to TotalParties-1).
	PartyIndex int

	// PartyID is an optional identifier for this party.
	PartyID []byte

	// Randomness source (defaults to crypto/rand if nil).
	Rand io.Reader
}

type DKGMessage interface {
	// Round returns which round this message belongs to.
	Round() int

	// FromParty returns the index of the party that created this message.
	FromParty() int

	// Bytes serializes the message for transmission.
	Bytes() []byte
}

type DealerConfig struct {
	// Threshold is the minimum number of parties required to sign.
	Threshold int

	// TotalParties is the total number of parties.
	TotalParties int

	// Randomness source (defaults to crypto/rand if nil).
	Rand io.Reader
}

type IdentifiableAbortError struct {
	// PartyIndex is the index of the misbehaving party.
	PartyIndex int

	// Round is the protocol round where misbehavior was detected.
	Round int

	// Reason describes the misbehavior.
	Reason string

	// Proof contains cryptographic proof of misbehavior (scheme-specific).
	Proof []byte
}

type KeyRefresh interface {
	// Round1 generates the first round of key refresh messages.
	Round1(ctx context.Context) (DKGMessage, error)

	// Round2 processes Round1 messages and generates new shares.
	Round2(ctx context.Context, round1Messages map[int]DKGMessage) (KeyShare, error)
}

type KeyShare interface {
	// Index returns the party index for this share.
	Index() int

	// GroupKey returns the group public key.
	GroupKey() PublicKey

	// PublicShare returns this party's public key share.
	// This can be used for share verification.
	PublicShare() []byte

	// Threshold returns the signing threshold.
	Threshold() int

	// TotalParties returns the total number of parties.
	TotalParties() int

	// Bytes serializes the key share.
	Bytes() []byte

	// SchemeID returns the scheme this share belongs to.
	SchemeID() SchemeID
}

type NonceCommitment interface {
	// Bytes serializes the commitment.
	Bytes() []byte

	// FromParty returns the index of the party that created this commitment.
	FromParty() int
}

type NonceState interface {
	// Bytes serializes the nonce state (for secure storage).
	Bytes() []byte

	// FromParty returns the index of the party that owns this nonce.
	FromParty() int
}

type PublicKey interface {
	// Bytes serializes the public key.
	Bytes() []byte

	// Equal returns true if the public keys are identical.
	Equal(other PublicKey) bool

	// SchemeID returns the scheme this key belongs to.
	SchemeID() SchemeID
}

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

type Resharing interface {
	// GenerateReshareMessages creates messages for resharing to new parties.
	GenerateReshareMessages(ctx context.Context, newThreshold, newTotal int) ([]DKGMessage, error)

	// ProcessReshareMessages processes reshare messages to create a new share.
	ProcessReshareMessages(ctx context.Context, messages []DKGMessage) (KeyShare, error)
}

type Scheme interface {
	// ID returns the unique identifier for this scheme.
	ID() SchemeID

	// Name returns a human-readable name for the scheme.
	Name() string

	// KeyShareSize returns the serialized size of a key share in bytes.
	KeyShareSize() int

	// SignatureShareSize returns the serialized size of a signature share in bytes.
	SignatureShareSize() int

	// SignatureSize returns the serialized size of the final signature in bytes.
	SignatureSize() int

	// PublicKeySize returns the serialized size of the group public key in bytes.
	PublicKeySize() int

	// NewDKG creates a new distributed key generation instance.
	NewDKG(config DKGConfig) (DKG, error)

	// NewTrustedDealer creates a trusted dealer for centralized key generation.
	// Returns an error if the scheme doesn't support trusted dealer setup.
	NewTrustedDealer(config DealerConfig) (TrustedDealer, error)

	// NewSigner creates a signer from a key share.
	NewSigner(share KeyShare) (Signer, error)

	// NewAggregator creates a signature aggregator for the given group key.
	NewAggregator(groupKey PublicKey) (Aggregator, error)

	// NewVerifier creates a signature verifier for the given group key.
	NewVerifier(groupKey PublicKey) (Verifier, error)

	// ParseKeyShare deserializes a key share from bytes.
	ParseKeyShare(data []byte) (KeyShare, error)

	// ParsePublicKey deserializes a group public key from bytes.
	ParsePublicKey(data []byte) (PublicKey, error)

	// ParseSignatureShare deserializes a signature share from bytes.
	ParseSignatureShare(data []byte) (SignatureShare, error)

	// ParseSignature deserializes a final signature from bytes.
	ParseSignature(data []byte) (Signature, error)
}

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

type SchemeID uint8

type SchemeInfo struct {
	ID             SchemeID
	Name           string
	Description    string
	PostQuantum    bool
	NonInteractive bool
	KeyShareSize   int
	SignatureSize  int
	DKGRounds      int
	SigningRounds  int
}

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

type SessionState uint8

type ShareError struct {
	Index int
	Err   error
}

type Signature interface {
	// Bytes serializes the signature.
	Bytes() []byte

	// SchemeID returns the scheme that produced this signature.
	SchemeID() SchemeID
}

type SignatureShare interface {
	// Index returns the party index that created this share.
	Index() int

	// Bytes serializes the signature share.
	Bytes() []byte

	// SchemeID returns the scheme this share belongs to.
	SchemeID() SchemeID
}

type Signer interface {
	// Index returns the party index for this signer.
	Index() int

	// PublicShare returns this party's public key share.
	PublicShare() []byte

	// NonceGen generates a nonce commitment for signing.
	// Returns a commitment to broadcast and nonce state to preserve.
	// Not all schemes require this step.
	NonceGen(ctx context.Context) (NonceCommitment, NonceState, error)

	// SignShare creates a signature share for the given message.
	// For multi-round schemes, this may require nonce state from NonceGen.
	// The signers parameter contains the indices of all participating signers.
	SignShare(ctx context.Context, message []byte, signers []int, nonce NonceState) (SignatureShare, error)

	// KeyShare returns the underlying key share.
	KeyShare() KeyShare
}

type SigningSession struct {
	// ID is a unique identifier for this session.
	ID string

	// SchemeID identifies the threshold scheme being used.
	SchemeID SchemeID

	// Message is the message being signed.
	Message []byte

	// GroupKey is the threshold group public key.
	GroupKey PublicKey

	// Threshold is the minimum number of signers required.
	Threshold int

	// Participants contains the indices of parties participating in this session.
	Participants []int

	// Commitments stores nonce commitments from each participant.
	// Keyed by party index.
	Commitments map[int]NonceCommitment

	// Shares stores signature shares from each participant.
	// Keyed by party index.
	Shares map[int]SignatureShare

	// PublicShares stores public key shares for verification.
	// Keyed by party index.
	PublicShares map[int][]byte

	// State is the current session state.
	State SessionState

	// Result holds the final signature on success.
	Result Signature

	// Error holds the error if the session failed.
	Error error

	// CreatedAt is when the session was created.
	CreatedAt time.Time

	// UpdatedAt is when the session was last updated.
	UpdatedAt time.Time

	// Timeout is the session timeout duration.
	Timeout time.Duration
	// contains filtered or unexported fields
}

type TrustedDealer interface {
	// GenerateShares creates all key shares and the group public key.
	// Returns a slice of key shares (indexed 0 to n-1) and the group key.
	GenerateShares(ctx context.Context) ([]KeyShare, PublicKey, error)
}

type Verifier interface {
	// Verify checks if a signature is valid for the given message.
	Verify(message []byte, signature Signature) bool

	// VerifyBytes verifies a serialized signature.
	VerifyBytes(message, signature []byte) bool

	// GroupKey returns the group public key for this verifier.
	GroupKey() PublicKey
}