Struct Ceremony 

pub(super) struct Ceremony<TContext, TReceiver, TSender>
where
    TContext: Clock + Metrics + Storage,
    TReceiver: Receiver,
    TSender: Sender,
{
    config: Config,
    previous_role: Role,
    dealer_me: Option<Dealer>,
    player_me: Option<Player<PublicKey, MinSig>>,
    players_indexed: IndexSet<PublicKey>,
    arbiter: Arbiter<PublicKey, MinSig>,
    ceremony_metadata: Arc<Mutex<Metadata<TContext, U64, State>>>,
    receiver: SubReceiver<TReceiver>,
    sender: SubSender<TSender>,
    metrics: Metrics,
}

Fields

config: Config

previous_role: Role

The previous role of this node in the network. This contains either the polynomial (if the node was just a verifier), or the polynomial and share of the private key if the node was a signer.

dealer_me: Option<Dealer>

Dealer metadata, if this manager is also dealing.

player_me: Option<Player<PublicKey, MinSig>>

The local [Player] for this round, if the manager is playing.

players_indexed: IndexSet<PublicKey>

The indexed set of all players. Whereas config.players is a sorted list of unique playes, players_indexed is an actual set data structure that allows O(1) lookup of both keys and indices.

It is an invariant that players_indexed.get_index_of(players[i]) == i.

arbiter: Arbiter<PublicKey, MinSig>

The local [Arbiter] for this round.

ceremony_metadata: Arc<Mutex<Metadata<TContext, U64, State>>>

receiver: SubReceiver<TReceiver>

sender: SubSender<TSender>

metrics: Metrics

Implementations

impl<TContext, TReceiver, TSender> Ceremony<TContext, TReceiver, TSender>

where TContext: Clock + CryptoRngCore + Metrics + Storage, TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

pub(super) async fn init( context: &mut TContext, mux: &mut MuxHandle<TSender, TReceiver>, ceremony_metadata: Arc<Mutex<Metadata<TContext, U64, State>>>, config: Config, metrics: Metrics, ) -> Result<Self>

Initialize a DKG ceremony.

pub(super) async fn distribute_shares(&mut self) -> Result<()>

Sends shares to all players for acknowledgements.

Does not send shares if we are not a dealer in this ceremony.

If we are both a dealer and a player, then we acknowledge our shares immediately without going over the p2p network.

pub(super) async fn process_messages(&mut self) -> Result<()>

Processes all received shares and acks on the ceremony’s p2p subchannel.

If we receive a share and are a player: construct an ack and return it to the sender.

If we receive an ack and are a dealer: track the ack.

async fn process_ack( &mut self, peer: PublicKey, ack: Ack, ) -> Result<&'static str>

async fn process_share( &mut self, peer: PublicKey, __arg2: Share, ) -> Result<&'static str>

pub(super) async fn process_dealings_in_block( &mut self, block: &Block, hardfork_regime: HardforkRegime, ) -> Result<()>

Process block by reading [IntermediateOutcome] from its header.

If the block contains this outcome, the ceremony will verify it and track it in its arbiter.

pub(super) async fn construct_intermediate_outcome( &mut self, hardfork_regime: HardforkRegime, ) -> Result<()>

Constructs and stores the intermediate ceremony outcome.

If the node is not a dealer, then this is a no-op.

pub(super) fn finalize(self) -> Result<PrivateOutcome, PrivateOutcome>

Finalizes the ceremony, returning the participants and key pair for the next epoch.

If the ceremony was successful, the players of the ceremony and the new public key will be returned in Ok-position. If this node was a player, it will also contain its private share.

If the ceremony failed, the dealers of the ceremony and the old public key will be returned in Err-position. If this node was a dealer, this will include its old private share.

pub(super) fn epoch(&self) -> Epoch

pub(super) fn deal_outcome(&self) -> Option<&IntermediateOutcome>

pub(super) fn dealers(&self) -> &Ordered<PublicKey>

pub(super) fn players(&self) -> &[PublicKey]

pub(super) fn is_dealer(&self) -> bool

pub(super) fn is_player(&self) -> bool

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.