Struct SequencerContext 

pub struct SequencerContext<N: ConnectedNetwork<PubKey>, P: SequencerPersistence> {
    consensus_handle: Arc<ConsensusHandle<SeqTypes, Node<N, P>>>,
    pub request_response_protocol: RequestResponseProtocol<Node<N, P>, N, P>,
    state_signer: Arc<RwLock<StateSigner<SequencerApiVersion>>>,
    wait_for_orchestrator: Option<Arc<OrchestratorClient>>,
    tasks: TaskList,
    events_streamer: Arc<RwLock<EventsStreamer<SeqTypes>>>,
    detached: bool,
    node_state: NodeState,
    network_config: NetworkConfig<SeqTypes>,
    validator_config: ValidatorConfig<SeqTypes>,
}

The sequencer context contains a consensus handle and other sequencer specific information.

Fields

consensus_handle: Arc<ConsensusHandle<SeqTypes, Node<N, P>>>

The consensus adapter that dispatches between old HotShot and new coordinator.

request_response_protocol: RequestResponseProtocol<Node<N, P>, N, P>

The request-response protocol

state_signer: Arc<RwLock<StateSigner<SequencerApiVersion>>>

Context for generating state signatures.

wait_for_orchestrator: Option<Arc<OrchestratorClient>>

An orchestrator to wait for before starting consensus.

tasks: TaskList

Background tasks to shut down when the node is dropped.

events_streamer: Arc<RwLock<EventsStreamer<SeqTypes>>>

events streamer to stream hotshot events to external clients

detached: bool

node_state: NodeState

network_config: NetworkConfig<SeqTypes>

validator_config: ValidatorConfig<SeqTypes>

Implementations

impl<N, P> SequencerContext<N, P>

where N: ConnectedNetwork<PubKey>, P: SequencerPersistence,

pub async fn init<F>( network_config: NetworkConfig<SeqTypes>, upgrade: Upgrade, validator_config: ValidatorConfig<SeqTypes>, membership_coordinator: EpochMembershipCoordinator<SeqTypes>, instance_state: NodeState, storage: Option<RequestResponseStorage>, state_catchup: ParallelStateCatchup, persistence: Arc<P>, network: Arc<N>, coordinator_network: F, state_relay_server: Option<Url>, metrics: &dyn Metrics, stake_table_capacity: usize, event_consumer: impl PersistenceEventConsumer + 'static, proposal_fetcher_cfg: ProposalFetcherConfig, bootstrap_epoch_catchup_timeout: Duration, ) -> Result<Self>

where F: AsyncFnOnce(UpgradeLock<SeqTypes>) -> Result<Cliquenet<SeqTypes>, NetworkError>,

fn new( consensus_handle: Arc<ConsensusHandle<SeqTypes, Node<N, P>>>, persistence: Arc<P>, state_signer: StateSigner<SequencerApiVersion>, external_event_handler: ExternalEventHandler, request_response_protocol: RequestResponseProtocol<Node<N, P>, N, P>, event_streamer: Arc<RwLock<EventsStreamer<SeqTypes>>>, node_state: NodeState, network_config: NetworkConfig<SeqTypes>, validator_config: ValidatorConfig<SeqTypes>, event_consumer: impl PersistenceEventConsumer + 'static, anchor_view: Option<ViewNumber>, proposal_fetcher_cfg: ProposalFetcherConfig, metrics: &dyn Metrics, ) -> Self

Constructor

pub fn wait_for_orchestrator(self, client: OrchestratorClient) -> Self

Wait for a signal from the orchestrator before starting consensus.

pub(crate) fn with_task_list(self, tasks: TaskList) -> Self

Add a list of tasks to the given context.

pub fn state_signer(&self) -> Arc<RwLock<StateSigner<SequencerApiVersion>>>

Return a reference to the consensus state signer.

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

Stream consensus events.

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

pub fn event_streamer(&self) -> Arc<RwLock<EventsStreamer<SeqTypes>>>

get event streamer

pub fn consensus_handle(&self) -> Arc<ConsensusHandle<SeqTypes, Node<N, P>>>

Return a reference to the consensus adapter.

pub async fn upgrade_lock(&self) -> UpgradeLock<SeqTypes>

pub async fn shutdown_consensus(&self)

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

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

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

pub fn node_id(&self) -> u64

pub fn node_state(&self) -> NodeState

pub async fn start_consensus(&self)

Start participating in consensus.

pub fn spawn( &mut self, name: impl Display, task: impl Future<Output: Debug> + Send + 'static, )

Spawn a background task attached to this context.

When this context is dropped or shut_down, background tasks will be cancelled in the reverse order that they were spawned.

pub fn spawn_short_lived( &mut self, name: impl Display, task: impl Future<Output: Debug> + Send + 'static, )

Spawn a short-lived background task attached to this context.

When this context is dropped or shut_down, background tasks will be cancelled in the reverse order that they were spawned.

The only difference between a short-lived background task and a long-lived one is how urgently logging related to the task is treated.

pub async fn shut_down(&mut self)

Stop participating in consensus.

pub async fn join(&mut self)

Wait for consensus to complete.

Under normal conditions, this function will block forever, which is a convenient way of keeping the main thread from exiting as long as there are still active background tasks.

pub fn detach(&mut self)

Allow this node to continue participating in consensus even after it is dropped.

pub fn network_config(&self) -> NetworkConfig<SeqTypes>

Get the network config

Trait Implementations

impl<N: Clone + ConnectedNetwork<PubKey>, P: Clone + SequencerPersistence> Clone for SequencerContext<N, P>

fn clone(&self) -> SequencerContext<N, P>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N: ConnectedNetwork<PubKey>, P: SequencerPersistence> Debug for SequencerContext<N, P>

fn fmt(&self, __f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<N: ConnectedNetwork<PubKey>, P: SequencerPersistence> Drop for SequencerContext<N, P>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.