Struct massa_grpc::server::MassaPublicGrpc

pub struct MassaPublicGrpc {

    pub consensus_controller: Box<dyn ConsensusController>,
    pub consensus_broadcasts: ConsensusBroadcasts,
    pub execution_controller: Box<dyn ExecutionController>,
    pub execution_channels: ExecutionChannels,
    pub pool_broadcasts: PoolBroadcasts,
    pub pool_controller: Box<dyn PoolController>,
    pub protocol_controller: Box<dyn ProtocolController>,
    pub selector_controller: Box<dyn SelectorController>,
    pub storage: Storage,
    pub grpc_config: GrpcConfig,
    pub protocol_config: ProtocolConfig,
    pub node_id: NodeId,
    pub version: Version,
    pub keypair_factory: KeyPairFactory,
}

gRPC PUBLIC API content

Fields

consensus_controller: Box<dyn ConsensusController>

link to the consensus component

consensus_broadcasts: ConsensusBroadcasts

Broadcasts made by consensus component

execution_controller: Box<dyn ExecutionController>

link to the execution component

execution_channels: ExecutionChannels

link(channels) to the execution component

pool_broadcasts: PoolBroadcasts

Broadcasts made by pool component

pool_controller: Box<dyn PoolController>

link to the pool component

protocol_controller: Box<dyn ProtocolController>

link to the protocol component

selector_controller: Box<dyn SelectorController>

link to the selector component

storage: Storage

link to the storage component

grpc_config: GrpcConfig

gRPC configuration

protocol_config: ProtocolConfig

Massa protocol configuration

node_id: NodeId

our node id

version: Version

node version

keypair_factory: KeyPairFactory

keypair factory

Implementations

impl MassaPublicGrpc

pub async fn serve(self, config: &GrpcConfig) -> Result<StopHandle, GrpcError>

Start the gRPC PUBLIC API

Trait Implementations

impl Clone for MassaPublicGrpc

fn clone(&self) -> MassaPublicGrpc

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PublicService for MassaPublicGrpc

fn execute_read_only_call<'life0, 'async_trait>( &'life0 self, request: Request<ExecuteReadOnlyCallRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<ExecuteReadOnlyCallResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Execute read only call

fn get_blocks<'life0, 'async_trait>( &'life0 self, request: Request<GetBlocksRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetBlocksResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get blocks

fn get_datastore_entries<'life0, 'async_trait>( &'life0 self, request: Request<GetDatastoreEntriesRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetDatastoreEntriesResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get multiple datastore entries

fn get_endorsements<'life0, 'async_trait>( &'life0 self, request: Request<GetEndorsementsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetEndorsementsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get endorsements

fn get_stakers<'life0, 'async_trait>( &'life0 self, request: Request<GetStakersRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetStakersResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get largest stakers

fn get_status<'life0, 'async_trait>( &'life0 self, request: Request<GetStatusRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetStatusResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get satatus

fn get_next_block_best_parents<'life0, 'async_trait>( &'life0 self, request: Request<GetNextBlockBestParentsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetNextBlockBestParentsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get next block best parents

fn get_operations<'life0, 'async_trait>( &'life0 self, request: Request<GetOperationsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetOperationsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get operations

fn get_sc_execution_events<'life0, 'async_trait>( &'life0 self, request: Request<GetScExecutionEventsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetScExecutionEventsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get smart contract execution events

fn get_selector_draws<'life0, 'async_trait>( &'life0 self, request: Request<GetSelectorDrawsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetSelectorDrawsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get selector draws

fn get_transactions_throughput<'life0, 'async_trait>( &'life0 self, request: Request<GetTransactionsThroughputRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetTransactionsThroughputResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get transactions throughput

fn query_state<'life0, 'async_trait>( &'life0 self, request: Request<QueryStateRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<QueryStateResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for get version

fn search_blocks<'life0, 'async_trait>( &'life0 self, request: Request<SearchBlocksRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SearchBlocksResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for search blocks

fn search_endorsements<'life0, 'async_trait>( &'life0 self, request: Request<SearchEndorsementsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SearchEndorsementsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for search endorsemets

fn search_operations<'life0, 'async_trait>( &'life0 self, request: Request<SearchOperationsRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<SearchOperationsResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for search operations

fn new_blocks<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<NewBlocksRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::NewBlocksStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for subscribe new blocks

fn new_endorsements<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<NewEndorsementsRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::NewEndorsementsStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for subscribe new operations stream

fn new_filled_blocks<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<NewFilledBlocksRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::NewFilledBlocksStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for subscribe new blocks with operations content

fn new_operations<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<NewOperationsRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::NewOperationsStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for subscribe new operations stream

fn new_slot_execution_outputs<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<NewSlotExecutionOutputsRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::NewSlotExecutionOutputsStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for subscribe new slot execution output stream

fn new_slot_transfers<'life0, 'async_trait>( &'life0 self, _request: Request<Streaming<NewSlotTransfersRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::NewSlotTransfersStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for subscribe new slot transfers stream

fn new_slot_abi_call_stacks<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<NewSlotAbiCallStacksRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::NewSlotABICallStacksStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for subscribe new slot abi call stacks stream

fn send_blocks<'life0, 'async_trait>( &'life0 self, _request: Request<Streaming<SendBlocksRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::SendBlocksStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for send_blocks_stream

fn send_endorsements<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<SendEndorsementsRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::SendEndorsementsStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for send_endorsements

fn send_operations<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<SendOperationsRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::SendOperationsStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for send_operations

fn transactions_throughput<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<TransactionsThroughputRequest>> ) -> Pin<Box<dyn Future<Output = Result<Response<Self::TransactionsThroughputStream>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

handler for transactions throughput

fn get_operation_abi_call_stacks<'life0, 'async_trait>( &'life0 self, _request: Request<GetOperationAbiCallStacksRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetOperationAbiCallStacksResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get ABI call stack of an operation

fn get_slot_abi_call_stacks<'life0, 'async_trait>( &'life0 self, _request: Request<GetSlotAbiCallStacksRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetSlotAbiCallStacksResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get ABI call stack of all asynchronous executions and all operations for a given slot

fn get_slot_transfers<'life0, 'async_trait>( &'life0 self, _request: Request<GetSlotTransfersRequest> ) -> Pin<Box<dyn Future<Output = Result<Response<GetSlotTransfersResponse>, Status>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Get all the transfers of MAS for a given slot

type NewBlocksStream = Pin<Box<dyn Stream<Item = Result<NewBlocksResponse, Status>> + Send, Global>>

Server streaming response type for the NewBlocks method.

type NewEndorsementsStream = Pin<Box<dyn Stream<Item = Result<NewEndorsementsResponse, Status>> + Send, Global>>

Server streaming response type for the NewEndorsements method.

type NewFilledBlocksStream = Pin<Box<dyn Stream<Item = Result<NewFilledBlocksResponse, Status>> + Send, Global>>

Server streaming response type for the NewFilledBlocks method.

type NewOperationsStream = Pin<Box<dyn Stream<Item = Result<NewOperationsResponse, Status>> + Send, Global>>

Server streaming response type for the NewOperations method.

type NewSlotExecutionOutputsStream = Pin<Box<dyn Stream<Item = Result<NewSlotExecutionOutputsResponse, Status>> + Send, Global>>

Server streaming response type for the NewSlotExecutionOutputs method.

type NewSlotTransfersStream = Pin<Box<dyn Stream<Item = Result<NewSlotTransfersResponse, Status>> + Send, Global>>

Server streaming response type for the NewSlotTransfers method.

type NewSlotABICallStacksStream = Pin<Box<dyn Stream<Item = Result<NewSlotAbiCallStacksResponse, Status>> + Send, Global>>

Server streaming response type for the NewSlotABICallStacks method.

type SendBlocksStream = Pin<Box<dyn Stream<Item = Result<SendBlocksResponse, Status>> + Send, Global>>

Server streaming response type for the SendBlocks method.

type SendEndorsementsStream = Pin<Box<dyn Stream<Item = Result<SendEndorsementsResponse, Status>> + Send, Global>>

Server streaming response type for the SendEndorsements method.

type SendOperationsStream = Pin<Box<dyn Stream<Item = Result<SendOperationsResponse, Status>> + Send, Global>>

Server streaming response type for the SendOperations method.

type TransactionsThroughputStream = Pin<Box<dyn Stream<Item = Result<TransactionsThroughputResponse, Status>> + Send, Global>>

Server streaming response type for the TransactionsThroughput method.