Struct Party 

pub struct Party {
    pub party_id: u32,
    pub key_ids: Vec<u32>,
    /* private fields */
}

A WSTS party, which encapsulates a single polynomial, nonce, and one private key per key ID

Fields

party_id: u32

The party ID

key_ids: Vec<u32>

The key IDs for this party

Implementations

impl Party

pub fn new<RNG: RngCore + CryptoRng>( party_id: u32, key_ids: &[u32], num_parties: u32, num_keys: u32, threshold: u32, rng: &mut RNG, ) -> Self

Construct a random Party with the passed party ID, key IDs, and parameters

pub fn gen_nonce<RNG: RngCore + CryptoRng>( &mut self, secret_key: &Scalar, rng: &mut RNG, ) -> PublicNonce

Generate and store a private nonce for a signing round

pub fn get_poly_commitment<RNG: RngCore + CryptoRng>( &self, ctx: &[u8], rng: &mut RNG, ) -> Option<PolyCommitment>

Get a public commitment to the private polynomial

pub fn get_shares(&self) -> HashMap<u32, Scalar>

Get the shares of this party’s private polynomial for all keys

pub fn compute_secret( &mut self, private_shares: &HashMap<u32, HashMap<u32, Scalar>>, public_shares: &HashMap<u32, PolyCommitment>, ctx: &[u8], ) -> Result<(), DkgError>

Compute this party’s share of the group secret key, but first check that the data is valid and consistent. This raises an issue though: what if we have private_shares and public_shares from different parties? To resolve the ambiguity, assume that the public_shares represent the correct group of parties.

pub fn id(&self) -> Scalar

Compute a Scalar from this party’s ID

pub fn sign( &self, msg: &[u8], party_ids: &[u32], key_ids: &[u32], nonces: &[PublicNonce], ) -> SignatureShare

Sign msg with this party’s shares of the group private key, using the set of party_ids, key_ids and corresponding nonces

pub fn sign_with_tweak( &self, msg: &[u8], party_ids: &[u32], key_ids: &[u32], nonces: &[PublicNonce], tweak: Option<Scalar>, ) -> SignatureShare

Sign msg with this party’s shares of the group private key, using the set of party_ids, key_ids and corresponding nonces with a tweaked public key. The posible values for tweak are None - standard FROST signature Some(0) - BIP-340 schnorr signature using 32-byte private key adjustments Some(t) - BIP-340 schnorr signature with BIP-341 tweaked keys, using 32-byte private key adjustments

Trait Implementations

impl Clone for Party

fn clone(&self) -> Party

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Party

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

Formats the value using the given formatter.

impl PartialEq for Party

fn eq(&self, other: &Party) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Signer for Party

fn new<RNG: RngCore + CryptoRng>( party_id: u32, key_ids: &[u32], num_signers: u32, num_keys: u32, threshold: u32, rng: &mut RNG, ) -> Self

Create a new Signer

fn load(state: &SignerState) -> Self

Load a signer from the previously saved state

fn save(&self) -> SignerState

Save the state required to reconstruct the party

fn get_id(&self) -> u32

Get the signer ID for this signer

fn get_key_ids(&self) -> Vec<u32>

Get all key IDs for this signer

fn get_num_parties(&self) -> u32

Get the total number of parties

fn get_poly_commitments<RNG: RngCore + CryptoRng>( &self, ctx: &[u8], rng: &mut RNG, ) -> Vec<PolyCommitment>

Get all poly commitments for this signer and the passed context

fn reset_polys<RNG: RngCore + CryptoRng>(&mut self, rng: &mut RNG)

Reset all polynomials for this signer

fn clear_polys(&mut self)

Clear all polynomials for this signer

fn get_shares(&self) -> HashMap<u32, HashMap<u32, Scalar>>

Get all private shares for this signer

fn compute_secrets( &mut self, private_shares: &HashMap<u32, HashMap<u32, Scalar>>, polys: &HashMap<u32, PolyCommitment>, ctx: &[u8], ) -> Result<(), HashMap<u32, DkgError>>

Compute all secrets for this signer

fn gen_nonces<RNG: RngCore + CryptoRng>( &mut self, secret_key: &Scalar, rng: &mut RNG, ) -> Vec<PublicNonce>

Generate all nonces for this signer

fn compute_intermediate( msg: &[u8], signer_ids: &[u32], _key_ids: &[u32], nonces: &[PublicNonce], ) -> (Vec<Point>, Point)

Compute intermediate values

fn validate_party_id( signer_id: u32, party_id: u32, _signer_key_ids: &HashMap<u32, HashSet<u32>>, ) -> bool

Validate that signer_id owns party_id

fn sign( &self, msg: &[u8], signer_ids: &[u32], key_ids: &[u32], nonces: &[PublicNonce], ) -> Vec<SignatureShare>

Sign msg using all this signer’s keys

fn sign_schnorr( &self, msg: &[u8], signer_ids: &[u32], key_ids: &[u32], nonces: &[PublicNonce], ) -> Vec<SignatureShare>

Sign msg using all this signer’s keys

fn sign_taproot( &self, msg: &[u8], signer_ids: &[u32], key_ids: &[u32], nonces: &[PublicNonce], merkle_root: Option<[u8; 32]>, ) -> Vec<SignatureShare>

Sign msg using all this signer’s keys and a tweaked public key

impl Eq for Party

impl StructuralPartialEq for Party