Struct hotshot_task_impls::quorum_proposal::QuorumProposalTaskState

pub struct QuorumProposalTaskState<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> {

    pub latest_proposed_view: TYPES::View,
    pub cur_epoch: TYPES::Epoch,
    pub proposal_dependencies: BTreeMap<TYPES::View, JoinHandle<()>>,
    pub instance_state: Arc<TYPES::InstanceState>,
    pub membership: Arc<RwLock<TYPES::Membership>>,
    pub public_key: TYPES::SignatureKey,
    pub private_key: <TYPES::SignatureKey as SignatureKey>::PrivateKey,
    pub timeout: u64,
    pub storage: Arc<RwLock<I::Storage>>,
    pub consensus: OuterConsensus<TYPES>,
    pub id: u64,
    pub formed_upgrade_certificate: Option<UpgradeCertificate<TYPES>>,
    pub upgrade_lock: UpgradeLock<TYPES, V>,
    pub epoch_height: u64,
    pub highest_qc: QuorumCertificate2<TYPES>,
}

The state for the quorum proposal task.

Fields

latest_proposed_view: TYPES::View

Latest view number that has been proposed for.

cur_epoch: TYPES::Epoch

Current epoch

proposal_dependencies: BTreeMap<TYPES::View, JoinHandle<()>>

Table for the in-progress proposal dependency tasks.

instance_state: Arc<TYPES::InstanceState>

Immutable instance state

membership: Arc<RwLock<TYPES::Membership>>

Membership for Quorum Certs/votes

public_key: TYPES::SignatureKey

Our public key

private_key: <TYPES::SignatureKey as SignatureKey>::PrivateKey

Our Private Key

timeout: u64

View timeout from config.

storage: Arc<RwLock<I::Storage>>

This node’s storage ref

consensus: OuterConsensus<TYPES>

Shared consensus task state

id: u64

The node’s id

formed_upgrade_certificate: Option<UpgradeCertificate<TYPES>>

The most recent upgrade certificate this node formed. Note: this is ONLY for certificates that have been formed internally, so that we can propose with them.

Certificates received from other nodes will get reattached regardless of this fields, since they will be present in the leaf we propose off of.

upgrade_lock: UpgradeLock<TYPES, V>

Lock for a decided upgrade

epoch_height: u64

Number of blocks in an epoch, zero means there are no epochs

highest_qc: QuorumCertificate2<TYPES>

The highest_qc we’ve seen at the start of this task

Implementations

impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> QuorumProposalTaskState<TYPES, I, V>

fn create_event_dependency( &self, dependency_type: ProposalDependency, view_number: TYPES::View, event_receiver: Receiver<Arc<HotShotEvent<TYPES>>>, ) -> EventDependency<Arc<HotShotEvent<TYPES>>>

Create an event dependency

fn create_and_complete_dependencies( &self, view_number: TYPES::View, event_receiver: &Receiver<Arc<HotShotEvent<TYPES>>>, event: Arc<HotShotEvent<TYPES>>, ) -> AndDependency<Vec<Vec<Arc<HotShotEvent<TYPES>>>>>

Creates the requisite dependencies for the Quorum Proposal task. It also handles any event forwarding.

async fn create_dependency_task_if_new( &mut self, view_number: TYPES::View, epoch_number: TYPES::Epoch, event_receiver: Receiver<Arc<HotShotEvent<TYPES>>>, event_sender: Sender<Arc<HotShotEvent<TYPES>>>, event: Arc<HotShotEvent<TYPES>>, epoch_transition_indicator: EpochTransitionIndicator, ) -> Result<()>

Create and store an AndDependency combining EventDependencys associated with the given view number if it doesn’t exist. Also takes in the received event to seed a dependency as already completed. This allows for the task to receive a proposable event without losing the data that it received, as the dependency task would otherwise have no ability to receive the event and, thus, would never propose.

async fn update_latest_proposed_view(&mut self, new_view: TYPES::View) -> bool

Update the latest proposed view number.

pub async fn handle( &mut self, event: Arc<HotShotEvent<TYPES>>, event_receiver: Receiver<Arc<HotShotEvent<TYPES>>>, event_sender: Sender<Arc<HotShotEvent<TYPES>>>, ) -> Result<()>

Handles a consensus event received on the event stream

pub fn cancel_tasks(&mut self, view: TYPES::View)

Cancel all tasks the consensus tasks has spawned before the given view

Trait Implementations

impl<TYPES: NodeType, I: NodeImplementation<TYPES>, V: Versions> TaskState for QuorumProposalTaskState<TYPES, I, V>

type Event = HotShotEvent<TYPES>

Type of event sent and received by the task

fn handle_event<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, event: Arc<Self::Event>, sender: &'life1 Sender<Arc<Self::Event>>, receiver: &'life2 Receiver<Arc<Self::Event>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handles an event, providing direct access to the specific channel we received the event on.

fn cancel_subtasks(&mut self)

Joins all subtasks.