use Sysvar rent account

Author: zubayr1

sdk/pinocchio/src/entrypoint/mod.rs

@@ -19,8 +19,6 @@ use crate::{
     BPF_ALIGN_OF_U128, MAX_TX_ACCOUNTS, NON_DUP_MARKER,
 };
 
-use core::mem::MaybeUninit;
-
 /// Start address of the memory region used for program heap.
 pub const HEAP_START_ADDRESS: u64 = 0x300000000;
 
@@ -501,6 +499,7 @@ macro_rules! default_allocator {
         #[global_allocator]
         static A: $crate::entrypoint::BumpAllocator = $crate::entrypoint::BumpAllocator {
             start: $crate::entrypoint::HEAP_START_ADDRESS as usize,
+            len: $crate::entrypoint::HEAP_LENGTH,
         };
 
         /// A default allocator for when the program is compiled on a target different than
@@ -519,7 +518,7 @@ macro_rules! default_allocator {
 /// Using this macro with the "`std`" feature enabled will result in a compile error.
 #[cfg(feature = "std")]
 #[macro_export]
-macro_rules! panic_on_alloc {
+macro_rules! no_allocator {
     () => {
         compile_error!("Feature 'std' cannot be enabled.");
     };
@@ -536,7 +535,7 @@ macro_rules! panic_on_alloc {
 /// This is used when the `"std"` feature is disabled.
 #[cfg(not(feature = "std"))]
 #[macro_export]
-macro_rules! panic_on_alloc {
+macro_rules! no_allocator {
     () => {
         #[cfg(target_os = "solana")]
         #[global_allocator]
@@ -558,14 +557,9 @@ macro_rules! panic_on_alloc {
         // Make this `const` once `const_mut_refs` is stable for the platform-tools
         // toolchain Rust version.
         #[inline(always)]
-        pub unsafe fn allocate_unchecked<T: Sized>(offset: usize) -> &'static mut MaybeUninit<T> {
+        pub unsafe fn allocate_unchecked<T: Sized>(offset: usize) -> &'static mut T {
             // SAFETY: The pointer is within a valid range and aligned to `T`.
-            let start = HEAP_START_ADDRESS as usize + offset;
-            let end = start + core::mem::size_of::<T>();
-            const_assert!(core::mem::align_of::<T>() <= MAX_HEAP_ALIGNMENT);
-            const_assert!(end <= (HEAP_START_ADDRESS as usize ) + HEAP_LENGTH);
-
-            unsafe { &mut *(calculate_offset::<T>(offset) as *mut MaybeUninit T) }
+            unsafe { &mut *(calculate_offset::<T>(offset) as *mut T) }
         }
 
         #[inline(always)]
@@ -605,12 +599,11 @@ mod alloc {
     //! The bump allocator used as the default rust heap when running programs.
 
     extern crate alloc;
-    use static_assertions::const_assert;
-    use crate::entrypoint::{HEAP_START_ADDRESS, HEAP_LENGTH};
 
     /// The bump allocator used as the default rust heap when running programs.
     pub struct BumpAllocator {
         pub start: usize,
+        pub len: usize,
     }
 
     /// Integer arithmetic in this global allocator implementation is safe when
@@ -626,7 +619,7 @@ mod alloc {
             let mut pos = *pos_ptr;
             if pos == 0 {
                 // First time, set starting position.
-                pos = self.start + HEAP_LENGTH;
+                pos = self.start + self.len;
             }
             pos = pos.saturating_sub(layout.size());
             pos &= !(layout.align().wrapping_sub(1));
@@ -641,8 +634,6 @@ mod alloc {
             // I'm a bump allocator, I don't free.
         }
     }
-
-
 }
 
 #[cfg(not(feature = "std"))]
@@ -662,30 +653,161 @@ unsafe impl core::alloc::GlobalAlloc for NoAllocator {
     }
 }
 
-#[cfg(not(feature = "std"))]
-impl NoAllocator {
-    #[inline(always)]
-        pub unsafe fn allocate_unchecked<T: Sized>(offset: usize) -> &'static mut MaybeUninit<T> {
-            // SAFETY: The pointer is within a valid range and aligned to `T`.
-            let start = HEAP_START_ADDRESS as usize + offset;
-            let end = start + core::mem::size_of::<T>();
-            const_assert!(core::mem::align_of::<T>() <= MAX_HEAP_ALIGNMENT);
-            const_assert!(end <= (HEAP_START_ADDRESS as usize ) + HEAP_LENGTH);
+#[cfg(all(test, not(target_os = "solana")))]
+mod tests {
+    extern crate std;
+
+    use core::{alloc::Layout, ptr::copy_nonoverlapping};
+    use std::{
+        alloc::{alloc, dealloc},
+        vec,
+    };
+
+    use super::*;
 
-            unsafe { &mut *(calculate_offset::<T>(offset) as *mut MaybeUninit T) }
+    /// The mock program ID used for testing.
+    const MOCK_PROGRAM_ID: Pubkey = [5u8; 32];
+
+    /// An uninitialized account info.
+    const UNINIT: MaybeUninit<AccountInfo> = MaybeUninit::<AccountInfo>::uninit();
+
+    /// Struct representing a memory region with a specific alignment.
+    struct AlignedMemory {
+        ptr: *mut u8,
+        layout: Layout,
+    }
+
+    impl AlignedMemory {
+        pub fn new(len: usize) -> Self {
+            let layout = Layout::from_size_align(len, BPF_ALIGN_OF_U128).unwrap();
+            // SAFETY: `align` is set to `BPF_ALIGN_OF_U128`.
+            unsafe {
+                let ptr = alloc(layout);
+                if ptr.is_null() {
+                    std::alloc::handle_alloc_error(layout);
+                }
+                AlignedMemory { ptr, layout }
+            }
         }
-}
 
-#[cfg(not(feature = "std"))]
-impl NoAllocator {
-    #[inline(always)]
-        pub unsafe fn allocate_unchecked<T: Sized>(offset: usize) -> &'static mut MaybeUninit<T> {
-            // SAFETY: The pointer is within a valid range and aligned to `T`.
-            let start = HEAP_START_ADDRESS as usize + offset;
-            let end = start + core::mem::size_of::<T>();
-            const_assert!(core::mem::align_of::<T>() <= MAX_HEAP_ALIGNMENT);
-            const_assert!(end <= (HEAP_START_ADDRESS as usize ) + HEAP_LENGTH);
+        /// Write data to the memory region at the specified offset.
+        ///
+        /// # Safety
+        ///
+        /// The caller must ensure that the `data` length does not exceed the
+        /// remaining space in the memory region starting from the `offset`.
+        pub unsafe fn write(&mut self, data: &[u8], offset: usize) {
+            copy_nonoverlapping(data.as_ptr(), self.ptr.add(offset), data.len());
+        }
 
-            unsafe { &mut *(calculate_offset::<T>(offset) as *mut MaybeUninit T) }
+        /// Return a mutable pointer to the memory region.
+        pub fn as_mut_ptr(&mut self) -> *mut u8 {
+            self.ptr
         }
-}
+    }
+
+    impl Drop for AlignedMemory {
+        fn drop(&mut self) {
+            unsafe {
+                dealloc(self.ptr, self.layout);
+            }
+        }
+    }
+
+    /// Creates an input buffer with a specified number of accounts and
+    /// instruction data.
+    ///
+    /// This function mimics the input buffer created by the SVM loader.
+    /// Each account created has zeroed data, apart from the `data_len`
+    /// field, which is set to the index of the account.
+    ///
+    /// # Safety
+    ///
+    /// The returned `AlignedMemory` should only be used within the test
+    /// context.
+    unsafe fn create_input(accounts: usize, instruction_data: &[u8]) -> AlignedMemory {
+        let mut input = AlignedMemory::new(1_000_000_000);
+        // Number of accounts.
+        input.write(&(accounts as u64).to_le_bytes(), 0);
+        let mut offset = size_of::<u64>();
+
+        for i in 0..accounts {
+            // Account data.
+            let mut account = [0u8; STATIC_ACCOUNT_DATA + size_of::<u64>()];
+            account[0] = NON_DUP_MARKER;
+            // Set the accounts data length. The actual account data is zeroed.
+            account[80..88].copy_from_slice(&i.to_le_bytes());
+            input.write(&account, offset);
+            offset += account.len();
+            // Padding for the account data to align to `BPF_ALIGN_OF_U128`.
+            let padding_for_data = (i + (BPF_ALIGN_OF_U128 - 1)) & !(BPF_ALIGN_OF_U128 - 1);
+            input.write(&vec![0u8; padding_for_data], offset);
+            offset += padding_for_data;
+        }
+
+        // Instruction data length.
+        input.write(&instruction_data.len().to_le_bytes(), offset);
+        offset += size_of::<u64>();
+        // Instruction data.
+        input.write(instruction_data, offset);
+        offset += instruction_data.len();
+        // Program ID (mock).
+        input.write(&MOCK_PROGRAM_ID, offset);
+
+        input
+    }
+
+    /// Asserts that the accounts slice contains the expected number of accounts
+    /// and that each account's data length matches its index.
+    fn assert_accounts(accounts: &[MaybeUninit<AccountInfo>]) {
+        for (i, account) in accounts.iter().enumerate() {
+            let account_info = unsafe { account.assume_init_ref() };
+            assert_eq!(account_info.data_len(), i);
+        }
+    }
+
+    #[test]
+    fn test_deserialize() {
+        let ix_data = [3u8; 100];
+
+        // Input with 0 accounts.
+
+        let mut input = unsafe { create_input(0, &ix_data) };
+        let mut accounts = [UNINIT; 1];
+
+        let (program_id, count, parsed_ix_data) =
+            unsafe { deserialize(input.as_mut_ptr(), &mut accounts) };
+
+        assert_eq!(count, 0);
+        assert_eq!(program_id, &MOCK_PROGRAM_ID);
+        assert_eq!(&ix_data, parsed_ix_data);
+
+        // Input with 3 accounts but the accounts array has only space
+        // for 1.
+
+        let mut input = unsafe { create_input(3, &ix_data) };
+        let mut accounts = [UNINIT; 1];
+
+        let (program_id, count, parsed_ix_data) =
+            unsafe { deserialize(input.as_mut_ptr(), &mut accounts) };
+
+        assert_eq!(count, 1);
+        assert_eq!(program_id, &MOCK_PROGRAM_ID);
+        assert_eq!(&ix_data, parsed_ix_data);
+        assert_accounts(&accounts[..count]);
+
+        // Input with `MAX_TX_ACCOUNTS` accounts but accounts array has
+        // only space for 64.
+
+        let mut input = unsafe { create_input(MAX_TX_ACCOUNTS, &ix_data) };
+        let mut accounts = [UNINIT; 64];
+
+        let (program_id, count, parsed_ix_data) =
+            unsafe { deserialize(input.as_mut_ptr(), &mut accounts) };
+
+        assert_eq!(count, 64);
+        assert_eq!(program_id, &MOCK_PROGRAM_ID);
+        assert_eq!(&ix_data, parsed_ix_data);
+        assert_accounts(&accounts);
+    }
+}