Struct Signer 

pub struct Signer<SignerType: SignerTrait> {

    pub dkg_id: u64,
    pub sign_id: u64,
    pub sign_iter_id: u64,
    pub threshold: u32,
    pub dkg_threshold: u32,
    pub total_signers: u32,
    pub total_keys: u32,
    pub signer: SignerType,
    pub signer_id: u32,
    pub state: State,
    pub commitments: HashMap<u32, PolyCommitment>,
    pub decrypted_shares: HashMap<u32, HashMap<u32, Scalar>>,
    pub decryption_keys: HashMap<u32, (u32, Point)>,
    pub invalid_private_shares: HashMap<u32, BadPrivateShare>,
    pub public_nonces: Vec<PublicNonce>,
    pub network_private_key: Scalar,
    pub public_keys: PublicKeys,
    pub dkg_public_shares: BTreeMap<u32, DkgPublicShares>,
    pub dkg_private_shares: BTreeMap<u32, DkgPrivateShares>,
    pub dkg_private_begin_msg: Option<DkgPrivateBegin>,
    pub dkg_end_begin_msg: Option<DkgEndBegin>,
    pub verify_packet_sigs: bool,
    pub coordinator_public_key: Option<PublicKey>,
    /* private fields */
}

A state machine for a signing round

Fields

dkg_id: u64

current DKG round ID

sign_id: u64

current signing round ID

sign_iter_id: u64

current signing iteration ID

threshold: u32

the threshold of the keys needed for a valid signature

dkg_threshold: u32

the threshold of the keys needed for a valid DKG

total_signers: u32

the total number of signers

total_keys: u32

the total number of keys

signer: SignerType

the Signer object

signer_id: u32

the Signer ID

state: State

the current state

commitments: HashMap<u32, PolyCommitment>

map of polynomial commitments for each party party_id => PolyCommitment

decrypted_shares: HashMap<u32, HashMap<u32, Scalar>>

map of decrypted DKG private shares src_party_id => (dst_key_id => private_share)

decryption_keys: HashMap<u32, (u32, Point)>

shared secrets used to decrypt private shares src_party_id => (signer_id, dh shared key)

invalid_private_shares: HashMap<u32, BadPrivateShare>

invalid private shares signer_id => {shared_key, tuple_proof}

public_nonces: Vec<PublicNonce>

public nonces for this signing round

network_private_key: Scalar

the private key used to sign messages sent over the network

public_keys: PublicKeys

the public keys for all signers and coordinator

dkg_public_shares: BTreeMap<u32, DkgPublicShares>

the DKG public shares received in this round

dkg_private_shares: BTreeMap<u32, DkgPrivateShares>

the DKG private shares received in this round

dkg_private_begin_msg: Option<DkgPrivateBegin>

the DKG private begin message received in this round

dkg_end_begin_msg: Option<DkgEndBegin>

the DKG end begin message received in this round

verify_packet_sigs: bool

whether to verify the signature on Packets

coordinator_public_key: Option<PublicKey>

coordinator public key

Implementations

impl<SignerType: SignerTrait> Signer<SignerType>

pub fn new<R: RngCore + CryptoRng>( threshold: u32, dkg_threshold: u32, total_signers: u32, total_keys: u32, signer_id: u32, key_ids: Vec<u32>, network_private_key: Scalar, public_keys: PublicKeys, rng: &mut R, ) -> Result<Self, Error>

create a Signer

pub fn load(state: &SavedState) -> Self

Load a coordinator from the previously saved state

pub fn save(&self) -> SavedState

Save the state required to reconstruct the coordinator

pub fn reset<T: RngCore + CryptoRng>(&mut self, dkg_id: u64, rng: &mut T)

Reset internal state

pub fn process<R: RngCore + CryptoRng>( &mut self, packet: &Packet, rng: &mut R, ) -> Result<Vec<Message>, Error>

process the passed incoming message, and return any outgoing messages needed in response

pub fn dkg_ended<R: RngCore + CryptoRng>( &mut self, rng: &mut R, ) -> Result<Message, Error>

DKG is done so compute secrets

pub fn public_shares_done(&self) -> bool

do we have all DkgPublicShares?

pub fn can_dkg_end(&self) -> bool

do we have all DkgPublicShares and DkgPrivateShares?

pub fn dkg_end_begin( &mut self, dkg_end_begin: &DkgEndBegin, ) -> Result<Vec<Message>, Error>

handle incoming DkgEndBegin

pub fn dkg_public_share( &mut self, dkg_public_shares: &DkgPublicShares, ) -> Result<Vec<Message>, Error>

handle incoming DkgPublicShares

pub fn dkg_private_shares<R: RngCore + CryptoRng>( &mut self, dkg_private_shares: &DkgPrivateShares, rng: &mut R, ) -> Result<Vec<Message>, Error>

handle incoming DkgPrivateShares

Trait Implementations

impl<SignerType: Clone + SignerTrait> Clone for Signer<SignerType>

fn clone(&self) -> Signer<SignerType>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<SignerType: SignerTrait> Debug for Signer<SignerType>

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

Formats the value using the given formatter.

impl<SignerType: PartialEq + SignerTrait> PartialEq for Signer<SignerType>

fn eq(&self, other: &Signer<SignerType>) -> 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<SignerType: SignerTrait> StateMachine<State, Error> for Signer<SignerType>

fn move_to(&mut self, state: State) -> Result<(), Error>

Attempt to move the state machine to a new state

fn can_move_to(&self, state: &State) -> Result<(), Error>

Check if the state machine can move to a new state

impl<SignerType: SignerTrait> StructuralPartialEq for Signer<SignerType>