Struct Actor 

pub(crate) struct Actor<TContext, TPeerManager>
where
    TContext: Clock + Metrics + Storage,
    TPeerManager: Manager,
{
    config: Config<TPeerManager>,
    context: ContextCell<TContext>,
    mailbox: UnboundedReceiver<Message>,
    ceremony_metadata: Arc<Mutex<Metadata<ContextCell<TContext>, U64, State>>>,
    post_allegretto_metadatas: Metadatas<ContextCell<TContext>>,
    pre_allegretto_metadatas: Metadatas<ContextCell<TContext>>,
    validators_metadata: Metadata<ContextCell<TContext>, U64, ValidatorState>,
    metrics: Metrics,
}

Fields

config: Config<TPeerManager>

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.

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

Persisted information on the currently running ceremony and its predecessor (epochs i and i-1). This ceremony metadata is updated on the last height of en epoch (the height on which the ceremony for the next epoch will be started).

post_allegretto_metadatas: Metadatas<ContextCell<TContext>>

Persisted information on the current epoch for DKG ceremonies that were started after the allegretto hardfork.

pre_allegretto_metadatas: Metadatas<ContextCell<TContext>>

Persisted information on the current epoch for DKG ceremonies that were started before the allegretto hardfork.

validators_metadata: Metadata<ContextCell<TContext>, U64, ValidatorState>

Information on the peers registered on the p2p peer manager for a given epoch i and its precursors i-1 and i-2. Peer information is persisted on the last height of an epoch.

Note that validators are also persisted in the epoch metadata and are the main source of truth. The validators are also tracked here so that they can be registered as peers for older epoch states that are no longer tracked.

metrics: Metrics

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

Implementations

impl<TContext, TPeerManager> Actor<TContext, TPeerManager>

where TContext: Clock + CryptoRngCore + Metrics + Spawner + Storage, TPeerManager: Manager<PublicKey = PublicKey, Peers = OrderedAssociated<PublicKey, SocketAddr>>,

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

pub(super) async fn handle_finalized_post_allegretto<TReceiver, TSender>( &mut self, cause: Span, block: Block, maybe_ceremony: &mut Option<Ceremony<ContextCell<TContext>, TReceiver, TSender>>, ceremony_mux: &mut MuxHandle<TSender, TReceiver>, )

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

Handles a finalized block.

Some block heights are special cased:

• first height of an epoch: notify the epoch manager that the previous epoch can be shut down.
• pre-to-last height of an epoch: finalize the ceremony and generate the the state for the next ceremony.
• last height of an epoch:
  1. notify the epoch manager that a new epoch can be entered;
  2. start a new ceremony by reading the validator config 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 dealing (the intermediate outcome) of the ceremony.
• second half of an epoch: if we are a dealer, send it to the application if a request comes in (the application is supposed to add this to the block it is proposing). Always attempt to read dealings from the blocks and track them (if a dealer or player both).

pub(super) async fn transition_from_static_validator_sets<TReceiver, TSender>( &mut self, pre_allegretto_epoch_state: EpochState, mux: &mut MuxHandle<TSender, TReceiver>, ) -> Result<Ceremony<ContextCell<TContext>, TReceiver, TSender>>

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

pub(super) async fn start_post_allegretto_ceremony<TReceiver, TSender>( &mut self, mux: &mut MuxHandle<TSender, TReceiver>, ) -> Ceremony<ContextCell<TContext>, TReceiver, TSender>

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

async fn update_and_register_current_epoch_state(&mut self)

async fn enter_current_epoch_and_remove_old_state(&mut self)

Reports that a new epoch was fully entered, that the previous epoch can be ended.

impl<TContext, TPeerManager> Actor<TContext, TPeerManager>

where TContext: Clock + CryptoRngCore + Metrics + Spawner + Storage, TPeerManager: Manager<PublicKey = PublicKey, Peers = OrderedAssociated<PublicKey, SocketAddr>>,

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

Runs the pre-allegretto initialization routines.

This is a no-op if post-allegretto artifacts exists on disk and there no pre-allegretto artifacts remaining. The assumption is that the last pre- allegretto ceremony deletes its state from disk.

If neither pre- nor post-allegretto artifacts are found, this method assumes that the node is starting from genesis.

pub(super) async fn handle_finalized_pre_allegretto<TReceiver, TSender>( &mut self, cause: Span, block: Block, maybe_ceremony: &mut Option<Ceremony<ContextCell<TContext>, TReceiver, TSender>>, ceremony_mux: &mut MuxHandle<TSender, TReceiver>, )

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

Handles a finalized block.

Depending on which height of an epoch the block is, this method exhibits different behavior:

• first height of an epoch: notify the epoch manager that the previous epoch can be shut down.
• first half of an epoch: distribute the shares generated during the DKG ceremony and collect shares from other dealers, and acks from other players.
• exact middle of an epoch: generate the intermediate outcome of the ceremony.
• second half of an epoch: read intermediate outcomes from blocks.
• pre-to-last height of an epoch: generate the overall ceremony outcome, update CURRENT_EPOCH_KEY.
• last height of an epoch: notify the epoch manager that a new epoch can be started, using the outcome of the last epoch. Start a new ceremony for the next epoch.

pub(super) async fn start_pre_allegretto_ceremony<TReceiver, TSender>( &mut self, mux: &mut MuxHandle<TSender, TReceiver>, ) -> Ceremony<ContextCell<TContext>, TReceiver, TSender>

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

async fn transition_to_dynamic_validator_sets<TReceiver, TSender>( &mut self, mux: &mut MuxHandle<TSender, TReceiver>, ) -> Result<Ceremony<ContextCell<TContext>, TReceiver, TSender>>

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

impl<TContext, TPeerManager> Actor<TContext, TPeerManager>

where TContext: Clock + CryptoRngCore + Metrics + Spawner + Storage, TPeerManager: Manager<PublicKey = PublicKey, Peers = OrderedAssociated<PublicKey, SocketAddr>>,

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

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

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

async fn handle_get_intermediate_dealing<TReceiver, TSender>( &mut self, cause: Span, __arg2: GetIntermediateDealing, ceremony: Option<&mut Ceremony<ContextCell<TContext>, TReceiver, TSender>>, ) -> Result<()>

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

async fn handle_get_outcome( &mut self, cause: Span, __arg2: GetOutcome, ) -> Result<()>

async fn handle_finalized<TReceiver, TSender>( &mut self, cause: Span, __arg2: Finalize, maybe_ceremony: &mut Option<Ceremony<ContextCell<TContext>, TReceiver, TSender>>, ceremony_mux: &mut MuxHandle<TSender, TReceiver>, )

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

Handles a finalized block.

Some block heights are special cased:

• first height of an epoch: notify the epoch manager that the previous epoch can be shut down.
• pre-to-last height of an epoch: finalize the ceremony and generate the the state for the next ceremony.
• last height of an epoch:
  1. notify the epoch manager that a new epoch can be entered;
  2. start a new ceremony by reading the validator config 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 dealing (the intermediate outcome) of the ceremony.
• second half of an epoch: if we are a dealer, send it to the application if a request comes in (the application is supposed to add this to the block it is proposing). Always attempt to read dealings from the blocks and track them (if a dealer or player both).

async fn start_ceremony_for_current_epoch_state<TReceiver, TSender>( &mut self, mux: &mut MuxHandle<TSender, TReceiver>, ) -> Ceremony<ContextCell<TContext>, TReceiver, TSender>

where TReceiver: Receiver<PublicKey = PublicKey>, TSender: Sender<PublicKey = PublicKey>,

Starts a new ceremony for the epoch state tracked by the actor.

async fn register_current_epoch_state(&mut self)

Registers the new epoch by reporting to the epoch manager that it should be entered and registering its peers on the peers manager.

async fn register_previous_epoch_state(&mut self)

Reports that the previous epoch should be entered.

This method is called on startup to ensure that a consensus engine for the previous epoch i-1 is started in case the node went down before the new epoch i was firmly locked in.

This method also registers the validators for epochs i-1 and i-2.

Panics

Panics if no current epoch state exists on disk.

async fn register_validators( &mut self, epoch: Epoch, validator_state: ValidatorState, )

Registers peers derived from validator_state for epoch on the peer manager.

fn is_running_post_allegretto(&self, block: &Block) -> bool

Returns if the DKG manager is running a post-allegretto ceremony.

The DKG manager is running a post-allegretto ceremony if block.timestamp is after the allegretto timestamp, and if the post-allegretto epoch state is set.

This is to account for ceremonies that are started pre-allegretto, and are running past the hardfork timestamp: we need to run the ceremony to its conclusion and then start a new post-allegretto ceremony at the epoch boundary.

fn previous_epoch_state(&self) -> Option<EpochState>

Returns the previous epoch state.

Always prefers the post allegretto state, if it exists.

fn current_epoch_state(&self) -> EpochState

Returns the current epoch state.

Always prefers the post allegretto state, if it exists.

Panics

Panics if no epoch state exists, neither for the pre- nor post-allegretto regime. There must always be an epoch state.

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.