Struct Actor 

pub(crate) struct Actor<TContext>
where
    TContext: Clock + Metrics + Storage,
{
    config: Config,
    context: ContextCell<TContext>,
    mailbox: UnboundedReceiver<Message>,
    metrics: Metrics,
}

Fields

config: Config

The actor configuration passed in when constructing the actor.

context: ContextCell<TContext>

The runtime context passed in when constructing the actor.

mailbox: UnboundedReceiver<Message>

The channel over which the actor will receive messages.

metrics: Metrics

Handles to the metrics objects that the actor will update during its runtime.

Implementations

impl<TContext> Actor<TContext>

where TContext: BufferPooler + Clock + CryptoRngCore + Metrics + Spawner + Storage,

pub(super) async fn new( config: Config, context: TContext, mailbox: UnboundedReceiver<Message>, ) -> Result<Self>

pub(crate) fn start( self, dkg_channel: (impl Sender<PublicKey = PublicKey>, impl Receiver<PublicKey = PublicKey>), ) -> Handle<()>

async fn run( self, __arg1: (impl Sender<PublicKey = PublicKey>, impl Receiver<PublicKey = PublicKey>), )

async fn run_dkg_loop<TStorageContext, TSender, TReceiver>( &mut self, storage: &mut Storage<TStorageContext>, mux: &mut MuxHandle<TSender, TReceiver>, ) -> Result<()>

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

fn handle_verify_dealer_log( &self, state: &State, round: &Round, _: VerifyDealerLog, )

async fn should_skip_round( &mut self, round: &Round, finalized_tip: Height, ) -> bool

Determines if it makes sense to continue with the current DKG ceremony.

If finalized_tip indicates that the next epoch was already finalized, then there is no point in continuing with the current DKG round.

We know that an epoch was finalized by either observing the boundary block for said epoch, or by observing an even newer epoch.

async fn handle_finalized_block<TStorageContext, TSender>( &mut self, cause: Span, state: &State, round: &Round, round_channel: &mut TSender, storage: &mut Storage<TStorageContext>, dealer_state: &mut Option<Dealer>, player_state: &mut Option<Player>, block: Block, ) -> Result<Option<State>>

where TStorageContext: Metrics + Clock + Storage, TSender: Sender<PublicKey = PublicKey>,

Handles a finalized block.

Returns a new State after finalizing the boundary block of the epoch.

Some block heights are special cased:

• first height of an epoch: notify the epoch manager that the previous epoch can be shut down.
• last height of an epoch:
  1. notify the epoch manager that a new epoch can be entered;
  2. prepare for the state of the next iteration by finalizing the current DKG round and reading the next players (players in the DKG round after the immediately next one) from the smart contract.

The processing of all other blocks depends on which part of the epoch they fall in:

• first half: if we are a dealer, distribute the generated DKG shares to the players and collect their acks. If we are a player, receive DKG shares and respond with an ack.
• exact middle of an epoch: if we are a dealer, generate the dealer log of the DKG ceremony.
• second half of the epoch: read dealer logs from blocks.

async fn handle_finalized_boundary( &mut self, cause: Span, round: &Round, block: Block, ) -> Result<Option<State>>

Looks for and handles a finalized boundary block.

Called if the DKG round if asked to skip ahead to the boundary block. Does not consider any state for the current DKG round; just reads the DKG outcome from the header and returns it.

async fn distribute_shares<TStorageContext, TSender>( &self, storage: &mut Storage<TStorageContext>, epoch: Epoch, dealer_state: &mut Dealer, player_state: &mut Option<Player>, round_channel: &mut TSender, )

where TStorageContext: Metrics + Clock + Storage, TSender: Sender<PublicKey = PublicKey>,

async fn handle_network_msg<TStorageContext>( &self, round: &Round, round_channel: &mut impl Sender<PublicKey = PublicKey>, storage: &mut Storage<TStorageContext>, dealer_state: Option<&mut Dealer>, player_state: Option<&mut Player>, from: PublicKey, message: IoBuf, ) -> Result<()>

where TStorageContext: Metrics + Clock + Storage,

async fn handle_get_dkg_outcome<TStorageContext>( &mut self, cause: &Span, storage: &mut Storage<TStorageContext>, player_state: &Option<Player>, round: &Round, state: &State, request: GetDkgOutcome, ) -> Result<Option<(Digest, GetDkgOutcome)>>

where TStorageContext: Metrics + Clock + Storage,

Attempts to serve a GetDkgOutcome request by finalizing the DKG outcome.

A DKG outcome can be finalized in one of the following cases:

1. if the DKG actor has observed as many dealer logs as there are dealers.
2. if all blocks in an epoch were observed (finalized + notarized leading up to request.digest).

If the DKG was finalized this way, this method will return None. Otherwise will return Some((digest, request)) if the block identified by digest was missing and needs to be fetched first to ensure all blocks in an epoch were observed.

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

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

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.