refactor: cpi context account, system program account checks, account compression program nullify create output order

Author: ananas-block

program-libs/account-checks/src/account_info/pinocchio.rs

@@ -19,14 +19,17 @@ impl AccountInfoTrait for pinocchio::account_info::AccountInfo {
         bytes
     }
 
+    #[inline(always)]
     fn is_writable(&self) -> bool {
         self.is_writable()
     }
 
+    #[inline(always)]
     fn is_signer(&self) -> bool {
         self.is_signer()
     }
 
+    #[inline(always)]
     fn executable(&self) -> bool {
         self.executable()
     }

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

@@ -0,0 +1,203 @@
+use std::panic::Location;
+
+use crate::{
+    checks::{check_mut, check_non_mut, check_signer},
+    AccountError, AccountInfoTrait,
+};
+
+/// Iterator over accounts that provides detailed error messages when accounts are missing.
+///
+/// This iterator helps with debugging account setup issues by tracking which accounts
+/// are requested and providing clear error messages when there are insufficient accounts.
+pub struct AccountIterator<'info, T: AccountInfoTrait> {
+    accounts: &'info [T],
+    position: usize,
+    #[allow(unused)]
+    owner: [u8; 32],
+}
+
+impl<'info, T: AccountInfoTrait> AccountIterator<'info, T> {
+    /// Create a new AccountIterator from a slice of AccountInfo.
+    #[inline(always)]
+    pub fn new(accounts: &'info [T]) -> Self {
+        Self {
+            accounts,
+            position: 0,
+            owner: [0; 32],
+        }
+    }
+
+    #[inline(always)]
+    pub fn new_with_owner(accounts: &'info [T], owner: [u8; 32]) -> Self {
+        Self {
+            accounts,
+            position: 0,
+            owner,
+        }
+    }
+
+    /// Get the next account with a descriptive name.
+    ///
+    /// # Arguments
+    /// * `account_name` - A descriptive name for the account being requested (for debugging)
+    ///
+    /// # Returns
+    /// * `Ok(&T)` - The next account in the iterator
+    /// * `Err(AccountError::NotEnoughAccountKeys)` - If no more accounts are available
+    #[track_caller]
+    #[inline(always)]
+    pub fn next_account(&mut self, account_name: &str) -> Result<&'info T, AccountError> {
+        if self.position >= self.accounts.len() {
+            let location = Location::caller();
+            solana_msg::msg!(
+                "ERROR: Not enough accounts. Requested '{}' at index {} but only {} accounts available. {}:{}:{}",
+                account_name, self.position, self.accounts.len(), location.file(), location.line(), location.column()
+            );
+            return Err(AccountError::NotEnoughAccountKeys);
+        }
+
+        let account = &self.accounts[self.position];
+        self.position += 1;
+
+        Ok(account)
+    }
+
+    #[inline(always)]
+    #[track_caller]
+    pub fn next_option(
+        &mut self,
+        account_name: &str,
+        is_some: bool,
+    ) -> Result<Option<&'info T>, AccountError> {
+        if is_some {
+            let account_info = self.next_account(account_name)?;
+            Ok(Some(account_info))
+        } else {
+            Ok(None)
+        }
+    }
+
+    #[inline(always)]
+    #[track_caller]
+    pub fn next_option_mut(
+        &mut self,
+        account_name: &str,
+        is_some: bool,
+    ) -> Result<Option<&'info T>, AccountError> {
+        if is_some {
+            let account_info = self.next_mut(account_name)?;
+            Ok(Some(account_info))
+        } else {
+            Ok(None)
+        }
+    }
+
+    #[inline(always)]
+    #[track_caller]
+    pub fn next_signer_mut(&mut self, account_name: &str) -> Result<&'info T, AccountError> {
+        let account_info = self.next_signer(account_name)?;
+        check_mut(account_info)
+            .inspect_err(|e| self.print_on_error(e, account_name, Location::caller()))?;
+        Ok(account_info)
+    }
+
+    #[inline(always)]
+    #[track_caller]
+    pub fn next_signer(&mut self, account_name: &str) -> Result<&'info T, AccountError> {
+        let account_info = self.next_account(account_name)?;
+        check_signer(account_info)
+            .inspect_err(|e| self.print_on_error(e, account_name, Location::caller()))?;
+        Ok(account_info)
+    }
+
+    #[inline(always)]
+    #[track_caller]
+    pub fn next_signer_non_mut(&mut self, account_name: &str) -> Result<&'info T, AccountError> {
+        let account_info = self.next_signer(account_name)?;
+        check_non_mut(account_info)
+            .inspect_err(|e| self.print_on_error(e, account_name, Location::caller()))?;
+        Ok(account_info)
+    }
+
+    #[inline(always)]
+    #[track_caller]
+    pub fn next_non_mut(&mut self, account_name: &str) -> Result<&'info T, AccountError> {
+        let account_info = self.next_account(account_name)?;
+        check_non_mut(account_info)
+            .inspect_err(|e| self.print_on_error(e, account_name, Location::caller()))?;
+        Ok(account_info)
+    }
+
+    #[inline(always)]
+    #[track_caller]
+    pub fn next_mut(&mut self, account_name: &str) -> Result<&'info T, AccountError> {
+        let account_info = self.next_account(account_name)?;
+        check_mut(account_info)
+            .inspect_err(|e| self.print_on_error(e, account_name, Location::caller()))?;
+        Ok(account_info)
+    }
+
+    /// Get all remaining accounts in the iterator.
+    #[inline(always)]
+    #[track_caller]
+    pub fn remaining(&self) -> Result<&'info [T], AccountError> {
+        if self.position >= self.accounts.len() {
+            let location = Location::caller();
+            let account_name = "remaining accounts";
+            solana_msg::msg!(
+                "ERROR: Not enough accounts. Requested '{}' at index {} but only {} accounts available. {}:{}:{}",
+                account_name, self.position, self.accounts.len(), location.file(), location.line(), location.column()
+            );
+            return Err(AccountError::NotEnoughAccountKeys);
+        }
+        Ok(&self.accounts[self.position..])
+    }
+
+    /// Get all remaining accounts in the iterator.
+    #[inline(always)]
+    #[track_caller]
+    pub fn remaining_unchecked(&self) -> Result<&'info [T], AccountError> {
+        if self.position >= self.accounts.len() {
+            Ok(&[])
+        } else {
+            Ok(&self.accounts[self.position..])
+        }
+    }
+
+    /// Get the current position in the iterator.
+    #[inline(always)]
+    pub fn position(&self) -> usize {
+        self.position
+    }
+
+    /// Get the total number of accounts.
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.accounts.len()
+    }
+
+    /// Check if the iterator is empty.
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.accounts.is_empty()
+    }
+
+    #[inline(always)]
+    pub fn iterator_is_empty(&self) -> bool {
+        self.len() == self.position()
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn print_on_error(&self, error: &AccountError, account_name: &str, location: &Location) {
+        solana_msg::msg!(
+            "ERROR: {}. for account '{}' at index {}  {}:{}:{}",
+            error,
+            account_name,
+            self.position.saturating_sub(1),
+            location.file(),
+            location.line(),
+            location.column()
+        );
+    }
+}

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

@@ -30,6 +30,8 @@ pub enum AccountError {
     ProgramNotExecutable,
     #[error("Account not zeroed.")]
     AccountNotZeroed,
+    #[error("Not enough account keys provided.")]
+    NotEnoughAccountKeys,
     #[error("Pinocchio program error with code: {0}")]
     PinocchioProgramError(u32),
 }
@@ -52,6 +54,7 @@ impl From<AccountError> for u32 {
             AccountError::InvalidProgramId => 12017,
             AccountError::ProgramNotExecutable => 12018,
             AccountError::AccountNotZeroed => 12019,
+            AccountError::NotEnoughAccountKeys => 12020,
             AccountError::PinocchioProgramError(code) => code,
         }
     }

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

@@ -1,6 +1,10 @@
 pub mod account_info;
+pub mod account_iterator;
 pub mod checks;
 pub mod discriminator;
 pub mod error;
+pub mod packed_accounts;
 
 pub use account_info::account_info_trait::AccountInfoTrait;
+pub use account_iterator::AccountIterator;
+pub use error::AccountError;

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

@@ -0,0 +1,33 @@
+use std::panic::Location;
+
+use crate::{AccountError, AccountInfoTrait};
+
+/// Dynamic accounts slice for index-based access
+/// Contains mint, owner, delegate, merkle tree, and queue accounts
+pub struct ProgramPackedAccounts<'info, A: AccountInfoTrait> {
+    pub accounts: &'info [A],
+}
+
+impl<A: AccountInfoTrait> ProgramPackedAccounts<'_, A> {
+    /// Get account by index with bounds checking
+    #[track_caller]
+    #[inline(always)]
+    pub fn get(&self, index: usize, name: &str) -> Result<&A, AccountError> {
+        if index >= self.accounts.len() {
+            let location = Location::caller();
+            solana_msg::msg!(
+                "ERROR: Not enough accounts. Requested '{}' at index {} but only {} accounts available. {}:{}:{}",
+                name, index, self.accounts.len(), location.file(), location.line(), location.column()
+            );
+            return Err(AccountError::NotEnoughAccountKeys);
+        }
+        Ok(&self.accounts[index])
+    }
+
+    /// Get account by u8 index with bounds checking
+    #[track_caller]
+    #[inline(always)]
+    pub fn get_u8(&self, index: u8, name: &str) -> Result<&A, AccountError> {
+        self.get(index as usize, name)
+    }
+}

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

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use light_hasher::{Hasher, Poseidon};
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
 
 use crate::{
     address::pack_account,
@@ -11,7 +12,8 @@ use crate::{
     AnchorDeserialize, AnchorSerialize, CompressedAccountError, Pubkey, TreeType,
 };
 
-#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize)]
+#[repr(C)]
+#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct PackedCompressedAccountWithMerkleContext {
     pub compressed_account: CompressedAccount,
     pub merkle_context: PackedMerkleContext,
@@ -133,7 +135,8 @@ pub struct ReadOnlyCompressedAccount {
     pub root_index: u16,
 }
 
-#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize)]
+#[repr(C)]
+#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct PackedReadOnlyCompressedAccount {
     pub account_hash: [u8; 32],
     pub merkle_context: PackedMerkleContext,
@@ -149,7 +152,18 @@ pub struct MerkleContext {
     pub tree_type: TreeType,
 }
 
-#[derive(Debug, Clone, Copy, AnchorSerialize, AnchorDeserialize, PartialEq, Default)]
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    AnchorSerialize,
+    AnchorDeserialize,
+    PartialEq,
+    Default,
+    ZeroCopy,
+    ZeroCopyMut,
+)]
 pub struct PackedMerkleContext {
     pub merkle_tree_pubkey_index: u8,
     pub queue_pubkey_index: u8,
@@ -217,7 +231,8 @@ pub fn pack_merkle_context(
         .collect::<Vec<_>>()
 }
 
-#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize)]
+#[repr(C)]
+#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct CompressedAccount {
     pub owner: Pubkey,
     pub lamports: u64,
@@ -234,7 +249,8 @@ pub struct InCompressedAccount {
     pub address: Option<[u8; 32]>,
 }
 
-#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize)]
+#[repr(C)]
+#[derive(Debug, PartialEq, Default, Clone, AnchorSerialize, AnchorDeserialize, ZeroCopyMut)]
 pub struct CompressedAccountData {
     pub discriminator: [u8; 8],
     pub data: Vec<u8>,
@@ -283,7 +299,6 @@ pub fn hash_with_hashed_values(
 
         vec.push(lamports_bytes.as_slice());
     }
-
     if let Some(address) = address {
         vec.push(address);
     }