Struct ViewCall 

pub struct ViewCall<T> { /* private fields */ }

Query builder for calling view functions on contracts.

Example

let near = Near::testnet().build();

// Simple view call without args
let count: u64 = near.view("counter.testnet", "get_count").await?;

// View call with args
let messages: Vec<String> = near.view("guestbook.testnet", "get_messages")
    .args(serde_json::json!({ "limit": 10 }))
    .await?;

// Query at specific block
let old_count: u64 = near.view("counter.testnet", "get_count")
    .at_block(100_000_000)
    .await?;

Implementations

impl<T> ViewCall<T>

pub fn args<A: Serialize>(self, args: A) -> Self

Set JSON arguments for the view call.

The arguments will be serialized to JSON.

pub fn args_raw(self, args: Vec<u8>) -> Self

Set raw byte arguments (e.g., Borsh encoded).

pub fn args_borsh<A: BorshSerialize>(self, args: A) -> Self

Set Borsh-encoded arguments.

pub fn at_block(self, height: u64) -> Self

Query at a specific block height.

pub fn at_block_hash(self, hash: CryptoHash) -> Self

Query at a specific block hash.

pub fn finality(self, finality: Finality) -> Self

Query with specific finality.

pub fn borsh(self) -> ViewCallBorsh<T>

Switch to Borsh deserialization for the response.

By default, ViewCall deserializes responses as JSON. Call this method to deserialize as Borsh instead. This is useful for contracts that return Borsh-encoded data.

Example

use near_kit::*;
use borsh::BorshDeserialize;

#[derive(BorshDeserialize)]
struct ContractState { count: u64 }

async fn example() -> Result<(), near_kit::Error> {
    let near = Near::testnet().build();

    // Borsh response deserialization
    let state: ContractState = near.view("contract.testnet", "get_state")
        .borsh()
        .await?;
    Ok(())
}

Trait Implementations

impl<T: DeserializeOwned + Send + 'static> IntoFuture for ViewCall<T>

type Output = Result<T, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <ViewCall<T> as IntoFuture>::Output> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.