Struct ConsensusHandle 

pub struct ConsensusHandle<T: NodeType, S> {
    epoch_height: BlockNumber,
    event_rx: InactiveReceiver<CoordinatorEvent<T>>,
    upgrade_lock: UpgradeLock<T>,
    membership_coordinator: EpochMembershipCoordinator<T>,
    resting: Arc<RwLock<Resting<T>>>,
    coordinator: Arc<RwLock<CoordinatorState<T, S>>>,
    exited: CancellationToken,
}

The node’s handle on consensus: the Coordinator, run on its own task from start_consensus on, and what the rest of the node reads from it.

Fields

epoch_height: BlockNumber

event_rx: InactiveReceiver<CoordinatorEvent<T>>

upgrade_lock: UpgradeLock<T>

membership_coordinator: EpochMembershipCoordinator<T>

resting: Arc<RwLock<Resting<T>>>

coordinator: Arc<RwLock<CoordinatorState<T, S>>>

exited: CancellationToken

Cancelled once the coordinator task has ended, however it ended.

Implementations

impl<T, S> ConsensusHandle<T, S>

where T: NodeType, S: NewProtocolStorage<T>,

pub fn new( coordinator: Coordinator<T, S>, external_rx: UnboundedReceiver<OpaqueMessage<T::SignatureKey>>, upgrade_lock: UpgradeLock<T>, membership_coordinator: EpochMembershipCoordinator<T>, initializer: &HotShotInitializer<T>, event_channel_capacity: usize, metrics: &dyn Metrics, ) -> Self

pub async fn start_consensus(&self)

pub fn event_stream(&self) -> BoxStream<'static, CoordinatorEvent<T>>

pub async fn stopped(&self)

Resolves once the coordinator task has ended, whether shut_down stopped it or it died on a critical error or a panic. Never resolves if consensus never started.

pub async fn current_view(&self) -> ViewNumber

Serves the resting state once the coordinator has been told to shut down, waiting for the state it leaves on the way out if a request fails meanwhile. Panics if the coordinator died instead: the node must not answer as if the chain had stopped.

pub async fn decided_leaf(&self) -> Leaf2<T>

See Self::current_view.

pub async fn decided_state(&self) -> Option<Arc<T::ValidatedState>>

See Self::current_view.

async fn resting_unless_dead( &self, err: QueryError, ) -> RwLockReadGuard<'_, Resting<T>>

Where a failed request leaves a reader: the coordinator was told to shut down and the resting state it leaves behind answers, or no shutdown was asked for, so it died.

pub async fn state(&self, view: ViewNumber) -> Option<Arc<T::ValidatedState>>

pub async fn state_and_delta(&self, view: ViewNumber) -> StateAndDelta<T>

pub async fn undecided_leaves(&self) -> Vec<Leaf2<T>>

pub async fn current_epoch(&self) -> Option<EpochNumber>

pub fn epoch_height(&self) -> BlockNumber

pub fn membership_coordinator(&self) -> EpochMembershipCoordinator<T>

pub fn upgrade_lock(&self) -> UpgradeLock<T>

pub async fn current_proposal_participation( &self, ) -> HashMap<T::SignatureKey, f64>

pub async fn proposal_participation( &self, epoch: EpochNumber, ) -> HashMap<T::SignatureKey, f64>

pub async fn current_vote_participation( &self, ) -> HashMap<<T::SignatureKey as SignatureKey>::VerificationKeyType, f64>

pub async fn vote_participation( &self, epoch: EpochNumber, ) -> HashMap<<T::SignatureKey as SignatureKey>::VerificationKeyType, f64>

pub async fn request_proposal( &self, view: ViewNumber, leaf_commitment: Commitment<Leaf2<T>>, ) -> Result<BoxFuture<'static, Result<SignedProposal<T, QuorumProposalWrapper<T>>>>>

pub async fn submit_transaction(&self, tx: T::Transaction) -> Result<()>

pub async fn update_leaf( &self, leaf: Leaf2<T>, state: Arc<T::ValidatedState>, delta: Option<Arc<<T::ValidatedState as ValidatedState<T>>::Delta>>, ) -> Result<()>

pub async fn shut_down(&self)

Stops the coordinator if it runs, and drops it if it never started so that nothing can start it afterwards; the readers serve the resting state from here on.

pub(crate) async fn client_api(&self) -> Option<ClientApi<T>>

Trait Implementations

impl<P: SequencerPersistence> ConsensusSource for ConsensusHandle<SeqTypes, Arc<P>>

fn decided_leaf<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Leaf2> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn decided_state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<Arc<ValidatedState>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn state<'life0, 'async_trait>( &'life0 self, view: ViewNumber, ) -> Pin<Box<dyn Future<Output = Option<Arc<ValidatedState>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn state_and_delta<'life0, 'async_trait>( &'life0 self, view: ViewNumber, ) -> Pin<Box<dyn Future<Output = StateAndDelta<SeqTypes>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn undecided_leaves<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Vec<Leaf2>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn current_epoch<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Option<EpochNumber>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn membership_coordinator<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = EpochMembershipCoordinator<SeqTypes>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn upgrade_lock<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = UpgradeLock<SeqTypes>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn submit_transaction<'life0, 'async_trait>( &'life0 self, tx: Transaction, ) -> Pin<Box<dyn Future<Output = Result<Commitment<Transaction>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The commitment the accepting node reports, which the submit API returns.

fn update_leaf<'life0, 'async_trait>( &'life0 self, leaf: Leaf2, state: Arc<ValidatedState>, delta: Option<Arc<Delta>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

How catchup pushes a state it recovered from storage back into memory.

fn current_proposal_participation<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HashMap<PubKey, f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn proposal_participation<'life0, 'async_trait>( &'life0 self, epoch: EpochNumber, ) -> Pin<Box<dyn Future<Output = HashMap<PubKey, f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn current_vote_participation<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HashMap<PubKey, f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn vote_participation<'life0, 'async_trait>( &'life0 self, epoch: EpochNumber, ) -> Pin<Box<dyn Future<Output = HashMap<PubKey, f64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,