Struct MultiRpcBuilder 

pub struct MultiRpcBuilder<Query, Handler>
where
    Query: RpcType,
    Query::Response: Debug + Send + Sync,
    Query::Error: Debug + Send + Sync,
    Handler: Send + Sync,
{
    reference: Query::RpcReference,
    requests: Vec<Arc<dyn RpcType<Response = Query::Response, RpcReference = Query::RpcReference, Error = Query::Error> + 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 RequestBuilder instead.

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

• Tokens::ft_balance
• StakingPool::staking_pool_info

Fields

reference: Query::RpcReference

requests: Vec<Arc<dyn RpcType<Response = Query::Response, RpcReference = Query::RpcReference, Error = Query::Error> + Send + Sync>>

handler: Handler

Implementations

impl<Query, Handler> MultiRpcBuilder<Query, Handler>

where Handler: Default + Send + Sync, Query: RpcType, Query::Response: Debug + Send + Sync, Query::Error: Debug + Send + Sync,

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

impl<Query, Handler> MultiRpcBuilder<Query, Handler>

where Handler: ResponseHandler<Query = Query> + Send + Sync, Query: RpcType, Query::Response: Debug + Send + Sync, Query::Error: Debug + Send + Sync,

pub fn new(handler: Handler, reference: impl Into<Query::RpcReference>) -> Self

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

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 RequestBuilder instead.

Example

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

// 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, Reference::Optimistic);

// 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 and_then<MappedType>( self, map: impl Fn(Handler::Response) -> Result<MappedType, Box<dyn Error + Send + Sync>> + Send + Sync + 'static, ) -> MultiRpcBuilder<Query, AndThenHandler<MappedType, Handler>>

Post-process the response of the query with error handling

This is useful if you want to convert one type to another but your function might fail.

The error will be wrapped in a QueryError::ConversionError and returned to the caller.

Example

use near_api::*;

let balance: NearToken = Contract("some_contract.testnet".parse()?)
        .call_function("get_balance", ())?
        .read_only()
        .and_then(|balance: Data<String>| Ok(NearToken::from_yoctonear(balance.data.parse()?)))
        .fetch_from_testnet()
        .await?;
println!("Balance: {}", balance);

pub fn add_query( self, request: Arc<dyn RpcType<Response = Query::Response, RpcReference = Query::RpcReference, Error = Query::Error> + 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<Handler2>( self, query_builder: RpcBuilder<Query, Handler2>, ) -> Self

where Handler2: ResponseHandler<Query = Query> + Send + Sync,

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

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

Set the block reference for the queries.

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

Fetch the queries from the provided network.

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

Fetch the queries from the default mainnet network configuration.

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

Fetch the queries from the default testnet network configuration.