participant

type DkgParticipant struct {
	Curve elliptic.Curve
	State *DkgState
	Id    uint32
	Round uint
}

type DkgParticipantCommitment struct {
	PublicKey   *paillier.PublicKey
	ProofParams *dealer.ProofParams
	Commitment  core.Commitment
}

type DkgParticipantData struct {
	PublicKey   *paillier.PublicKey
	ProofParams *dealer.ProofParams
}

type DkgResult struct {
	SecretKey       *paillier.SecretKey
	ShamirShare     *v1.ShamirShare
	EcdsaPublicKey  *curves.EcPoint
	PublicShares    []*curves.EcPoint
	ParticipantData map[uint32]*DkgParticipantData
}

type DkgRound1Bcast struct {
	Identifier       uint32
	Ci               core.Commitment
	Pki              *paillier.PublicKey
	H1i, H2i, Ni     *big.Int
	Proof1i, Proof2i *proof.CdlProof
}

type DkgRound2Bcast struct {
	Di *core.Witness
}

type DkgRound2P2PSend struct {
	Xij *v1.ShamirShare
}

type DkgRound3Bcast struct {
	PsfProof paillier.PsfProof
}

type DkgState struct {
	// Round 1 variables
	D  *core.Witness
	Sk *paillier.SecretKey
	Pk *paillier.PublicKey
	N  *big.Int
	H1 *big.Int
	H2 *big.Int
	// This participants verifiers from FeldmanShare
	V []*v1.ShareVerifier
	// This participants shares from FeldmanShare
	X         []*v1.ShamirShare
	Y         *curves.EcPoint
	Threshold uint32
	Limit     uint32
	// Commitments and paillier public keys received from other participants
	OtherParticipantData map[uint32]*DkgParticipantCommitment
	// xi returned from Round 3
	ShamirShare *v1.ShamirShare
	// X1,...,Xn returned from Round 3
	PublicShares []*curves.EcPoint
}

type Participant struct {
	ShamirShare v1.ShamirShare
	SecretKey   *paillier.SecretKey
}

type Round1Bcast struct {
	Identifier uint32
	C          core.Commitment
	Ctxt       *big.Int
	Proof      *proof.Range1Proof
}

type Round1P2PSend struct {
	Range1Proof *proof.Range1Proof
}

type Round2P2PSend struct {
	Proof2, Proof3 *proof.ResponseProof
}

type Round3Bcast struct {
	// Note that DeltaElement is some element of the entire δ vector.
	// In this round, it's δ_i. For the recepients of this message in the next round
	// this will be δ_j
	DeltaElement *big.Int
}

type Round4Bcast struct {
	Witness *core.Witness
}

type Round5Bcast struct {
	Rbar  *curves.EcPoint
	Proof *proof.PdlProof
}

type Round5P2PSend struct {
	PdlProof *proof.PdlProof
}

type Round6FullBcast struct {
	// Note that SElement is some element of the entire s vector.
	// In this round, it's s_i. For the recepients of this message in the final
	// sign output round, this will be s_j
	SElement *big.Int
}

type Signer struct {
	SecretKey       *paillier.SecretKey            // paillier secret key assigned to this signer
	ShamirShare     *v1.ShamirShare                // secret signing share for this signer
	PublicSharesMap map[uint32]*dealer.PublicShare // public shares of our cosigners
	Id              uint32                         // The ID assigned to this signer's shamir share
	// This is minimum number of signers required to produce a valid signature,
	// not the security Threshold (as specified in [spec][GG20])
	Threshold uint
	PublicKey *curves.EcPoint
	Curve     elliptic.Curve
	Round     uint // current signing round in our linear state machine
	// contains filtered or unexported fields
}