Struct JsonRpcProvider

Source
pub struct JsonRpcProvider { /* private fields */ }
Expand description

Represents a provider that uses JSON RPC to interact with the NEAR blockchain.

Implementations§

Source§

impl JsonRpcProvider

Source

pub fn new(rpc_endpoint: &str) -> JsonRpcProvider

Constructs a new JsonRpcProvider with the specified RPC endpoint.

Examples found in repository?
examples/get_access_key.rs (line 12)
7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    env_logger::init();
9
10    let account_id: AccountId = "near-api-rs.testnet".parse::<AccountId>()?;
11
12    let provider = Arc::new(JsonRpcProvider::new("https://rpc.testnet.near.org"));
13
14    let result = get_access_key(provider, account_id).await;
15
16    println!("response: {:#?}", result);
17
18    Ok(())
19}
More examples
Hide additional examples
examples/view_state.rs (line 10)
7async fn main() -> Result<(), Box<dyn std::error::Error>> {
8    env_logger::init();
9
10    let provider = Arc::new(JsonRpcProvider::new("https://rpc.testnet.near.org"));
11
12    let contract_id: AccountId = "contract.near-api-rs.testnet".parse::<AccountId>()?;
13
14    let result = view_state(provider, contract_id, None).await;
15    println!("response: {:#?}", result);
16
17    Ok(())
18}
examples/create_account.rs (line 27)
12async fn main() -> Result<(), Box<dyn std::error::Error>> {
13    env_logger::init();
14
15    let signer_account_id: AccountId = utils::input("Enter the signer Account ID: ")?.parse()?;
16    let signer_secret_key = utils::input("Enter the signer's private key: ")?.parse()?;
17    //To-do, implement account exist check.
18    let new_account_id: AccountId = utils::input("Enter new account name: ")?.parse()?;
19
20    let signer = InMemorySigner::from_secret_key(signer_account_id.clone(), signer_secret_key);
21
22    // Amount to transfer to the new account
23    let gas: Gas = 100_000_000_000_000; // Example amount in yoctoNEAR
24    let amount: Balance = 10_000_000_000_000_000_000_000; // Example amount in yoctoNEAR
25
26    let new_secret_key = near_crypto::SecretKey::from_random(near_crypto::KeyType::ED25519);
27    let provider = Arc::new(JsonRpcProvider::new("https://rpc.testnet.near.org"));
28    let signer = Arc::new(signer);
29
30    let account = Account::new(signer_account_id, signer, provider);
31
32    let contract_id: AccountId = "testnet".parse::<AccountId>()?;
33    let method_name = "create_account".to_string();
34
35    let args_json = json!({
36        "new_account_id": new_account_id,
37        "new_public_key": new_secret_key.public_key()
38    });
39
40    let result = account
41        .function_call(contract_id, method_name, args_json, gas, amount)
42        .await;
43
44    println!("response: {:#?}", result);
45    println!("New Account ID: {}", new_account_id);
46    println!("Secret Key: {}", new_secret_key);
47
48    Ok(())
49}
examples/contract_change_method_commit.rs (line 22)
17async fn main() -> Result<(), Box<dyn std::error::Error>> {
18    env_logger::init();
19
20    let client = JsonRpcClient::connect("https://rpc.testnet.near.org");
21
22    let provider = JsonRpcProvider::new("https://rpc.testnet.near.org");
23
24    let signer_account_id = utils::input("Enter the signer Account ID: ")?.parse()?;
25    let signer_secret_key = utils::input("Enter the signer's private key: ")?.parse()?;
26
27    let signer = near_crypto::InMemorySigner::from_secret_key(signer_account_id, signer_secret_key);
28
29    let access_key_query_response = client
30        .call(methods::query::RpcQueryRequest {
31            block_reference: BlockReference::latest(),
32            request: near_primitives::views::QueryRequest::ViewAccessKey {
33                account_id: signer.account_id.clone(),
34                public_key: signer.public_key.clone(),
35            },
36        })
37        .await?;
38
39    let current_nonce = match access_key_query_response.kind {
40        QueryResponseKind::AccessKey(access_key) => access_key.nonce,
41        _ => Err("failed to extract current nonce")?,
42    };
43
44    let other_account = utils::input("Enter the account to be rated: ")?;
45    let rating = utils::input("Enter a rating: ")?.parse::<f32>()?;
46
47    let transaction = Transaction {
48        signer_id: signer.account_id.clone(),
49        public_key: signer.public_key.clone(),
50        nonce: current_nonce + 1,
51        receiver_id: "nosedive.testnet".parse()?,
52        block_hash: access_key_query_response.block_hash,
53        actions: vec![Action::FunctionCall(Box::new(FunctionCallAction {
54            method_name: "rate".to_string(),
55            args: json!({
56                "account_id": other_account,
57                "rating": rating,
58            })
59            .to_string()
60            .into_bytes(),
61            gas: 100_000_000_000_000, // 100 TeraGas
62            deposit: 0,
63        }))],
64    };
65
66    let response = provider.send_transaction(transaction.sign(&signer)).await?;
67
68    println!("response: {:#?}", response);
69
70    Ok(())
71}

Trait Implementations§

Source§

impl Provider for JsonRpcProvider

Source§

fn status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StatusResponse, JsonRpcError<RpcStatusError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Retrieves the current status of the NEAR blockchain.

Source§

fn query<'life0, 'async_trait>( &'life0 self, request: QueryRequest, ) -> Pin<Box<dyn Future<Output = Result<RpcQueryResponse, JsonRpcError<RpcQueryError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Executes a query on the NEAR blockchain using a given QueryRequest.

Source§

fn send_transaction<'life0, 'async_trait>( &'life0 self, signed_transaction: SignedTransaction, ) -> Pin<Box<dyn Future<Output = Result<FinalExecutionOutcomeView, JsonRpcError<RpcTransactionError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Sends a signed transaction to the NEAR blockchain, waiting for its final execution outcome.

Source§

fn send_transaction_async<'life0, 'async_trait>( &'life0 self, signed_transaction: SignedTransaction, ) -> Pin<Box<dyn Future<Output = Result<CryptoHash, JsonRpcError<RpcBroadcastTxAsyncError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Sends a signed transaction to the NEAR blockchain asynchronously, without waiting for its final execution outcome.

Source§

fn tx_status<'life0, 'async_trait>( &'life0 self, transaction_info: TransactionInfo, ) -> Pin<Box<dyn Future<Output = Result<FinalExecutionOutcomeView, JsonRpcError<RpcTransactionError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Retrieves the status of a transaction on the NEAR blockchain, identified by TransactionInfo.

Source§

fn chunk<'life0, 'async_trait>( &'life0 self, chunk_reference: ChunkReference, ) -> Pin<Box<dyn Future<Output = Result<ChunkView, JsonRpcError<RpcChunkError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Fetches details of a specific chunk from the NEAR blockchain, identified by ChunkReference.

Source§

fn block<'life0, 'async_trait>( &'life0 self, block_reference: BlockReference, ) -> Pin<Box<dyn Future<Output = Result<BlockView, JsonRpcError<RpcBlockError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Retrieves a block from the NEAR blockchain, specified by its BlockReference.

Source§

fn experimental_protocol_config<'life0, 'async_trait>( &'life0 self, block_reference: BlockReference, ) -> Pin<Box<dyn Future<Output = Result<ProtocolConfigView, JsonRpcError<RpcProtocolConfigError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Fetches the experimental protocol configuration for a specific block, identified by BlockReference.

Source§

fn validators<'life0, 'async_trait>( &'life0 self, epoch_reference: EpochReference, ) -> Pin<Box<dyn Future<Output = Result<EpochValidatorInfo, JsonRpcError<RpcValidatorError>>> + Send + 'async_trait>>
where 'life0: 'async_trait, JsonRpcProvider: 'async_trait,

Retrieves information about validators for a given epoch, specified by EpochReference.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> ErasedDestructor for T
where T: 'static,