near-api 0.8.5

Rust library to interact with NEAR Protocol via RPC API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use near_api::{
    Contract, NetworkConfig, Signer, Tokens,
    types::{AccountId, NearToken, nft::TokenMetadata},
};
use near_sandbox::{
    GenesisAccount, SandboxConfig,
    config::{DEFAULT_GENESIS_ACCOUNT, DEFAULT_GENESIS_ACCOUNT_PRIVATE_KEY},
};
use serde_json::json;

#[tokio::main]
async fn main() -> testresult::TestResult {
    let nft = GenesisAccount::generate_with_name("nft".parse()?);
    let account: AccountId = DEFAULT_GENESIS_ACCOUNT.into();
    let account2 = GenesisAccount::generate_with_name("account2".parse()?);

    let sandbox = near_sandbox::Sandbox::start_sandbox_with_config(SandboxConfig {
        additional_accounts: vec![nft.clone(), account2.clone()],
        ..Default::default()
    })
    .await?;
    let network = NetworkConfig::from_rpc_url("sandbox", sandbox.rpc_addr.parse()?);

    let nft_signer = Signer::from_secret_key(nft.private_key.clone().parse()?)?;
    let account_signer = Signer::from_secret_key(DEFAULT_GENESIS_ACCOUNT_PRIVATE_KEY.parse()?)?;

    // Deploying token contract
    Contract::deploy(nft.account_id.clone())
        .use_code(include_bytes!("../resources/nft.wasm").to_vec())
        .with_init_call(
            "new_default_meta",
            json!({
                "owner_id": nft.account_id.to_string(),
            }),
        )?
        .with_signer(nft_signer.clone())
        .send_to(&network)
        .await?
        .assert_success();

    let contract = Contract(nft.account_id.clone());

    // Mint NFT via contract call
    contract
        .call_function(
            "nft_mint",
            json!({
                "token_id": "1",
                "receiver_id": account.to_string(),
                "token_metadata": TokenMetadata {
                    title: Some("My NFT".to_string()),
                    description: Some("My first NFT".to_string()),
                    ..Default::default()
                }
            }),
        )
        .transaction()
        .deposit(NearToken::from_millinear(100))
        .with_signer(nft.account_id.clone(), nft_signer.clone())
        .send_to(&network)
        .await?
        .assert_success();

    // Verifying that account has our nft token
    let tokens = Tokens::account(account.clone())
        .nft_assets(nft.account_id.clone())
        .fetch_from(&network)
        .await?;

    assert_eq!(tokens.data.len(), 1);
    println!(
        "Account has {}",
        tokens.data.first().ok_or("No token found")?.token_id
    );

    Tokens::account(account.clone())
        .send_to(account2.account_id.clone())
        .nft(nft.account_id.clone(), "1".to_string())
        .with_signer(account_signer.clone())
        .send_to(&network)
        .await?
        .assert_success();

    // Verifying that account doesn't have nft anymore
    let tokens = Tokens::account(account.clone())
        .nft_assets(nft.account_id.clone())
        .fetch_from(&network)
        .await?;

    assert!(tokens.data.is_empty());

    let tokens = Tokens::account(account2.account_id.clone())
        .nft_assets(nft.account_id.clone())
        .fetch_from(&network)
        .await?;

    assert_eq!(tokens.data.len(), 1);
    println!(
        "account 2 has {}",
        tokens.data.first().ok_or("No token found")?.token_id
    );

    Ok(())
}