Struct penumbra_view::ViewService

pub struct ViewService { /* private fields */ }

A service that synchronizes private chain state and responds to queries about it.

The ViewService implements the Tonic-derived [ViewProtocol] trait, so it can be used as a gRPC server, or called directly. It spawns a task internally that performs synchronization and scanning. The ViewService can be cloned; each clone will read from the same shared state, but there will only be a single scanning task.

Implementations

impl ViewService

pub async fn load_or_initialize( storage_path: Option<impl AsRef<Utf8Path>>, fvk: &FullViewingKey, node: Url ) -> Result<Self>

Convenience method that calls Storage::load_or_initialize and then Self::new.

pub async fn new(storage: Storage, node: Url) -> Result<Self>

Constructs a new ViewService, spawning a sync task internally.

The sync task uses the provided client to sync with the chain.

To create multiple ViewServices, clone the ViewService returned by this method, rather than calling it multiple times. That way, each clone will be backed by the same scanning task, rather than each spawning its own.

pub async fn latest_known_block_height(&self) -> Result<(u64, bool)>

Return the latest block height known by the fullnode or its peers, as well as whether the fullnode is caught up with that height.

pub async fn status(&self) -> Result<StatusResponse>

Trait Implementations

impl Clone for ViewService

fn clone(&self) -> ViewService

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ViewProtocolService for ViewService

type NotesStream = Pin<Box<dyn Stream<Item = Result<NotesResponse, Status>> + Send, Global>>

Server streaming response type for the Notes method.

type NotesForVotingStream = Pin<Box<dyn Stream<Item = Result<NotesForVotingResponse, Status>> + Send, Global>>

Server streaming response type for the NotesForVoting method.

type AssetsStream = Pin<Box<dyn Stream<Item = Result<AssetsResponse, Status>> + Send, Global>>

Server streaming response type for the Assets method.

type StatusStreamStream = Pin<Box<dyn Stream<Item = Result<StatusStreamResponse, Status>> + Send, Global>>

Server streaming response type for the StatusStream method.

type TransactionInfoStream = Pin<Box<dyn Stream<Item = Result<TransactionInfoResponse, Status>> + Send, Global>>

Server streaming response type for the TransactionInfo method.

type BalancesStream = Pin<Box<dyn Stream<Item = Result<BalancesResponse, Status>> + Send, Global>>

Server streaming response type for the Balances method.

type OwnedPositionIdsStream = Pin<Box<dyn Stream<Item = Result<OwnedPositionIdsResponse, Status>> + Send, Global>>

Server streaming response type for the OwnedPositionIds method.

type UnclaimedSwapsStream = Pin<Box<dyn Stream<Item = Result<UnclaimedSwapsResponse, Status>> + Send, Global>>

Server streaming response type for the UnclaimedSwaps method.

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

Broadcast a transaction to the network, optionally waiting for full confirmation.

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

Query for a transaction plan

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

Query for an address given an address index

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

Query for an address given an address index

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

Query for an ephemeral address

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

Query for a given transaction by its hash.

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

Query for a swap by its swap commitment, optionally waiting until the swap is detected.

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

Query for balance of a given address. Returns a stream of BalancesResponses.

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

Query for a note by its note commitment, optionally waiting until the note is detected.

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

Query for whether a nullifier has been spent, optionally waiting until it is spent.

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

Get current status of chain sync

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

Stream sync status updates until the view service has caught up with the chain. Returns a stream of StatusStreamResponses.

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

Queries for notes that have been accepted by the chain. Returns a stream of NotesResponses.

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

Returns a stream of NotesForVotingResponses.

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

Queries for assets. Returns a stream of AssetsResponses.

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

Query for the full transactions in the given range of blocks. Returns a stream of TransactionInfoResponses.

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

Returns authentication paths for the given note commitments.

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

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

Query for the current chain parameters.

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

Query for the current FMD parameters.

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

Query for owned position IDs for the given trading pair and in the given position state.

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

Authorize a transaction plan and build the transaction.

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

Query for all unclaimed swaps.