light_compressed_account/instruction_data/
data.rs

1use light_zero_copy::ZeroCopyMut;
2
3use crate::{
4    compressed_account::{CompressedAccount, PackedCompressedAccountWithMerkleContext},
5    discriminators::DISCRIMINATOR_INVOKE,
6    instruction_data::{compressed_proof::CompressedProof, traits::LightInstructionData},
7    InstructionDiscriminator, Pubkey, Vec,
8};
9
10#[cfg_attr(
11    all(feature = "std", feature = "anchor"),
12    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
13)]
14#[cfg_attr(
15    not(feature = "anchor"),
16    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
17)]
18#[derive(Debug, PartialEq, Default, Clone)]
19pub struct InstructionDataInvoke {
20    pub proof: Option<CompressedProof>,
21    pub input_compressed_accounts_with_merkle_context:
22        Vec<PackedCompressedAccountWithMerkleContext>,
23    pub output_compressed_accounts: Vec<OutputCompressedAccountWithPackedContext>,
24    pub relay_fee: Option<u64>,
25    pub new_address_params: Vec<NewAddressParamsPacked>,
26    pub compress_or_decompress_lamports: Option<u64>,
27    pub is_compress: bool,
28}
29
30impl InstructionDataInvoke {
31    pub fn new(proof: Option<CompressedProof>) -> Self {
32        Self {
33            proof,
34            ..Default::default()
35        }
36    }
37
38    pub fn with_input_compressed_accounts_with_merkle_context(
39        mut self,
40        input_compressed_accounts_with_merkle_context: &[PackedCompressedAccountWithMerkleContext],
41    ) -> Self {
42        if !input_compressed_accounts_with_merkle_context.is_empty() {
43            self.input_compressed_accounts_with_merkle_context
44                .extend_from_slice(input_compressed_accounts_with_merkle_context);
45        }
46        self
47    }
48
49    pub fn with_output_compressed_accounts(
50        mut self,
51        output_compressed_accounts: &[OutputCompressedAccountWithPackedContext],
52    ) -> Self {
53        if !output_compressed_accounts.is_empty() {
54            self.output_compressed_accounts
55                .extend_from_slice(output_compressed_accounts);
56        }
57        self
58    }
59
60    pub fn with_new_addresses(mut self, new_address_params: &[NewAddressParamsPacked]) -> Self {
61        if !new_address_params.is_empty() {
62            self.new_address_params
63                .extend_from_slice(new_address_params);
64        }
65        self
66    }
67
68    pub fn compress_lamports(mut self, lamports: u64) -> Self {
69        self.compress_or_decompress_lamports = Some(lamports);
70        self.is_compress = true;
71        self
72    }
73
74    pub fn decompress_lamports(mut self, lamports: u64) -> Self {
75        self.compress_or_decompress_lamports = Some(lamports);
76        self.is_compress = false;
77        self
78    }
79}
80
81impl InstructionDiscriminator for InstructionDataInvoke {
82    fn discriminator(&self) -> &'static [u8] {
83        &DISCRIMINATOR_INVOKE
84    }
85}
86
87impl LightInstructionData for InstructionDataInvoke {}
88
89#[cfg_attr(
90    all(feature = "std", feature = "anchor"),
91    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
92)]
93#[cfg_attr(
94    not(feature = "anchor"),
95    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
96)]
97#[derive(Debug, PartialEq, Default, Clone)]
98pub struct OutputCompressedAccountWithContext {
99    pub compressed_account: CompressedAccount,
100    pub merkle_tree: Pubkey,
101}
102
103#[repr(C)]
104#[cfg_attr(
105    all(feature = "std", feature = "anchor"),
106    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
107)]
108#[cfg_attr(
109    not(feature = "anchor"),
110    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
111)]
112#[derive(Debug, PartialEq, Default, Clone, ZeroCopyMut)]
113pub struct OutputCompressedAccountWithPackedContext {
114    pub compressed_account: CompressedAccount,
115    pub merkle_tree_index: u8,
116}
117
118#[repr(C)]
119#[cfg_attr(
120    all(feature = "std", feature = "anchor"),
121    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
122)]
123#[cfg_attr(
124    not(feature = "anchor"),
125    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
126)]
127#[derive(Debug, PartialEq, Default, Clone, Copy, ZeroCopyMut)]
128pub struct NewAddressParamsPacked {
129    pub seed: [u8; 32],
130    pub address_queue_account_index: u8,
131    pub address_merkle_tree_account_index: u8,
132    pub address_merkle_tree_root_index: u16,
133}
134
135#[repr(C)]
136#[cfg_attr(
137    all(feature = "std", feature = "anchor"),
138    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
139)]
140#[cfg_attr(
141    not(feature = "anchor"),
142    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
143)]
144#[derive(Debug, PartialEq, Default, Clone, Copy, ZeroCopyMut)]
145pub struct NewAddressParamsAssignedPacked {
146    pub seed: [u8; 32],
147    pub address_queue_account_index: u8,
148    pub address_merkle_tree_account_index: u8,
149    pub address_merkle_tree_root_index: u16,
150    pub assigned_to_account: bool,
151    pub assigned_account_index: u8,
152}
153
154impl NewAddressParamsAssignedPacked {
155    pub fn new(address_params: NewAddressParamsPacked, index: Option<u8>) -> Self {
156        Self {
157            seed: address_params.seed,
158            address_queue_account_index: address_params.address_queue_account_index,
159            address_merkle_tree_account_index: address_params.address_merkle_tree_account_index,
160            address_merkle_tree_root_index: address_params.address_merkle_tree_root_index,
161            assigned_to_account: index.is_some(),
162            assigned_account_index: index.unwrap_or_default(),
163        }
164    }
165
166    pub fn assigned_account_index(&self) -> Option<u8> {
167        if self.assigned_to_account {
168            Some(self.assigned_account_index)
169        } else {
170            None
171        }
172    }
173}
174
175#[cfg_attr(
176    all(feature = "std", feature = "anchor"),
177    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
178)]
179#[cfg_attr(
180    not(feature = "anchor"),
181    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
182)]
183#[derive(Debug, PartialEq, Default, Clone)]
184pub struct NewAddressParams {
185    pub seed: [u8; 32],
186    pub address_queue_pubkey: Pubkey,
187    pub address_merkle_tree_pubkey: Pubkey,
188    pub address_merkle_tree_root_index: u16,
189}
190
191#[cfg_attr(
192    all(feature = "std", feature = "anchor"),
193    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
194)]
195#[cfg_attr(
196    not(feature = "anchor"),
197    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
198)]
199#[derive(Debug, PartialEq, Default, Clone)]
200pub struct NewAddressParamsAssigned {
201    pub seed: [u8; 32],
202    pub address_queue_pubkey: Pubkey,
203    pub address_merkle_tree_pubkey: Pubkey,
204    pub address_merkle_tree_root_index: u16,
205    pub assigned_account_index: Option<u8>,
206}
207
208#[repr(C)]
209#[cfg_attr(
210    all(feature = "std", feature = "anchor"),
211    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
212)]
213#[cfg_attr(
214    not(feature = "anchor"),
215    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
216)]
217#[derive(Debug, PartialEq, Default, Clone, Copy, ZeroCopyMut)]
218pub struct PackedReadOnlyAddress {
219    pub address: [u8; 32],
220    pub address_merkle_tree_root_index: u16,
221    pub address_merkle_tree_account_index: u8,
222}
223
224#[cfg_attr(
225    all(feature = "std", feature = "anchor"),
226    derive(anchor_lang::AnchorDeserialize, anchor_lang::AnchorSerialize)
227)]
228#[cfg_attr(
229    not(feature = "anchor"),
230    derive(borsh::BorshDeserialize, borsh::BorshSerialize)
231)]
232#[derive(Debug, PartialEq, Default, Clone)]
233pub struct ReadOnlyAddress {
234    pub address: [u8; 32],
235    pub address_merkle_tree_pubkey: Pubkey,
236    pub address_merkle_tree_root_index: u16,
237}
light_compressed_account/instruction_data/data.rs

light_compressed_account/instruction_data/
data.rs
