Struct SequencerContext

pub struct SequencerContext<N: ConnectedNetwork<PubKey>, P: SequencerPersistence, V: Versions> {
    handle: Arc<RwLock<Consensus<N, P, V>>>,
    pub request_response_protocol: RequestResponseProtocol<Node<N, P>, V, 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

handle: Arc<RwLock<Consensus<N, P, V>>>

The consensus handle

request_response_protocol: RequestResponseProtocol<Node<N, P>, V, 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: ConnectedNetwork<PubKey>, P: SequencerPersistence, V: Versions> SequencerContext<N, P, V>

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

fn new( handle: Consensus<N, P, V>, persistence: Arc<P>, state_signer: StateSigner<SequencerApiVersion>, external_event_handler: ExternalEventHandler<V>, request_response_protocol: RequestResponseProtocol<Node<N, P>, V, 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 async fn event_stream(&self) -> impl Stream<Item = Event<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(&self) -> Arc<RwLock<Consensus<N, P, V>>>

Return a reference to the underlying consensus handle.

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) -> 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(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, V: Clone + Versions> Clone for SequencerContext<N, P, V>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.