wip

Author: SwenSchaeferjohann

sdk-libs/program-test/src/indexer/test_indexer.rs

@@ -230,11 +230,35 @@ impl Indexer for TestIndexer {
             res
         };
 
-        let account_data = account
+        let mut account_data: CompressedAccount = account
             .ok_or(IndexerError::AccountNotFound)?
             .clone()
             .try_into()?;
 
+        // CRITICAL FIX: For V2 trees, if the account is found in the output queue by its leaf index,
+        // use the event hash from the queue instead of the calculated hash
+        // This ensures that the returned account hash matches what's in the output queue
+        if account_data.tree_info.tree_type == TreeType::StateV2 {
+            println!("using output queue");
+            if let Some(merkle_tree) = self
+                .state_merkle_trees
+                .iter()
+                .find(|t| t.accounts.merkle_tree == account_data.tree_info.tree)
+            {
+                println!("found merkle tree");
+                if let Some((event_hash, _)) = merkle_tree
+                    .output_queue_elements
+                    .iter()
+                    .find(|(_, leaf_idx)| *leaf_idx == account_data.leaf_index as u64)
+                {
+                    println!("found hash in output queue: {:?}", event_hash);
+                    // Found the account in output queue by leaf index - use the event hash
+                    // This allows the account to be found in output queue for prove_by_index
+                    account_data.hash = *event_hash;
+                }
+            }
+        }
+
         Ok(Response {
             context: Context {
                 slot: self.get_current_slot(),
@@ -445,6 +469,7 @@ impl Indexer for TestIndexer {
         new_addresses_with_trees: Vec<AddressWithTree>,
         _config: Option<IndexerRpcConfig>,
     ) -> Result<Response<ValidityProofWithContext>, IndexerError> {
+        // DEBUG: Only print essential info
         #[cfg(feature = "v2")]
         {
             // V2 implementation with queue handling
@@ -457,9 +482,11 @@ impl Indexer for TestIndexer {
             let mut proof_inputs = vec![];
 
             let mut indices_to_remove = Vec::new();
-            // for all accounts in batched trees, check whether values are in tree or queue
+            // For all accounts in batched trees, check whether values are in tree or queue.
+
             let compressed_accounts = if !hashes.is_empty() && !state_merkle_tree_pubkeys.is_empty()
             {
+                // Processing compressed accounts
                 let zipped_accounts = hashes.iter().zip(state_merkle_tree_pubkeys.iter());
 
                 for (i, (compressed_account, state_merkle_tree_pubkey)) in
@@ -469,7 +496,7 @@ impl Indexer for TestIndexer {
                         x.accounts.merkle_tree == *state_merkle_tree_pubkey
                             && x.tree_type == TreeType::StateV2
                     });
-
+                    // Check if account is in output queue
                     if let Some(accounts) = accounts {
                         let queue_element = accounts
                             .output_queue_elements
@@ -481,6 +508,8 @@ impl Indexer for TestIndexer {
                             {
                                 use light_client::indexer::RootIndex;
 
+                                // Account found in output queue - use prove_by_index
+
                                 indices_to_remove.push(i);
                                 proof_inputs.push(AccountProofInputs {
                                     hash: *compressed_account,
@@ -500,8 +529,14 @@ impl Indexer for TestIndexer {
                                         tree_type: accounts.tree_type,
                                     },
                                 })
+                            } else {
+                                // Account found but not in valid queue range
                             }
+                        } else {
+                            // Account not found in output queue - will need merkle proof
                         }
+                    } else {
+                        // No StateV2 tree found
                     }
                 }
 
@@ -512,15 +547,22 @@ impl Indexer for TestIndexer {
                     .map(|(_, x)| *x)
                     .collect::<Vec<[u8; 32]>>();
 
+                // Final compressed_accounts that need merkle proofs
+
                 if compress_accounts.is_empty() {
                     None
                 } else {
                     Some(compress_accounts)
                 }
             } else {
+                println!(
+                    "No hashes or state_merkle_tree_pubkeys provided, skipping compressed_accounts computation."
+                );
                 None
             };
 
+            // Processing remaining accounts that need merkle proofs
+
             // Get the basic validity proof if needed
             let rpc_result: Option<ValidityProofWithContext> = if (compressed_accounts.is_some()
                 && !compressed_accounts.as_ref().unwrap().is_empty())
@@ -1920,6 +1962,7 @@ impl TestIndexer {
                 tree_types.push(bundle.tree_type);
                 println!("merkle_tree {:?}", merkle_tree);
                 println!("account {:?}", account);
+                println!("bundle {:?}", bundle.accounts);
                 let leaf_index = merkle_tree.get_leaf_index(account).unwrap();
                 let proof = merkle_tree.get_proof_of_leaf(leaf_index, true).unwrap();
 

sdk-tests/anchor-compressible/Cargo.toml

@@ -32,7 +32,7 @@ light-compressed-token-types = { workspace = true, features = ["anchor"] }
 
 [dev-dependencies]
 light-program-test = { workspace = true, features = ["v2"] }
-light-client = { workspace = true, features = ["devenv", "v2"] }
+light-client = { workspace = true, features = ["v2"] }
 light-compressible-client = { workspace = true, features = ["anchor"] }
 light-test-utils = { workspace = true}
 tokio = { workspace = true }

sdk-tests/anchor-compressible/tests/test_decompress_multiple.rs

@@ -1,5 +1,7 @@
 #![cfg(feature = "test-sbf")]
 
+use std::{thread::sleep, time::Duration};
+
 use anchor_compressible::{CompressedAccountVariant, GameSession, UserRecord};
 use anchor_lang::{
     AccountDeserialize, AnchorDeserialize, Discriminator, InstructionData, ToAccountMetas,
@@ -37,7 +39,9 @@ pub const RENT_RECIPIENT: Pubkey = pubkey!("CLEuMG7pzJX9xAuKCFzBP154uiG1GaNo4Fq7
 #[tokio::test]
 async fn test_create_and_decompress_two_accounts() {
     let program_id = anchor_compressible::ID;
-    let config = ProgramTestConfig::new_v2(true, Some(vec![("anchor_compressible", program_id)]));
+    let mut config =
+        ProgramTestConfig::new_v2(true, Some(vec![("anchor_compressible", program_id)]));
+    config = config.with_light_protocol_events();
     let mut rpc = LightProgramTest::new(config).await.unwrap();
     let payer = rpc.get_payer().insecure_clone();
 
@@ -132,6 +136,7 @@ async fn test_create_and_decompress_two_accounts() {
 
     rpc.warp_to_slot(200).unwrap();
 
+    // sleep(Duration::from_secs(10));
     println!("henlo? decompress multiple");
     test_decompress_multiple_pdas(
         &mut rpc,
@@ -485,6 +490,13 @@ async fn test_decompress_multiple_pdas(
         "test-decompress-multiple-pdas: c_game_session: {:?}",
         c_game_session
     );
+
+    println!("c_user_pda: {:?}", c_user_pda);
+    println!("c_user_pda hash: {:?}", c_user_pda.hash);
+    println!("c_user_pda tree_info: {:?}", c_user_pda.tree_info);
+    println!("c_game_pda: {:?}", c_game_pda);
+    println!("c_game_pda hash: {:?}", c_game_pda.hash);
+    println!("c_game_pda tree_info: {:?}", c_game_pda.tree_info);
     // Get validity proof for both compressed accounts
     let rpc_result = rpc
         .get_validity_proof(vec![c_user_pda.hash, c_game_pda.hash], vec![], None)