Struct Coordinator 

pub struct Coordinator<Aggregator: AggregatorTrait> {
    pub current_dkg_id: u64,
    pub current_sign_id: u64,
    pub current_sign_iter_id: u64,
    pub party_polynomials: HashMap<u32, PolyCommitment>,
    pub aggregate_public_key: Option<Point>,
    pub dkg_wait_signer_ids: HashSet<u32>,
    pub message: Vec<u8>,
    pub state: State,
    pub coordinator_public_key: Option<PublicKey>,
    /* private fields */
}

The coordinator for the FIRE algorithm

Fields

current_dkg_id: u64

current DKG round ID

current_sign_id: u64

current signing round ID

current_sign_iter_id: u64

current signing iteration ID

party_polynomials: HashMap<u32, PolyCommitment>

the current view of a successful DKG’s participants’ commitments

aggregate_public_key: Option<Point>

aggregate public key

dkg_wait_signer_ids: HashSet<u32>

which signers we’re currently waiting on for DKG

message: Vec<u8>

the bytes that we’re signing

state: State

current state of the state machine

coordinator_public_key: Option<PublicKey>

coordinator public key

Implementations

impl<Aggregator: AggregatorTrait> Coordinator<Aggregator>

pub fn process_timeout( &mut self, ) -> Result<(Option<Packet>, Option<OperationResult>), Error>

Check the timeout

pub fn process_message( &mut self, packet: &Packet, ) -> Result<(Option<Packet>, Option<OperationResult>), Error>

Process the message inside the passed packet

pub fn start_public_shares(&mut self) -> Result<Packet, Error>

Ask signers to send DKG public shares

pub fn start_private_shares(&mut self) -> Result<Packet, Error>

Ask signers to send DKG private shares

pub fn start_dkg_end(&mut self) -> Result<Packet, Error>

Ask signers to compute shares and send DKG end

Trait Implementations

impl<Aggregator: Clone + AggregatorTrait> Clone for Coordinator<Aggregator>

fn clone(&self) -> Coordinator<Aggregator>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Aggregator: AggregatorTrait> Coordinator for Coordinator<Aggregator>

fn new(config: Config) -> Self

Create a new coordinator

fn get_config(&self) -> Config

Retrieve the config

fn set_key_and_party_polynomials( &mut self, aggregate_key: Point, party_polynomials: Vec<(u32, PolyCommitment)>, ) -> Result<(), Error>

Set the aggregate key and polynomial commitments used to form that key. Check if the polynomial commitments match the key

fn get_aggregate_public_key(&self) -> Option<Point>

Retrieve the aggregate public key

fn set_aggregate_public_key(&mut self, aggregate_public_key: Option<Point>)

Set the aggregate public key

fn get_message(&self) -> Vec<u8>

Retrieve the current message bytes being signed

fn get_state(&self) -> State

Retrive the current state

fn start_dkg_round(&mut self, dkg_id: Option<u64>) -> Result<Packet, Error>

Start a DKG round, with an optional dkg_id

fn process( &mut self, packet: &Packet, ) -> Result<(Option<Packet>, Option<OperationResult>), Error>

Process the timeouts, and if none of them fire then process the passed packet If a timeout does fire, then the coordinator state has changed; this means the packet is now stale and must be dropped

fn start_signing_round( &mut self, message: &[u8], signature_type: SignatureType, sign_id: Option<u64>, ) -> Result<Packet, Error>

Start a signing round

fn load(state: &SavedState) -> Self

Load a coordinator from the previously saved state

fn save(&self) -> SavedState

Save the state required to reconstruct the coordinator

fn set_coordinator_public_key(&mut self, key: Option<PublicKey>)

Set the coordinator public key

fn reset(&mut self)

Reset internal state

impl<Aggregator: Debug + AggregatorTrait> Debug for Coordinator<Aggregator>

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

Formats the value using the given formatter.

impl<Aggregator: PartialEq + AggregatorTrait> PartialEq for Coordinator<Aggregator>

fn eq(&self, other: &Coordinator<Aggregator>) -> 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<Aggregator: AggregatorTrait> StateMachine<State, Error> for Coordinator<Aggregator>

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<Aggregator: AggregatorTrait> StructuralPartialEq for Coordinator<Aggregator>