chore: programs cleanup (#1581)

* chore: rename light-utils -> light-compressed-account, move account checks to light-account-checks

* chore: compile system program without readonly feature and warnings

* chore: rename insert nullify instruction data, remove insert queues context struct

* chore: remove account compression program context

* chore: add docs insert into queues

* test: reactivate cpi context tests

* test: add insert into queues instruction data, fix account compression test compilation

Author: ananas-block

program-libs/account-checks/src/error.rs

@@ -1,6 +1,6 @@
 use thiserror::Error;
 
-#[derive(Debug, Error, PartialEq)]
+#[derive(Debug, Clone, Copy, Error, PartialEq)]
 pub enum AccountError {
     #[error("Account owned by wrong program.")]
     AccountOwnedByWrongProgram,
@@ -20,6 +20,8 @@ pub enum AccountError {
     InvalidAccountBalance,
     #[error("Failed to borrow rent sysvar.")]
     FailedBorrowRentSysvar,
+    #[error("Invalid Signer")]
+    InvalidSigner,
 }
 
 // TODO: reconfigure error codes
@@ -35,6 +37,7 @@ impl From<AccountError> for u32 {
             AccountError::AlreadyInitialized => 12012,
             AccountError::InvalidAccountBalance => 12013,
             AccountError::FailedBorrowRentSysvar => 12014,
+            AccountError::InvalidSigner => 12015,
         }
     }
 }

program-libs/compressed-account/src/event.rs

@@ -2,7 +2,7 @@ use borsh::{BorshDeserialize, BorshSerialize};
 use light_zero_copy::{borsh::Deserialize, errors::ZeroCopyError};
 use solana_program::pubkey::Pubkey;
 
-use super::{discriminators::*, insert_into_queues::AppendNullifyCreateAddressInputsIndexer};
+use super::{discriminators::*, insert_into_queues::InsertIntoQueuesInstructionData};
 use crate::instruction_data::{
     data::OutputCompressedAccountWithPackedContext,
     zero_copy::{
@@ -116,7 +116,7 @@ pub fn match_account_compression_program_instruction(
     match instruction_discriminator {
         DISCRIMINATOR_INSERT_INTO_QUEUES => {
             let (_, instruction) = instruction.split_at(12);
-            let (data, _) = AppendNullifyCreateAddressInputsIndexer::zero_copy_at(instruction)?;
+            let (data, _) = InsertIntoQueuesInstructionData::zero_copy_at(instruction)?;
             event.input_compressed_account_hashes =
                 data.nullifiers.iter().map(|x| x.account_hash).collect();
             event.output_compressed_account_hashes = data.leaves.iter().map(|x| x.leaf).collect();
@@ -140,7 +140,7 @@ pub fn match_account_compression_program_instruction(
                 .iter_mut()
                 .zip(data.leaves.iter())
                 .for_each(|(x, y)| {
-                    x.merkle_tree_index = y.tree_account_index;
+                    x.merkle_tree_index = y.account_index;
                 });
             data.addresses.iter().for_each(|x| {
                 if x.tree_index == x.queue_index {

program-libs/compressed-account/src/insert_into_queues.rs

@@ -36,7 +36,7 @@ impl InsertNullifierInput {
     KnownLayout, IntoBytes, Immutable, Copy, Clone, FromBytes, PartialEq, Debug, Unaligned,
 )]
 pub struct AppendLeavesInput {
-    pub tree_account_index: u8,
+    pub account_index: u8,
     pub leaf: [u8; 32],
 }
 #[repr(C)]
@@ -60,26 +60,33 @@ pub struct MerkleTreeSequenceNumber {
 }
 
 #[derive(Debug, Clone)]
-pub struct AppendNullifyCreateAddressInputsIndexer<'a> {
-    meta: Ref<&'a [u8], AppendNullifyCreateAddressInputsMeta>,
+pub struct InsertIntoQueuesInstructionData<'a> {
+    meta: Ref<&'a [u8], InsertIntoQueuesInstructionDataMeta>,
     pub leaves: ZeroCopySlice<'a, u8, AppendLeavesInput, false>,
     pub nullifiers: ZeroCopySlice<'a, u8, InsertNullifierInput, false>,
     pub addresses: ZeroCopySlice<'a, u8, InsertAddressInput, false>,
     pub sequence_numbers: ZeroCopySlice<'a, u8, MerkleTreeSequenceNumber, false>,
     pub output_leaf_indices: ZeroCopySlice<'a, u8, U32, false>,
 }
-impl Deref for AppendNullifyCreateAddressInputsIndexer<'_> {
-    type Target = AppendNullifyCreateAddressInputsMeta;
+
+impl InsertIntoQueuesInstructionData<'_> {
+    pub fn is_invoked_by_program(&self) -> bool {
+        self.meta.is_invoked_by_program == 1
+    }
+}
+
+impl Deref for InsertIntoQueuesInstructionData<'_> {
+    type Target = InsertIntoQueuesInstructionDataMeta;
 
     fn deref(&self) -> &Self::Target {
         &self.meta
     }
 }
 
-impl<'a> Deserialize<'a> for AppendNullifyCreateAddressInputsIndexer<'a> {
+impl<'a> Deserialize<'a> for InsertIntoQueuesInstructionData<'a> {
     type Output = Self;
     fn zero_copy_at(bytes: &'a [u8]) -> std::result::Result<(Self, &'a [u8]), ZeroCopyError> {
-        let (meta, bytes) = Ref::<&[u8], AppendNullifyCreateAddressInputsMeta>::from_prefix(bytes)?;
+        let (meta, bytes) = Ref::<&[u8], InsertIntoQueuesInstructionDataMeta>::from_prefix(bytes)?;
 
         let (leaves, bytes) = ZeroCopySlice::<u8, AppendLeavesInput, false>::from_bytes_at(bytes)?;
 
@@ -94,7 +101,7 @@ impl<'a> Deserialize<'a> for AppendNullifyCreateAddressInputsIndexer<'a> {
         let output_leaf_indices =
             ZeroCopySlice::<u8, zerocopy::little_endian::U32, false>::from_bytes(bytes)?;
         Ok((
-            AppendNullifyCreateAddressInputsIndexer {
+            InsertIntoQueuesInstructionData {
                 meta,
                 leaves,
                 nullifiers,
@@ -111,7 +118,7 @@ impl<'a> Deserialize<'a> for AppendNullifyCreateAddressInputsIndexer<'a> {
 #[derive(
     FromBytes, IntoBytes, KnownLayout, Immutable, Copy, Clone, PartialEq, Debug, Unaligned,
 )]
-pub struct AppendNullifyCreateAddressInputsMeta {
+pub struct InsertIntoQueuesInstructionDataMeta {
     is_invoked_by_program: u8,
     pub bump: u8,
     pub num_queues: u8,
@@ -122,16 +129,16 @@ pub struct AppendNullifyCreateAddressInputsMeta {
 }
 
 #[derive(Debug)]
-pub struct AppendNullifyCreateAddressInputs<'a> {
-    meta: Ref<&'a mut [u8], AppendNullifyCreateAddressInputsMeta>,
+pub struct InsertIntoQueuesInstructionDataMut<'a> {
+    meta: Ref<&'a mut [u8], InsertIntoQueuesInstructionDataMeta>,
     pub leaves: ZeroCopySliceMut<'a, u8, AppendLeavesInput, false>,
     pub nullifiers: ZeroCopySliceMut<'a, u8, InsertNullifierInput, false>,
     pub addresses: ZeroCopySliceMut<'a, u8, InsertAddressInput, false>,
     pub sequence_numbers: ZeroCopySliceMut<'a, u8, MerkleTreeSequenceNumber, false>,
     pub output_leaf_indices: ZeroCopySliceMut<'a, u8, U32, false>,
 }
 
-impl<'a> AppendNullifyCreateAddressInputs<'a> {
+impl<'a> InsertIntoQueuesInstructionDataMut<'a> {
     pub fn is_invoked_by_program(&self) -> bool {
         self.meta.is_invoked_by_program == 1
     }
@@ -146,7 +153,7 @@ impl<'a> AppendNullifyCreateAddressInputs<'a> {
         addresses_capacity: u8,
         num_output_trees: u8,
     ) -> usize {
-        size_of::<AppendNullifyCreateAddressInputsMeta>()
+        size_of::<InsertIntoQueuesInstructionDataMeta>()
             + ZeroCopySliceMut::<u8, AppendLeavesInput, false>::required_size_for_capacity(
                 leaves_capacity,
             )
@@ -170,7 +177,7 @@ impl<'a> AppendNullifyCreateAddressInputs<'a> {
         num_output_trees: u8,
     ) -> std::result::Result<Self, ZeroCopyError> {
         let (meta, bytes) =
-            Ref::<&mut [u8], AppendNullifyCreateAddressInputsMeta>::from_prefix(bytes)?;
+            Ref::<&mut [u8], InsertIntoQueuesInstructionDataMeta>::from_prefix(bytes)?;
         let (leaves, bytes) =
             ZeroCopySliceMut::<u8, AppendLeavesInput, false>::new_at(leaves_capacity, bytes)?;
         let (nullifiers, bytes) = ZeroCopySliceMut::<u8, InsertNullifierInput, false>::new_at(
@@ -185,7 +192,7 @@ impl<'a> AppendNullifyCreateAddressInputs<'a> {
                 bytes,
             )?;
         let output_leaf_indices = ZeroCopySliceMut::<u8, U32, false>::new(leaves_capacity, bytes)?;
-        Ok(AppendNullifyCreateAddressInputs {
+        Ok(InsertIntoQueuesInstructionDataMut {
             meta,
             leaves,
             nullifiers,
@@ -196,38 +203,89 @@ impl<'a> AppendNullifyCreateAddressInputs<'a> {
     }
 }
 
-impl Deref for AppendNullifyCreateAddressInputs<'_> {
-    type Target = AppendNullifyCreateAddressInputsMeta;
+impl Deref for InsertIntoQueuesInstructionDataMut<'_> {
+    type Target = InsertIntoQueuesInstructionDataMeta;
 
     fn deref(&self) -> &Self::Target {
         &self.meta
     }
 }
 
-impl DerefMut for AppendNullifyCreateAddressInputs<'_> {
+impl DerefMut for InsertIntoQueuesInstructionDataMut<'_> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.meta
     }
 }
 
-pub fn deserialize_insert_into_queues(
-    bytes: &mut [u8],
-) -> std::result::Result<AppendNullifyCreateAddressInputs<'_>, ZeroCopyError> {
-    let (meta, bytes) = Ref::<&mut [u8], AppendNullifyCreateAddressInputsMeta>::from_prefix(bytes)?;
-    let (leaves, bytes) = ZeroCopySliceMut::<u8, AppendLeavesInput, false>::from_bytes_at(bytes)?;
-    let (nullifiers, bytes) =
-        ZeroCopySliceMut::<u8, InsertNullifierInput, false>::from_bytes_at(bytes)?;
-    let (addresses, bytes) =
-        ZeroCopySliceMut::<u8, InsertAddressInput, false>::from_bytes_at(bytes)?;
-    let (sequence_numbers, bytes) =
-        ZeroCopySliceMut::<u8, MerkleTreeSequenceNumber, false>::from_bytes_at(bytes)?;
-    let output_leaf_indices = ZeroCopySliceMut::<u8, U32, false>::from_bytes(bytes)?;
-    Ok(AppendNullifyCreateAddressInputs {
-        meta,
-        leaves,
-        nullifiers,
-        addresses,
-        sequence_numbers,
-        output_leaf_indices,
-    })
+#[test]
+fn test_rnd_insert_into_queues_ix_data() {
+    use rand::{rngs::StdRng, thread_rng, Rng, SeedableRng};
+    let seed = thread_rng().gen();
+    println!("seed {}", seed);
+    let mut rng = StdRng::seed_from_u64(seed);
+    let num_iters = 1000;
+
+    for _ in 0..num_iters {
+        let leaves_capacity: u8 = rng.gen();
+        let nullifiers_capacity: u8 = rng.gen();
+        let addresses_capacity: u8 = rng.gen();
+        let num_output_trees: u8 = rng.gen();
+        let size = InsertIntoQueuesInstructionDataMut::required_size_for_capacity(
+            leaves_capacity,
+            nullifiers_capacity,
+            addresses_capacity,
+            num_output_trees,
+        );
+        let mut bytes = vec![0u8; size];
+        let mut new_data = InsertIntoQueuesInstructionDataMut::new(
+            &mut bytes,
+            leaves_capacity,
+            nullifiers_capacity,
+            addresses_capacity,
+            num_output_trees,
+        )
+        .unwrap();
+        *new_data.meta = InsertIntoQueuesInstructionDataMeta {
+            is_invoked_by_program: rng.gen(),
+            bump: rng.gen(),
+            num_queues: rng.gen(),
+            num_output_queues: rng.gen(),
+            start_output_appends: rng.gen(),
+            num_address_queues: rng.gen(),
+            tx_hash: rng.gen(),
+        };
+        for i in 0..leaves_capacity {
+            new_data.leaves[i as usize] = AppendLeavesInput {
+                account_index: rng.gen(),
+                leaf: rng.gen(),
+            };
+        }
+        for i in 0..nullifiers_capacity {
+            new_data.nullifiers[i as usize] = InsertNullifierInput {
+                account_hash: rng.gen(),
+                leaf_index: rng.gen::<u32>().into(),
+                prove_by_index: rng.gen(),
+                tree_index: rng.gen(),
+                queue_index: rng.gen(),
+            };
+        }
+        for i in 0..addresses_capacity {
+            new_data.addresses[i as usize] = InsertAddressInput {
+                address: rng.gen(),
+                tree_index: rng.gen(),
+                queue_index: rng.gen(),
+            };
+        }
+        let nullifiers = new_data.nullifiers.to_vec();
+        let leaves = new_data.leaves.to_vec();
+        let addresses = new_data.addresses.to_vec();
+        let meta = *new_data.meta;
+        let zero_copy = InsertIntoQueuesInstructionData::zero_copy_at(&bytes)
+            .unwrap()
+            .0;
+        assert_eq!(meta, *zero_copy.meta);
+        assert_eq!(leaves.as_slice(), zero_copy.leaves.as_slice());
+        assert_eq!(nullifiers.as_slice(), zero_copy.nullifiers.as_slice());
+        assert_eq!(addresses.as_slice(), zero_copy.addresses.as_slice());
+    }
 }

program-tests/account-compression-test/tests/batched_merkle_tree_test.rs

@@ -25,7 +25,7 @@ use light_batched_merkle_tree::{
 };
 use light_compressed_account::{
     bigint::bigint_to_be_bytes_array, hash_chain::create_tx_hash,
-    insert_into_queues::AppendNullifyCreateAddressInputs,
+    insert_into_queues::InsertIntoQueuesInstructionDataMut,
     instruction_data::compressed_proof::CompressedProof,
 };
 use light_merkle_tree_metadata::errors::MerkleTreeMetadataError;
@@ -543,15 +543,15 @@ pub async fn perform_insert_into_output_queue(
 ) -> Result<Signature, RpcError> {
     let mut bytes = vec![
         0u8;
-        AppendNullifyCreateAddressInputs::required_size_for_capacity(
+        InsertIntoQueuesInstructionDataMut::required_size_for_capacity(
             num_of_leaves as u8,
             0,
             0,
             1
         )
     ];
     let mut ix_data =
-        AppendNullifyCreateAddressInputs::new(&mut bytes, num_of_leaves as u8, 0, 0, 1).unwrap();
+        InsertIntoQueuesInstructionDataMut::new(&mut bytes, num_of_leaves as u8, 0, 0, 1).unwrap();
     ix_data.num_output_queues = 1;
     for i in 0..num_of_leaves {
         let mut leaf = [0u8; 32];
@@ -729,15 +729,15 @@ pub async fn perform_insert_into_input_queue(
     });
     let mut bytes = vec![
         0u8;
-        AppendNullifyCreateAddressInputs::required_size_for_capacity(
+        InsertIntoQueuesInstructionDataMut::required_size_for_capacity(
             0,
             num_of_leaves as u8,
             0,
             1
         )
     ];
     let mut ix_data =
-        AppendNullifyCreateAddressInputs::new(&mut bytes, 0, num_of_leaves as u8, 0, 1).unwrap();
+        InsertIntoQueuesInstructionDataMut::new(&mut bytes, 0, num_of_leaves as u8, 0, 1).unwrap();
     ix_data.num_queues = 1;
     for (i, ix_nf) in ix_data.nullifiers.iter_mut().enumerate() {
         ix_nf.account_hash = leaves[i];
@@ -1631,7 +1631,12 @@ async fn test_batch_address_merkle_trees() {
             addresses.clone(),
         )
         .await;
-        assert_rpc_error(result, 0, ErrorCode::AccountDiscriminatorMismatch.into()).unwrap();
+        assert_rpc_error(
+            result,
+            0,
+            AccountCompressionErrorCode::AddressMerkleTreeAccountDiscriminatorMismatch.into(),
+        )
+        .unwrap();
 
         let result = insert_addresses(
             &mut context,
@@ -1640,7 +1645,12 @@ async fn test_batch_address_merkle_trees() {
             addresses.clone(),
         )
         .await;
-        assert_rpc_error(result, 0, MerkleTreeMetadataError::InvalidTreeType.into()).unwrap();
+        assert_rpc_error(
+            result,
+            0,
+            AccountCompressionErrorCode::AddressMerkleTreeAccountDiscriminatorMismatch.into(),
+        )
+        .unwrap();
     }
     // fill address queue batch
     {