fix: make queue field nullable in accounts model (helius-labs#283)

* fix: make queue field nullable in accounts model

* handle optional queue

Author: sergeytimoshin

src/api/method/get_compressed_account_proof/v2.rs

@@ -128,7 +128,8 @@ pub async fn get_compressed_account_proof_v2(
     // Enrich with account data if available
     if let Some(account) = account {
         result.tree_context.tree_type = account.tree_type.map(|t| t as u16).unwrap_or(0);
-        result.tree_context.queue = SerializablePubkey::try_from(account.queue)?;
+        result.tree_context.queue =
+            SerializablePubkey::try_from(account.queue.unwrap_or_default())?;
     }
 
     let response = GetCompressedAccountProofResponseV2 {

src/api/method/get_multiple_compressed_account_proofs/v2.rs

@@ -148,7 +148,7 @@ pub async fn get_multiple_compressed_account_proofs_v2(
             value.tree_context = TreeContextInfo {
                 tree_type: account.tree_type.map(|t| t as u16).unwrap_or(0),
                 tree: SerializablePubkey::try_from(account.tree.clone())?,
-                queue: SerializablePubkey::try_from(account.queue.clone())?,
+                queue: SerializablePubkey::try_from(account.queue.clone().unwrap_or_default())?,
                 cpi_context: None,
             };
         }

src/api/method/get_validity_proof/v2.rs

@@ -203,8 +203,10 @@ pub async fn get_validity_proof_v2(
                         tree_type: acc_model.tree_type.map(|t| t as u16).unwrap_or(0),
                         tree: SerializablePubkey::try_from_slice(&acc_model.tree)
                             .unwrap_or_default(),
-                        queue: SerializablePubkey::try_from_slice(&acc_model.queue)
-                            .unwrap_or_default(),
+                        queue: SerializablePubkey::try_from_slice(
+                            &acc_model.queue.clone().unwrap_or_default(),
+                        )
+                        .unwrap_or_default(),
                         cpi_context: None,
                         next_tree_context: None,
                     },

src/common/typedefs/account/context.rs

@@ -137,7 +137,7 @@ impl TryFrom<Model> for AccountWithContext {
                 seq: account.seq.map(|seq| UnsignedInteger(seq as u64)),
             },
             context: AccountContext {
-                queue: account.queue.try_into()?,
+                queue: account.queue.unwrap_or_default().try_into()?,
                 in_output_queue: account.in_output_queue,
                 spent: account.spent,
                 nullified_in_tree: account.nullified_in_tree,

src/common/typedefs/account/v2.rs

@@ -70,7 +70,7 @@ impl TryFrom<Model> for AccountV2 {
             merkle_context: MerkleContextV2 {
                 tree_type: account.tree_type.map(|t| t as u16).unwrap_or(0),
                 tree: account.tree.try_into()?,
-                queue: account.queue.clone().try_into()?,
+                queue: account.queue.unwrap_or_default().try_into()?,
                 cpi_context: None,
                 next_tree_context: None,
             },

src/dao/generated/accounts.rs

@@ -25,7 +25,7 @@ pub struct Model {
     pub nullified_in_tree: bool,
     pub nullifier_queue_index: Option<i64>,
     pub in_output_queue: bool,
-    pub queue: Vec<u8>,
+    pub queue: Option<Vec<u8>>,
     pub nullifier: Option<Vec<u8>>,
     pub tx_hash: Option<Vec<u8>>,
 }

src/ingester/persist/mod.rs

@@ -421,7 +421,7 @@ async fn append_output_accounts(
             data: Set(account.account.data.as_ref().map(|x| x.data.clone().0)),
             data_hash: Set(account.account.data.as_ref().map(|x| x.data_hash.to_vec())),
             tree: Set(account.account.tree.to_bytes_vec()),
-            queue: Set(account.context.queue.to_bytes_vec()),
+            queue: Set(Some(account.context.queue.to_bytes_vec())),
             leaf_index: Set(account.account.leaf_index.0 as i64),
             in_output_queue: Set(account.context.in_output_queue),
             nullifier_queue_index: Set(account.context.nullifier_queue_index.map(|x| x.0 as i64)),

tests/integration_tests/mock_tests.rs

@@ -572,7 +572,7 @@ async fn test_persist_token_data(
             discriminator: Set(Some(Decimal::from(1))),
             data_hash: Set(Some(Hash::new_unique().to_vec())),
             tree: Set(Pubkey::new_unique().to_bytes().to_vec()),
-            queue: Set(Pubkey::new_unique().to_bytes().to_vec()),
+            queue: Set(Some(Pubkey::new_unique().to_bytes().to_vec())),
             tree_type: Set(Some(TreeType::StateV1 as i32)),
             seq: Set(Some(0)),
             ..Default::default()

tests/integration_tests/zeroeth_element_fix_test.rs

@@ -1,23 +1,22 @@
 // This test demonstrates that re-indexing fixes the wrong zeroeth element in v1 trees.
-// 
+//
 // The bug: v1 trees were initialized with wrong zeroeth element (next_index = 0 instead of 1)
 // The fix: Re-indexing now correctly sets next_index = 1 for v1 trees
 
 use crate::utils::*;
+use function_name::named;
+use light_compressed_account::TreeType;
 use photon_indexer::dao::generated::indexed_trees;
-use photon_indexer::ingester::persist::persisted_indexed_merkle_tree::persist_indexed_tree_updates;
+use photon_indexer::ingester::parser::indexer_events::RawIndexedElement;
+use photon_indexer::ingester::parser::state_update::IndexedTreeLeafUpdate;
 use photon_indexer::ingester::persist::indexed_merkle_tree::{
-    get_zeroeth_exclusion_range_v1,
-    compute_range_node_hash_v1,
+    compute_range_node_hash_v1, get_zeroeth_exclusion_range_v1,
 };
-use photon_indexer::ingester::parser::state_update::IndexedTreeLeafUpdate;
-use photon_indexer::ingester::parser::indexer_events::RawIndexedElement;
-use light_compressed_account::TreeType;
+use photon_indexer::ingester::persist::persisted_indexed_merkle_tree::persist_indexed_tree_updates;
+use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, Set, TransactionTrait};
+use serial_test::serial;
 use solana_pubkey::Pubkey;
-use sea_orm::{EntityTrait, Set, QueryFilter, ColumnTrait, TransactionTrait};
 use std::collections::HashMap;
-use function_name::named;
-use serial_test::serial;
 
 #[named]
 #[rstest]
@@ -30,17 +29,17 @@ async fn test_reindex_fixes_wrong_zeroeth_element(
     let name = trim_test_name(function_name!());
     let setup = setup(name.clone(), db_backend).await;
     let conn = setup.db_conn;
-    
+
     // Create a v1 address tree
     let tree_pubkey = Pubkey::new_unique();
     let tree_bytes = tree_pubkey.to_bytes().to_vec();
-    
+
     // Step 1: Insert tree with wrong zeroeth element (simulating the bug)
     let txn = conn.begin().await.unwrap();
-    
+
     // Get the correct v1 zeroeth element to use its values
     let correct_v1_zeroeth = get_zeroeth_exclusion_range_v1(tree_bytes.clone());
-    
+
     // Insert wrong zeroeth element (using v2 style with next_index = 0 instead of 1)
     let wrong_zeroeth = indexed_trees::ActiveModel {
         tree: Set(tree_bytes.clone()),
@@ -54,10 +53,11 @@ async fn test_reindex_fixes_wrong_zeroeth_element(
         .exec(&txn)
         .await
         .unwrap();
-    
+
     // Get top element for v1 trees
-    let top_element_model = photon_indexer::ingester::persist::indexed_merkle_tree::get_top_element(tree_bytes.clone());
-    
+    let top_element_model =
+        photon_indexer::ingester::persist::indexed_merkle_tree::get_top_element(tree_bytes.clone());
+
     // Insert top element at index 1 (required for v1 trees)
     let top_element = indexed_trees::ActiveModel {
         tree: Set(tree_bytes.clone()),
@@ -71,9 +71,9 @@ async fn test_reindex_fixes_wrong_zeroeth_element(
         .exec(&txn)
         .await
         .unwrap();
-    
+
     txn.commit().await.unwrap();
-    
+
     // Verify wrong data exists
     let wrong_zeroeth_from_db = indexed_trees::Entity::find()
         .filter(indexed_trees::Column::Tree.eq(tree_bytes.clone()))
@@ -82,20 +82,23 @@ async fn test_reindex_fixes_wrong_zeroeth_element(
         .await
         .unwrap()
         .expect("Should find zeroeth element");
-    
-    assert_eq!(wrong_zeroeth_from_db.next_index, 0, "Zeroeth element should have wrong next_index");
-    
+
+    assert_eq!(
+        wrong_zeroeth_from_db.next_index, 0,
+        "Zeroeth element should have wrong next_index"
+    );
+
     // Step 2: Simulate re-indexing that will fix the zeroeth element
     let txn = conn.begin().await.unwrap();
-    
+
     // Create the correct zeroeth element update
     let correct_zeroeth_leaf = RawIndexedElement {
         value: [0u8; 32],
         next_index: 1, // Correct value for v1
         next_value: wrong_zeroeth_from_db.next_value.clone().try_into().unwrap(),
         index: 0,
     };
-    
+
     // Compute the correct hash for v1 tree
     let correct_zeroeth_model = indexed_trees::Model {
         tree: tree_bytes.clone(),
@@ -106,23 +109,23 @@ async fn test_reindex_fixes_wrong_zeroeth_element(
         seq: Some(2),
     };
     let correct_hash = compute_range_node_hash_v1(&correct_zeroeth_model).unwrap();
-    
+
     let update = IndexedTreeLeafUpdate {
         tree: tree_pubkey,
         tree_type: TreeType::AddressV1,
         leaf: correct_zeroeth_leaf,
         hash: correct_hash.0,
         seq: 2, // Higher seq number to ensure update
     };
-    
+
     // Create HashMap with the update
     let mut updates = HashMap::new();
     updates.insert((tree_pubkey, 0u64), update);
-    
+
     // Persist the update which should fix the zeroeth element
     persist_indexed_tree_updates(&txn, updates).await.unwrap();
     txn.commit().await.unwrap();
-    
+
     // Step 3: Verify the zeroeth element is now correct
     let fixed_zeroeth = indexed_trees::Entity::find()
         .filter(indexed_trees::Column::Tree.eq(tree_bytes.clone()))
@@ -131,15 +134,18 @@ async fn test_reindex_fixes_wrong_zeroeth_element(
         .await
         .unwrap()
         .expect("Should find zeroeth element");
-    
-    assert_eq!(fixed_zeroeth.next_index, 1, "Zeroeth element should now have correct next_index");
+
+    assert_eq!(
+        fixed_zeroeth.next_index, 1,
+        "Zeroeth element should now have correct next_index"
+    );
     assert_eq!(fixed_zeroeth.seq, Some(2), "Seq should be updated");
-    
+
     // Verify it matches what get_zeroeth_exclusion_range_v1 would create
     let expected_zeroeth = get_zeroeth_exclusion_range_v1(tree_bytes.clone());
     assert_eq!(fixed_zeroeth.next_index, expected_zeroeth.next_index);
     assert_eq!(fixed_zeroeth.value, expected_zeroeth.value);
-    
+
     println!("✅ Re-indexing successfully fixed zeroeth element from wrong v2-style (next_index=0) to correct v1-style (next_index=1)");
 }
 
@@ -154,16 +160,16 @@ async fn test_reindex_preserves_correct_zeroeth_element(
     let name = trim_test_name(function_name!());
     let setup = setup(name.clone(), db_backend).await;
     let conn = setup.db_conn;
-    
+
     // Create a v1 address tree
     let tree_pubkey = Pubkey::new_unique();
     let tree_bytes = tree_pubkey.to_bytes().to_vec();
-    
+
     // Insert correct zeroeth element
     let txn = conn.begin().await.unwrap();
-    
+
     let correct_v1_zeroeth = get_zeroeth_exclusion_range_v1(tree_bytes.clone());
-    
+
     let correct_zeroeth = indexed_trees::ActiveModel {
         tree: Set(tree_bytes.clone()),
         leaf_index: Set(0),
@@ -176,19 +182,19 @@ async fn test_reindex_preserves_correct_zeroeth_element(
         .exec(&txn)
         .await
         .unwrap();
-    
+
     txn.commit().await.unwrap();
-    
+
     // Simulate re-indexing with the same correct data
     let txn = conn.begin().await.unwrap();
-    
+
     let leaf = RawIndexedElement {
         value: correct_v1_zeroeth.value.clone().try_into().unwrap(),
         next_index: 1,
         next_value: correct_v1_zeroeth.next_value.clone().try_into().unwrap(),
         index: 0,
     };
-    
+
     let model = indexed_trees::Model {
         tree: tree_bytes.clone(),
         leaf_index: 0,
@@ -198,21 +204,21 @@ async fn test_reindex_preserves_correct_zeroeth_element(
         seq: Some(1),
     };
     let hash = compute_range_node_hash_v1(&model).unwrap();
-    
+
     let update = IndexedTreeLeafUpdate {
         tree: tree_pubkey,
         tree_type: TreeType::AddressV1,
         leaf,
         hash: hash.0,
         seq: 1,
     };
-    
+
     let mut updates = HashMap::new();
     updates.insert((tree_pubkey, 0u64), update);
-    
+
     persist_indexed_tree_updates(&txn, updates).await.unwrap();
     txn.commit().await.unwrap();
-    
+
     // Verify it's still correct
     let zeroeth = indexed_trees::Entity::find()
         .filter(indexed_trees::Column::Tree.eq(tree_bytes.clone()))
@@ -221,9 +227,12 @@ async fn test_reindex_preserves_correct_zeroeth_element(
         .await
         .unwrap()
         .expect("Should find zeroeth element");
-    
-    assert_eq!(zeroeth.next_index, 1, "Zeroeth element should still be correct");
+
+    assert_eq!(
+        zeroeth.next_index, 1,
+        "Zeroeth element should still be correct"
+    );
     assert_eq!(zeroeth.seq, Some(1), "Seq should be updated");
-    
+
     println!("✅ Re-indexing preserves already correct zeroeth elements");
 }