carbon-virtuals-decoder 1.0.0

Virtuals Program Decoder
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! This code was AUTOGENERATED using the Codama library.
use carbon_core::{account_utils::next_account, deserialize::ArrangeAccounts};
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, borsh::BorshSerialize, borsh::BorshDeserialize, PartialEq)]
pub struct ClaimFees {}

#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ClaimFeesInstructionAccounts {
    pub payer: solana_pubkey::Pubkey,
    pub vpool: solana_pubkey::Pubkey,
    pub virtuals_mint: solana_pubkey::Pubkey,
    pub token_mint: solana_pubkey::Pubkey,
    pub vpool_virtuals_ata: solana_pubkey::Pubkey,
    pub vpool_token_ata: solana_pubkey::Pubkey,
    pub platform: solana_pubkey::Pubkey,
    pub platform_virtuals_ata: solana_pubkey::Pubkey,
    pub platform_token_ata: solana_pubkey::Pubkey,
    pub creator_virtuals_ata: solana_pubkey::Pubkey,
    pub creator_token_ata: solana_pubkey::Pubkey,
    pub pool: solana_pubkey::Pubkey,
    pub lp_mint: solana_pubkey::Pubkey,
    pub lock_escrow: solana_pubkey::Pubkey,
    pub escrow_vault: solana_pubkey::Pubkey,
    pub token_program: solana_pubkey::Pubkey,
    pub virtuals_vault: solana_pubkey::Pubkey,
    pub token_vault: solana_pubkey::Pubkey,
    pub virtuals_token_vault: solana_pubkey::Pubkey,
    pub token_token_vault: solana_pubkey::Pubkey,
    pub virtuals_vault_lp_mint: solana_pubkey::Pubkey,
    pub token_vault_lp_mint: solana_pubkey::Pubkey,
    pub virtuals_vault_lp: solana_pubkey::Pubkey,
    pub token_vault_lp: solana_pubkey::Pubkey,
    pub vault_program: solana_pubkey::Pubkey,
    pub associated_token_program: solana_pubkey::Pubkey,
    pub system_program: solana_pubkey::Pubkey,
    pub dynamic_amm_program: solana_pubkey::Pubkey,
    pub remaining: Vec<solana_instruction::AccountMeta>,
}

impl ClaimFees {
    pub fn decode(data: &[u8]) -> Option<Self> {
        if data.len() < 8 {
            return None;
        }
        let discriminator = &data[0..8];
        if discriminator != [82, 251, 233, 156, 12, 52, 184, 202] {
            return None;
        }

        let mut data_slice = data;

        data_slice = &data_slice[8..];

        borsh::BorshDeserialize::deserialize(&mut data_slice).ok()
    }
}

impl ArrangeAccounts for ClaimFees {
    type ArrangedAccounts = ClaimFeesInstructionAccounts;

    fn arrange_accounts(
        accounts: &[solana_instruction::AccountMeta],
    ) -> Option<Self::ArrangedAccounts> {
        let mut iter = accounts.iter();

        let payer = next_account(&mut iter)?;
        let vpool = next_account(&mut iter)?;
        let virtuals_mint = next_account(&mut iter)?;
        let token_mint = next_account(&mut iter)?;
        let vpool_virtuals_ata = next_account(&mut iter)?;
        let vpool_token_ata = next_account(&mut iter)?;
        let platform = next_account(&mut iter)?;
        let platform_virtuals_ata = next_account(&mut iter)?;
        let platform_token_ata = next_account(&mut iter)?;
        let creator_virtuals_ata = next_account(&mut iter)?;
        let creator_token_ata = next_account(&mut iter)?;
        let pool = next_account(&mut iter)?;
        let lp_mint = next_account(&mut iter)?;
        let lock_escrow = next_account(&mut iter)?;
        let escrow_vault = next_account(&mut iter)?;
        let token_program = next_account(&mut iter)?;
        let virtuals_vault = next_account(&mut iter)?;
        let token_vault = next_account(&mut iter)?;
        let virtuals_token_vault = next_account(&mut iter)?;
        let token_token_vault = next_account(&mut iter)?;
        let virtuals_vault_lp_mint = next_account(&mut iter)?;
        let token_vault_lp_mint = next_account(&mut iter)?;
        let virtuals_vault_lp = next_account(&mut iter)?;
        let token_vault_lp = next_account(&mut iter)?;
        let vault_program = next_account(&mut iter)?;
        let associated_token_program = next_account(&mut iter)?;
        let system_program = next_account(&mut iter)?;
        let dynamic_amm_program = next_account(&mut iter)?;

        let remaining = iter.as_slice();

        Some(ClaimFeesInstructionAccounts {
            payer,
            vpool,
            virtuals_mint,
            token_mint,
            vpool_virtuals_ata,
            vpool_token_ata,
            platform,
            platform_virtuals_ata,
            platform_token_ata,
            creator_virtuals_ata,
            creator_token_ata,
            pool,
            lp_mint,
            lock_escrow,
            escrow_vault,
            token_program,
            virtuals_vault,
            token_vault,
            virtuals_token_vault,
            token_token_vault,
            virtuals_vault_lp_mint,
            token_vault_lp_mint,
            virtuals_vault_lp,
            token_vault_lp,
            vault_program,
            associated_token_program,
            system_program,
            dynamic_amm_program,
            remaining: remaining.to_vec(),
        })
    }
}