Struct frost_dalek::keygen::SecretKey

pub struct SecretKey { /* fields omitted */ }

A secret key, used by one participant in a threshold signature scheme, to sign a message.

Implementations

impl SecretKey

pub fn to_public(&self) -> IndividualPublicKey

Derive the corresponding public key for this secret key.

impl SecretKey

pub fn sign(
    &self,
    message_hash: &[u8; 64],
    group_key: &GroupKey,
    my_secret_commitment_share_list: &mut SecretCommitmentShareList,
    my_commitment_share_index: usize,
    signers: &[Signer]
) -> Result<PartialThresholdSignature, &'static str>

Compute an individual signer's PartialThresholdSignature contribution to a ThresholdSignature on a message.

Inputs

• The message_hash to be signed by every individual signer, this should be the Sha512 digest of the message, optionally along with some application-specific context string, and can be calculated with the helper function compute_message_hash.
• The public GroupKey for this group of signing participants,
• This signer's SecretCommitmentShareList being used in this instantiation and
• The index of the particular CommitmentShare being used, and
• The list of all the currently participating Signers (including ourself).

Warning

The secret share index here must be the same secret share corresponding to its public commitment which is passed to SignatureAggregrator.include_signer().

Returns

A Result whose Ok value contains a PartialThresholdSignature, which should be sent to the SignatureAggregator. Otherwise, its Err value contains a string describing the error which occurred.

Trait Implementations

impl Debug for SecretKey

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for SecretKey

pub fn drop(&mut self)

Executes the destructor for this type.

impl From<&'_ SecretKey> for IndividualPublicKey

pub fn from(source: &SecretKey) -> IndividualPublicKey

Performs the conversion.

impl Zeroize for SecretKey

pub fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not "optimized away" by the compiler.