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
134
135
136
137
138
139
140
141
142
143
144

//! This code was AUTOGENERATED using the Codama library.
use crate::types::AuthorizationDataLocal;
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 TakeBidLegacy {
    pub min_amount: u64,
    pub optional_royalty_pct: Option<u16>,
    pub rules_acc_present: bool,
    pub authorization_data: Option<AuthorizationDataLocal>,
}

#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TakeBidLegacyInstructionAccounts {
    pub tcomp: solana_pubkey::Pubkey,
    pub seller: solana_pubkey::Pubkey,
    pub bid_state: solana_pubkey::Pubkey,
    pub owner: solana_pubkey::Pubkey,
    pub taker_broker: Option<solana_pubkey::Pubkey>,
    pub maker_broker: Option<solana_pubkey::Pubkey>,
    pub margin_account: solana_pubkey::Pubkey,
    pub whitelist: solana_pubkey::Pubkey,
    pub nft_seller_acc: solana_pubkey::Pubkey,
    pub nft_mint: solana_pubkey::Pubkey,
    pub nft_metadata: solana_pubkey::Pubkey,
    pub owner_ata_acc: solana_pubkey::Pubkey,
    pub nft_edition: solana_pubkey::Pubkey,
    pub owner_token_record: solana_pubkey::Pubkey,
    pub dest_token_record: solana_pubkey::Pubkey,
    pub token_metadata_program: solana_pubkey::Pubkey,
    pub instructions: solana_pubkey::Pubkey,
    pub authorization_rules_program: solana_pubkey::Pubkey,
    pub nft_escrow: solana_pubkey::Pubkey,
    pub temp_escrow_token_record: solana_pubkey::Pubkey,
    pub auth_rules: solana_pubkey::Pubkey,
    pub token_program: solana_pubkey::Pubkey,
    pub associated_token_program: solana_pubkey::Pubkey,
    pub system_program: solana_pubkey::Pubkey,
    pub tcomp_program: solana_pubkey::Pubkey,
    pub tensorswap_program: solana_pubkey::Pubkey,
    pub cosigner: solana_pubkey::Pubkey,
    pub mint_proof: solana_pubkey::Pubkey,
    pub rent_dest: solana_pubkey::Pubkey,
    pub remaining: Vec<solana_instruction::AccountMeta>,
}

impl TakeBidLegacy {
    pub fn decode(data: &[u8]) -> Option<Self> {
        if data.len() < 8 {
            return None;
        }
        let discriminator = &data[0..8];
        if discriminator != &[188, 35, 116, 108, 0, 233, 237, 201] {
            return None;
        }

        let data_slice = data;

        let data_slice = &data_slice[8..];

        Self::deserialize(data_slice)
    }
}

impl ArrangeAccounts for TakeBidLegacy {
    type ArrangedAccounts = TakeBidLegacyInstructionAccounts;

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

        let tcomp = next_account(&mut iter)?;
        let seller = next_account(&mut iter)?;
        let bid_state = next_account(&mut iter)?;
        let owner = next_account(&mut iter)?;
        let taker_broker = next_account(&mut iter);
        let maker_broker = next_account(&mut iter);
        let margin_account = next_account(&mut iter)?;
        let whitelist = next_account(&mut iter)?;
        let nft_seller_acc = next_account(&mut iter)?;
        let nft_mint = next_account(&mut iter)?;
        let nft_metadata = next_account(&mut iter)?;
        let owner_ata_acc = next_account(&mut iter)?;
        let nft_edition = next_account(&mut iter)?;
        let owner_token_record = next_account(&mut iter)?;
        let dest_token_record = next_account(&mut iter)?;
        let token_metadata_program = next_account(&mut iter)?;
        let instructions = next_account(&mut iter)?;
        let authorization_rules_program = next_account(&mut iter)?;
        let nft_escrow = next_account(&mut iter)?;
        let temp_escrow_token_record = next_account(&mut iter)?;
        let auth_rules = next_account(&mut iter)?;
        let token_program = next_account(&mut iter)?;
        let associated_token_program = next_account(&mut iter)?;
        let system_program = next_account(&mut iter)?;
        let tcomp_program = next_account(&mut iter)?;
        let tensorswap_program = next_account(&mut iter)?;
        let cosigner = next_account(&mut iter)?;
        let mint_proof = next_account(&mut iter)?;
        let rent_dest = next_account(&mut iter)?;

        let remaining = iter.as_slice();

        Some(TakeBidLegacyInstructionAccounts {
            tcomp,
            seller,
            bid_state,
            owner,
            taker_broker,
            maker_broker,
            margin_account,
            whitelist,
            nft_seller_acc,
            nft_mint,
            nft_metadata,
            owner_ata_acc,
            nft_edition,
            owner_token_record,
            dest_token_record,
            token_metadata_program,
            instructions,
            authorization_rules_program,
            nft_escrow,
            temp_escrow_token_record,
            auth_rules,
            token_program,
            associated_token_program,
            system_program,
            tcomp_program,
            tensorswap_program,
            cosigner,
            mint_proof,
            rent_dest,
            remaining: remaining.to_vec(),
        })
    }
}