From 0ac395e2f6aacd9fd8c5b807f58239a81dc1d36b Mon Sep 17 00:00:00 2001 From: Michal Rostecki Date: Thu, 27 Jun 2024 10:09:16 +0200 Subject: [PATCH 1/5] test: Use on-chain queues with different sizes Initialize queues with non-default sizes and use them in all functional tests to make sure that zero-copy serialization works. --- ...nitialize_address_merkle_tree_and_queue.rs | 4 - ...e_state_merkle_tree_and_nullifier_queue.rs | 3 - .../tests/address_merkle_tree_tests.rs | 166 +++++++--- .../tests/merkle_tree_tests.rs | 308 ++++++++++++------ .../tests/test_program_owned_trees.rs | 3 +- test-utils/src/address_tree_rollover.rs | 7 +- test-utils/src/e2e_test_env.rs | 3 +- test-utils/src/indexer/test_indexer.rs | 3 +- test-utils/src/test_env.rs | 17 +- test-utils/src/test_forester.rs | 2 +- utils/src/prime.rs | 6 +- 11 files changed, 345 insertions(+), 177 deletions(-) diff --git a/programs/account-compression/src/instructions/initialize_address_merkle_tree_and_queue.rs b/programs/account-compression/src/instructions/initialize_address_merkle_tree_and_queue.rs index c6f8ac9022..c5fa256a65 100644 --- a/programs/account-compression/src/instructions/initialize_address_merkle_tree_and_queue.rs +++ b/programs/account-compression/src/instructions/initialize_address_merkle_tree_and_queue.rs @@ -59,10 +59,6 @@ pub fn process_initialize_address_merkle_tree_and_queue<'info>( merkle_tree_config: AddressMerkleTreeConfig, queue_config: AddressQueueConfig, ) -> Result<()> { - if queue_config != AddressQueueConfig::default() { - unimplemented!("Only default address queue config is supported."); - } - let merkle_tree_rent = ctx.accounts.merkle_tree.get_lamports(); process_initialize_address_queue( &ctx.accounts.queue.to_account_info(), diff --git a/programs/account-compression/src/instructions/initialize_state_merkle_tree_and_nullifier_queue.rs b/programs/account-compression/src/instructions/initialize_state_merkle_tree_and_nullifier_queue.rs index 272822adf1..8d3f516f14 100644 --- a/programs/account-compression/src/instructions/initialize_state_merkle_tree_and_nullifier_queue.rs +++ b/programs/account-compression/src/instructions/initialize_state_merkle_tree_and_nullifier_queue.rs @@ -75,9 +75,6 @@ pub fn process_initialize_state_merkle_tree_and_nullifier_queue( nullifier_queue_config: NullifierQueueConfig, additional_rent: u64, ) -> Result<()> { - if nullifier_queue_config != NullifierQueueConfig::default() { - unimplemented!("Only default nullifier queue config is supported."); - } // Will be used to configure rollover fees for additional accounts (cpi // context account). if additional_rent != 0 { diff --git a/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs b/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs index b6070722e7..5dde908807 100644 --- a/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs +++ b/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs @@ -42,10 +42,13 @@ use solana_sdk::{ /// 2. inserts two addresses to the queue /// 3. inserts two addresses into the address Merkle tree /// 4. insert third address -async fn address_queue_and_tree_functional(merkle_tree_config: &AddressMerkleTreeConfig) { +async fn address_queue_and_tree_functional( + merkle_tree_config: &AddressMerkleTreeConfig, + queue_config: &AddressQueueConfig, +) { // CHECK: 1 create address Merkle tree and queue accounts let (mut context, _, mut address_merkle_tree_bundle) = - test_setup_with_address_merkle_tree(merkle_tree_config).await; + test_setup_with_address_merkle_tree(merkle_tree_config, queue_config).await; let payer = context.get_payer().insecure_clone(); let address_queue_pubkey = address_merkle_tree_bundle.accounts.queue; let address_merkle_tree_pubkey = address_merkle_tree_bundle.accounts.merkle_tree; @@ -104,26 +107,39 @@ async fn address_queue_and_tree_functional(merkle_tree_config: &AddressMerkleTre #[tokio::test] async fn test_address_queue_and_tree_functional_default() { - address_queue_and_tree_functional(&AddressMerkleTreeConfig::default()).await + address_queue_and_tree_functional( + &AddressMerkleTreeConfig::default(), + &AddressQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_address_queue_and_tree_functional_custom() { - for changelog_size in (500..5000).step_by(500) { - let roots_size = changelog_size * 2; - - for address_changelog_size in (250..1000).step_by(250) { - address_queue_and_tree_functional(&AddressMerkleTreeConfig { - height: ADDRESS_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: ADDRESS_MERKLE_TREE_CANOPY_DEPTH, - address_changelog_size, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + + for address_changelog_size in (250..1000).step_by(250) { + address_queue_and_tree_functional( + &AddressMerkleTreeConfig { + height: ADDRESS_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: ADDRESS_MERKLE_TREE_CANOPY_DEPTH, + address_changelog_size, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &AddressQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } } @@ -241,9 +257,12 @@ async fn test_address_queue_and_tree_invalid_sizes() { /// 11. invalid queue account /// 12. invalid Merkle tree account /// 13. non-associated Merkle tree -async fn update_address_merkle_tree_failing_tests(merkle_tree_config: &AddressMerkleTreeConfig) { +async fn update_address_merkle_tree_failing_tests( + merkle_tree_config: &AddressMerkleTreeConfig, + queue_config: &AddressQueueConfig, +) { let (mut context, payer, mut address_merkle_tree_bundle) = - test_setup_with_address_merkle_tree(merkle_tree_config).await; + test_setup_with_address_merkle_tree(merkle_tree_config, queue_config).await; let address_queue_pubkey = address_merkle_tree_bundle.accounts.queue; let address_merkle_tree_pubkey = address_merkle_tree_bundle.accounts.merkle_tree; // Insert a pair of addresses, correctly. Just do it with relayer. @@ -627,6 +646,7 @@ async fn update_address_merkle_tree_failing_tests(merkle_tree_config: &AddressMe &invalid_address_queue_keypair, None, merkle_tree_config, + queue_config, 2, ) .await; @@ -659,26 +679,39 @@ async fn update_address_merkle_tree_failing_tests(merkle_tree_config: &AddressMe #[tokio::test] async fn update_address_merkle_tree_failing_tests_default() { - update_address_merkle_tree_failing_tests(&AddressMerkleTreeConfig::default()).await + update_address_merkle_tree_failing_tests( + &AddressMerkleTreeConfig::default(), + &AddressQueueConfig::default(), + ) + .await } #[tokio::test] async fn update_address_merkle_tree_failing_tests_custom() { - for changelog_size in (500..5000).step_by(500) { - let roots_size = changelog_size * 2; - - for address_changelog_size in (250..1000).step_by(250) { - update_address_merkle_tree_failing_tests(&AddressMerkleTreeConfig { - height: ADDRESS_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: ADDRESS_MERKLE_TREE_CANOPY_DEPTH, - address_changelog_size, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + + for address_changelog_size in (250..1000).step_by(250) { + update_address_merkle_tree_failing_tests( + &AddressMerkleTreeConfig { + height: ADDRESS_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: ADDRESS_MERKLE_TREE_CANOPY_DEPTH, + address_changelog_size, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &AddressQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } } @@ -690,9 +723,12 @@ async fn update_address_merkle_tree_failing_tests_custom() { /// 4. Merkle tree and queue not associated (Invalid Merkle tree). /// 5. Successful rollover. /// 6. Attempt to rollover already rolled over Queue and Merkle tree. -async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerkleTreeConfig) { +async fn address_merkle_tree_and_queue_rollover( + merkle_tree_config: &AddressMerkleTreeConfig, + queue_config: &AddressQueueConfig, +) { let (mut context, payer, bundle) = - test_setup_with_address_merkle_tree(merkle_tree_config).await; + test_setup_with_address_merkle_tree(merkle_tree_config, queue_config).await; let address_merkle_tree_pubkey = bundle.accounts.merkle_tree; let address_queue_pubkey = bundle.accounts.queue; let address_merkle_tree_keypair_2 = Keypair::new(); @@ -705,6 +741,7 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk &address_queue_keypair_2, None, merkle_tree_config, + queue_config, 2, ) .await; @@ -722,6 +759,7 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk &address_merkle_tree_pubkey, &address_queue_pubkey, merkle_tree_config, + queue_config, ) .await; @@ -770,6 +808,7 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk &address_merkle_tree_pubkey, &address_queue_pubkey, merkle_tree_config, + queue_config, ) .await; @@ -796,6 +835,7 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk &address_merkle_tree_pubkey, &address_queue_keypair_2.pubkey(), merkle_tree_config, + queue_config, ) .await; @@ -814,6 +854,7 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk &address_merkle_tree_keypair_2.pubkey(), &address_queue_pubkey, merkle_tree_config, + queue_config, ) .await; @@ -838,6 +879,7 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk &address_merkle_tree_pubkey, &address_queue_pubkey, merkle_tree_config, + queue_config, ) .await .unwrap(); @@ -863,6 +905,7 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk &address_merkle_tree_pubkey, &address_queue_pubkey, merkle_tree_config, + queue_config, ) .await; @@ -876,32 +919,46 @@ async fn address_merkle_tree_and_queue_rollover(merkle_tree_config: &AddressMerk #[tokio::test] async fn test_address_merkle_tree_and_queue_rollover_default() { - address_merkle_tree_and_queue_rollover(&AddressMerkleTreeConfig::default()).await + address_merkle_tree_and_queue_rollover( + &AddressMerkleTreeConfig::default(), + &AddressQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_address_merkle_tree_and_queue_rollover_custom() { - for changelog_size in (500..5000).step_by(500) { - let roots_size = changelog_size * 2; - - for address_changelog_size in (250..1000).step_by(250) { - address_merkle_tree_and_queue_rollover(&AddressMerkleTreeConfig { - height: ADDRESS_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: ADDRESS_MERKLE_TREE_CANOPY_DEPTH, - address_changelog_size, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + + for address_changelog_size in (250..1000).step_by(250) { + address_merkle_tree_and_queue_rollover( + &AddressMerkleTreeConfig { + height: ADDRESS_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: ADDRESS_MERKLE_TREE_CANOPY_DEPTH, + address_changelog_size, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &AddressQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } } pub async fn test_setup_with_address_merkle_tree( merkle_tree_config: &AddressMerkleTreeConfig, + queue_config: &AddressQueueConfig, ) -> ( ProgramTestRpcConnection, // rpc Keypair, // payer @@ -924,6 +981,7 @@ pub async fn test_setup_with_address_merkle_tree( &address_queue_keypair, None, merkle_tree_config, + queue_config, 1, ) .await; diff --git a/test-programs/account-compression-test/tests/merkle_tree_tests.rs b/test-programs/account-compression-test/tests/merkle_tree_tests.rs index 6edb05dc56..a5bd74a986 100644 --- a/test-programs/account-compression-test/tests/merkle_tree_tests.rs +++ b/test-programs/account-compression-test/tests/merkle_tree_tests.rs @@ -9,10 +9,10 @@ use account_compression::{ state::{queue_from_bytes_zero_copy_mut, QueueAccount}, utils::constants::{ STATE_MERKLE_TREE_CANOPY_DEPTH, STATE_MERKLE_TREE_CHANGELOG, STATE_MERKLE_TREE_HEIGHT, - STATE_MERKLE_TREE_ROOTS, STATE_NULLIFIER_QUEUE_VALUES, + STATE_MERKLE_TREE_ROOTS, }, - AddressMerkleTreeConfig, NullifierQueueConfig, QueueType, StateMerkleTreeAccount, - StateMerkleTreeConfig, ID, SAFETY_MARGIN, + AddressMerkleTreeConfig, AddressQueueConfig, NullifierQueueConfig, QueueType, + StateMerkleTreeAccount, StateMerkleTreeConfig, ID, SAFETY_MARGIN, }; use anchor_lang::{error::ErrorCode, system_program, InstructionData, ToAccountMetas}; use light_concurrent_merkle_tree::{ @@ -58,7 +58,10 @@ use solana_sdk::{account::WritableAccount, pubkey::Pubkey}; /// 3. Failing: Insert the same elements into nullifier queue again (3 and 1 element(s)) /// 4. Failing: Insert into nullifier queue with invalid authority /// 5. Functional: Insert one element into nullifier queue -async fn test_init_and_insert_into_nullifier_queue(merkle_tree_config: &StateMerkleTreeConfig) { +async fn test_init_and_insert_into_nullifier_queue( + merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, +) { let mut program_test = ProgramTest::default(); program_test.add_program("account_compression", ID, None); program_test.add_program( @@ -80,6 +83,7 @@ async fn test_init_and_insert_into_nullifier_queue(merkle_tree_config: &StateMer &merkle_tree_keypair, &nullifier_queue_keypair, merkle_tree_config, + queue_config, ) .await; functional_1_initialize_state_merkle_tree_and_nullifier_queue( @@ -88,6 +92,7 @@ async fn test_init_and_insert_into_nullifier_queue(merkle_tree_config: &StateMer &merkle_tree_keypair, &nullifier_queue_keypair, merkle_tree_config, + queue_config, ) .await; let merkle_tree_keypair_2 = Keypair::new(); @@ -98,6 +103,7 @@ async fn test_init_and_insert_into_nullifier_queue(merkle_tree_config: &StateMer &merkle_tree_keypair_2, &nullifier_queue_keypair_2, merkle_tree_config, + queue_config, ) .await; functional_2_test_insert_into_nullifier_queues( @@ -170,23 +176,36 @@ async fn test_init_and_insert_into_nullifier_queue(merkle_tree_config: &StateMer #[tokio::test] async fn test_init_and_insert_into_nullifier_queue_default() { - test_init_and_insert_into_nullifier_queue(&StateMerkleTreeConfig::default()).await + test_init_and_insert_into_nullifier_queue( + &StateMerkleTreeConfig::default(), + &NullifierQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_init_and_insert_into_nullifier_queue_custom() { - for changelog_size in (500..10_000).step_by(500) { - let roots_size = changelog_size * 2; - test_init_and_insert_into_nullifier_queue(&StateMerkleTreeConfig { - height: STATE_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + test_init_and_insert_into_nullifier_queue( + &StateMerkleTreeConfig { + height: STATE_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &NullifierQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } @@ -199,7 +218,10 @@ async fn test_init_and_insert_into_nullifier_queue_custom() { /// 4. advance Merkle tree seq until one before it would work check that it still fails /// 5. advance Merkle tree seq by one and check that inserting works now /// 6.try inserting again it should fail with full error -async fn test_full_nullifier_queue(merkle_tree_config: &StateMerkleTreeConfig) { +async fn test_full_nullifier_queue( + merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, +) { let mut program_test = ProgramTest::default(); program_test.add_program("account_compression", ID, None); program_test.add_program( @@ -221,6 +243,7 @@ async fn test_full_nullifier_queue(merkle_tree_config: &StateMerkleTreeConfig) { &merkle_tree_keypair, &nullifier_queue_keypair, merkle_tree_config, + queue_config, ) .await; let leaf: [u8; 32] = bigint_to_be_bytes_array(&1.to_biguint().unwrap()).unwrap(); @@ -293,6 +316,7 @@ async fn test_full_nullifier_queue(merkle_tree_config: &StateMerkleTreeConfig) { &mut rpc, &merkle_tree_pubkey, &nullifier_queue_pubkey, + queue_config, &mut reference_merkle_tree, &leaf, merkle_tree.changelog_index() as u64, @@ -374,23 +398,36 @@ async fn test_full_nullifier_queue(merkle_tree_config: &StateMerkleTreeConfig) { #[tokio::test] async fn test_full_nullifier_queue_default() { - test_full_nullifier_queue(&StateMerkleTreeConfig::default()).await + test_full_nullifier_queue( + &StateMerkleTreeConfig::default(), + &NullifierQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_full_nullifier_queue_custom() { - for changelog_size in (500..10_000).step_by(500) { - let roots_size = changelog_size * 2; - test_full_nullifier_queue(&StateMerkleTreeConfig { - height: STATE_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + test_full_nullifier_queue( + &StateMerkleTreeConfig { + height: STATE_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &NullifierQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } @@ -405,7 +442,10 @@ async fn test_full_nullifier_queue_custom() { /// 4. invalid Merkle tree accounts: /// 4.1 pass non Merkle tree account as Merkle tree account /// 4.2 pass non associated Merkle tree account -async fn failing_queue(merkle_tree_config: &StateMerkleTreeConfig) { +async fn failing_queue( + merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, +) { let mut program_test = ProgramTest::default(); program_test.add_program("account_compression", ID, None); program_test.add_program( @@ -428,6 +468,7 @@ async fn failing_queue(merkle_tree_config: &StateMerkleTreeConfig) { &merkle_tree_keypair, &nullifier_queue_keypair, merkle_tree_config, + queue_config, ) .await; let merkle_tree_keypair_2 = Keypair::new(); @@ -438,6 +479,7 @@ async fn failing_queue(merkle_tree_config: &StateMerkleTreeConfig) { &merkle_tree_keypair_2, &nullifier_queue_keypair_2, merkle_tree_config, + queue_config, ) .await; @@ -451,6 +493,7 @@ async fn failing_queue(merkle_tree_config: &StateMerkleTreeConfig) { &address_queue_keypair, None, &AddressMerkleTreeConfig::default(), + &AddressQueueConfig::default(), 1, ) .await; @@ -570,23 +613,36 @@ async fn failing_queue(merkle_tree_config: &StateMerkleTreeConfig) { #[tokio::test] async fn test_failing_queue_default() { - failing_queue(&StateMerkleTreeConfig::default()).await + failing_queue( + &StateMerkleTreeConfig::default(), + &NullifierQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_failing_queue_custom() { - for changelog_size in (500..10_000).step_by(500) { - let roots_size = changelog_size * 2; - failing_queue(&StateMerkleTreeConfig { - height: STATE_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + failing_queue( + &StateMerkleTreeConfig { + height: STATE_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &NullifierQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } @@ -596,7 +652,10 @@ async fn test_failing_queue_custom() { /// 3. Should fail: merkle tree and queue not associated (invalid queue) /// 4. Should succeed: rollover state merkle tree /// 5. Should fail: merkle tree already rolled over -async fn test_init_and_rollover_state_merkle_tree(merkle_tree_config: &StateMerkleTreeConfig) { +async fn test_init_and_rollover_state_merkle_tree( + merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, +) { let mut program_test = ProgramTest::default(); program_test.add_program("account_compression", ID, None); program_test.add_program( @@ -618,6 +677,7 @@ async fn test_init_and_rollover_state_merkle_tree(merkle_tree_config: &StateMerk &merkle_tree_keypair, &nullifier_queue_keypair, merkle_tree_config, + queue_config, ) .await; @@ -630,6 +690,7 @@ async fn test_init_and_rollover_state_merkle_tree(merkle_tree_config: &StateMerk &merkle_tree_keypair_2, &nullifier_queue_keypair_2, merkle_tree_config, + queue_config, ) .await; @@ -798,23 +859,36 @@ async fn test_init_and_rollover_state_merkle_tree(merkle_tree_config: &StateMerk #[tokio::test] async fn test_init_and_rollover_state_merkle_tree_default() { - test_init_and_rollover_state_merkle_tree(&StateMerkleTreeConfig::default()).await + test_init_and_rollover_state_merkle_tree( + &StateMerkleTreeConfig::default(), + &NullifierQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_init_and_rollover_state_merkle_tree_custom() { - for changelog_size in (500..10_000).step_by(500) { - let roots_size = changelog_size * 2; - test_init_and_rollover_state_merkle_tree(&StateMerkleTreeConfig { - height: STATE_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + test_init_and_rollover_state_merkle_tree( + &StateMerkleTreeConfig { + height: STATE_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &NullifierQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } @@ -825,7 +899,10 @@ async fn test_init_and_rollover_state_merkle_tree_custom() { /// 4. Functional: Append leaves to merkle tree /// 5. Functional: Append leaves to multiple merkle trees not-ordered /// 6. Failing: Append leaves with invalid authority -async fn test_append_functional_and_failing(merkle_tree_config: &StateMerkleTreeConfig) { +async fn test_append_functional_and_failing( + merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, +) { let mut program_test = ProgramTest::default(); program_test.add_program("account_compression", ID, None); program_test.add_program( @@ -847,6 +924,7 @@ async fn test_append_functional_and_failing(merkle_tree_config: &StateMerkleTree &merkle_tree_keypair, &queue_keypair, merkle_tree_config, + queue_config, ) .await; let merkle_tree_keypair_2 = Keypair::new(); @@ -857,6 +935,7 @@ async fn test_append_functional_and_failing(merkle_tree_config: &StateMerkleTree &merkle_tree_keypair_2, &queue_keypair_2, merkle_tree_config, + queue_config, ) .await; @@ -941,23 +1020,36 @@ async fn test_append_functional_and_failing(merkle_tree_config: &StateMerkleTree #[tokio::test] async fn test_append_functional_and_failing_default() { - test_append_functional_and_failing(&StateMerkleTreeConfig::default()).await + test_append_functional_and_failing( + &StateMerkleTreeConfig::default(), + &NullifierQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_append_functional_and_failing_custom() { - for changelog_size in (500..10_000).step_by(500) { - let roots_size = changelog_size * 2; - test_append_functional_and_failing(&StateMerkleTreeConfig { - height: STATE_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + test_append_functional_and_failing( + &StateMerkleTreeConfig { + height: STATE_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &NullifierQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } @@ -968,7 +1060,10 @@ async fn test_append_functional_and_failing_custom() { /// 4. Failing: nullify leaf with invalid change log index /// 5. Functional: nullify other leaf /// 6. Failing: nullify leaf with nullifier queue that is not associated with the merkle tree -async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { +async fn test_nullify_leaves( + merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, +) { let mut program_test = ProgramTest::default(); program_test.add_program("account_compression", ID, None); program_test.add_program( @@ -991,6 +1086,7 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { &merkle_tree_keypair, &nullifier_queue_keypair, merkle_tree_config, + queue_config, ) .await; @@ -1003,6 +1099,7 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { &other_merkle_tree_keypair, &invalid_nullifier_queue_keypair, merkle_tree_config, + queue_config, ) .await; @@ -1063,6 +1160,7 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { &mut context, &merkle_tree_pubkey, &nullifier_queue_pubkey, + queue_config, &mut reference_merkle_tree, &elements[0].1, 2, @@ -1093,6 +1191,7 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { &mut context, &merkle_tree_pubkey, &nullifier_queue_pubkey, + queue_config, &mut reference_merkle_tree, &elements[1].1, valid_changelog_index, @@ -1107,6 +1206,7 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { &mut context, &merkle_tree_pubkey, &nullifier_queue_pubkey, + queue_config, &mut reference_merkle_tree, &elements[1].1, valid_changelog_index, @@ -1119,6 +1219,7 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { &mut context, &merkle_tree_pubkey, &nullifier_queue_pubkey, + queue_config, &mut reference_merkle_tree, &elements[1].1, valid_changelog_index, @@ -1132,6 +1233,7 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { &mut context, &merkle_tree_pubkey, &invalid_nullifier_queue_pubkey, + queue_config, &mut reference_merkle_tree, &elements[0].1, 2, @@ -1144,23 +1246,36 @@ async fn test_nullify_leaves(merkle_tree_config: &StateMerkleTreeConfig) { #[tokio::test] async fn test_nullify_leaves_default() { - test_nullify_leaves(&StateMerkleTreeConfig::default()).await + test_nullify_leaves( + &StateMerkleTreeConfig::default(), + &NullifierQueueConfig::default(), + ) + .await } #[tokio::test] async fn test_nullify_leaves_custom() { - for changelog_size in (500..10_000).step_by(500) { - let roots_size = changelog_size * 2; - test_nullify_leaves(&StateMerkleTreeConfig { - height: STATE_MERKLE_TREE_HEIGHT as u32, - changelog_size, - roots_size, - canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, - network_fee: Some(5000), - rollover_threshold: Some(95), - close_threshold: None, - }) - .await; + for changelog_size in (1000..5000).step_by(1000) { + for queue_capacity in [5003, 6857, 7901] { + let roots_size = changelog_size * 2; + test_nullify_leaves( + &StateMerkleTreeConfig { + height: STATE_MERKLE_TREE_HEIGHT as u32, + changelog_size, + roots_size, + canopy_depth: STATE_MERKLE_TREE_CANOPY_DEPTH, + network_fee: Some(5000), + rollover_threshold: Some(95), + close_threshold: None, + }, + &NullifierQueueConfig { + capacity: queue_capacity, + sequence_threshold: roots_size, + network_fee: None, + }, + ) + .await; + } } } @@ -1348,6 +1463,7 @@ pub async fn fail_initialize_state_merkle_tree_and_nullifier_queue_invalid_sizes merkle_tree_keypair: &Keypair, queue_keypair: &Keypair, merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, ) { let valid_tree_size = account_compression::state::StateMerkleTreeAccount::size( merkle_tree_config.height as usize, @@ -1355,7 +1471,7 @@ pub async fn fail_initialize_state_merkle_tree_and_nullifier_queue_invalid_sizes merkle_tree_config.roots_size as usize, merkle_tree_config.canopy_depth as usize, ); - let valid_queue_size = QueueAccount::size(STATE_NULLIFIER_QUEUE_VALUES as usize).unwrap(); + let valid_queue_size = QueueAccount::size(queue_config.capacity as usize).unwrap(); // NOTE: Starting from 0 to the account struct size triggers a panic in Anchor // macros (sadly, not assertable...), which happens earlier than our @@ -1427,6 +1543,7 @@ async fn functional_1_initialize_state_merkle_tree_and_nullifier_queue Pubkey { let size = account_compression::state::StateMerkleTreeAccount::size( merkle_tree_config.height as usize, @@ -1444,7 +1561,7 @@ async fn functional_1_initialize_state_merkle_tree_and_nullifier_queue( rpc: &mut R, merkle_tree_pubkey: &Pubkey, nullifier_queue_pubkey: &Pubkey, + nullifier_queue_config: &NullifierQueueConfig, reference_merkle_tree: &mut MerkleTree, element: &[u8; 32], change_log_index: u64, @@ -1727,11 +1845,7 @@ pub async fn nullify( assert_eq!(&array_element.value_bytes(), element); assert_eq!( array_element.sequence_number(), - Some( - merkle_tree.sequence_number() - + STATE_MERKLE_TREE_ROOTS as usize - + SAFETY_MARGIN as usize - ) + Some(merkle_tree.sequence_number() + nullifier_queue_config.sequence_threshold as usize) ); let event = event.unwrap().0; match event { diff --git a/test-programs/system-cpi-test/tests/test_program_owned_trees.rs b/test-programs/system-cpi-test/tests/test_program_owned_trees.rs index 3d76147997..54a6de2cfd 100644 --- a/test-programs/system-cpi-test/tests/test_program_owned_trees.rs +++ b/test-programs/system-cpi-test/tests/test_program_owned_trees.rs @@ -7,7 +7,7 @@ use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction use account_compression::sdk::create_insert_leaves_instruction; use account_compression::utils::constants::{CPI_AUTHORITY_PDA_SEED, STATE_NULLIFIER_QUEUE_VALUES}; use account_compression::{ - AddressMerkleTreeConfig, QueueAccount, StateMerkleTreeAccount, StateMerkleTreeConfig, + AddressMerkleTreeConfig, AddressQueueConfig, QueueAccount, StateMerkleTreeAccount, StateMerkleTreeConfig, }; use light_compressed_token::mint_sdk::create_mint_to_instruction; use light_hasher::Poseidon; @@ -210,6 +210,7 @@ async fn test_invalid_registered_program() { &invalid_group_address_queue, None, &AddressMerkleTreeConfig::default(), + &AddressQueueConfig::default(), 3, ) .await; diff --git a/test-utils/src/address_tree_rollover.rs b/test-utils/src/address_tree_rollover.rs index c6c55de027..cb6f530b77 100644 --- a/test-utils/src/address_tree_rollover.rs +++ b/test-utils/src/address_tree_rollover.rs @@ -10,11 +10,11 @@ use crate::{ }, get_hash_set, }; -use account_compression::AddressMerkleTreeConfig; use account_compression::{ accounts, initialize_address_merkle_tree::AccountLoader, instruction, state::QueueAccount, AddressMerkleTreeAccount, }; +use account_compression::{AddressMerkleTreeConfig, AddressQueueConfig}; use anchor_lang::{InstructionData, Key, Lamports, ToAccountMetas}; use light_hasher::Poseidon; use light_indexed_merkle_tree::zero_copy::IndexedMerkleTreeZeroCopyMut; @@ -62,11 +62,10 @@ pub async fn perform_address_merkle_tree_roll_over( old_merkle_tree_pubkey: &Pubkey, old_queue_pubkey: &Pubkey, merkle_tree_config: &AddressMerkleTreeConfig, + queue_config: &AddressQueueConfig, ) -> Result { let payer = context.get_payer().insecure_clone(); - let size = - QueueAccount::size(account_compression::utils::constants::ADDRESS_QUEUE_VALUES as usize) - .unwrap(); + let size = QueueAccount::size(queue_config.capacity as usize).unwrap(); let account_create_ix = crate::create_account_instruction( &payer.pubkey(), size, diff --git a/test-utils/src/e2e_test_env.rs b/test-utils/src/e2e_test_env.rs index ebd996597d..9e3d2d6a51 100644 --- a/test-utils/src/e2e_test_env.rs +++ b/test-utils/src/e2e_test_env.rs @@ -99,7 +99,7 @@ use account_compression::utils::constants::{ use light_hasher::Poseidon; use light_indexed_merkle_tree::{array::IndexedArray, reference::IndexedMerkleTree}; -use account_compression::{AddressMerkleTreeConfig, StateMerkleTreeConfig}; +use account_compression::{AddressMerkleTreeConfig, AddressQueueConfig, StateMerkleTreeConfig}; use light_system_program::sdk::compressed_account::CompressedAccountWithMerkleContext; use light_utils::bigint::bigint_to_be_bytes_array; use num_bigint::{BigUint, RandBigInt}; @@ -438,6 +438,7 @@ where &nullifier_queue_keypair, None, &config, + &AddressQueueConfig::default(), self.indexer.address_merkle_trees.len() as u64, ) .await; diff --git a/test-utils/src/indexer/test_indexer.rs b/test-utils/src/indexer/test_indexer.rs index 54b11bc388..2566b8f198 100644 --- a/test-utils/src/indexer/test_indexer.rs +++ b/test-utils/src/indexer/test_indexer.rs @@ -4,7 +4,7 @@ use solana_sdk::bs58; use std::marker::PhantomData; use std::sync::{Arc, Mutex}; -use account_compression::{AddressMerkleTreeConfig, StateMerkleTreeConfig}; +use account_compression::{AddressMerkleTreeConfig, AddressQueueConfig, StateMerkleTreeConfig}; use light_compressed_token::constants::TOKEN_COMPRESSED_ACCOUNT_DISCRIMINATOR; use light_compressed_token::mint_sdk::create_create_token_pool_instruction; use light_compressed_token::{get_token_pool_pda, TokenData}; @@ -488,6 +488,7 @@ impl TestIndexer( address_queue_keypair: &Keypair, program_owner: Option, merkle_tree_config: &AddressMerkleTreeConfig, + queue_config: &AddressQueueConfig, index: u64, ) { - use account_compression::{ - sdk::create_initialize_address_merkle_tree_and_queue_instruction, AddressQueueConfig, - }; + use account_compression::sdk::create_initialize_address_merkle_tree_and_queue_instruction; - let size = account_compression::state::QueueAccount::size( - account_compression::utils::constants::ADDRESS_QUEUE_VALUES as usize, - ) - .unwrap(); + let size = + account_compression::state::QueueAccount::size(queue_config.capacity as usize).unwrap(); let account_create_ix = create_account_instruction( &payer.pubkey(), size, @@ -462,7 +460,6 @@ pub async fn create_address_merkle_tree_and_queue_account( &account_compression::ID, Some(address_merkle_tree_keypair), ); - let queue_config = AddressQueueConfig::default(); let instruction = create_initialize_address_merkle_tree_and_queue_instruction( index, payer.pubkey(), @@ -531,7 +528,7 @@ pub async fn create_address_merkle_tree_and_queue_account( assert_address_queue_initialized( context, &address_queue_keypair.pubkey(), - &queue_config, + queue_config, &address_merkle_tree_keypair.pubkey(), merkle_tree_config, QueueType::AddressQueue, diff --git a/test-utils/src/test_forester.rs b/test-utils/src/test_forester.rs index b927a563f7..cd5d6d47ae 100644 --- a/test-utils/src/test_forester.rs +++ b/test-utils/src/test_forester.rs @@ -452,7 +452,7 @@ pub async fn empty_address_queue_test Date: Thu, 27 Jun 2024 16:02:31 +0200 Subject: [PATCH 2/5] chore: Include `SAFETY_MARGIN` in tests with non-default queue configs --- .../tests/address_merkle_tree_tests.rs | 8 +++--- .../tests/merkle_tree_tests.rs | 26 ++++++++++++------- 2 files changed, 21 insertions(+), 13 deletions(-) diff --git a/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs b/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs index 5dde908807..3bd437b4ec 100644 --- a/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs +++ b/test-programs/account-compression-test/tests/address_merkle_tree_tests.rs @@ -6,7 +6,7 @@ use account_compression::{ errors::AccountCompressionErrorCode, state::QueueAccount, utils::constants::{ADDRESS_MERKLE_TREE_CANOPY_DEPTH, ADDRESS_MERKLE_TREE_HEIGHT}, - AddressMerkleTreeAccount, AddressMerkleTreeConfig, AddressQueueConfig, ID, + AddressMerkleTreeAccount, AddressMerkleTreeConfig, AddressQueueConfig, ID, SAFETY_MARGIN, }; use anchor_lang::error::ErrorCode; use light_hash_set::{HashSet, HashSetError}; @@ -134,7 +134,7 @@ async fn test_address_queue_and_tree_functional_custom() { }, &AddressQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -706,7 +706,7 @@ async fn update_address_merkle_tree_failing_tests_custom() { }, &AddressQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -946,7 +946,7 @@ async fn test_address_merkle_tree_and_queue_rollover_custom() { }, &AddressQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) diff --git a/test-programs/account-compression-test/tests/merkle_tree_tests.rs b/test-programs/account-compression-test/tests/merkle_tree_tests.rs index a5bd74a986..d311d225c0 100644 --- a/test-programs/account-compression-test/tests/merkle_tree_tests.rs +++ b/test-programs/account-compression-test/tests/merkle_tree_tests.rs @@ -200,7 +200,7 @@ async fn test_init_and_insert_into_nullifier_queue_custom() { }, &NullifierQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -222,6 +222,7 @@ async fn test_full_nullifier_queue( merkle_tree_config: &StateMerkleTreeConfig, queue_config: &NullifierQueueConfig, ) { + println!("SEQUENCE THRESHOLD: {}", queue_config.sequence_threshold); let mut program_test = ProgramTest::default(); program_test.add_program("account_compression", ID, None); program_test.add_program( @@ -333,11 +334,12 @@ async fn test_full_nullifier_queue( vec![element], ) .await; - // advance to sequence number minus one + // Advance to sequence threshold + 1 (expected sequence number of the last + // element - 1). set_state_merkle_tree_sequence( &mut rpc, &merkle_tree_pubkey, - 2402 + SAFETY_MARGIN, + queue_config.sequence_threshold + 1, lamports_queue_accounts, ) .await; @@ -350,10 +352,12 @@ async fn test_full_nullifier_queue( ) .await; // TODO: add e2e test in compressed pda program for this + // Advance to sequence threshold + 2 (expected sequence number of the last + // element). set_state_merkle_tree_sequence( &mut rpc, &merkle_tree_pubkey, - 2403 + SAFETY_MARGIN, + queue_config.sequence_threshold + 2, lamports_queue_accounts, ) .await; @@ -422,7 +426,7 @@ async fn test_full_nullifier_queue_custom() { }, &NullifierQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -637,7 +641,7 @@ async fn test_failing_queue_custom() { }, &NullifierQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -883,7 +887,7 @@ async fn test_init_and_rollover_state_merkle_tree_custom() { }, &NullifierQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -1044,7 +1048,7 @@ async fn test_append_functional_and_failing_custom() { }, &NullifierQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -1270,7 +1274,7 @@ async fn test_nullify_leaves_custom() { }, &NullifierQueueConfig { capacity: queue_capacity, - sequence_threshold: roots_size, + sequence_threshold: roots_size + SAFETY_MARGIN, network_fee: None, }, ) @@ -1847,6 +1851,10 @@ pub async fn nullify( array_element.sequence_number(), Some(merkle_tree.sequence_number() + nullifier_queue_config.sequence_threshold as usize) ); + println!( + "ARRAY ELEMENT SEQ NUM: {}", + array_element.sequence_number().unwrap() + ); let event = event.unwrap().0; match event { MerkleTreeEvent::V1(_) => panic!("Expected V2 event"), From a2f670217c5f0cf20ee00ad4c1916afe1a780632 Mon Sep 17 00:00:00 2001 From: Michal Rostecki Date: Thu, 27 Jun 2024 16:49:04 +0200 Subject: [PATCH 3/5] fix: Pass queue config when rolling over --- .../account-compression-test/tests/merkle_tree_tests.rs | 7 +++++++ test-utils/src/e2e_test_env.rs | 5 ++++- test-utils/src/state_tree_rollover.rs | 7 ++++--- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/test-programs/account-compression-test/tests/merkle_tree_tests.rs b/test-programs/account-compression-test/tests/merkle_tree_tests.rs index d311d225c0..1d376092c5 100644 --- a/test-programs/account-compression-test/tests/merkle_tree_tests.rs +++ b/test-programs/account-compression-test/tests/merkle_tree_tests.rs @@ -731,6 +731,7 @@ async fn test_init_and_rollover_state_merkle_tree( &merkle_tree_pubkey, &nullifier_queue_pubkey, merkle_tree_config, + queue_config, None, ) .await; @@ -749,6 +750,7 @@ async fn test_init_and_rollover_state_merkle_tree( &merkle_tree_pubkey, &nullifier_queue_pubkey, merkle_tree_config, + queue_config, Some(StateMerkleTreeRolloverMode::QueueInvalidSize), ) .await; @@ -761,6 +763,7 @@ async fn test_init_and_rollover_state_merkle_tree( &merkle_tree_pubkey, &nullifier_queue_pubkey, merkle_tree_config, + queue_config, Some(StateMerkleTreeRolloverMode::TreeInvalidSize), ) .await; @@ -781,6 +784,7 @@ async fn test_init_and_rollover_state_merkle_tree( &merkle_tree_pubkey, &nullifier_queue_keypair_2.pubkey(), merkle_tree_config, + queue_config, None, ) .await; @@ -799,6 +803,7 @@ async fn test_init_and_rollover_state_merkle_tree( &merkle_tree_pubkey_2, &nullifier_queue_keypair.pubkey(), merkle_tree_config, + queue_config, None, ) .await; @@ -824,6 +829,7 @@ async fn test_init_and_rollover_state_merkle_tree( &merkle_tree_pubkey, &nullifier_queue_pubkey, merkle_tree_config, + queue_config, None, ) .await @@ -849,6 +855,7 @@ async fn test_init_and_rollover_state_merkle_tree( &merkle_tree_pubkey, &nullifier_queue_pubkey, merkle_tree_config, + queue_config, None, ) .await; diff --git a/test-utils/src/e2e_test_env.rs b/test-utils/src/e2e_test_env.rs index 9e3d2d6a51..8b2af1282c 100644 --- a/test-utils/src/e2e_test_env.rs +++ b/test-utils/src/e2e_test_env.rs @@ -99,7 +99,9 @@ use account_compression::utils::constants::{ use light_hasher::Poseidon; use light_indexed_merkle_tree::{array::IndexedArray, reference::IndexedMerkleTree}; -use account_compression::{AddressMerkleTreeConfig, AddressQueueConfig, StateMerkleTreeConfig}; +use account_compression::{ + AddressMerkleTreeConfig, AddressQueueConfig, NullifierQueueConfig, StateMerkleTreeConfig, +}; use light_system_program::sdk::compressed_account::CompressedAccountWithMerkleContext; use light_utils::bigint::bigint_to_be_bytes_array; use num_bigint::{BigUint, RandBigInt}; @@ -575,6 +577,7 @@ where &bundle.merkle_tree, &bundle.nullifier_queue, &StateMerkleTreeConfig::default(), + &NullifierQueueConfig::default(), None, ) .await diff --git a/test-utils/src/state_tree_rollover.rs b/test-utils/src/state_tree_rollover.rs index c847b75919..b2aa698273 100644 --- a/test-utils/src/state_tree_rollover.rs +++ b/test-utils/src/state_tree_rollover.rs @@ -9,10 +9,10 @@ use crate::{ }, create_account_instruction, get_hash_set, }; +use account_compression::NullifierQueueConfig; use account_compression::{ self, initialize_address_merkle_tree::AccountLoader, state::QueueAccount, - utils::constants::STATE_NULLIFIER_QUEUE_VALUES, StateMerkleTreeAccount, StateMerkleTreeConfig, - ID, + StateMerkleTreeAccount, StateMerkleTreeConfig, ID, }; use anchor_lang::{InstructionData, Lamports, ToAccountMetas}; use light_concurrent_merkle_tree::{ @@ -41,10 +41,11 @@ pub async fn perform_state_merkle_tree_roll_over( merkle_tree_pubkey: &Pubkey, nullifier_queue_pubkey: &Pubkey, merkle_tree_config: &StateMerkleTreeConfig, + queue_config: &NullifierQueueConfig, mode: Option, ) -> Result { let payer_pubkey = rpc.get_payer().pubkey(); - let mut size = QueueAccount::size(STATE_NULLIFIER_QUEUE_VALUES as usize).unwrap(); + let mut size = QueueAccount::size(queue_config.capacity as usize).unwrap(); if let Some(StateMerkleTreeRolloverMode::QueueInvalidSize) = mode { size += 1; } From 0c3c07f20b229f1b22a1086776846ec561e55284 Mon Sep 17 00:00:00 2001 From: Michal Rostecki Date: Thu, 27 Jun 2024 17:41:10 +0200 Subject: [PATCH 4/5] chore: Fix clippy error --- test-utils/src/state_tree_rollover.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/test-utils/src/state_tree_rollover.rs b/test-utils/src/state_tree_rollover.rs index b2aa698273..c541da4a46 100644 --- a/test-utils/src/state_tree_rollover.rs +++ b/test-utils/src/state_tree_rollover.rs @@ -34,6 +34,7 @@ pub enum StateMerkleTreeRolloverMode { TreeInvalidSize, } +#[allow(clippy::too_many_arguments)] pub async fn perform_state_merkle_tree_roll_over( rpc: &mut R, new_nullifier_queue_keypair: &Keypair, From f10aa24c846dd7789c9ecc5613101a0bb368ef75 Mon Sep 17 00:00:00 2001 From: ananas-block Date: Fri, 28 Jun 2024 00:02:39 +0100 Subject: [PATCH 5/5] fix clippy --- .../system-cpi-test/tests/test_program_owned_trees.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test-programs/system-cpi-test/tests/test_program_owned_trees.rs b/test-programs/system-cpi-test/tests/test_program_owned_trees.rs index 54a6de2cfd..e499606354 100644 --- a/test-programs/system-cpi-test/tests/test_program_owned_trees.rs +++ b/test-programs/system-cpi-test/tests/test_program_owned_trees.rs @@ -7,7 +7,8 @@ use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction use account_compression::sdk::create_insert_leaves_instruction; use account_compression::utils::constants::{CPI_AUTHORITY_PDA_SEED, STATE_NULLIFIER_QUEUE_VALUES}; use account_compression::{ - AddressMerkleTreeConfig, AddressQueueConfig, QueueAccount, StateMerkleTreeAccount, StateMerkleTreeConfig, + AddressMerkleTreeConfig, AddressQueueConfig, QueueAccount, StateMerkleTreeAccount, + StateMerkleTreeConfig, }; use light_compressed_token::mint_sdk::create_mint_to_instruction; use light_hasher::Poseidon;