Struct JsonRpcProvider

pub struct JsonRpcProvider { /* private fields */ }

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

Implementations

impl JsonRpcProvider

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)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let account_id: AccountId = "near-api-rs.testnet".parse::<AccountId>()?;

    let provider = Arc::new(JsonRpcProvider::new("https://rpc.testnet.near.org"));

    let result = get_access_key(provider, account_id).await;

    println!("response: {:#?}", result);

    Ok(())
}

examples/view_state.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let provider = Arc::new(JsonRpcProvider::new("https://rpc.testnet.near.org"));

    let contract_id: AccountId = "contract.near-api-rs.testnet".parse::<AccountId>()?;

    let result = view_state(provider, contract_id, None).await;
    println!("response: {:#?}", result);

    Ok(())
}

examples/create_account.rs (line 27)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let signer_account_id: AccountId = utils::input("Enter the signer Account ID: ")?.parse()?;
    let signer_secret_key = utils::input("Enter the signer's private key: ")?.parse()?;
    //To-do, implement account exist check.
    let new_account_id: AccountId = utils::input("Enter new account name: ")?.parse()?;

    let signer = InMemorySigner::from_secret_key(signer_account_id.clone(), signer_secret_key);

    // Amount to transfer to the new account
    let gas: Gas = 100_000_000_000_000; // Example amount in yoctoNEAR
    let amount: Balance = 10_000_000_000_000_000_000_000; // Example amount in yoctoNEAR

    let new_secret_key = near_crypto::SecretKey::from_random(near_crypto::KeyType::ED25519);
    let provider = Arc::new(JsonRpcProvider::new("https://rpc.testnet.near.org"));
    let signer = Arc::new(signer);

    let account = Account::new(signer_account_id, signer, provider);

    let contract_id: AccountId = "testnet".parse::<AccountId>()?;
    let method_name = "create_account".to_string();

    let args_json = json!({
        "new_account_id": new_account_id,
        "new_public_key": new_secret_key.public_key()
    });

    let result = account
        .function_call(contract_id, method_name, args_json, gas, amount)
        .await;

    println!("response: {:#?}", result);
    println!("New Account ID: {}", new_account_id);
    println!("Secret Key: {}", new_secret_key);

    Ok(())
}

examples/contract_change_method_commit.rs (line 22)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

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

    let provider = JsonRpcProvider::new("https://rpc.testnet.near.org");

    let signer_account_id = utils::input("Enter the signer Account ID: ")?.parse()?;
    let signer_secret_key = utils::input("Enter the signer's private key: ")?.parse()?;

    let signer = near_crypto::InMemorySigner::from_secret_key(signer_account_id, signer_secret_key);

    let access_key_query_response = client
        .call(methods::query::RpcQueryRequest {
            block_reference: BlockReference::latest(),
            request: near_primitives::views::QueryRequest::ViewAccessKey {
                account_id: signer.account_id.clone(),
                public_key: signer.public_key.clone(),
            },
        })
        .await?;

    let current_nonce = match access_key_query_response.kind {
        QueryResponseKind::AccessKey(access_key) => access_key.nonce,
        _ => Err("failed to extract current nonce")?,
    };

    let other_account = utils::input("Enter the account to be rated: ")?;
    let rating = utils::input("Enter a rating: ")?.parse::<f32>()?;

    let transaction = Transaction {
        signer_id: signer.account_id.clone(),
        public_key: signer.public_key.clone(),
        nonce: current_nonce + 1,
        receiver_id: "nosedive.testnet".parse()?,
        block_hash: access_key_query_response.block_hash,
        actions: vec![Action::FunctionCall(Box::new(FunctionCallAction {
            method_name: "rate".to_string(),
            args: json!({
                "account_id": other_account,
                "rating": rating,
            })
            .to_string()
            .into_bytes(),
            gas: 100_000_000_000_000, // 100 TeraGas
            deposit: 0,
        }))],
    };

    let response = provider.send_transaction(transaction.sign(&signer)).await?;

    println!("response: {:#?}", response);

    Ok(())
}

Trait Implementations

impl Provider for JsonRpcProvider

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.

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.

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.

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.

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.

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.

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.

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.

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.