light_test_utils/
assert_queue.rs

1use account_compression::{QueueAccount, QueueMetadata, QueueType, RolloverMetadata};
2use forester_utils::{get_hash_set, AccountZeroCopy};
3use light_client::rpc::RpcConnection;
4use light_utils::fee::compute_rollover_fee;
5use solana_sdk::pubkey::Pubkey;
6
7#[allow(clippy::too_many_arguments)]
8pub async fn assert_address_queue_initialized<R: RpcConnection>(
9    rpc: &mut R,
10    queue_pubkey: &Pubkey,
11    queue_config: &account_compression::AddressQueueConfig,
12    associated_merkle_tree_pubkey: &Pubkey,
13    associated_tree_config: &account_compression::AddressMerkleTreeConfig,
14    expected_queue_type: QueueType,
15    expected_index: u64,
16    expected_program_owner: Option<Pubkey>,
17    expected_forester: Option<Pubkey>,
18    payer_pubkey: &Pubkey,
19) {
20    assert_address_queue(
21        rpc,
22        queue_pubkey,
23        queue_config,
24        associated_merkle_tree_pubkey,
25        associated_tree_config,
26        expected_queue_type,
27        expected_index,
28        expected_program_owner,
29        expected_forester,
30        None,
31        None,
32        payer_pubkey,
33    )
34    .await;
35}
36
37#[allow(clippy::too_many_arguments)]
38pub async fn assert_nullifier_queue_initialized<R: RpcConnection>(
39    rpc: &mut R,
40    queue_pubkey: &Pubkey,
41    queue_config: &account_compression::NullifierQueueConfig,
42    associated_merkle_tree_pubkey: &Pubkey,
43    associated_tree_config: &account_compression::StateMerkleTreeConfig,
44    expected_queue_type: QueueType,
45    expected_index: u64,
46    expected_program_owner: Option<Pubkey>,
47    expected_forester: Option<Pubkey>,
48    payer_pubkey: &Pubkey,
49) {
50    let associated_tree_config = account_compression::AddressMerkleTreeConfig {
51        height: associated_tree_config.height,
52        changelog_size: associated_tree_config.changelog_size,
53        // not asserted here
54        address_changelog_size: 0,
55        roots_size: associated_tree_config.roots_size,
56        canopy_depth: associated_tree_config.canopy_depth,
57        rollover_threshold: associated_tree_config.rollover_threshold,
58        close_threshold: associated_tree_config.close_threshold,
59        network_fee: associated_tree_config.network_fee,
60    };
61    // The address queue is the only account that collects the rollover fees.
62    let expected_rollover_fee = 0;
63    assert_queue(
64        rpc,
65        queue_pubkey,
66        queue_config,
67        associated_merkle_tree_pubkey,
68        &associated_tree_config,
69        expected_rollover_fee,
70        expected_queue_type,
71        expected_index,
72        expected_program_owner,
73        expected_forester,
74        None,
75        None,
76        payer_pubkey,
77    )
78    .await;
79}
80
81#[allow(clippy::too_many_arguments)]
82pub async fn assert_address_queue<R: RpcConnection>(
83    rpc: &mut R,
84    queue_pubkey: &Pubkey,
85    queue_config: &account_compression::AddressQueueConfig,
86    associated_merkle_tree_pubkey: &Pubkey,
87    associated_tree_config: &account_compression::AddressMerkleTreeConfig,
88    expected_queue_type: QueueType,
89    expected_index: u64,
90    expected_program_owner: Option<Pubkey>,
91    expected_forester: Option<Pubkey>,
92    expected_rolledover_slot: Option<u64>,
93    expected_next_queue: Option<Pubkey>,
94    payer_pubkey: &Pubkey,
95) {
96    let balance_merkle_tree = rpc
97        .get_account(*associated_merkle_tree_pubkey)
98        .await
99        .unwrap()
100        .unwrap()
101        .lamports;
102    let balance_queue = rpc
103        .get_account(*queue_pubkey)
104        .await
105        .unwrap()
106        .unwrap()
107        .lamports;
108    // The address queue is the only account that collects the rollover fees.
109    let expected_rollover_fee = match associated_tree_config.rollover_threshold {
110        Some(threshold) => {
111            compute_rollover_fee(threshold, associated_tree_config.height, balance_queue).unwrap()
112                + compute_rollover_fee(
113                    threshold,
114                    associated_tree_config.height,
115                    balance_merkle_tree,
116                )
117                .unwrap()
118        }
119        None => 0,
120    };
121    assert_queue(
122        rpc,
123        queue_pubkey,
124        queue_config,
125        associated_merkle_tree_pubkey,
126        associated_tree_config,
127        expected_rollover_fee,
128        expected_queue_type,
129        expected_index,
130        expected_program_owner,
131        expected_forester,
132        expected_rolledover_slot,
133        expected_next_queue,
134        payer_pubkey,
135    )
136    .await;
137}
138#[allow(clippy::too_many_arguments)]
139pub async fn assert_queue<R: RpcConnection>(
140    rpc: &mut R,
141    queue_pubkey: &Pubkey,
142    queue_config: &account_compression::AddressQueueConfig,
143    associated_merkle_tree_pubkey: &Pubkey,
144    associated_tree_config: &account_compression::AddressMerkleTreeConfig,
145    expected_rollover_fee: u64,
146    expected_queue_type: QueueType,
147    expected_index: u64,
148    expected_program_owner: Option<Pubkey>,
149    expected_forester: Option<Pubkey>,
150    expected_rolledover_slot: Option<u64>,
151    expected_next_queue: Option<Pubkey>,
152    payer_pubkey: &Pubkey,
153) {
154    let queue = AccountZeroCopy::<account_compression::QueueAccount>::new(rpc, *queue_pubkey).await;
155    let queue_account = queue.deserialized();
156
157    let expected_rollover_meta_data = RolloverMetadata {
158        index: expected_index,
159        rolledover_slot: expected_rolledover_slot.unwrap_or(u64::MAX),
160        rollover_threshold: associated_tree_config
161            .rollover_threshold
162            .unwrap_or_default(),
163        network_fee: queue_config.network_fee.unwrap_or_default(),
164        rollover_fee: expected_rollover_fee,
165        close_threshold: associated_tree_config.close_threshold.unwrap_or(u64::MAX),
166        additional_bytes: 0,
167    };
168    let expected_access_meta_data = account_compression::AccessMetadata {
169        owner: *payer_pubkey,
170        program_owner: expected_program_owner.unwrap_or_default(),
171        forester: expected_forester.unwrap_or_default(),
172    };
173    let expected_queue_meta_data = QueueMetadata {
174        access_metadata: expected_access_meta_data,
175        rollover_metadata: expected_rollover_meta_data,
176        associated_merkle_tree: *associated_merkle_tree_pubkey,
177        next_queue: expected_next_queue.unwrap_or_default(),
178        queue_type: expected_queue_type as u64,
179    };
180    assert_eq!(queue_account.metadata, expected_queue_meta_data);
181
182    let queue = unsafe { get_hash_set::<QueueAccount, R>(rpc, *queue_pubkey).await };
183    assert_eq!(queue.get_capacity(), queue_config.capacity as usize);
184    assert_eq!(
185        queue.sequence_threshold,
186        queue_config.sequence_threshold as usize
187    );
188}
light_test_utils/assert_queue.rs

light_test_utils/
assert_queue.rs
