sig

type AllMultiPub interface {
	MultiPub
	Pub
}

type AllMultiSig interface {
	MultiSig
	Sig
}

type BasicSignedMessage []byte

type BasicThresholdInterface interface {
	ThresholdCountInterface
	// GetPartialPub() Pub // Get the partial public key for this node.
	GetSharedPub() Pub // Get the shared public key for the threshold.
}

type CoinProof interface {
	Sig
}

type CoinProofPubInterface interface {
	ThresholdCountInterface
	CheckCoinProof(SignedMessage, CoinProof) error // Check if a coin proof is valid for a message.
	CombineProofs(myPriv Priv, items []*SigItem) (coinVal types.BinVal, err error)
	// DeserializeCoinProof(m *messages.Message) (coinProof CoinProof, size int, err error)
	NewCoinProof() CoinProof // returns an empty coin proof object
}

type ConsIDPub struct {
	ID  types.ConsensusID
	Pub Pub
}

type CorruptInterface interface {
	Corrupt() // Corrupts a signature for testing
}

type EncodeInterface interface {
	Encode(writer io.Writer) (n int, err error)
	Decode(reader io.Reader) (n int, err error)
}

type EncodedMsg struct {
	*messages.Message
	WasEncrypted bool
	Pub          Pub
}

type MultiPub interface {
	// Clone returns a new pub only containing the points (no bitid), should be called before merging the first set of keys with MergePubPartial
	Clone() MultiPub
	// MergePubPartial merges the pubs without updating the BitID identifiers.
	MergePubPartial(MultiPub)
	// DonePartialMerge should be called after merging keys with MergePubPartial to set the bitid.
	DonePartialMerge(idInterface bitid.NewBitIDInterface)
	// MergePub combines two BLS public key objects into a single one (doing all necessary steps)
	MergePub(MultiPub) (MultiPub, error)
	// GetBitID returns the BitID for this public key
	GetBitID() bitid.NewBitIDInterface
	// SubMultiPub removes the input pub from he pub and returns the new pub
	SubMultiPub(MultiPub) (MultiPub, error)
	// GenerateSerializedSig serialized the public key and the signature and returns the bytes
	GenerateSerializedSig(MultiSig) ([]byte, error)
}

type MultiSig interface {
	// SubSig removes sig2 from sig1, it assumes sig 1 already contains sig2
	SubSig(MultiSig) (MultiSig, error)
	// MergeBlsSig combines two signatures, it assumes the sigs are valid to be merged
	MergeSig(MultiSig) (MultiSig, error)
}

type MultiSignTestMsg struct {
	Round  uint32
	BinVal types.BinVal
}

type MultipleSignedMessage struct {
	messages.InternalSignedMsgHeader                      // the specific message
	Index                            types.ConsensusIndex // the cons index of the message

	Hash types.HashBytes // The hash of the signed part of the message as bytes

	Msg      []byte     // The signed part of the message
	SigItems []*SigItem // A list of signatures
	// contains filtered or unexported fields
}

type NewPrivFunc func() (Priv, error)

type Priv interface {
	ComputeSharedSecret(pub Pub) [32]byte // ComputeSharedSecret should perform Diffie-Hellman.
	GetPub() Pub                          // GetPub returns the public key associated with this private key
	// SetIndex should be called after sorting the pubs (see SetUsePubIndex) with the sorted pub and the new pub key.
	SetIndex(newPubIndex PubKeyIndex)
	GenerateSig(msg SignedMessage, vrf VRFProof, signType types.SignType) (*SigItem, error) // Signs a message and returns the SigItem object containing the signature
	GetPrivForSignType(signType types.SignType) (Priv, error)                               // Returns key that is used for signing the sign type.
	Sign(message SignedMessage) (Sig, error)                                                // Signs a message and returns the signature
	GetBaseKey() Priv                                                                       // Returns the normal version of the key (eg. for partial signature keys returns the normal key)
	ShallowCopy() Priv
	Clean() // Called when the priv key is no longer used

	//////////////////////////////////////////////////////
	// Static methods
	/////////////////////////////////////////////////////
	// New() Priv   // Creates a new private key object of the same type
	NewSig() Sig // Creates an empty sig object of the same type.
}

type PrivList []Priv

type Pub interface {
	VerifySig(SignedMessage, Sig) (bool, error) // Verify a signature, returns (true, nil) if valid, (false, nil) if invalid, or (false, error) if there was an error verifying the signature
	// CheckSignature will should check what kind of message and signature to verify. It will call CheckCoinProof or VerfiySig
	// depending on the message type.
	CheckSignature(msg *MultipleSignedMessage, sig *SigItem) error
	GetPubBytes() (PubKeyBytes, error) // This is the key we use to sign/verify (might be an hash/operation performed on the original key)
	// GetRealPubBytes is the original unmodified public key. This is used when adding new public keys, from this we can generate all
	// the other values.
	GetRealPubBytes() (PubKeyBytes, error)
	GetPubString() (PubKeyStr, error) // This is the same as GetPubBytes, except returns a string, this is used to sort the keys
	GetSigMemberNumber() int          // This returns the number of members this sig counts for (can be > 1 for multisigs and threshold sigs)
	// GetPubID returns the id of the public key (see type definition for PubKeyID). IMPORTANT: this should only be used by
	// the member checker objects and when sending messages, since the id is based on the current set of member for a consensus index and can chage.
	// GetPubBytes, GetRealPubBytes, GetPubString should be used in other cases.
	// The member checker may change the PubID, after making a ShallowCopy, using AfterSortPubs to assign new IDs.
	GetPubID() (PubKeyID, error)
	SetIndex(PubKeyIndex)                  // This should be called after sorting all if the benchmark is using the index as the key id (see SetUsePubIndex)
	FromPubBytes(PubKeyBytes) (Pub, error) // This creates a public key object from the public key bytes
	ShallowCopy() Pub
	// GetIndex gets the index of the node represented by this key in the consensus participants
	GetIndex() PubKeyIndex

	New() Pub                                                                                            // Creates a new public key object of the same type
	DeserializeSig(m *messages.Message, signType types.SignType) (sigItem *SigItem, size int, err error) // Deserializes a public key and signature object from m, size is the number of bytes read

	messages.MsgHeader
	EncodeInterface
}

type PubKeyBytes []byte

type PubKeyID string

type PubKeyIndex int

type PubKeyStr string

type PubKeyStrList []PubKeyStr

type PubList []Pub

type SecondaryPriv interface {
	GetSecondaryPriv() Priv
}

type SecondaryPub interface {
	VerifySecondarySig(SignedMessage, Sig) (bool, error) // Verify a signature, returns (true, nil) if valid, (false, nil) if invalid, or (false, error) if there was an error verifying the signature
}

type Sig interface {
	//////////////////////////////////////////////////////
	// Static methods
	/////////////////////////////////////////////////////
	New() Sig // Creates a new sig object of the same type

	messages.MsgHeader
	EncodeInterface
}

type SigItem struct {
	WasEncrypted bool     // Set to true if this was an encrypted message
	Pub          Pub      // The public key that will be used to verify the signature
	Sig          Sig      // The signature
	VRFProof     VRFProof // The VRF proof if enabled
	VRFID        uint64   // The first uint64 computed by the vrf
	SigBytes     []byte   // The bytes of the signature

}

type SigStats struct {
	PubSize, SigSize, ThrshShareSize, VRFSize        int
	SigVerifyTime, SignTime                          time.Duration
	ShareVerifyTime, ShareGenTime                    time.Duration
	ShareCombineTime                                 time.Duration
	MultiCombineTime                                 time.Duration
	VRFGenTime, VRFVerifyTime                        time.Duration
	AllowsCoin, AllowsMulti, AllowsThresh, AllowsVRF bool
}

type SignedMessage interface {
	GetSignedHash() types.HashBytes
	GetSignedMessage() []byte
}

type SortPriv []Priv

type SortPub []Pub

type ThreshStateInterface interface {
	BasicThresholdInterface
	// VerifyPartialSig([]byte, Pub, Sig) error    // Verify a partial signature.
	CombinePartialSigs([]Sig) (*SigItem, error) // Create a threshold signatue for the partial signatures.
	PartialSign(msg SignedMessage) (Sig, error) // Sign a message using the local node's partial key.
}

type ThresholdCountInterface interface {
	GetT() int // Get the number of signatures needed for the threshold.
	GetN() int // Get the number of participants.
}

type ThrshSig interface {
	GetRand() types.BinVal // Get a random binary from the signature if supported.
}

type UnsignedMessage struct {
	messages.InternalSignedMsgHeader                      // the specific message
	Index                            types.ConsensusIndex // the cons index of the message

	Hash types.HashBytes // The hash of the signed part of the message as bytes

	Msg         []byte // The signed part of the message
	EncryptPubs []Pub  // The nodes who sent this message
	// contains filtered or unexported fields
}

type VRFPriv interface {
	Evaluate(m SignedMessage) (index [32]byte, proof VRFProof) // For generating VRFs.
}

type VRFProof interface {
	EncodeInterface

	//////////////////////////////////////////////////////
	// Static methods
	/////////////////////////////////////////////////////
	New() VRFProof // Creates a VRFProof oject of the same type
}

type VRFPub interface {
	// NewVRFProof returns an empty VRFProof object
	NewVRFProof() VRFProof
	// ProofToHash checks the VRF for the message and returns the random bytes if valid
	ProofToHash(m SignedMessage, proof VRFProof) (index [32]byte, err error) // For validating VRFs
}