Struct NodeApiStateImpl 

pub struct NodeApiStateImpl<D> {
    data_source: D,
    env_vars: Arc<Vec<String>>,
    public_node_config: Option<Arc<PublicNodeConfig>>,
    ranges_concurrency: NonZeroUsize,
}

Node API state implementation

This struct implements the v1 API traits (internal types) and the v2 tonic service traits (proto types).

Fields

data_source: D

env_vars: Arc<Vec<String>>

public_node_config: Option<Arc<PublicNodeConfig>>

ranges_concurrency: NonZeroUsize

Implementations

impl<D> NodeApiStateImpl<D>

pub fn new(data_source: D) -> Self

pub fn with_ranges_concurrency(self, concurrency: NonZeroUsize) -> Self

pub fn with_env_vars(self, env_vars: Vec<String>) -> Self

pub fn with_public_node_config(self, config: Option<PublicNodeConfig>) -> Self

fn cloned_public_node_config(&self) -> Result<PublicNodeConfig>

Trait Implementations

impl<D> AvailabilityApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: AvailabilityDataSource<SeqTypes> + NodeDataSource<SeqTypes> + RequestResponseDataSource<SeqTypes> + StateCertDataSource + StateCertFetchingDataSource<SeqTypes> + Send + Sync,

fn get_namespace_proof<'life0, 'async_trait>( &'life0 self, block_id: BlockId, namespace: u32, ) -> Pin<Box<dyn Future<Output = Result<NamespaceProofQueryData>> + Send + 'async_trait>>

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

fn get_namespace_proof_range<'life0, 'async_trait>( &'life0 self, from: u64, until: u64, namespace: u32, ) -> Pin<Box<dyn Future<Output = Result<Vec<NamespaceProofQueryData>>> + Send + 'async_trait>>

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

fn stream_namespace_proofs<'life0, 'async_trait>( &'life0 self, from: usize, namespace: u32, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, NamespaceProofQueryData>>> + Send + 'async_trait>>

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

fn get_incorrect_encoding_proof<'life0, 'async_trait>( &'life0 self, block_id: BlockId, namespace: u32, ) -> Pin<Box<dyn Future<Output = Result<AvidMIncorrectEncodingNsProof>> + Send + 'async_trait>>

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

fn get_state_cert<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<StateCertQueryDataV1<SeqTypes>>> + Send + 'async_trait>>

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

fn get_state_cert_v2<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<StateCertQueryDataV2<SeqTypes>>> + Send + 'async_trait>>

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

impl<D> AvailabilityService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: AvailabilityDataSource<SeqTypes> + VersionedDataSource + NodeDataSource<SeqTypes> + RequestResponseDataSource<SeqTypes> + StateCertDataSource + StateCertFetchingDataSource<SeqTypes> + Send + Sync, for<'a> <D::Target as VersionedDataSource>::ReadOnly<'a>: AvailabilityStorage<SeqTypes>,

type StreamLeavesStream = Pin<Box<dyn Stream<Item = Result<LeafResponse, Status>> + Send>>

Server streaming response type for the StreamLeaves method.

type StreamHeadersStream = Pin<Box<dyn Stream<Item = Result<HeaderResponse, Status>> + Send>>

Server streaming response type for the StreamHeaders method.

type StreamBlocksStream = Pin<Box<dyn Stream<Item = Result<BlockResponse, Status>> + Send>>

Server streaming response type for the StreamBlocks method.

type StreamPayloadsStream = Pin<Box<dyn Stream<Item = Result<PayloadResponse, Status>> + Send>>

Server streaming response type for the StreamPayloads method.

type StreamVidCommonStream = Pin<Box<dyn Stream<Item = Result<VidCommonResponse, Status>> + Send>>

Server streaming response type for the StreamVidCommon method.

type StreamTransactionsStream = Pin<Box<dyn Stream<Item = Result<TransactionResponse, Status>> + Send>>

Server streaming response type for the StreamTransactions method.

type StreamNamespaceProofsStream = Pin<Box<dyn Stream<Item = Result<NamespaceProofResponse, Status>> + Send>>

Server streaming response type for the StreamNamespaceProofs method.

fn get_limits<'life0, 'async_trait>( &'life0 self, _request: Request<GetLimitsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<LimitsResponse>, Status>> + Send + 'async_trait>>

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

Get the most objects one range query may load, per object class

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

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

Get one block header. Exactly one of height, hash or payload_hash selects the block. None or several is a 400

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

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

Get the headers of a height range, bounded by the large-object range limit

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

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

Get one leaf with the QC certifying it. Exactly one of height or hash selects it. None or both is a 400

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

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

Get the leaves of a height range, bounded by the small-object range limit

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

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

Get the leaves of several height ranges in one request, for peers catching up. The whole set is served or none of it, in the order the ranges were given

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

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

Get the new protocol’s phase-2 certificate for a height. Not found before the new protocol took over, or while the node is still fetching it

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

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

Get one block, header and payload together. Exactly one of height, hash or payload_hash selects it. None or several is a 400

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

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

Get the blocks of a height range, bounded by the large-object range limit

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

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

Get the blocks of several height ranges in one request, for peers catching up. The whole set is served or none of it, in the order the ranges were given

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

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

Get one payload. Exactly one of height, hash or block_hash selects it. None or several is a 400

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

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

Get the payloads of a height range, bounded by the large-object range limit

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

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

Get the VID common data of one block. Exactly one of height, hash or payload_hash selects the block. None or several is a 400

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

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

Get the VID common data of a height range, bounded by the small-object range limit

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

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

Get the VID common data of several height ranges in one request, for peers catching up. The whole set is served or none of it, in the order the ranges were given

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

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

Get one transaction. Either height and index together, or hash, selects it. Anything else is a 400

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

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

Get one transaction with its inclusion proof. Either height and index together, or hash, selects it. Anything else is a 400

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

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

Get a block’s header with its hash, size and transaction count, without the payload

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

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

Get the block summaries of a height range, bounded by the large-object range limit

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

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

Get a namespace’s transactions and its proof against one block’s payload commitment. Exactly one of height, hash or payload_hash selects the block. None or several is a 400

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

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

Get a namespace’s proofs over a height range, bounded by the namespace-proof range limit

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

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

Get the proof that an AvidM block’s disperser encoded a namespace incorrectly

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

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

Get the light-client state certificate finalizing an epoch, in its first form

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

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

Get the light-client state certificate finalizing an epoch, with both contract signatures

fn stream_leaves<'life0, 'async_trait>( &'life0 self, request: Request<StreamLeavesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamLeavesStream>, Status>> + Send + 'async_trait>>

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

Subscribe to leaves from a height onward. Over REST this is server-sent events, one JSON data: frame per leaf. A stream follows the chain head and never ends on its own

fn stream_headers<'life0, 'async_trait>( &'life0 self, request: Request<StreamHeadersRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamHeadersStream>, Status>> + Send + 'async_trait>>

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

Subscribe to headers from a height onward, as server-sent events

fn stream_blocks<'life0, 'async_trait>( &'life0 self, request: Request<StreamBlocksRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamBlocksStream>, Status>> + Send + 'async_trait>>

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

Subscribe to blocks from a height onward, as server-sent events

fn stream_payloads<'life0, 'async_trait>( &'life0 self, request: Request<StreamPayloadsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamPayloadsStream>, Status>> + Send + 'async_trait>>

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

Subscribe to payloads from a height onward, as server-sent events

fn stream_vid_common<'life0, 'async_trait>( &'life0 self, request: Request<StreamVidCommonRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamVidCommonStream>, Status>> + Send + 'async_trait>>

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

Subscribe to VID common data from a height onward, as server-sent events

fn stream_transactions<'life0, 'async_trait>( &'life0 self, request: Request<StreamTransactionsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamTransactionsStream>, Status>> + Send + 'async_trait>>

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

Subscribe to transactions from a height onward, optionally of one namespace, as server-sent events

fn stream_namespace_proofs<'life0, 'async_trait>( &'life0 self, request: Request<StreamNamespaceProofsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::StreamNamespaceProofsStream>, Status>> + Send + 'async_trait>>

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

Subscribe to one namespace’s proofs from a height onward, as server-sent events

impl<D> BlockStateApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: MerklizedStateDataSource<SeqTypes, BlockMerkleTree, { <espresso_types::BlockMerkleTree as jf_merkle_tree_compat::MerkleTreeScheme>::ARITY }> + MerklizedStateHeightPersistence + Send + Sync,

fn get_block_state_path<'life0, 'async_trait>( &'life0 self, snapshot: Snapshot, key: String, ) -> Pin<Box<dyn Future<Output = Result<BlockStatePath>> + Send + 'async_trait>>

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

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

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

impl<D> CatchupApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: CatchupDataSource + NodeStateDataSource + Send + Sync,

fn get_account<'life0, 'async_trait>( &'life0 self, height: u64, view: u64, address: String, ) -> Pin<Box<dyn Future<Output = Result<AccountQueryData>> + Send + 'async_trait>>

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

fn get_accounts<'life0, 'async_trait>( &'life0 self, height: u64, view: u64, accounts: Vec<FeeAccount>, ) -> Pin<Box<dyn Future<Output = Result<FeeMerkleTree>> + Send + 'async_trait>>

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

fn get_blocks_frontier<'life0, 'async_trait>( &'life0 self, height: u64, view: u64, ) -> Pin<Box<dyn Future<Output = Result<BlocksFrontier>> + Send + 'async_trait>>

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

fn get_chain_config<'life0, 'async_trait>( &'life0 self, commitment: String, ) -> Pin<Box<dyn Future<Output = Result<ChainConfig>> + Send + 'async_trait>>

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

fn get_leaf_chain<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<Leaf2>>> + Send + 'async_trait>>

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

fn get_cert2<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<Certificate2<SeqTypes>>> + Send + 'async_trait>>

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

fn get_reward_account_v1<'life0, 'async_trait>( &'life0 self, height: u64, view: u64, address: String, ) -> Pin<Box<dyn Future<Output = Result<RewardAccountQueryDataV1>> + Send + 'async_trait>>

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

fn get_reward_accounts_v1<'life0, 'async_trait>( &'life0 self, height: u64, view: u64, accounts: Vec<RewardAccountV1>, ) -> Pin<Box<dyn Future<Output = Result<RewardMerkleTreeV1>> + Send + 'async_trait>>

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

fn get_reward_account_v2<'life0, 'async_trait>( &'life0 self, height: u64, view: u64, address: String, ) -> Pin<Box<dyn Future<Output = Result<RewardAccountQueryDataV2>> + Send + 'async_trait>>

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

fn get_reward_merkle_tree_v2<'life0, 'async_trait>( &'life0 self, height: u64, view: u64, ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>

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

fn get_state_cert<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<LightClientStateUpdateCertificateV2<SeqTypes>>> + Send + 'async_trait>>

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

impl<D> CatchupService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: CatchupDataSource + NodeStateDataSource + Send + Sync,

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

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

Prove one fee account’s balance at a height and view

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

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

Get the fee merkle tree holding the given accounts at a height and view

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

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

Get the block merkle tree frontier at a height and view

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

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

Resolve a chain configuration by its commitment

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

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

Get the leaves from the given height up to the next decide

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

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

Get the phase-2 certificate finalizing a height

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

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

Prove one reward account’s balance in the v1 tree. An account with no entry gets an absence proof and a zero balance

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

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

Get the v1 reward merkle tree holding the given accounts

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

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

Prove one reward account’s balance in the v2 tree. An account with no entry gets an absence proof and a zero balance

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

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

Get the whole v2 reward merkle tree at a height and view, in the serialized form the merklized-state reward tree route serves

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

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

Get the certificate closing an epoch

impl<D: Clone> Clone for NodeApiStateImpl<D>

fn clone(&self) -> NodeApiStateImpl<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D> ConfigApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: HotShotConfigDataSource + Send + Sync,

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

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

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

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

The allowlisted environment variables, each as a single KEY=value string. Unset variables are present with an empty value.

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

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

impl<D> ConfigService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: HotShotConfigDataSource + Send + Sync,

fn get_hotshot_config<'life0, 'async_trait>( &'life0 self, _request: Request<GetHotshotConfigRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<HotshotConfigResponse>, Status>> + Send + 'async_trait>>

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

Get the consensus parameters this node runs with

fn get_env<'life0, 'async_trait>( &'life0 self, _request: Request<GetEnvRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<EnvResponse>, Status>> + Send + 'async_trait>>

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

Get the allowlisted environment variables of this node, set or not

fn get_runtime_config<'life0, 'async_trait>( &'life0 self, _request: Request<GetRuntimeConfigRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<RuntimeConfigResponse>, Status>> + Send + 'async_trait>>

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

Get the node’s effective runtime configuration

impl<D> DatabaseApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: DatabaseMetadataSource + Send + Sync,

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

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

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

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

impl<D> DatabaseService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: DatabaseMetadataSource + Send + Sync,

fn get_table_sizes<'life0, 'async_trait>( &'life0 self, _request: Request<GetTableSizesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<TableSizesResponse>, Status>> + Send + 'async_trait>>

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

Get the row count and disk usage of every database table

fn get_migration_status<'life0, 'async_trait>( &'life0 self, _request: Request<GetMigrationStatusRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<MigrationStatusResponse>, Status>> + Send + 'async_trait>>

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

Get the progress of the deferred background migrations

impl<D> ExplorerApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: ExplorerDataSource<SeqTypes> + Send + Sync,

fn get_block_detail<'life0, 'async_trait>( &'life0 self, ident: BlockIdent, ) -> Pin<Box<dyn Future<Output = Result<BlockDetailResponse<SeqTypes>>> + Send + 'async_trait>>

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

fn get_block_summaries<'life0, 'async_trait>( &'life0 self, target: BlockIdent, limit: u64, ) -> Pin<Box<dyn Future<Output = Result<BlockSummaryResponse<SeqTypes>>> + Send + 'async_trait>>

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

fn get_transaction_detail<'life0, 'async_trait>( &'life0 self, ident: TxIdent, ) -> Pin<Box<dyn Future<Output = Result<TransactionDetailResponse<SeqTypes>>> + Send + 'async_trait>>

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

fn get_transaction_summaries<'life0, 'async_trait>( &'life0 self, target: TxIdent, limit: u64, filter: TxSummaryFilter, ) -> Pin<Box<dyn Future<Output = Result<TransactionSummariesResponse<SeqTypes>>> + Send + 'async_trait>>

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

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

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

fn get_search_result<'life0, 'async_trait>( &'life0 self, query: String, ) -> Pin<Box<dyn Future<Output = Result<SearchResultResponse<SeqTypes>>> + Send + 'async_trait>>

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

impl<D> ExplorerService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: ExplorerDataSource<SeqTypes> + Send + Sync,

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

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

Get one block in full

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

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

Get a window of blocks ending at the target block

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

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

Get one transaction in full, with its payloads

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

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

Get a window of transactions ending at the target transaction

fn get_explorer_summary<'life0, 'async_trait>( &'life0 self, _request: Request<GetExplorerSummaryRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ExplorerSummaryResponse>, Status>> + Send + 'async_trait>>

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

Get an at-a-glance snapshot of the chain

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

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

Search the chain for blocks and transactions matching a hash

impl<D> FeeStateApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: MerklizedStateDataSource<SeqTypes, FeeMerkleTree, { <espresso_types::FeeMerkleTree as jf_merkle_tree_compat::MerkleTreeScheme>::ARITY }> + MerklizedStateHeightPersistence + Send + Sync,

fn get_fee_state_path<'life0, 'async_trait>( &'life0 self, snapshot: Snapshot, key: String, ) -> Pin<Box<dyn Future<Output = Result<FeeStatePath>> + Send + 'async_trait>>

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

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

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

fn get_fee_balance_latest<'life0, 'async_trait>( &'life0 self, address: String, ) -> Pin<Box<dyn Future<Output = Result<Option<FeeAmount>>> + Send + 'async_trait>>

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

impl<D> HotShotAvailabilityApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: AvailabilityDataSource<SeqTypes> + VersionedDataSource + Send + Sync, for<'a> <D::Target as VersionedDataSource>::ReadOnly<'a>: AvailabilityStorage<SeqTypes>,

fn get_leaf<'life0, 'async_trait>( &'life0 self, id: LeafId, ) -> Pin<Box<dyn Future<Output = Result<LeafQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_leaf_range<'life0, 'async_trait>( &'life0 self, from: usize, until: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<LeafQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn get_header<'life0, 'async_trait>( &'life0 self, id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<HsHeader<SeqTypes>>> + Send + 'async_trait>>

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

fn get_header_range<'life0, 'async_trait>( &'life0 self, from: usize, until: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<HsHeader<SeqTypes>>>> + Send + 'async_trait>>

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

fn get_block<'life0, 'async_trait>( &'life0 self, id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<BlockQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_block_range<'life0, 'async_trait>( &'life0 self, from: usize, until: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn get_payload<'life0, 'async_trait>( &'life0 self, id: PayloadId, ) -> Pin<Box<dyn Future<Output = Result<PayloadQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_payload_range<'life0, 'async_trait>( &'life0 self, from: usize, until: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<PayloadQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn get_vid_common<'life0, 'async_trait>( &'life0 self, id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<VidCommonQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_vid_common_range<'life0, 'async_trait>( &'life0 self, from: usize, until: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<VidCommonQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn get_leaf_ranges<'life0, 'async_trait>( &'life0 self, ranges: Vec<Range<u64>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<LeafQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

The objects for a set of half-open height ranges, which must be ascending and disjoint.

fn get_block_ranges<'life0, 'async_trait>( &'life0 self, ranges: Vec<Range<u64>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn get_vid_common_ranges<'life0, 'async_trait>( &'life0 self, ranges: Vec<Range<u64>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<VidCommonQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn get_transaction_by_position<'life0, 'async_trait>( &'life0 self, height: u64, index: u64, ) -> Pin<Box<dyn Future<Output = Result<TransactionQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_transaction_by_hash<'life0, 'async_trait>( &'life0 self, hash: String, ) -> Pin<Box<dyn Future<Output = Result<TransactionQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_transaction_proof_by_position<'life0, 'async_trait>( &'life0 self, height: u64, index: u64, ) -> Pin<Box<dyn Future<Output = Result<TransactionWithProofQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_transaction_proof_by_hash<'life0, 'async_trait>( &'life0 self, hash: String, ) -> Pin<Box<dyn Future<Output = Result<TransactionWithProofQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_block_summary<'life0, 'async_trait>( &'life0 self, height: usize, ) -> Pin<Box<dyn Future<Output = Result<BlockSummaryQueryData<SeqTypes>>> + Send + 'async_trait>>

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

fn get_block_summary_range<'life0, 'async_trait>( &'life0 self, from: usize, until: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlockSummaryQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

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

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

fn get_cert2<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<Certificate2<SeqTypes>>>> + Send + 'async_trait>>

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

fn stream_leaves<'life0, 'async_trait>( &'life0 self, from: usize, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, LeafQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn stream_headers<'life0, 'async_trait>( &'life0 self, from: usize, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, HsHeader<SeqTypes>>>> + Send + 'async_trait>>

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

fn stream_blocks<'life0, 'async_trait>( &'life0 self, from: usize, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, BlockQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn stream_payloads<'life0, 'async_trait>( &'life0 self, from: usize, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, PayloadQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn stream_vid_common<'life0, 'async_trait>( &'life0 self, from: usize, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, VidCommonQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

fn stream_transactions<'life0, 'async_trait>( &'life0 self, from: usize, namespace: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<BoxStream<'static, TransactionQueryData<SeqTypes>>>> + Send + 'async_trait>>

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

impl<D> LightClientApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: AvailabilityDataSource<SeqTypes> + MerklizedStateDataSource<SeqTypes, BlockMerkleTree, 3> + MerklizedStateHeightPersistence + NodeStateDataSource + StakeTableDataSource<SeqTypes> + VersionedDataSource + Sized + Clone + Send + Sync + 'static, for<'a> <D::Target as VersionedDataSource>::ReadOnly<'a>: NodeStorage<SeqTypes> + AvailabilityStorage<SeqTypes>,

fn get_leaf_proof<'life0, 'async_trait>( &'life0 self, query: LeafQuery, finalized: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<LeafProof>> + Send + 'async_trait>>

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

fn get_header_proof<'life0, 'async_trait>( &'life0 self, root: u64, requested: HeaderQuery, ) -> Pin<Box<dyn Future<Output = Result<HeaderProof>> + Send + 'async_trait>>

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

fn get_light_client_stake_table<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<StakeTableEvent>>> + Send + 'async_trait>>

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

fn get_payload_proof<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<PayloadProof>> + Send + 'async_trait>>

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

fn get_payload_proof_range<'life0, 'async_trait>( &'life0 self, start: u64, end: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<PayloadProof>>> + Send + 'async_trait>>

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

fn get_payload_proof_ranges<'life0, 'async_trait>( &'life0 self, ranges: Vec<Range<u64>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<PayloadProof>>> + Send + 'async_trait>>

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

Payload proofs for a set of (from, until) half-open height ranges, which need not be contiguous.

fn get_lc_namespace_proof<'life0, 'async_trait>( &'life0 self, height: u64, namespace: u64, ) -> Pin<Box<dyn Future<Output = Result<NamespaceProof>> + Send + 'async_trait>>

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

fn get_lc_namespace_proof_range<'life0, 'async_trait>( &'life0 self, start: u64, end: u64, namespace: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<NamespaceProof>>> + Send + 'async_trait>>

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

fn get_lc_namespaces_proof_range<'life0, 'async_trait>( &'life0 self, start: u64, end: u64, namespaces: String, ) -> Pin<Box<dyn Future<Output = Result<Vec<HashMap<u64, NamespaceProof>>>> + Send + 'async_trait>>

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

namespaces is the raw TaggedBase64-encoded path segment produced by the light-client client (tag NS, wrapping a JSON Vec<u64>); decoding it is left to the implementation so this crate does not need a tagged-base64 dependency.

impl<D> LightClientService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: AvailabilityDataSource<SeqTypes> + MerklizedStateDataSource<SeqTypes, BlockMerkleTree, 3> + MerklizedStateHeightPersistence + NodeStateDataSource + StakeTableDataSource<SeqTypes> + VersionedDataSource + Sized + Clone + Send + Sync + 'static, for<'a> <D::Target as VersionedDataSource>::ReadOnly<'a>: NodeStorage<SeqTypes> + AvailabilityStorage<SeqTypes>,

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

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

Get a leaf with a proof that it is finalized

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

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

Get a header with a proof of membership under a trusted block merkle tree root

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

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

Get the stake table events that turn the previous epoch’s stake table into this epoch’s

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

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

Get a block payload with the data to check it against its header

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

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

Get payload proofs for a range of blocks

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

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

Get payload proofs for several ranges of blocks in one request

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

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

Get a proof of one namespace’s transactions in a block, checked against its header

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

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

Get one namespace’s proofs for a range of blocks

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

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

Get several namespaces’ proofs for a range of blocks

impl<D> MerklizedStateService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: MerklizedStateDataSource<SeqTypes, BlockMerkleTree, { <espresso_types::BlockMerkleTree as jf_merkle_tree_compat::MerkleTreeScheme>::ARITY }> + MerklizedStateDataSource<SeqTypes, FeeMerkleTree, { <espresso_types::FeeMerkleTree as jf_merkle_tree_compat::MerkleTreeScheme>::ARITY }> + MerklizedStateHeightPersistence + Send + Sync,

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

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

Get the Merkle path to one leaf of the block merkle tree, which commits to past block headers. Exactly one of height or commit selects the snapshot. None or both is a 400

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

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

Get the Merkle path to one account of the fee merkle tree, which holds the fee balances. Exactly one of height or commit selects the snapshot. None or both is a 400

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

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

Get an account’s fee balance in the newest persisted state

fn get_state_height<'life0, 'async_trait>( &'life0 self, _request: Request<GetStateHeightRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<StateHeightResponse>, Status>> + Send + 'async_trait>>

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

Get the height of the newest persisted merklized state, which every tree shares

impl<D> NodeApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: NodeDataSource<SeqTypes> + StakeTableDataSource<SeqTypes> + PruningDataSource + Send + Sync,

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

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

fn count_transactions<'life0, 'async_trait>( &'life0 self, from: Option<u64>, to: Option<u64>, namespace: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

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

fn payload_size<'life0, 'async_trait>( &'life0 self, from: Option<u64>, to: Option<u64>, namespace: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

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

fn get_vid_share<'life0, 'async_trait>( &'life0 self, id: VidShareId, ) -> Pin<Box<dyn Future<Output = Result<VidShare>> + Send + 'async_trait>>

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

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

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

fn get_header_window<'life0, 'async_trait>( &'life0 self, start: HeaderWindowStart, end: u64, ) -> Pin<Box<dyn Future<Output = Result<TimeWindowQueryData<Header<SeqTypes>>>> + Send + 'async_trait>>

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

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

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

fn stake_table<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<PeerConfig<SeqTypes>>>> + Send + 'async_trait>>

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

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

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

fn da_stake_table<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<PeerConfig<SeqTypes>>>> + Send + 'async_trait>>

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

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

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

fn get_validators<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<IndexMap<Address, AuthenticatedValidator<PubKey>>>> + Send + 'async_trait>>

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

fn get_all_validators<'life0, 'async_trait>( &'life0 self, epoch: u64, offset: u64, limit: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<RegisteredValidator<PubKey>>>> + Send + 'async_trait>>

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

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

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

fn proposal_participation<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<HashMap<PubKey, f64>>> + Send + 'async_trait>>

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

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

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

fn vote_participation<'life0, 'async_trait>( &'life0 self, epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<HashMap<PubKey, f64>>> + Send + 'async_trait>>

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

fn get_block_reward<'life0, 'async_trait>( &'life0 self, epoch: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<Option<RewardAmount>>> + Send + 'async_trait>>

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

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

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

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

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

impl<D> NodeService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: NodeDataSource<SeqTypes> + StakeTableDataSource<SeqTypes> + PruningDataSource + Send + Sync,

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

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

Count the transactions in a block range, optionally in one namespace

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

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

Get the cumulative payload size of a block range, optionally of one namespace

fn get_sync_status<'life0, 'async_trait>( &'life0 self, _request: Request<GetSyncStatusRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<SyncStatusResponse>, Status>> + Send + 'async_trait>>

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

Get which blocks, leaves and VID common data this node stores, still fetches, or has pruned

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

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

Get the block reward for an epoch

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

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

Get this node’s VID share for a block, selected by exactly one of height, hash or payload_hash

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

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

Get the headers whose timestamps fall in a window, plus the headers either side of it. The window starts at exactly one of start_time, start_height or start_hash

fn get_node_block_height<'life0, 'async_trait>( &'life0 self, _request: Request<GetNodeBlockHeightRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<NodeBlockHeightResponse>, Status>> + Send + 'async_trait>>

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

Get the height of the chain as this node sees it. /v2/status/block-height answers the same question; both exist because v1 has both, and a client watching one module should not have to call into another.

fn get_node_limits<'life0, 'async_trait>( &'life0 self, _request: Request<GetNodeLimitsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<NodeLimitsResponse>, Status>> + Send + 'async_trait>>

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

Get this node’s request limits

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

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

Get the consensus stake table for an epoch

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

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

Get the validators eligible for consensus in an epoch

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

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

Get a page of every registered validator in an epoch, eligible or not

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

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

Get, per validator, the proposals it made as a fraction of the views it led in an epoch

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

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

Get, per validator, the votes it cast as a fraction of an epoch’s views

impl<D> RewardApi for NodeApiStateImpl<D>

where D: RewardMerkleTreeDataSource + Deref, D::Target: MerklizedStateHeightPersistence + MerklizedStateDataSource<SeqTypes, RewardMerkleTreeV1, { <espresso_types::v0_3::RewardMerkleTreeV1 as jf_merkle_tree_compat::MerkleTreeScheme>::ARITY }> + MerklizedStateDataSource<SeqTypes, RewardMerkleTreeV2, { <espresso_types::v0_4::RewardMerkleTreeV2 as jf_merkle_tree_compat::MerkleTreeScheme>::ARITY }> + Send + Sync,

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

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

Get the height of the last persisted reward-state-v1 merklized state snapshot

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

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

Get the height of the last persisted reward-state-v2 merklized state snapshot

fn get_reward_account_proof_v1<'life0, 'async_trait>( &'life0 self, height: u64, address: String, ) -> Pin<Box<dyn Future<Output = Result<RewardAccountQueryDataV1>> + Send + 'async_trait>>

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

Get Merkle proof for a reward account against the V1 (RewardMerkleTreeV1) tree

fn get_reward_claim_input<'life0, 'async_trait>( &'life0 self, block_height: u64, address: String, ) -> Pin<Box<dyn Future<Output = Result<InternalRewardClaimInput>> + Send + 'async_trait>>

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

Get reward claim input for L1 contract submission

fn get_reward_balance<'life0, 'async_trait>( &'life0 self, height: u64, address: String, ) -> Pin<Box<dyn Future<Output = Result<InternalRewardAmount>> + Send + 'async_trait>>

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

Get reward balance at a specific height

fn get_latest_reward_balance<'life0, 'async_trait>( &'life0 self, address: String, ) -> Pin<Box<dyn Future<Output = Result<InternalRewardAmount>> + Send + 'async_trait>>

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

Get latest reward balance at the most recent finalized height

fn get_reward_account_proof<'life0, 'async_trait>( &'life0 self, height: u64, address: String, ) -> Pin<Box<dyn Future<Output = Result<InternalRewardAccountQueryData>> + Send + 'async_trait>>

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

Get Merkle proof for a reward account at a specific height

fn get_latest_reward_account_proof<'life0, 'async_trait>( &'life0 self, address: String, ) -> Pin<Box<dyn Future<Output = Result<InternalRewardAccountQueryData>> + Send + 'async_trait>>

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

Get Merkle proof for a reward account at the latest finalized height

fn get_reward_amounts<'life0, 'async_trait>( &'life0 self, height: u64, offset: u64, limit: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<(Address, InternalRewardAmount)>>> + Send + 'async_trait>>

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

Get paginated list of reward amounts at a specific height

fn get_reward_merkle_tree_v2<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>

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

Get raw RewardMerkleTreeV2 snapshot at a given height

fn get_reward_state_path_v1<'life0, 'async_trait>( &'life0 self, snapshot: Snapshot, key: String, ) -> Pin<Box<dyn Future<Output = Result<RewardStatePathV1>> + Send + 'async_trait>>

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

Get the Merkle path for a key in the reward-state (RewardMerkleTreeV1) tree

fn get_reward_state_path_v2<'life0, 'async_trait>( &'life0 self, snapshot: Snapshot, key: String, ) -> Pin<Box<dyn Future<Output = Result<RewardStatePathV2>> + Send + 'async_trait>>

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

Get the Merkle path for a key in the reward-state-v2 (RewardMerkleTreeV2) tree

impl<D> RewardStateService for NodeApiStateImpl<D>

where D: RewardMerkleTreeDataSource + Deref + Clone + Send + Sync + 'static, D::Target: MerklizedStateHeightPersistence + MerklizedStateDataSource<SeqTypes, RewardMerkleTreeV1, { <RewardMerkleTreeV1 as MerkleTreeScheme>::ARITY }> + MerklizedStateDataSource<SeqTypes, RewardMerkleTreeV2, { <RewardMerkleTreeV2 as MerkleTreeScheme>::ARITY }> + Send + Sync,

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

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

Get an account’s lifetime rewards at a height finalized by the light client contract, or at the newest one

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

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

Get an account’s lifetime rewards with the Merkle proof backing them, at a height finalized by the light client contract, or at the newest one

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

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

Get everything needed to call claimRewards on the L1 contract

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

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

Get a page of reward amounts at a block height

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

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

Get this node’s serialized RewardMerkleTreeV2 snapshot at a block height

impl<D> StateSignatureApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: StateSignatureDataSourceErased + Send + Sync,

fn get_state_signature<'life0, 'async_trait>( &'life0 self, height: u64, ) -> Pin<Box<dyn Future<Output = Result<LCV3StateSignatureRequestBody>> + Send + 'async_trait>>

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

impl<D> StateSignatureService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: StateSignatureDataSourceErased + Send + Sync,

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

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

Get this node’s light client state signature for a block

impl<D> StatusApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: StatusDataSource + NodeKeysDataSource + Send + Sync,

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

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

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

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

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

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

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

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

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

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

impl<D> StatusService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: StatusDataSource + NodeKeysDataSource + Send + Sync,

fn get_block_height<'life0, 'async_trait>( &'life0 self, _request: Request<GetBlockHeightRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<BlockHeightResponse>, Status>> + Send + 'async_trait>>

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

Get the height of the latest decided block

fn get_success_rate<'life0, 'async_trait>( &'life0 self, _request: Request<GetSuccessRateRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<SuccessRateResponse>, Status>> + Send + 'async_trait>>

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

Get the fraction of views in which this node decided a block

fn get_time_since_last_decide<'life0, 'async_trait>( &'life0 self, _request: Request<GetTimeSinceLastDecideRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<TimeSinceLastDecideResponse>, Status>> + Send + 'async_trait>>

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

Get the seconds elapsed since this node last decided a block

fn get_node_keys<'life0, 'async_trait>( &'life0 self, _request: Request<GetNodeKeysRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<NodeKeysResponse>, Status>> + Send + 'async_trait>>

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

Get the node’s public keys

impl<D> SubmitApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: SubmitDataSourceErased + Send + Sync,

fn submit<'life0, 'async_trait>( &'life0 self, tx: Transaction, ) -> Pin<Box<dyn Future<Output = Result<Commitment<Transaction>>> + Send + 'async_trait>>

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

impl<D> SubmitService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: SubmitDataSourceErased + Send + Sync,

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

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

Submit a transaction for sequencing

impl<D> TokenApi for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: TokenDataSource<SeqTypes> + NodeStateDataSource + Send + Sync,

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

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

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

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

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

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

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

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

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

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

impl<D> TokenService for NodeApiStateImpl<D>

where D: Deref + Clone + Send + Sync + 'static, D::Target: TokenDataSource<SeqTypes> + NodeStateDataSource + Send + Sync,

fn get_total_minted_supply<'life0, 'async_trait>( &'life0 self, _request: Request<GetTotalMintedSupplyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<TotalMintedSupplyResponse>, Status>> + Send + 'async_trait>>

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

Get the total supply of the ESP token minted on Ethereum; excludes unclaimed rewards

fn get_circulating_supply<'life0, 'async_trait>( &'life0 self, _request: Request<GetCirculatingSupplyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CirculatingSupplyResponse>, Status>> + Send + 'async_trait>>

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

Get the circulating supply, following the mainnet unlock schedule

fn get_circulating_supply_ethereum<'life0, 'async_trait>( &'life0 self, _request: Request<GetCirculatingSupplyEthereumRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CirculatingSupplyEthereumResponse>, Status>> + Send + 'async_trait>>

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

Get the circulating supply of ESP tokens on Ethereum L1

fn get_total_issued_supply<'life0, 'async_trait>( &'life0 self, _request: Request<GetTotalIssuedSupplyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<TotalIssuedSupplyResponse>, Status>> + Send + 'async_trait>>

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

Get the total issued supply, including rewards not yet claimed on Ethereum

fn get_total_reward_distributed<'life0, 'async_trait>( &'life0 self, _request: Request<GetTotalRewardDistributedRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<TotalRewardDistributedResponse>, Status>> + Send + 'async_trait>>

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

Get the total rewards distributed by consensus, including rewards not yet claimed on Ethereum