fix: resolve pinocchio feature compile issues

Author: ananas-block

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

@@ -0,0 +1,42 @@
+use core::ops::{Deref, DerefMut};
+
+use crate::error::AccountError;
+
+/// Trait to abstract over different AccountInfo implementations (pinocchio vs solana)
+pub trait AccountInfoTrait {
+    type DataRef<'a>: Deref<Target = [u8]>
+    where
+        Self: 'a;
+    type DataRefMut<'a>: DerefMut<Target = [u8]>
+    where
+        Self: 'a;
+
+    /// Return raw byte array for maximum compatibility
+    fn key(&self) -> [u8; 32];
+    fn is_writable(&self) -> bool;
+    fn is_signer(&self) -> bool;
+    fn executable(&self) -> bool;
+    fn lamports(&self) -> u64;
+    fn data_len(&self) -> usize;
+
+    /// Unified data access interface
+    fn try_borrow_data(&self) -> Result<Self::DataRef<'_>, AccountError>;
+    fn try_borrow_mut_data(&self) -> Result<Self::DataRefMut<'_>, AccountError>;
+
+    /// Check ownership safely - each implementation handles this without exposing owner
+    fn is_owned_by(&self, program: &[u8; 32]) -> bool;
+
+    /// PDA functions - each implementation uses its own backend
+    fn find_program_address(seeds: &[&[u8]], program_id: &[u8; 32]) -> ([u8; 32], u8);
+    fn create_program_address(
+        seeds: &[&[u8]],
+        program_id: &[u8; 32],
+    ) -> Result<[u8; 32], AccountError>;
+
+    /// Get minimum rent balance for a given size
+    fn get_min_rent_balance(size: usize) -> Result<u64, AccountError>;
+
+    fn data_is_empty(&self) -> bool {
+        self.data_len() == 0
+    }
+}

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

@@ -0,0 +1,6 @@
+pub mod account_info_trait;
+#[cfg(feature = "pinocchio")]
+pub mod pinocchio;
+#[cfg(feature = "solana")]
+pub mod solana;
+pub mod test_account_info;

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

@@ -0,0 +1,113 @@
+use super::account_info_trait::AccountInfoTrait;
+use crate::error::AccountError;
+
+/// Implement trait for pinocchio AccountInfo
+impl AccountInfoTrait for pinocchio::account_info::AccountInfo {
+    type DataRef<'a> = pinocchio::account_info::Ref<'a, [u8]>;
+    type DataRefMut<'a> = pinocchio::account_info::RefMut<'a, [u8]>;
+
+    fn key(&self) -> [u8; 32] {
+        *self.key()
+    }
+
+    fn is_writable(&self) -> bool {
+        self.is_writable()
+    }
+
+    fn is_signer(&self) -> bool {
+        self.is_signer()
+    }
+
+    fn executable(&self) -> bool {
+        self.executable()
+    }
+
+    fn lamports(&self) -> u64 {
+        self.lamports()
+    }
+
+    fn data_len(&self) -> usize {
+        self.data_len()
+    }
+
+    fn try_borrow_data(&self) -> Result<Self::DataRef<'_>, AccountError> {
+        self.try_borrow_data().map_err(Into::into)
+    }
+
+    fn try_borrow_mut_data(&self) -> Result<Self::DataRefMut<'_>, AccountError> {
+        self.try_borrow_mut_data().map_err(Into::into)
+    }
+
+    fn is_owned_by(&self, program: &[u8; 32]) -> bool {
+        pinocchio::account_info::AccountInfo::is_owned_by(self, program)
+    }
+
+    fn find_program_address(_seeds: &[&[u8]], _program_id: &[u8; 32]) -> ([u8; 32], u8) {
+        #[cfg(target_os = "solana")]
+        {
+            let program_pubkey = pinocchio::pubkey::Pubkey::from(*_program_id);
+            let (pubkey, bump) = pinocchio::pubkey::find_program_address(_seeds, &program_pubkey);
+            (pubkey, bump)
+        }
+        // Pinocchio does not support find_program_address outside of target_os solana.
+        // That is annoying for rust unit tests.
+        #[cfg(all(not(target_os = "solana"), feature = "solana"))]
+        {
+            let program_pubkey = solana_pubkey::Pubkey::from(*_program_id);
+            let (pubkey, bump) =
+                solana_pubkey::Pubkey::find_program_address(_seeds, &program_pubkey);
+            (pubkey.to_bytes(), bump)
+        }
+        #[cfg(all(not(target_os = "solana"), not(feature = "solana")))]
+        {
+            panic!("find_program_address not supported with pinocchio outside target_os = solana without solana feature");
+        }
+    }
+
+    fn create_program_address(
+        _seeds: &[&[u8]],
+        _program_id: &[u8; 32],
+    ) -> Result<[u8; 32], AccountError> {
+        #[cfg(target_os = "solana")]
+        {
+            let program_pubkey = pinocchio::pubkey::Pubkey::from(*_program_id);
+            pinocchio::pubkey::create_program_address(_seeds, &program_pubkey)
+                .map_err(|_| AccountError::InvalidSeeds)
+        }
+        // Pinocchio does not support find_program_address outside of target_os solana.
+        // That is annoying for rust unit tests.
+        #[cfg(all(not(target_os = "solana"), feature = "solana"))]
+        {
+            let program_pubkey = solana_pubkey::Pubkey::from(*_program_id);
+            let pubkey = solana_pubkey::Pubkey::create_program_address(_seeds, &program_pubkey)
+                .map_err(|_| AccountError::InvalidSeeds)?;
+            Ok(pubkey.to_bytes())
+        }
+        #[cfg(all(not(target_os = "solana"), not(feature = "solana")))]
+        {
+            Err(AccountError::InvalidSeeds)
+        }
+    }
+
+    fn get_min_rent_balance(_size: usize) -> Result<u64, AccountError> {
+        #[cfg(target_os = "solana")]
+        {
+            use pinocchio::sysvars::Sysvar;
+            pinocchio::sysvars::rent::Rent::get()
+                .map(|rent| rent.minimum_balance(_size))
+                .map_err(|_| AccountError::FailedBorrowRentSysvar)
+        }
+        #[cfg(all(not(target_os = "solana"), feature = "solana"))]
+        {
+            use solana_sysvar::Sysvar;
+
+            solana_sysvar::rent::Rent::get()
+                .map(|rent| rent.minimum_balance(_size))
+                .map_err(|_| AccountError::FailedBorrowRentSysvar)
+        }
+        #[cfg(all(not(target_os = "solana"), not(feature = "solana")))]
+        {
+            Err(AccountError::FailedBorrowRentSysvar)
+        }
+    }
+}

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

@@ -0,0 +1,79 @@
+use super::account_info_trait::AccountInfoTrait;
+use crate::error::AccountError;
+
+/// Implement trait for solana AccountInfo
+impl AccountInfoTrait for solana_account_info::AccountInfo<'_> {
+    type DataRef<'a>
+        = std::cell::Ref<'a, [u8]>
+    where
+        Self: 'a;
+    type DataRefMut<'a>
+        = std::cell::RefMut<'a, [u8]>
+    where
+        Self: 'a;
+
+    fn key(&self) -> [u8; 32] {
+        self.key.to_bytes()
+    }
+
+    fn is_writable(&self) -> bool {
+        self.is_writable
+    }
+
+    fn is_signer(&self) -> bool {
+        self.is_signer
+    }
+
+    fn executable(&self) -> bool {
+        self.executable
+    }
+
+    fn lamports(&self) -> u64 {
+        **self.lamports.borrow()
+    }
+
+    fn data_len(&self) -> usize {
+        self.data.borrow().len()
+    }
+
+    fn try_borrow_data(&self) -> Result<Self::DataRef<'_>, AccountError> {
+        self.data
+            .try_borrow()
+            .map(|r| std::cell::Ref::map(r, |data| &**data))
+            .map_err(Into::into)
+    }
+
+    fn try_borrow_mut_data(&self) -> Result<Self::DataRefMut<'_>, AccountError> {
+        self.data
+            .try_borrow_mut()
+            .map(|r| std::cell::RefMut::map(r, |data| &mut **data))
+            .map_err(Into::into)
+    }
+
+    fn is_owned_by(&self, program: &[u8; 32]) -> bool {
+        self.owner.as_ref() == program
+    }
+
+    fn find_program_address(seeds: &[&[u8]], program_id: &[u8; 32]) -> ([u8; 32], u8) {
+        let program_pubkey = solana_pubkey::Pubkey::from(*program_id);
+        let (pubkey, bump) = solana_pubkey::Pubkey::find_program_address(seeds, &program_pubkey);
+        (pubkey.to_bytes(), bump)
+    }
+
+    fn create_program_address(
+        seeds: &[&[u8]],
+        program_id: &[u8; 32],
+    ) -> Result<[u8; 32], AccountError> {
+        let program_pubkey = solana_pubkey::Pubkey::from(*program_id);
+        solana_pubkey::Pubkey::create_program_address(seeds, &program_pubkey)
+            .map(|pubkey| pubkey.to_bytes())
+            .map_err(|_| AccountError::InvalidSeeds)
+    }
+
+    fn get_min_rent_balance(size: usize) -> Result<u64, AccountError> {
+        use solana_sysvar::Sysvar;
+        solana_sysvar::rent::Rent::get()
+            .map(|rent| rent.minimum_balance(size))
+            .map_err(|_| AccountError::FailedBorrowRentSysvar)
+    }
+}