Struct RpcBuilder 

pub struct RpcBuilder<Query, Handler>
where
    Query: RpcType,
    Query::Response: Debug + Send + Sync,
    Query::Error: Debug + Send + Sync,
    Handler: Send + Sync,
{
    reference: Query::RpcReference,
    request: Arc<dyn RpcType<Response = Query::Response, RpcReference = Query::RpcReference, Error = Query::Error> + Send + Sync>,
    handler: Handler,
}

Fields

reference: Query::RpcReference

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

handler: Handler

Implementations

impl<Query, Handler> RpcBuilder<Query, Handler>

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

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

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

Set the block reference for the query.

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

Post-process the response of the query.

This is useful if you want to convert one type to another.

Example

use near_api::*;

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

pub fn and_then<MappedType>( self, map: impl Fn(Handler::Response) -> Result<MappedType, Box<dyn Error + Send + Sync>> + Send + Sync + 'static, ) -> RpcBuilder<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 async fn fetch_from( self, network: &NetworkConfig, ) -> Result<Handler::Response, QueryError<Query::Error>>

Fetch the query from the provided network.

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

Fetch the query from the default mainnet network configuration.

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

Fetch the query from the default testnet network configuration.