custom rent get, pod for epoch sysvars

Author: rustopian

epoch-rewards/src/lib.rs

@@ -19,18 +19,18 @@ extern crate std;
 use serde_derive::{Deserialize, Serialize};
 use {solana_hash::Hash, solana_sdk_macro::CloneZeroed};
 
-#[repr(C)]
+#[repr(C, align(16))]
 #[cfg_attr(feature = "frozen-abi", derive(solana_frozen_abi_macro::AbiExample))]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 #[derive(Debug, PartialEq, Eq, Default, CloneZeroed)]
 pub struct EpochRewards {
     /// The starting block height of the rewards distribution in the current
     /// epoch
-    distribution_starting_block_height: [u8; 8],
+    pub distribution_starting_block_height: u64,
 
     /// Number of partitions in the rewards distribution in the current epoch,
     /// used to generate an EpochRewardsHasher
-    num_partitions: [u8; 8],
+    pub num_partitions: u64,
 
     /// The blockhash of the parent block of the first block in the epoch, used
     /// to seed an EpochRewardsHasher
@@ -39,71 +39,72 @@ pub struct EpochRewards {
     /// The total rewards points calculated for the current epoch, where points
     /// equals the sum of (delegated stake * credits observed) for all
     /// delegations
-    total_points: [u8; 16],
+    pub total_points: u128,
 
     /// The total rewards calculated for the current epoch. This may be greater
     /// than the total `distributed_rewards` at the end of the rewards period,
     /// due to rounding and inability to deliver rewards smaller than 1 lamport.
-    total_rewards: [u8; 8],
+    pub total_rewards: u64,
 
     /// The rewards currently distributed for the current epoch, in lamports
-    distributed_rewards: [u8; 8],
+    pub distributed_rewards: u64,
 
     /// Whether the rewards period (including calculation and distribution) is
     /// active
-    pub active: u8,
+    pub active: bool,
 }
 
-impl EpochRewards {
-    pub fn distribution_starting_block_height(&self) -> u64 {
-        u64::from_le_bytes(self.distribution_starting_block_height)
-    }
-
-    pub fn num_partitions(&self) -> u64 {
-        u64::from_le_bytes(self.num_partitions)
-    }
-
-    pub fn parent_blockhash(&self) -> &Hash {
-        &self.parent_blockhash
-    }
-
-    pub fn total_points(&self) -> u128 {
-        u128::from_le_bytes(self.total_points)
-    }
+/// Pod (Plain Old Data) representation of [`EpochRewards`] with no padding.
+///
+/// This type can be safely loaded via `sol_get_sysvar` without undefined behavior.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PodEpochRewards {
+    pub distribution_starting_block_height: [u8; 8],
+    pub num_partitions: [u8; 8],
+    pub parent_blockhash: [u8; 32],
+    pub total_points: [u8; 16],
+    pub total_rewards: [u8; 8],
+    pub distributed_rewards: [u8; 8],
+    pub active: u8,
+}
 
-    pub fn total_rewards(&self) -> u64 {
-        u64::from_le_bytes(self.total_rewards)
-    }
+const _: () = assert!(core::mem::size_of::<PodEpochRewards>() == 81);
 
-    pub fn distributed_rewards(&self) -> u64 {
-        u64::from_le_bytes(self.distributed_rewards)
-    }
-
-    pub fn active(&self) -> bool {
-        match self.active {
-            0 => false,
-            1 => true,
-            _ => panic!("invalid active value"),
+impl From<PodEpochRewards> for EpochRewards {
+    fn from(pod: PodEpochRewards) -> Self {
+        Self {
+            distribution_starting_block_height: u64::from_le_bytes(
+                pod.distribution_starting_block_height,
+            ),
+            num_partitions: u64::from_le_bytes(pod.num_partitions),
+            parent_blockhash: Hash::new_from_array(pod.parent_blockhash),
+            total_points: u128::from_le_bytes(pod.total_points),
+            total_rewards: u64::from_le_bytes(pod.total_rewards),
+            distributed_rewards: u64::from_le_bytes(pod.distributed_rewards),
+            active: pod.active != 0,
         }
     }
+}
 
+impl EpochRewards {
     pub fn new(
         total_rewards: u64,
         distributed_rewards: u64,
         distribution_starting_block_height: u64,
     ) -> Self {
         Self {
-            distribution_starting_block_height: distribution_starting_block_height.to_le_bytes(),
-            total_rewards: total_rewards.to_le_bytes(),
-            distributed_rewards: distributed_rewards.to_le_bytes(),
+            distribution_starting_block_height,
+            total_rewards,
+            distributed_rewards,
             ..Self::default()
         }
     }
 
     pub fn distribute(&mut self, amount: u64) {
-        let new_distributed_rewards = self.distributed_rewards().saturating_add(amount);
-        assert!(new_distributed_rewards <= self.total_rewards());
-        self.distributed_rewards = new_distributed_rewards.to_le_bytes();
+        let new_distributed_rewards = self.distributed_rewards.saturating_add(amount);
+        assert!(new_distributed_rewards <= self.total_rewards);
+        self.distributed_rewards = new_distributed_rewards;
     }
 }
 
@@ -116,8 +117,8 @@ mod tests {
         let mut epoch_rewards = EpochRewards::new(100, 0, 64);
         epoch_rewards.distribute(100);
 
-        assert_eq!(epoch_rewards.total_rewards(), 100);
-        assert_eq!(epoch_rewards.distributed_rewards(), 100);
+        assert_eq!(epoch_rewards.total_rewards, 100);
+        assert_eq!(epoch_rewards.distributed_rewards, 100);
     }
 
     #[test]

epoch-schedule/src/lib.rs

@@ -56,24 +56,51 @@ pub const MINIMUM_SLOTS_PER_EPOCH: u64 = 32;
 #[derive(Debug, CloneZeroed, PartialEq, Eq)]
 pub struct EpochSchedule {
     /// The maximum number of slots in each epoch.
-    slots_per_epoch: [u8; 8],
+    pub slots_per_epoch: u64,
 
     /// A number of slots before beginning of an epoch to calculate
     /// a leader schedule for that epoch.
-    leader_schedule_slot_offset: [u8; 8],
+    pub leader_schedule_slot_offset: u64,
 
     /// Whether epochs start short and grow.
-    pub warmup: u8,
+    pub warmup: bool,
 
     /// The first epoch after the warmup period.
     ///
     /// Basically: `log2(slots_per_epoch) - log2(MINIMUM_SLOTS_PER_EPOCH)`.
-    first_normal_epoch: [u8; 8],
+    pub first_normal_epoch: u64,
 
     /// The first slot after the warmup period.
     ///
     /// Basically: `MINIMUM_SLOTS_PER_EPOCH * (2.pow(first_normal_epoch) - 1)`.
-    first_normal_slot: [u8; 8],
+    pub first_normal_slot: u64,
+}
+
+/// Pod (Plain Old Data) representation of [`EpochSchedule`] with no padding.
+///
+/// This type can be safely loaded via `sol_get_sysvar` without undefined behavior.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PodEpochSchedule {
+    pub slots_per_epoch: [u8; 8],
+    pub leader_schedule_slot_offset: [u8; 8],
+    pub warmup: u8,
+    pub first_normal_epoch: [u8; 8],
+    pub first_normal_slot: [u8; 8],
+}
+
+const _: () = assert!(core::mem::size_of::<PodEpochSchedule>() == 33);
+
+impl From<PodEpochSchedule> for EpochSchedule {
+    fn from(pod: PodEpochSchedule) -> Self {
+        Self {
+            slots_per_epoch: u64::from_le_bytes(pod.slots_per_epoch),
+            leader_schedule_slot_offset: u64::from_le_bytes(pod.leader_schedule_slot_offset),
+            warmup: pod.warmup != 0,
+            first_normal_epoch: u64::from_le_bytes(pod.first_normal_epoch),
+            first_normal_slot: u64::from_le_bytes(pod.first_normal_slot),
+        }
+    }
 }
 
 impl Default for EpochSchedule {
@@ -87,40 +114,18 @@ impl Default for EpochSchedule {
 }
 
 impl EpochSchedule {
-    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 {
-        match self.warmup {
-            0 => false,
-            1 => true,
-            _ => panic!("invalid warmup value"),
-        }
-    }
-
-    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)
-    }
-
     pub fn new(slots_per_epoch: u64) -> Self {
         Self::custom(slots_per_epoch, slots_per_epoch, true)
     }
+
     pub fn without_warmup() -> Self {
         Self::custom(
             DEFAULT_SLOTS_PER_EPOCH,
             DEFAULT_LEADER_SCHEDULE_SLOT_OFFSET,
             false,
         )
     }
+
     pub fn custom(slots_per_epoch: u64, leader_schedule_slot_offset: u64, warmup: bool) -> Self {
         assert!(slots_per_epoch >= MINIMUM_SLOTS_PER_EPOCH);
         let (first_normal_epoch, first_normal_slot) = if warmup {
@@ -137,40 +142,40 @@ impl EpochSchedule {
             (0, 0)
         };
         EpochSchedule {
-            slots_per_epoch: slots_per_epoch.to_le_bytes(),
-            leader_schedule_slot_offset: leader_schedule_slot_offset.to_le_bytes(),
-            warmup: warmup as u8,
-            first_normal_epoch: first_normal_epoch.to_le_bytes(),
-            first_normal_slot: first_normal_slot.to_le_bytes(),
+            slots_per_epoch,
+            leader_schedule_slot_offset,
+            warmup,
+            first_normal_epoch,
+            first_normal_slot,
         }
     }
 
     /// get the length of the given epoch (in slots)
     pub fn get_slots_in_epoch(&self, epoch: u64) -> u64 {
-        if epoch < self.first_normal_epoch() {
+        if epoch < self.first_normal_epoch {
             2u64.saturating_pow(
                 (epoch as u32).saturating_add(MINIMUM_SLOTS_PER_EPOCH.trailing_zeros()),
             )
         } else {
-            self.slots_per_epoch()
+            self.slots_per_epoch
         }
     }
 
     /// get the epoch for which the given slot should save off
     ///  information about stakers
     pub fn get_leader_schedule_epoch(&self, slot: u64) -> u64 {
-        if slot < self.first_normal_slot() {
+        if slot < self.first_normal_slot {
             // until we get to normal slots, behave as if leader_schedule_slot_offset == slots_per_epoch
             self.get_epoch_and_slot_index(slot).0.saturating_add(1)
         } else {
-            let new_slots_since_first_normal_slot = slot.saturating_sub(self.first_normal_slot());
-            let new_first_normal_leader_schedule_slot = new_slots_since_first_normal_slot
-                .saturating_add(self.leader_schedule_slot_offset());
+            let new_slots_since_first_normal_slot = slot.saturating_sub(self.first_normal_slot);
+            let new_first_normal_leader_schedule_slot =
+                new_slots_since_first_normal_slot.saturating_add(self.leader_schedule_slot_offset);
             let new_epochs_since_first_normal_leader_schedule =
                 new_first_normal_leader_schedule_slot
-                    .checked_div(self.slots_per_epoch())
+                    .checked_div(self.slots_per_epoch)
                     .unwrap_or(0);
-            self.first_normal_epoch()
+            self.first_normal_epoch
                 .saturating_add(new_epochs_since_first_normal_leader_schedule)
         }
     }
@@ -182,7 +187,7 @@ impl EpochSchedule {
 
     /// get epoch and offset into the epoch for the given slot
     pub fn get_epoch_and_slot_index(&self, slot: u64) -> (u64, u64) {
-        if slot < self.first_normal_slot() {
+        if slot < self.first_normal_slot {
             let epoch = slot
                 .saturating_add(MINIMUM_SLOTS_PER_EPOCH)
                 .saturating_add(1)
@@ -199,28 +204,28 @@ impl EpochSchedule {
                 slot.saturating_sub(epoch_len.saturating_sub(MINIMUM_SLOTS_PER_EPOCH)),
             )
         } else {
-            let normal_slot_index = slot.saturating_sub(self.first_normal_slot());
+            let normal_slot_index = slot.saturating_sub(self.first_normal_slot);
             let normal_epoch_index = normal_slot_index
-                .checked_div(self.slots_per_epoch())
+                .checked_div(self.slots_per_epoch)
                 .unwrap_or(0);
-            let epoch = self.first_normal_epoch().saturating_add(normal_epoch_index);
+            let epoch = self.first_normal_epoch.saturating_add(normal_epoch_index);
             let slot_index = normal_slot_index
-                .checked_rem(self.slots_per_epoch())
+                .checked_rem(self.slots_per_epoch)
                 .unwrap_or(0);
             (epoch, slot_index)
         }
     }
 
     pub fn get_first_slot_in_epoch(&self, epoch: u64) -> u64 {
-        if epoch <= self.first_normal_epoch() {
+        if epoch <= self.first_normal_epoch {
             2u64.saturating_pow(epoch as u32)
                 .saturating_sub(1)
                 .saturating_mul(MINIMUM_SLOTS_PER_EPOCH)
         } else {
             epoch
-                .saturating_sub(self.first_normal_epoch())
-                .saturating_mul(self.slots_per_epoch())
-                .saturating_add(self.first_normal_slot())
+                .saturating_sub(self.first_normal_epoch)
+                .saturating_mul(self.slots_per_epoch)
+                .saturating_add(self.first_normal_slot)
         }
     }
 
@@ -295,8 +300,13 @@ mod tests {
 
     #[test]
     fn test_clone() {
-        let epoch_schedule =
-            EpochSchedule::custom(MINIMUM_SLOTS_PER_EPOCH, MINIMUM_SLOTS_PER_EPOCH, true);
+        let epoch_schedule = EpochSchedule {
+            slots_per_epoch: 1,
+            leader_schedule_slot_offset: 2,
+            warmup: true,
+            first_normal_epoch: 4,
+            first_normal_slot: 5,
+        };
         #[allow(clippy::clone_on_copy)]
         let cloned_epoch_schedule = epoch_schedule.clone();
         assert_eq!(cloned_epoch_schedule, epoch_schedule);

genesis-config/src/lib.rs

@@ -49,7 +49,7 @@ pub const UNUSED_DEFAULT: u64 = 1024;
 #[cfg_attr(
     feature = "frozen-abi",
     derive(AbiExample),
-    frozen_abi(digest = "CR76YX4Y3eHSCoRzkBEaJv7p3vAShUT56fX8WERoLBAp")
+    frozen_abi(digest = "3tUUJkZiUUGfuNCXbDuDR6KCQYPsh3m3cPw5vVUSt113")
 )]
 #[cfg_attr(
     feature = "serde",
@@ -244,8 +244,8 @@ impl fmt::Display for GenesisConfig {
             self.ticks_per_slot,
             self.poh_config.hashes_per_tick,
             self.poh_config.target_tick_duration,
-            self.epoch_schedule.slots_per_epoch(),
-            if self.epoch_schedule.warmup() {
+            self.epoch_schedule.slots_per_epoch,
+            if self.epoch_schedule.warmup {
                 "en"
             } else {
                 "dis"