Struct near_jsonrpc_client::JsonRpcClient

pub struct JsonRpcClient { /* private fields */ }

A NEAR JSON RPC Client.

This is the main struct that you will use to interact with the NEAR JSON RPC API.

Example

 use near_jsonrpc_client::{methods, JsonRpcClient};
 use near_primitives::types::{BlockReference, Finality};

 let client = JsonRpcClient::connect("https://rpc.testnet.near.org");

 let request = methods::block::RpcBlockRequest {
     block_reference: BlockReference::Finality(Finality::Final),
 };

 let server_status = client.call(request).await?;

 println!("{:?}", server_status);

Implementations

impl JsonRpcClient

pub fn connect<U: AsUrl>(server_addr: U) -> JsonRpcClient

Connect to a JSON RPC server using the default connector.

It’s virtually the same as calling new_client().connect(server_addr). Only, this method optimally reuses the same connector across invocations.

Example

use near_jsonrpc_client::JsonRpcClient;

let client = JsonRpcClient::connect("https://rpc.testnet.near.org");

pub fn server_addr(&self) -> &str

Get the server address the client connects to.

It basically returns the server address passed to connect().

Example

let client = JsonRpcClient::connect("https://rpc.testnet.near.org");

assert_eq!(client.server_addr(), "https://rpc.testnet.near.org");

pub async fn call<M>( &self, method: M, ) -> MethodCallResult<M::Response, M::Error>

where M: RpcMethod,

RPC method executor for the client.

Example

use near_jsonrpc_client::{methods, JsonRpcClient};

let client = JsonRpcClient::connect("https://rpc.testnet.near.org");

let request = methods::status::RpcStatusRequest;
let response = client.call(request).await?;

assert!(matches!(
    response,
    methods::status::RpcStatusResponse { .. }
));

pub fn header<H, D>(self, entry: H) -> D::Output

where H: HeaderEntry<D>, D: HeaderEntryDiscriminant<H>,

Add a header to this request.

Depending on the header specified, this method either returns back the client, or a result containing the client.

Example

use near_jsonrpc_client::JsonRpcClient;

let client = JsonRpcClient::connect("https://rpc.testnet.near.org");
let client = client.header(("user-agent", "someclient/0.1.0"))?; // <- returns a result

use near_jsonrpc_client::auth;

let client = client.header(
    auth::ApiKey::new("cadc4c83-5566-4c94-aa36-773605150f44")?, // <- error handling here
); // <- returns the client

pub fn headers(&self) -> &HeaderMap

Get a shared reference to the headers.

pub fn headers_mut(&mut self) -> &mut HeaderMap

Get an exclusive reference to the headers.

pub fn new_client() -> JsonRpcClientConnector

Manually create a new client connector.

It’s recommended to use the connect method instead as that method optimally reuses the default connector across invocations.

However, if for some reason you still need to manually create a new connector, you can do so. Just remember to properly reuse it as much as possible.

Example

let client_connector = JsonRpcClient::new_client();

let mainnet_client = client_connector.connect("https://rpc.mainnet.near.org");
let testnet_client = client_connector.connect("https://rpc.testnet.near.org");

pub fn with(client: Client) -> JsonRpcClientConnector

Create a new client constructor using a custom web client.

This is useful if you want to customize the reqwest::Client instance used by the JsonRpcClient.

Example

use near_jsonrpc_client::JsonRpcClient;

let web_client = reqwest::Client::builder()
    .proxy(reqwest::Proxy::all("https://192.168.1.1:4825")?)
    .build()?;

let testnet_client = JsonRpcClient::with(web_client).connect("https://rpc.testnet.near.org");

Trait Implementations

impl Clone for JsonRpcClient

fn clone(&self) -> JsonRpcClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for JsonRpcClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.