raydium-sdk-V2 0.0.9

Raydium SDK V2 adaptation
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

pub mod util;

use crate::common::pda::get_ata_address;
use crate::raydium::account::util::parse_token_account_resp;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_client::rpc_request::TokenAccountsFilter;
use solana_sdk::commitment_config::CommitmentConfig;
use solana_sdk::pubkey::Pubkey;
use tokio::join;
use crate::common::owner::Owner;

pub struct Account {
    pub owner: Option<Owner>,
    pub token_accounts: Vec<TokenAccount>,
}
#[derive(Debug)]
pub struct TokenAccount {
    pub pubkey: Option<Pubkey>,
    pub mint: Pubkey,
    pub is_associated: Option<bool>,
    pub amount: rug::Integer,
    pub is_native: bool,
    pub program_id: Pubkey,
}

impl Account {
    pub fn new(owner: Option<Owner>) -> Self {
        Self {
            owner,
            token_accounts: Vec::new(),
        }
    }

    pub fn owner_pubkey(&self) -> Result<Pubkey, String> {
        match &self.owner {
            None => Err("owner was not set".to_string()),
            Some(x) => Ok(x.pubkey()),
        }
    }

    // @TODO it's currently force_update only
    pub async fn fetch_wallet_token_accounts(
        &mut self,
        client: &RpcClient,
        /*force_update: bool,*/ commitment: CommitmentConfig,
    ) -> Result<&Vec<TokenAccount>, String> {
        let owner = &self.owner.as_ref().unwrap().pubkey();
        let (sol_account_resp, owner_token_account_resp, owner_token_2022_account_resp) = join!(
            client.get_account_with_commitment(owner, commitment),
            client.get_token_accounts_by_owner_with_commitment(
                owner,
                TokenAccountsFilter::ProgramId(spl_token::ID),
                commitment
            ),
            client.get_token_accounts_by_owner_with_commitment(
                owner,
                TokenAccountsFilter::ProgramId(spl_token_2022::ID),
                commitment
            ),
        );
        let sol_account_resp = sol_account_resp
            .map_err(|e| e.to_string())?
            .value
            .ok_or(format!("Account {} was not found.", owner.to_string()))?;
        let owner_token_account_resp = owner_token_account_resp.map_err(|e| e.to_string())?;
        let owner_token_2022_account_resp =
            owner_token_2022_account_resp.map_err(|e| e.to_string())?;
        let rpc_token_accounts = owner_token_account_resp
            .value
            .into_iter()
            .chain(owner_token_2022_account_resp.value.into_iter())
            .collect();
        let token_accounts =
            parse_token_account_resp(owner, Some(sol_account_resp), rpc_token_accounts);
        self.token_accounts = token_accounts;
        Ok(&self.token_accounts)
    }
    pub fn get_token_account(
        &self,
        mint: &Pubkey,
        token_program: Option<&Pubkey>,
        is_associated_only: bool,
    ) -> Option<&TokenAccount> {
        let token_program = token_program.unwrap_or_else(|| &spl_token::ID);
        let ata = self.get_associated_token_account(&mint, Some(token_program));
        let mut accs: Vec<&TokenAccount> = self
            .token_accounts
            .iter()
            .filter(|x| x.mint.eq(&mint) && (!is_associated_only || x.pubkey.eq(&Some(ata))))
            .collect();
        accs.sort_by_key(|x| &x.amount);
        accs.last().map(|v| &**v)
    }
    pub fn get_associated_token_account(
        &self,
        mint: &Pubkey,
        program_id: Option<&Pubkey>,
    ) -> Pubkey {
        get_ata_address(&self.owner_pubkey().unwrap(), mint, program_id).0
    }
}