Struct MultiRpcBuilder

pub struct MultiRpcBuilder<Handler, Method, Reference>
where
    Reference: Send + Sync,
    Handler: Send + Sync,
{
    reference: Reference,
    requests: Vec<Arc<dyn QueryCreator<Method, RpcReference = Reference> + Send + Sync>>,
    handler: Handler,
}

A builder for querying multiple items at once.

Sometimes to construct some complex type, you would need to query multiple items at once, and combine them into one. This is where this builder comes in handy. Almost every time, you would want to use Self::map method to combine the responses into your desired type.

Currently, MultiQueryHandler supports tuples of sizes 2 and 3. For single responses, use QueryBuilder instead.

Here is a list of examples on how to use this:

• Tokens::ft_balance
• StakingPool::staking_pool_info

Fields

reference: Reference

requests: Vec<Arc<dyn QueryCreator<Method, RpcReference = Reference> + Send + Sync>>

handler: Handler

Implementations

impl<Handler, Method, Reference> MultiRpcBuilder<Handler, Method, Reference>

where Reference: Send + Sync, Handler: Default + Send + Sync,

pub fn with_reference(reference: impl Into<Reference>) -> Self

impl<Handler, Method, Reference> MultiRpcBuilder<Handler, Method, Reference>

where Handler: ResponseHandler<QueryResponse = Method::Response, Method = Method> + Send + Sync, Method: RpcMethod + Debug + Send + Sync + 'static, Method::Response: Debug + Send + Sync, Method::Error: Display + Debug + Sync + Send, Reference: Clone + Send + Sync,

pub fn new(handler: Handler, reference: Reference) -> Self

pub fn map<MappedType>( self, map: impl Fn(Handler::Response) -> MappedType + Send + Sync + 'static, ) -> MultiRpcBuilder<PostprocessHandler<MappedType, Handler>, Method, Reference>

Map response of the queries to another type. The map function is executed after the queries are fetched.

The Handler::Response is the type returned by the handler’s process_response method.

For single responses, use QueryBuilder instead.

Example

use near_api::advanced::{MultiQueryHandler, CallResultHandler, MultiRpcBuilder};
use near_api::types::Data;
use std::marker::PhantomData;
use near_primitives::types::BlockReference;

// Create a handler for multiple query responses and specify the types of the responses
let handler = MultiQueryHandler::new((
    CallResultHandler::<String>::new(),
    CallResultHandler::<u128>::new(),
));

// Create the builder with the handler
let builder = MultiRpcBuilder::new(handler, BlockReference::latest());

// Add queries to the builder
builder.add_query(todo!());

// Map the tuple of responses to a combined type
let mapped_builder = builder.map(|(response1, response2): (Data<String>, Data<u128>)| {
    // Process the combined data
    format!("{}: {}", response1.data, response2.data)
});

See Tokens::ft_balance implementation for a real-world example.

pub fn add_query( self, request: Arc<dyn QueryCreator<Method, RpcReference = Reference> + Send + Sync>, ) -> Self

Add a query to the queried items. Sometimes you might need to query multiple items at once. To combine the result of multiple queries into one.

pub fn add_query_builder<T>( self, query_builder: RpcBuilder<T, Method, Reference>, ) -> Self

It might be easier to use this method to add a query builder to the queried items.

pub fn at(self, reference: impl Into<Reference>) -> Self

Set the block reference for the queries.

pub async fn fetch_from( self, network: &NetworkConfig, ) -> Result<Handler::Response, QueryError<Method>>

Fetch the queries from the provided network.

pub async fn fetch_from_mainnet( self, ) -> Result<Handler::Response, QueryError<Method>>

Fetch the queries from the default mainnet network configuration.

pub async fn fetch_from_testnet( self, ) -> Result<Handler::Response, QueryError<Method>>

Fetch the queries from the default testnet network configuration.