Struct trdelnik_client::Client

pub struct Client { /* private fields */ }

Client allows you to send typed RPC requests to a Solana cluster.

Implementations

impl Client

pub fn new(payer: Keypair) -> Self

Creates a new Client instance.

pub fn payer(&self) -> &Keypair

Gets client’s payer.

pub fn anchor_client(&self) -> &AnchorClient

Gets the internal Anchor client to call Anchor client’s methods directly.

pub fn program(&self, program_id: Pubkey) -> Program

Creates Program instance to communicate with the selected program.

pub async fn is_localnet_running(&self, retry: bool) -> bool

Finds out if the Solana localnet is running.

Set retry to true when you want to wait for up to 15 seconds until the localnet is running (until 30 retries with 500ms delays are performed).

pub async fn account_data<T>(&self, account: Pubkey) -> Result<T, Error> where
    T: AccountDeserialize + Send + 'static, 

Gets deserialized data from the chosen account serialized with Anchor

Errors

It fails when:

• the account does not exist.
• the Solana cluster is not running.
• deserialization failed.

pub async fn account_data_bincode<T>(&self, account: Pubkey) -> Result<T, Error> where
    T: DeserializeOwned + Send + 'static, 

Gets deserialized data from the chosen account serialized with Bincode

Errors

It fails when:

• the account does not exist.
• the Solana cluster is not running.
• deserialization failed.

pub async fn account_data_borsh<T>(&self, account: Pubkey) -> Result<T, Error> where
    T: BorshDeserialize + Send + 'static, 

Gets deserialized data from the chosen account serialized with Borsh

Errors

It fails when:

• the account does not exist.
• the Solana cluster is not running.
• deserialization failed.

pub async fn get_account(
    &self,
    account: Pubkey
) -> Result<Option<Account>, Error>

Returns all information associated with the account of the provided Pubkey.

Errors

It fails when the Solana cluster is not running.

pub async fn send_instruction(
    &self,
    program: Pubkey,
    instruction: impl InstructionData + Send + 'static,
    accounts: impl ToAccountMetas + Send + 'static,
    signers: impl IntoIterator<Item = Keypair> + Send + 'static
) -> Result<EncodedConfirmedTransaction, Error>

Sends the Anchor instruction with associated accounts and signers.

Example

use trdelnik_client::*;

pub async fn initialize(
    client: &Client,
    state: Pubkey,
    user: Pubkey,
    system_program: Pubkey,
    signers: impl IntoIterator<Item = Keypair> + Send + 'static,
) -> Result<EncodedConfirmedTransaction, ClientError> {
    Ok(client
        .send_instruction(
            PROGRAM_ID,
            turnstile::instruction::Initialize {},
            turnstile::accounts::Initialize {
                state: a_state,
                user: a_user,
                system_program: a_system_program,
            },
            signers,
        )
        .await?)
}

pub async fn send_transaction(
    &self,
    instructions: &[Instruction],
    signers: impl IntoIterator<Item = &Keypair> + Send
) -> Result<EncodedConfirmedTransaction, Error>

Sends the transaction with associated instructions and signers.

Example

#[throws]
pub async fn create_account(
    &self,
    keypair: &Keypair,
    lamports: u64,
    space: u64,
    owner: &Pubkey,
) -> EncodedConfirmedTransaction {
    self.send_transaction(
        &[system_instruction::create_account(
            &self.payer().pubkey(),
            &keypair.pubkey(),
            lamports,
            space,
            owner,
        )],
        [keypair],
    )
    .await?
}

pub async fn airdrop(&self, address: Pubkey, lamports: u64) -> Result<(), Error>

Airdrops lamports to the chosen account.

pub async fn get_balance(&mut self, address: Pubkey) -> Result<u64, Error>

Get balance of an account

pub async fn get_token_balance(
    &mut self,
    address: Pubkey
) -> Result<UiTokenAmount, Error>

Get token balance of an token account

pub async fn deploy_by_name(
    &self,
    program_keypair: &Keypair,
    program_name: &str
) -> Result<(), Error>

Deploys a program based on it’s name. This function wraps boilerplate code required for the successful deployment of a program, i.e. SOLs airdrop etc.

Arguments

• program_keypair - Keypair used for the program
• program_name - Name of the program to be deployed

Example:

Project structure

project/
- programs/
  - awesome_contract/
    - ...
    - Cargo.toml
  - turnstile/
    - ...
    - Cargo.toml
- ...
- Cargo.toml

Code

client.deploy_program(program_keypair(0), "awesome_contract");
client.deploy_program(program_keypair(1), "turnstile");

pub async fn create_account(
    &self,
    keypair: &Keypair,
    lamports: u64,
    space: u64,
    owner: &Pubkey
) -> Result<EncodedConfirmedTransaction, Error>

Creates accounts.

pub async fn create_account_rent_exempt(
    &mut self,
    keypair: &Keypair,
    space: u64,
    owner: &Pubkey
) -> Result<EncodedConfirmedTransaction, Error>

Creates rent exempt account.

pub async fn create_token_mint(
    &self,
    mint: &Keypair,
    authority: Pubkey,
    freeze_authority: Option<Pubkey>,
    decimals: u8
) -> Result<EncodedConfirmedTransaction, Error>

Executes a transaction constructing a token mint.

pub async fn mint_tokens(
    &self,
    mint: Pubkey,
    authority: &Keypair,
    account: Pubkey,
    amount: u64
) -> Result<EncodedConfirmedTransaction, Error>

Executes a transaction that mints tokens from a mint to an account belonging to that mint.

pub async fn create_token_account(
    &self,
    account: &Keypair,
    mint: &Pubkey,
    owner: &Pubkey
) -> Result<EncodedConfirmedTransaction, Error>

Executes a transaction constructing a token account of the specified mint. The account needs to be empty and belong to system for this to work. Prefer to use [create_associated_token_account] if you don’t need the provided account to contain the token account.

pub async fn create_associated_token_account(
    &self,
    owner: &Keypair,
    mint: Pubkey
) -> Result<Pubkey, Error>

Executes a transaction constructing the associated token account of the specified mint belonging to the owner. This will fail if the account already exists.

pub async fn create_account_with_data(
    &self,
    account: &Keypair,
    data: Vec<u8>
) -> Result<(), Error>

Executes a transaction creating and filling the given account with the given data. The account is required to be empty and will be owned by bpf_loader afterwards.