Enum Request 

pub enum Request {
    Accounts(u64, u64, Vec<FeeAccount>),
    Leaf(u64),
    ChainConfig(Commitment<ChainConfig>),
    BlocksFrontier(u64, u64),
    RewardAccountsV2(u64, u64, Vec<RewardAccountV2>),
    RewardAccountsV1(u64, u64, Vec<RewardAccountV1>),
    VidShare(u64, u64),
    StateCert(u64),
}

The outermost request type. This an enum that contains all the possible requests that the sequencer can make.

Variants

Accounts(u64, u64, Vec<FeeAccount>)

A request for the accounts at a given height and view

Leaf(u64)

A request for the leaf chain at a given height

ChainConfig(Commitment<ChainConfig>)

A request for a chain config with a particular commitment

BlocksFrontier(u64, u64)

A request for the blocks frontier

RewardAccountsV2(u64, u64, Vec<RewardAccountV2>)

A request for the reward accounts at a given height and view

RewardAccountsV1(u64, u64, Vec<RewardAccountV1>)

A request for the v1 reward accounts at a given height and view

VidShare(u64, u64)

A request for the VID share at the given block height

StateCert(u64)

A request for the state certificate at a given epoch

Trait Implementations

impl Clone for Request

fn clone(&self) -> Request

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: NodeImplementation<SeqTypes>, V: Versions, N: ConnectedNetwork<PubKey>, P: SequencerPersistence> DataSource<Request> for DataSource<I, V, N, P>

Implement the trait that allows the [RequestResponseProtocol] to calculate/derive a response for a specific request

fn derive_response_for<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 Request, ) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>>

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

Calculate/derive the response for a specific request

impl Debug for Request

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Request

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: NodeImplementation<SeqTypes>, V: Versions> RecipientSource<Request, VerKey> for RecipientSource<I, V>

Implement the RecipientSourceTrait, which allows the request-response protocol to derive the intended recipients for a given request

fn get_expected_responders<'life0, 'life1, 'async_trait>( &'life0 self, _request: &'life1 Request, ) -> Pin<Box<dyn Future<Output = Result<Vec<PubKey>>> + Send + 'async_trait>>

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

Get all the recipients that the specific request should expect responses from

impl Request for Request

Implement the RequestTrait trait for the Request type. This tells the request response protocol how to validate the request and what the response type is.

type Response = Response

The response type associated with this request

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

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

Validate the request, returning an error if it is not valid

impl Serializable for Request

Implement the Serializable trait for the Request type. This tells the request response protocol how to serialize and deserialize the request

fn to_bytes(&self) -> Result<Vec<u8>>

Serialize the type to a byte array. If this is for a Request and your Request type is represented as an enum, please make sure that you serialize it with a unique type ID. Otherwise, you may end up with collisions as the request hash is used as a unique identifier

fn from_bytes(bytes: &[u8]) -> Result<Self>

Deserialize the type from a byte array

impl Serialize for Request

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.