Struct Dealer 

pub struct Dealer<V: Variant, S: Signer> { /* private fields */ }

Implementations

impl<V: Variant, S: Signer> Dealer<V, S>

pub fn start( rng: impl CryptoRngCore, info: Info<V, S::PublicKey>, me: S, share: Option<Share>, ) -> Result<(Self, DealerPubMsg<V>, Vec<(S::PublicKey, DealerPrivMsg)>), Error>

Create a Dealer.

This needs randomness, to generate a dealing.

We also need the dealer’s private key, in order to produce the SignedDealerLog.

If we’re doing a reshare, the dealer should have a share from the previous round.

This will produce the Dealer, a DealerPubMsg to send to every player, and a list of DealerPrivMsgs, along with which players those need to be sent to.

The public message can be sent in the clear, but it’s important that players know which dealer sent what public message. You MUST ensure that dealers cannot impersonate each-other when sending this message.

The private message MUST be sent encrypted (or, in some other way, privately) to the target player. Similarly, that player MUST be convinced that this dealer sent it that message, without any possibility of impersonation. A simple way to provide both guarantees is through an authenticated channel, e.g. via crate::handshake, or commonware-p2p.

pub fn receive_player_ack( &mut self, player: S::PublicKey, ack: PlayerAck<S::PublicKey>, ) -> Result<(), Error>

Process an acknowledgement from a player.

Acknowledgements should really only be processed once per player, but this method is idempotent nonetheless.

pub fn finalize(self) -> SignedDealerLog<V, S>

Finalize the dealer, producing a signed log.

This should be called at the point where no more acks will be processed.