carbon-tcomp-decoder 0.12.1

Rust decoder for Tensor cNFT Compressed program on Solana
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
131
132
133

//! This code was AUTOGENERATED using the Codama library.
use carbon_core::CarbonDeserialize;
use carbon_core::account_utils::next_account;
use carbon_core::borsh;
use carbon_core::deserialize::ArrangeAccounts;
use carbon_core::deserialize::CarbonDeserialize;

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, borsh::BorshSerialize, CarbonDeserialize, PartialEq, Eq, Hash)]
pub struct BuySpl {
    pub nonce: u64,
    pub index: u32,
    pub root: [u8; 32],
    pub meta_hash: [u8; 32],
    pub creator_shares: Vec<u8>,
    pub creator_verified: Vec<bool>,
    pub seller_fee_basis_points: u16,
    pub max_amount: u64,
    pub optional_royalty_pct: Option<u16>,
}

#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BuySplInstructionAccounts {
    pub tcomp: solana_pubkey::Pubkey,
    pub tcomp_ata: solana_pubkey::Pubkey,
    pub tree_authority: solana_pubkey::Pubkey,
    pub merkle_tree: solana_pubkey::Pubkey,
    pub log_wrapper: solana_pubkey::Pubkey,
    pub compression_program: solana_pubkey::Pubkey,
    pub system_program: solana_pubkey::Pubkey,
    pub bubblegum_program: solana_pubkey::Pubkey,
    pub tcomp_program: solana_pubkey::Pubkey,
    pub token_program: solana_pubkey::Pubkey,
    pub associated_token_program: solana_pubkey::Pubkey,
    pub list_state: solana_pubkey::Pubkey,
    pub buyer: solana_pubkey::Pubkey,
    pub payer: solana_pubkey::Pubkey,
    pub payer_source: solana_pubkey::Pubkey,
    pub owner: solana_pubkey::Pubkey,
    pub owner_dest: solana_pubkey::Pubkey,
    pub currency: solana_pubkey::Pubkey,
    pub taker_broker: Option<solana_pubkey::Pubkey>,
    pub taker_broker_ata: Option<solana_pubkey::Pubkey>,
    pub maker_broker: Option<solana_pubkey::Pubkey>,
    pub maker_broker_ata: Option<solana_pubkey::Pubkey>,
    pub rent_dest: solana_pubkey::Pubkey,
    pub rent_payer: solana_pubkey::Pubkey,
    pub remaining: Vec<solana_instruction::AccountMeta>,
}

impl BuySpl {
    pub fn decode(data: &[u8]) -> Option<Self> {
        if data.len() < 8 {
            return None;
        }
        let discriminator = &data[0..8];
        if discriminator != &[65, 136, 254, 255, 59, 130, 234, 174] {
            return None;
        }

        let data_slice = data;

        let data_slice = &data_slice[8..];

        Self::deserialize(data_slice)
    }
}

impl ArrangeAccounts for BuySpl {
    type ArrangedAccounts = BuySplInstructionAccounts;

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

        let tcomp = next_account(&mut iter)?;
        let tcomp_ata = next_account(&mut iter)?;
        let tree_authority = next_account(&mut iter)?;
        let merkle_tree = next_account(&mut iter)?;
        let log_wrapper = next_account(&mut iter)?;
        let compression_program = next_account(&mut iter)?;
        let system_program = next_account(&mut iter)?;
        let bubblegum_program = next_account(&mut iter)?;
        let tcomp_program = next_account(&mut iter)?;
        let token_program = next_account(&mut iter)?;
        let associated_token_program = next_account(&mut iter)?;
        let list_state = next_account(&mut iter)?;
        let buyer = next_account(&mut iter)?;
        let payer = next_account(&mut iter)?;
        let payer_source = next_account(&mut iter)?;
        let owner = next_account(&mut iter)?;
        let owner_dest = next_account(&mut iter)?;
        let currency = next_account(&mut iter)?;
        let taker_broker = next_account(&mut iter);
        let taker_broker_ata = next_account(&mut iter);
        let maker_broker = next_account(&mut iter);
        let maker_broker_ata = next_account(&mut iter);
        let rent_dest = next_account(&mut iter)?;
        let rent_payer = next_account(&mut iter)?;

        let remaining = iter.as_slice();

        Some(BuySplInstructionAccounts {
            tcomp,
            tcomp_ata,
            tree_authority,
            merkle_tree,
            log_wrapper,
            compression_program,
            system_program,
            bubblegum_program,
            tcomp_program,
            token_program,
            associated_token_program,
            list_state,
            buyer,
            payer,
            payer_source,
            owner,
            owner_dest,
            currency,
            taker_broker,
            taker_broker_ata,
            maker_broker,
            maker_broker_ata,
            rent_dest,
            rent_payer,
            remaining: remaining.to_vec(),
        })
    }
}