Struct Account 

pub struct Account(pub AccountId);

Account management related interactions with the NEAR Protocol

The Account struct provides methods to interact with NEAR accounts, including querying account information, managing access keys, and creating new accounts.

Examples

use near_api::*;

let account_info = Account("alice.testnet".parse()?).view().fetch_from_testnet().await?;
println!("Account: {:?}", account_info);

Tuple Fields

0: AccountId

Implementations

impl Account

pub const fn account_id(&self) -> &AccountId

Returns the underlying account ID for this account.

Example

use near_api::*;

let account = Account("alice.testnet".parse()?);
let account_id = account.account_id();
println!("Account ID: {}", account_id);

pub fn as_contract(&self) -> Contract

Converts this account to a Contract for contract-related operations.

Example

use near_api::*;
use serde_json::json;

let account = Account("contract.testnet".parse()?);
let contract = account.as_contract();
let result: String = contract.call_function("get_value", ())?.read_only().fetch_from_testnet().await?.data;
println!("Contract value: {:?}", result);

pub fn tokens(&self) -> Tokens

Creates a Tokens wrapper for token-related operations on this account.

Example

use near_api::*;

let account = Account("alice.testnet".parse()?);
let tokens = account.tokens();
let balance = tokens.near_balance().fetch_from_testnet().await?;
println!("NEAR balance: {}", balance.total);

pub fn delegation(&self) -> Delegation

Creates a Delegation wrapper for staking-related operations on this account.

Example

use near_api::*;

let account = Account("alice.testnet".parse()?);
let delegation = account.delegation();
let staked = delegation.view_staked_balance("pool.testnet".parse()?)?.fetch_from_testnet().await?;
println!("Staked balance: {:?}", staked);

pub fn view(&self) -> RequestBuilder<AccountViewHandler>

Prepares a query to fetch the Data<AccountView> with the account information for the given account ID.

Example

use near_api::*;

let account_info = Account("alice.testnet".parse()?).view().fetch_from_testnet().await?;
println!("Account: {:?}", account_info);

pub fn access_key( &self, signer_public_key: impl Into<PublicKey>, ) -> RequestBuilder<AccessKeyHandler>

Prepares a query to fetch the Data<AccessKey> with the access key information for the given account public key.

Example

use near_api::*;
use std::str::FromStr;

let access_key = Account("alice.testnet".parse()?)
    .access_key(PublicKey::from_str("ed25519:H4sIAAAAAAAAA+2X0Q6CMBAAtVlJQgYAAAA=")?)
    .fetch_from_testnet()
    .await?;
println!("Access key: {:?}", access_key);

pub fn list_keys(&self) -> RequestBuilder<AccessKeyListHandler>

Prepares a query to fetch the Vec<(PublicKey, AccessKey)> list of access keys for the given account ID.

Example

use near_api::*;

let access_keys = Account("alice.testnet".parse()?).list_keys().fetch_from_testnet().await?;
println!("Access keys: {:?}", access_keys);

pub fn add_key( &self, permission: AccessKeyPermission, public_key: impl Into<PublicKey>, ) -> ConstructTransaction

Adds a new access key to the given account ID.

Example

use near_api::{*, types::AccessKeyPermission};
use std::str::FromStr;

let pk = PublicKey::from_str("ed25519:H4sIAAAAAAAAA+2X0Q6CMBAAtVlJQgYAAAA=")?;
let result = Account("alice.testnet".parse()?)
    .add_key(AccessKeyPermission::FullAccess, pk)
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

pub fn delete_key( &self, public_key: impl Into<PublicKey>, ) -> ConstructTransaction

Deletes an access key from the given account ID.

Example

use near_api::*;
use std::str::FromStr;
let result = Account("alice.testnet".parse()?)
    .delete_key(PublicKey::from_str("ed25519:H4sIAAAAAAAAA+2X0Q6CMBAAtVlJQgYAAAA=")?)
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

pub fn delete_keys(&self, public_keys: Vec<PublicKey>) -> ConstructTransaction

Deletes multiple access keys from the given account ID.

Example

use near_api::*;
use std::str::FromStr;

let result = Account("alice.testnet".parse()?)
    .delete_keys(vec![PublicKey::from_str("ed25519:H4sIAAAAAAAAA+2X0Q6CMBAAtVlJQgYAAAA=")?])
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

pub fn delete_account_with_beneficiary( &self, beneficiary_id: AccountId, ) -> ConstructTransaction

Deletes the account with the given beneficiary ID. The account balance will be transferred to the beneficiary.

Please note that this action is irreversible. Also, you have to understand that another person could potentially re-create the account with the same name and pretend to be you on other websites that use your account ID as a unique identifier. (near.social, devhub proposal, etc)

Do not use it unless you understand the consequences.

Example

use near_api::*;

let result = Account("alice.testnet".parse()?)
    .delete_account_with_beneficiary("bob.testnet".parse()?)
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

pub const fn create_account(account_id: AccountId) -> CreateAccountBuilder

Creates a new account builder for the given account ID.

Creating account sponsored by faucet service

This is a way to create an account without having to fund it. It works only on testnet. The account should be created as a sub-account of the testnet account

use near_api::*;

let secret = near_api::signer::generate_secret_key()?;
let result: reqwest::Response = Account::create_account("alice.testnet".parse()?)
    .sponsor_by_faucet_service()
    .public_key(secret.public_key())?
    .send_to_testnet_faucet()
    .await?;
// You have to save the secret key somewhere safe
std::fs::write("secret.key", secret.to_string())?;

Creating sub-account of the linkdrop root account funded by your own NEAR and signed by your account

There is a few linkdrop root accounts that you can use to create sub-accounts.

• For mainnet, you can use the near account.
• For testnet, you can use the testnet account.

use near_api::*;

let secret = near_api::signer::generate_secret_key()?;
let bob_signer = Signer::new(Signer::from_seed_phrase("lucky barrel fall come bottom can rib join rough around subway cloth ", None)?)?;
let result = Account::create_account("alice.testnet".parse()?)
    .fund_myself("bob.testnet".parse()?, NearToken::from_near(1))
    .public_key(secret.public_key())?
    .with_signer(bob_signer)
    .send_to_testnet()
    .await?;

Creating sub-account of your own account funded by your NEAR

You can create only one level deep of sub-accounts.

E.g you are alice.testnet, you can’t create sub.sub.alice.testnet, but you can create sub.alice.testnet. Though, ‘sub.alice.testnet’ can create sub-accounts of its own.

use near_api::*;

let secret = near_api::signer::generate_secret_key()?;
let bob_signer = Signer::new(Signer::from_seed_phrase("lucky barrel fall come bottom can rib join rough around subway cloth ", None)?)?;
let result = Account::create_account("sub.bob.testnet".parse()?)
    .fund_myself("bob.testnet".parse()?, NearToken::from_near(1))
    .public_key(secret.public_key())?
    .with_signer(bob_signer)
    .send_to_testnet()
    .await?;

Trait Implementations

impl Clone for Account

fn clone(&self) -> Account

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Account

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

Formats the value using the given formatter.