Use sol_get_sysvar instead of sol_get_<NAME>_sysvar, fixed

define-syscall/src/definitions.rs

@@ -49,12 +49,12 @@ define_syscall!(fn sol_get_return_data(data: *mut u8, length: u64, program_id: *
 // - `is_writable` (`u8`): `true` if the instruction requires the account to be writable
 define_syscall!(fn sol_get_processed_sibling_instruction(index: u64, meta: *mut u8, program_id: *mut u8, data: *mut u8, accounts: *mut u8) -> u64);
 
-// these are to be deprecated once they are superceded by sol_get_sysvar
-define_syscall!(fn sol_get_clock_sysvar(addr: *mut u8) -> u64);
-define_syscall!(fn sol_get_epoch_schedule_sysvar(addr: *mut u8) -> u64);
-define_syscall!(fn sol_get_rent_sysvar(addr: *mut u8) -> u64);
-define_syscall!(fn sol_get_last_restart_slot(addr: *mut u8) -> u64);
-define_syscall!(fn sol_get_epoch_rewards_sysvar(addr: *mut u8) -> u64);
+// these are deprecated - use sol_get_sysvar instead
+define_syscall!(#[deprecated(since = "4.1.0", note = "Use `sol_get_sysvar` with `Clock` sysvar address instead")] fn sol_get_clock_sysvar(addr: *mut u8) -> u64);
+define_syscall!(#[deprecated(since = "4.1.0", note = "Use `sol_get_sysvar` with `EpochSchedule` sysvar address instead")] fn sol_get_epoch_schedule_sysvar(addr: *mut u8) -> u64);
+define_syscall!(#[deprecated(since = "4.1.0", note = "Use `sol_get_sysvar` with `Rent` sysvar address instead")] fn sol_get_rent_sysvar(addr: *mut u8) -> u64);
+define_syscall!(#[deprecated(since = "4.1.0", note = "Use `sol_get_sysvar` with `LastRestartSlot` sysvar address instead")] fn sol_get_last_restart_slot(addr: *mut u8) -> u64);
+define_syscall!(#[deprecated(since = "4.1.0", note = "Use `sol_get_sysvar` with `EpochRewards` sysvar address instead")] fn sol_get_epoch_rewards_sysvar(addr: *mut u8) -> u64);
 
 // this cannot go through sol_get_sysvar but can be removed once no longer in use
 define_syscall!(fn sol_get_fees_sysvar(addr: *mut u8) -> u64);

define-syscall/src/lib.rs

@@ -9,7 +9,8 @@ pub mod definitions;
 ))]
 #[macro_export]
 macro_rules! define_syscall {
-    (fn $name:ident($($arg:ident: $typ:ty),*) -> $ret:ty) => {
+    ($(#[$attr:meta])* fn $name:ident($($arg:ident: $typ:ty),*) -> $ret:ty) => {
+        $(#[$attr])*
         #[inline]
         pub unsafe fn $name($($arg: $typ),*) -> $ret {
             // this enum is used to force the hash to be computed in a const context
@@ -23,8 +24,8 @@ macro_rules! define_syscall {
         }
 
     };
-    (fn $name:ident($($arg:ident: $typ:ty),*)) => {
-        define_syscall!(fn $name($($arg: $typ),*) -> ());
+    ($(#[$attr:meta])* fn $name:ident($($arg:ident: $typ:ty),*)) => {
+        define_syscall!($(#[$attr])* fn $name($($arg: $typ),*) -> ());
     }
 }
 
@@ -34,13 +35,14 @@ macro_rules! define_syscall {
 )))]
 #[macro_export]
 macro_rules! define_syscall {
-    (fn $name:ident($($arg:ident: $typ:ty),*) -> $ret:ty) => {
+    ($(#[$attr:meta])* fn $name:ident($($arg:ident: $typ:ty),*) -> $ret:ty) => {
         extern "C" {
+            $(#[$attr])*
             pub fn $name($($arg: $typ),*) -> $ret;
         }
     };
-    (fn $name:ident($($arg:ident: $typ:ty),*)) => {
-        define_syscall!(fn $name($($arg: $typ),*) -> ());
+    ($(#[$attr:meta])* fn $name:ident($($arg:ident: $typ:ty),*)) => {
+        define_syscall!($(#[$attr])* fn $name($($arg: $typ),*) -> ());
     }
 }
 

sysvar/src/clock.rs

@@ -130,8 +130,64 @@ pub use {
 };
 
 impl Sysvar for Clock {
-    impl_sysvar_get!(sol_get_clock_sysvar);
+    impl_sysvar_get!(id());
 }
 
 #[cfg(feature = "bincode")]
 impl SysvarSerialize for Clock {}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::tests::to_bytes, serial_test::serial};
+
+    #[test]
+    #[cfg(feature = "bincode")]
+    fn test_clock_size_matches_bincode() {
+        // Prove that Clock's in-memory layout matches its bincode serialization.
+        let clock = Clock::default();
+        let in_memory_size = core::mem::size_of::<Clock>();
+        let bincode_size = bincode::serialized_size(&clock).unwrap() as usize;
+
+        assert_eq!(
+            in_memory_size, bincode_size,
+            "Clock in-memory size ({in_memory_size}) must match bincode size ({bincode_size})",
+        );
+    }
+
+    #[test]
+    #[serial]
+    fn test_clock_get_uses_sysvar_syscall() {
+        let expected = Clock {
+            slot: 1,
+            epoch_start_timestamp: 2,
+            epoch: 3,
+            leader_schedule_epoch: 4,
+            unix_timestamp: 5,
+        };
+
+        let data = to_bytes(&expected);
+        crate::tests::mock_get_sysvar_syscall(&data);
+
+        let got = Clock::get().unwrap();
+        assert_eq!(got, expected);
+    }
+
+    #[test]
+    #[serial]
+    fn test_clock_get_passes_correct_sysvar_id() {
+        let expected = Clock {
+            slot: 11,
+            epoch_start_timestamp: 22,
+            epoch: 33,
+            leader_schedule_epoch: 44,
+            unix_timestamp: 55,
+        };
+        let data = to_bytes(&expected);
+        let prev = crate::tests::mock_get_sysvar_syscall_with_id(&data, &id());
+
+        let got = Clock::get().unwrap();
+        assert_eq!(got, expected);
+
+        let _ = crate::program_stubs::set_syscall_stubs(prev);
+    }
+}

sysvar/src/epoch_rewards.rs

@@ -163,8 +163,35 @@ pub use {
 };
 
 impl Sysvar for EpochRewards {
-    impl_sysvar_get!(sol_get_epoch_rewards_sysvar);
+    impl_sysvar_get!(id(), 15);
 }
 
 #[cfg(feature = "bincode")]
 impl SysvarSerialize for EpochRewards {}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::Sysvar, serial_test::serial};
+
+    #[test]
+    #[serial]
+    #[cfg(feature = "bincode")]
+    fn test_epoch_rewards_get() {
+        let expected = EpochRewards {
+            distribution_starting_block_height: 42,
+            num_partitions: 7,
+            parent_blockhash: solana_hash::Hash::new_unique(),
+            total_points: 1234567890,
+            total_rewards: 100,
+            distributed_rewards: 10,
+            active: true,
+        };
+
+        let data = bincode::serialize(&expected).unwrap();
+        assert_eq!(data.len(), 81);
+
+        crate::tests::mock_get_sysvar_syscall(&data);
+        let got = EpochRewards::get().unwrap();
+        assert_eq!(got, expected);
+    }
+}

sysvar/src/epoch_schedule.rs

@@ -119,17 +119,124 @@
 //! #
 //! # Ok::<(), anyhow::Error>(())
 //! ```
+use crate::Sysvar;
 #[cfg(feature = "bincode")]
 use crate::SysvarSerialize;
-use crate::{impl_sysvar_get, Sysvar};
 pub use {
     solana_epoch_schedule::EpochSchedule,
     solana_sdk_ids::sysvar::epoch_schedule::{check_id, id, ID},
 };
 
+/// Pod (Plain Old Data) representation of [`EpochSchedule`] with no padding.
+///
+/// This type can be safely loaded via `sol_get_sysvar` without undefined behavior.
+/// Provides performant zero-copy accessors as an alternative to the `EpochSchedule` type.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PodEpochSchedule {
+    slots_per_epoch: [u8; 8],
+    leader_schedule_slot_offset: [u8; 8],
+    warmup: u8,
+    first_normal_epoch: [u8; 8],
+    first_normal_slot: [u8; 8],
+}
+
+const POD_EPOCH_SCHEDULE_SIZE: usize = 33;
+const _: () = assert!(core::mem::size_of::<PodEpochSchedule>() == POD_EPOCH_SCHEDULE_SIZE);
+
+impl PodEpochSchedule {
+    /// Fetch the sysvar data using the `sol_get_sysvar` syscall.
+    /// This provides an alternative to `EpochSchedule` which provides zero-copy accessors.
+    pub fn fetch() -> Result<Self, solana_program_error::ProgramError> {
+        let mut pod = core::mem::MaybeUninit::<Self>::uninit();
+        // Safety: `get_sysvar_unchecked` will initialize `pod` with the sysvar data,
+        // and error if unsuccessful.
+        unsafe {
+            crate::get_sysvar_unchecked(
+                pod.as_mut_ptr() as *mut u8,
+                (&id()) as *const _ as *const u8,
+                0,
+                POD_EPOCH_SCHEDULE_SIZE as u64,
+            )?;
+            Ok(pod.assume_init())
+        }
+    }
+
+    pub fn slots_per_epoch(&self) -> u64 {
+        u64::from_le_bytes(self.slots_per_epoch)
+    }
+
+    pub fn leader_schedule_slot_offset(&self) -> u64 {
+        u64::from_le_bytes(self.leader_schedule_slot_offset)
+    }
+
+    pub fn warmup(&self) -> bool {
+        self.warmup != 0
+    }
+
+    pub fn first_normal_epoch(&self) -> u64 {
+        u64::from_le_bytes(self.first_normal_epoch)
+    }
+
+    pub fn first_normal_slot(&self) -> u64 {
+        u64::from_le_bytes(self.first_normal_slot)
+    }
+}
+
+impl From<PodEpochSchedule> for EpochSchedule {
+    fn from(pod: PodEpochSchedule) -> Self {
+        Self {
+            slots_per_epoch: pod.slots_per_epoch(),
+            leader_schedule_slot_offset: pod.leader_schedule_slot_offset(),
+            warmup: pod.warmup(),
+            first_normal_epoch: pod.first_normal_epoch(),
+            first_normal_slot: pod.first_normal_slot(),
+        }
+    }
+}
+
 impl Sysvar for EpochSchedule {
-    impl_sysvar_get!(sol_get_epoch_schedule_sysvar);
+    fn get() -> Result<Self, solana_program_error::ProgramError> {
+        Ok(Self::from(PodEpochSchedule::fetch()?))
+    }
 }
 
 #[cfg(feature = "bincode")]
 impl SysvarSerialize for EpochSchedule {}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::Sysvar, serial_test::serial};
+
+    #[test]
+    fn test_pod_epoch_schedule_conversion() {
+        let pod = PodEpochSchedule {
+            slots_per_epoch: 432000u64.to_le_bytes(),
+            leader_schedule_slot_offset: 432000u64.to_le_bytes(),
+            warmup: 1,
+            first_normal_epoch: 14u64.to_le_bytes(),
+            first_normal_slot: 524256u64.to_le_bytes(),
+        };
+
+        let epoch_schedule = EpochSchedule::from(pod);
+
+        assert_eq!(epoch_schedule.slots_per_epoch, 432000);
+        assert_eq!(epoch_schedule.leader_schedule_slot_offset, 432000);
+        assert!(epoch_schedule.warmup);
+        assert_eq!(epoch_schedule.first_normal_epoch, 14);
+        assert_eq!(epoch_schedule.first_normal_slot, 524256);
+    }
+
+    #[test]
+    #[serial]
+    #[cfg(feature = "bincode")]
+    fn test_epoch_schedule_get() {
+        let expected = EpochSchedule::custom(1234, 5678, false);
+        let data = bincode::serialize(&expected).unwrap();
+        assert_eq!(data.len(), 33);
+
+        crate::tests::mock_get_sysvar_syscall(&data);
+        let got = EpochSchedule::get().unwrap();
+        assert_eq!(got, expected);
+    }
+}

sysvar/src/fees.rs

@@ -64,7 +64,7 @@ impl SysvarSerialize for Fees {}
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use {super::*, serial_test::serial};
 
     #[test]
     fn test_clone() {
@@ -76,4 +76,50 @@ mod tests {
         let cloned_fees = fees.clone();
         assert_eq!(cloned_fees, fees);
     }
+
+    struct MockFeesSyscall;
+    impl crate::program_stubs::SyscallStubs for MockFeesSyscall {
+        fn sol_get_fees_sysvar(&self, var_addr: *mut u8) -> u64 {
+            let fees = Fees {
+                fee_calculator: FeeCalculator {
+                    lamports_per_signature: 42,
+                },
+            };
+            unsafe {
+                std::ptr::copy_nonoverlapping(
+                    &fees as *const _ as *const u8,
+                    var_addr,
+                    core::mem::size_of::<Fees>(),
+                );
+            }
+            solana_program_entrypoint::SUCCESS
+        }
+    }
+
+    #[test]
+    #[serial]
+    fn test_fees_get_deprecated_syscall_path() {
+        let _ = crate::program_stubs::set_syscall_stubs(Box::new(MockFeesSyscall));
+        let got = Fees::get().unwrap();
+        assert_eq!(got.fee_calculator.lamports_per_signature, 42);
+    }
+
+    struct FailFeesSyscall;
+    impl crate::program_stubs::SyscallStubs for FailFeesSyscall {
+        fn sol_get_fees_sysvar(&self, _var_addr: *mut u8) -> u64 {
+            9999
+        }
+    }
+
+    #[test]
+    #[serial]
+    fn test_fees_get_deprecated_non_success_maps_to_unsupported() {
+        let prev = crate::program_stubs::set_syscall_stubs(Box::new(FailFeesSyscall));
+        let got = Fees::get();
+        assert_eq!(
+            got,
+            Err(solana_program_error::ProgramError::UnsupportedSysvar)
+        );
+        let _ = crate::program_stubs::set_syscall_stubs(prev);
+    }
 }

sysvar/src/last_restart_slot.rs

@@ -45,8 +45,40 @@ pub use {
 };
 
 impl Sysvar for LastRestartSlot {
-    impl_sysvar_get!(sol_get_last_restart_slot);
+    impl_sysvar_get!(id());
 }
 
 #[cfg(feature = "bincode")]
 impl SysvarSerialize for LastRestartSlot {}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::tests::to_bytes, serial_test::serial};
+
+    #[test]
+    #[cfg(feature = "bincode")]
+    fn test_last_restart_slot_size_matches_bincode() {
+        // Prove that LastRestartSlot's in-memory layout matches its bincode serialization.
+        let slot = LastRestartSlot::default();
+        let in_memory_size = core::mem::size_of::<LastRestartSlot>();
+        let bincode_size = bincode::serialized_size(&slot).unwrap() as usize;
+
+        assert_eq!(
+            in_memory_size, bincode_size,
+            "LastRestartSlot in-memory size ({in_memory_size}) must match bincode size ({bincode_size})",
+        );
+    }
+
+    #[test]
+    #[serial]
+    fn test_last_restart_slot_get_uses_sysvar_syscall() {
+        let expected = LastRestartSlot {
+            last_restart_slot: 9999,
+        };
+        let data = to_bytes(&expected);
+        crate::tests::mock_get_sysvar_syscall(&data);
+
+        let got = LastRestartSlot::get().unwrap();
+        assert_eq!(got, expected);
+    }
+}