test: correct root

Author: ananas-block

src/api/method/get_transaction_with_compression_info.rs

@@ -4,6 +4,7 @@ use super::{
 use crate::api::method::utils::parse_account_model_with_context;
 use crate::common::typedefs::account::AccountV2;
 use crate::common::typedefs::account::AccountWithContext;
+use crate::common::typedefs::hash::Hash;
 use crate::common::typedefs::token_data::TokenData;
 use crate::common::typedefs::{account::Account, serializable_signature::SerializableSignature};
 use crate::dao::generated::accounts::Model;
@@ -99,11 +100,19 @@ pub struct AccountWithOptionalTokenDataV2 {
     pub optionalTokenData: Option<TokenData>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, ToSchema)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[allow(non_snake_case)]
+pub struct ClosedAccountWithOptionalTokenData {
+    pub account: ClosedAccount,
+    pub optionalTokenData: Option<TokenData>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, ToSchema)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 #[allow(non_snake_case)]
 pub struct CompressionInfoV2 {
-    pub closedAccounts: Vec<AccountWithOptionalTokenDataV2>,
+    pub closedAccounts: Vec<ClosedAccountWithOptionalTokenData>,
     pub openedAccounts: Vec<AccountWithOptionalTokenDataV2>,
 }
 
@@ -245,6 +254,30 @@ fn parse_optional_token_data_v2(
     })
 }
 
+fn parse_optional_token_data_for_multiple_accounts_closed_account(
+    accounts: Vec<ClosedAccount>,
+) -> Result<Vec<ClosedAccountWithOptionalTokenData>, PhotonApiError> {
+    accounts
+        .into_iter()
+        .map(parse_optional_token_data_closed_account)
+        .collect()
+}
+
+fn parse_optional_token_data_closed_account(
+    account: ClosedAccount,
+) -> Result<ClosedAccountWithOptionalTokenData, PhotonApiError> {
+    let hash = account.account.hash.clone();
+    Ok(ClosedAccountWithOptionalTokenData {
+        optionalTokenData: parse_token_data_v2(&account.account).map_err(|e| {
+            PhotonApiError::UnexpectedError(format!(
+                "Failed to parse token data for account {}: {}",
+                hash, e
+            ))
+        })?,
+        account,
+    })
+}
+
 fn parse_optional_token_data_for_multiple_accounts_v2(
     accounts: Vec<AccountV2>,
 ) -> Result<Vec<AccountWithOptionalTokenDataV2>, PhotonApiError> {
@@ -254,6 +287,14 @@ fn parse_optional_token_data_for_multiple_accounts_v2(
         .collect()
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, ToSchema, Default)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+pub struct ClosedAccount {
+    pub account: AccountV2,
+    pub nullifier: Hash,
+    pub tx_hash: Hash,
+}
+
 pub async fn get_transaction_helper_v2(
     conn: &DatabaseConnection,
     signature: SerializableSignature,
@@ -297,21 +338,32 @@ pub async fn get_transaction_helper_v2(
 
     println!("closed_accounts: {:?}", closed_accounts);
 
-    let closed_accounts = closed_accounts
-        .into_iter()
-        .map(|x| AccountV2 {
-            hash: x.account.hash,
-            address: x.account.address,
-            data: x.account.data,
-            owner: x.account.owner,
-            lamports: x.account.lamports,
-            tree: x.account.tree,
-            leaf_index: x.account.leaf_index,
-            seq: x.account.seq,
-            slot_created: x.account.slot_created,
-            queue: x.context.queue,
-        })
-        .collect::<Vec<AccountV2>>();
+    let closed_accounts =
+        closed_accounts
+            .into_iter()
+            .map(|x| -> Result<ClosedAccount, PhotonApiError> {
+                Ok(ClosedAccount {
+                    account: AccountV2 {
+                        hash: x.account.hash,
+                        address: x.account.address,
+                        data: x.account.data,
+                        owner: x.account.owner,
+                        lamports: x.account.lamports,
+                        tree: x.account.tree,
+                        leaf_index: x.account.leaf_index,
+                        seq: x.account.seq,
+                        slot_created: x.account.slot_created,
+                        queue: x.context.queue,
+                    },
+                    nullifier: x.context.nullifier.ok_or(PhotonApiError::UnexpectedError(
+                        String::from("Nullifier does not exist for closed account."),
+                    ))?,
+                    tx_hash: x.context.tx_hash.ok_or(PhotonApiError::UnexpectedError(
+                        String::from("Nullifier does not exist for closed account."),
+                    ))?,
+                })
+            })
+            .collect::<Result<Vec<ClosedAccount>, PhotonApiError>>()?;
 
     let out_accounts = status_update
         .out_accounts
@@ -333,7 +385,9 @@ pub async fn get_transaction_helper_v2(
     Ok(GetTransactionResponseV2 {
         transaction: txn,
         compressionInfo: CompressionInfoV2 {
-            closedAccounts: parse_optional_token_data_for_multiple_accounts_v2(closed_accounts)?,
+            closedAccounts: parse_optional_token_data_for_multiple_accounts_closed_account(
+                closed_accounts,
+            )?,
             openedAccounts: parse_optional_token_data_for_multiple_accounts_v2(out_accounts)?,
         },
     })

…gration_tests/batched_state_tree_test.rs …ration_tests/batched_state_tree_tests.rstests/integration_tests/batched_state_tree_test.rs renamed to tests/integration_tests/batched_state_tree_tests.rs tests/integration_tests/batched_state_tree_test.rs renamed to tests/integration_tests/batched_state_tree_tests.rs

@@ -7,7 +7,9 @@ use photon_indexer::api::method::get_compressed_token_balances_by_owner::{
     GetCompressedTokenBalancesByOwnerRequest, TokenBalance,
 };
 use photon_indexer::api::method::get_multiple_compressed_account_proofs::HashList;
-use photon_indexer::api::method::get_transaction_with_compression_info::get_transaction_helper;
+use photon_indexer::api::method::get_transaction_with_compression_info::{
+    get_transaction_helper, get_transaction_helper_v2,
+};
 use photon_indexer::api::method::utils::GetCompressedTokenAccountsByOwner;
 use photon_indexer::common::typedefs::serializable_pubkey::SerializablePubkey;
 use photon_indexer::common::typedefs::serializable_signature::SerializableSignature;
@@ -26,6 +28,10 @@ use solana_transaction_status::EncodedConfirmedTransactionWithStatusMeta;
 use std::str::FromStr;
 use std::sync::Arc;
 
+/// Test:
+/// 1. get compressed account by owner
+/// 2. get compressed account proofs
+/// 3. correct root update after batch append and batch nullify events
 #[named]
 #[rstest]
 #[tokio::test]
@@ -69,7 +75,7 @@ async fn test_batched_tree_transactions(
 
             // use get_transaction_helper because get_transaction_with_compression_info requires an rpc endpoint.
             // It fetches the instruction and parses the data.
-            let accounts = get_transaction_helper(
+            let accounts = get_transaction_helper_v2(
                 &setup.db_conn,
                 SerializableSignature(Signature::from_str(signature).unwrap()),
                 transaction,
@@ -78,28 +84,23 @@ async fn test_batched_tree_transactions(
             .unwrap()
             .compressionInfo;
             for account in accounts.closedAccounts.iter() {
-                // let full_account = setup
-                //     .api
-                //     .get_compressed_accounts_by_owner_v2(GetCompressedAccountsByOwnerRequest {
-                //         owner: account.account.owner,
-                //         ..Default::default()
-                //     })
-                //     .await
-                //     .unwrap();
-                // merkle_tree
-                //     .update(
-                //         &full_account.value.items[0]
-                //             .context
-                //             .nullifier
-                //             .as_ref()
-                //             .unwrap()
-                //             .0,
-                //         account.account.leaf_index.0 as usize,
-                //     )
-                //     .unwrap();
+                merkle_tree
+                    .update(
+                        &account.account.nullifier.0,
+                        account.account.account.leaf_index.0 as usize,
+                    )
+                    .unwrap();
             }
             for account in accounts.openedAccounts.iter() {
-                merkle_tree.append(&account.account.hash.0).unwrap();
+                while merkle_tree.rightmost_index <= account.account.leaf_index.0 as usize + 2 {
+                    merkle_tree.append(&[0u8; 32]).unwrap();
+                }
+                merkle_tree
+                    .update(
+                        &account.account.hash.0,
+                        account.account.leaf_index.0 as usize,
+                    )
+                    .unwrap();
             }
         }
 
@@ -124,13 +125,12 @@ async fn test_batched_tree_transactions(
                 })
                 .await
                 .unwrap();
-            println!("accounts {:?}", accounts);
             assert_eq!(accounts.value.items.len(), 1);
             let account = &accounts.value.items[0];
-            assert_eq!(account.account.lamports.0, 1_000_000u64);
-            assert_eq!(account.account.owner.0, owner);
+            assert_eq!(account.lamports.0, 1_000_000u64);
+            assert_eq!(account.owner.0, owner);
             assert_eq!(
-                account.account.leaf_index.0,
+                account.leaf_index.0,
                 leaf_index,
                 "owner {:?} i {}",
                 owner.to_bytes(),
@@ -143,23 +143,25 @@ async fn test_batched_tree_transactions(
                 .to_vec();
             let merkle_proof = setup
                 .api
-                .get_multiple_compressed_account_proofs(HashList(vec![account
-                    .account
-                    .hash
-                    .clone()]))
+                .get_multiple_compressed_account_proofs(HashList(vec![account.hash.clone()]))
                 .await
                 .unwrap();
+            assert_eq!(merkle_proof.value[0].hash.0, account.hash.0,);
+            assert_eq!(
+                merkle_proof.value[0].hash.0,
+                merkle_tree.leaf(leaf_index as usize)
+            );
+            assert_eq!(account.hash.0, merkle_tree.leaf(leaf_index as usize));
             assert_eq!(merkle_proof.value.len(), 1);
-            // TODO: enable when nullifiers are correctly inserted into the reference tree.
-            // assert_eq!(merkle_proof.value[0].root.0, merkle_tree.root());
-            // assert_eq!(
-            //     merkle_proof.value[0]
-            //         .proof
-            //         .iter()
-            //         .map(|x| x.0)
-            //         .collect::<Vec<[u8; 32]>>(),
-            //     reference_merkle_proof
-            // );
+            assert_eq!(merkle_proof.value[0].root.0, merkle_tree.root());
+            assert_eq!(
+                merkle_proof.value[0]
+                    .proof
+                    .iter()
+                    .map(|x| x.0)
+                    .collect::<Vec<[u8; 32]>>(),
+                reference_merkle_proof
+            );
             leaf_index += 2;
         }
     }

tests/integration_tests/main.rs

@@ -2,7 +2,7 @@
 // binary. This has a number of benefits:
 // 1. Faster compile time since we only have 1 binary.
 // 2. The ability to add global locks on the DB to prevent tests from interfering with each other.
-mod batched_state_tree_test;
+mod batched_state_tree_tests;
 mod e2e_tests;
 mod mock_tests;
 mod open_api_tests;