satisfy hunspell

Author: rustopian

scripts/setup/solana.dic

@@ -66,4 +66,6 @@ performant
 syscall/S
 bitmask
 pinocchio
-mainnet
+mainnet
+getter/S
+PRNG

sdk/pinocchio/src/sysvars/slot_hashes/mod.rs

@@ -23,21 +23,21 @@ use core::{mem, ops::Deref, slice::from_raw_parts};
 #[cfg(feature = "std")]
 use std::boxed::Box;
 
-/// SysvarS1otHashes111111111111111111111111111
+/// `SysvarS1otHashes111111111111111111111111111`
 pub const SLOTHASHES_ID: Pubkey = [
     6, 167, 213, 23, 25, 47, 10, 175, 198, 242, 101, 227, 251, 119, 204, 122, 218, 130, 197, 41,
     208, 190, 59, 19, 110, 45, 0, 85, 32, 0, 0, 0,
 ];
 /// Number of bytes in a hash.
 pub const HASH_BYTES: usize = 32;
 /// Sysvar data is:
-/// len    (8 bytes): little-endian entry count (≤ 512)
-/// entries(len × 40 bytes):    consecutive `(u64 slot, [u8;32] hash)` pairs
+/// `len`    (8 bytes): little-endian entry count (`≤ 512`)
+/// `entries`(`len × 40 bytes`):    consecutive `(u64 slot, [u8;32] hash)` pairs
 /// Size of the entry count field at the beginning of sysvar data.
 pub const NUM_ENTRIES_SIZE: usize = mem::size_of::<u64>();
 /// Size of a slot number in bytes.
 pub const SLOT_SIZE: usize = mem::size_of::<Slot>();
-/// Size of a single slot hash entry (slot + hash).
+/// Size of a single slot hash entry.
 pub const ENTRY_SIZE: usize = SLOT_SIZE + HASH_BYTES;
 /// Maximum number of slot hash entries that can be stored in the sysvar.
 pub const MAX_ENTRIES: usize = 512;
@@ -87,7 +87,7 @@ pub(crate) fn read_entry_count_from_bytes(data: &[u8]) -> Option<usize> {
 /// Reads the entry count from the first 8 bytes of data.
 ///
 /// # Safety
-/// Caller must ensure data has at least NUM_ENTRIES_SIZE bytes.
+/// Caller must ensure data has at least `NUM_ENTRIES_SIZE` bytes.
 #[inline(always)]
 pub(crate) unsafe fn read_entry_count_from_bytes_unchecked(data: &[u8]) -> usize {
     u64::from_le_bytes(*(data.as_ptr() as *const [u8; NUM_ENTRIES_SIZE])) as usize
@@ -119,7 +119,7 @@ fn parse_and_validate_data(data: &[u8]) -> Result<(), ProgramError> {
 }
 
 impl SlotHashEntry {
-    /// Returns the slot number as a u64.
+    /// Returns the slot number as a `u64`.
     #[inline(always)]
     pub fn slot(&self) -> Slot {
         u64::from_le_bytes(self.slot_le)
@@ -130,8 +130,8 @@ impl<T: Deref<Target = [u8]>> SlotHashes<T> {
     /// Creates a `SlotHashes` instance with validation of the entry count and buffer size.
     ///
     /// This constructor validates that the buffer has at least enough bytes to contain
-    /// the declared number of entries. The buffer can be any size >= the minimum required,
-    /// making it suitable for both full MAX_SIZE buffers and smaller test data.
+    /// the declared number of entries. The buffer can be any size above the minimum required,
+    /// making it suitable for both full `MAX_SIZE` buffers and smaller test data.
     /// Does not validate that entries are sorted in descending order.
     #[inline(always)]
     pub fn new(data: T) -> Result<Self, ProgramError> {
@@ -153,7 +153,7 @@ impl<T: Deref<Target = [u8]>> SlotHashes<T> {
     /// This function is unsafe because it does not validate the data size or format.
     /// The caller must ensure:
     /// 1. The underlying byte slice in `data` represents valid `SlotHashes` data
-    ///    (length prefix + entries, where entries are sorted in descending order by slot).
+    ///    (length prefix plus entries, where entries are sorted in descending order by slot).
     /// 2. The data slice has at least `NUM_ENTRIES_SIZE + (declared_entries * ENTRY_SIZE)` bytes.
     /// 3. The first 8 bytes contain a valid entry count in little-endian format.
     ///
@@ -292,8 +292,8 @@ impl SlotHashes<Box<[u8]>> {
     /// Fills the provided buffer with the full `SlotHashes` sysvar data.
     ///
     /// # Safety
-    /// The caller must ensure the buffer pointer is valid for MAX_SIZE bytes.
-    /// The syscall will write exactly MAX_SIZE bytes to the buffer.
+    /// The caller must ensure the buffer pointer is valid for `MAX_SIZE` bytes.
+    /// The syscall will write exactly `MAX_SIZE` bytes to the buffer.
     #[inline(always)]
     unsafe fn fill_from_sysvar(buffer_ptr: *mut u8) -> Result<(), ProgramError> {
         crate::sysvars::get_sysvar_unchecked(buffer_ptr, &SLOTHASHES_ID, 0, MAX_SIZE)?;

sdk/pinocchio/src/sysvars/slot_hashes/raw.rs

@@ -10,7 +10,7 @@ use super::*;
 
 /// Validates that a buffer is properly sized for `SlotHashes` data.
 ///
-/// Checks that the buffer length is 8 + (N × 40) for some N ≤ 512.
+/// Checks that the buffer length is `8 + (N × 40)` for some `N ≤ 512`.
 /// Unlike the `SlotHashes` constructor, this function does not require
 /// the buffer to be exactly 20,488 bytes.
 #[inline(always)]
@@ -36,8 +36,8 @@ pub(crate) fn validate_buffer_size(buffer_len: usize) -> Result<(), ProgramError
 
 /// Validates offset parameters for fetching `SlotHashes` data.
 ///
-/// * `offset` – Byte offset within the `SlotHashes` sysvar data.
-/// * `buffer_len` – Length of the destination buffer.
+/// * `offset` - Byte offset within the `SlotHashes` sysvar data.
+/// * `buffer_len` - Length of the destination buffer.
 #[inline(always)]
 pub fn validate_fetch_offset(offset: usize, buffer_len: usize) -> Result<(), ProgramError> {
     if offset >= MAX_SIZE {
@@ -80,7 +80,7 @@ pub fn fetch_into(buffer: &mut [u8], offset: usize) -> Result<usize, ProgramErro
 /// Copies `SlotHashes` sysvar bytes into `buffer` **without** validation.
 ///
 /// The caller is responsible for ensuring that:
-/// 1. `buffer` is large enough for the requested `offset` + `buffer.len()` range and
+/// 1. `buffer` is large enough for the requested `offset + buffer.len()` range and
 ///    properly laid out (see `validate_buffer_size` and `validate_fetch_offset`).
 /// 2. The memory behind `buffer` is writable for its full length.
 ///

sdk/pinocchio/src/sysvars/slot_hashes/test_utils.rs

@@ -33,9 +33,10 @@ pub struct AccountLayout {
 pub enum DecrementStrategy {
     /// Always decrement by exactly 1.
     Strictly1,
-    /// Mostly ‑1 with occasional ‑2 so that the *average* decrement ≈ 1.05.
+    /// Mostly a decrement of 1 with occasional decrement of 2 so that the
+    /// *average* decrement is `1.05`.
     Average1_05,
-    /// Roughly 50 % chance of ‑1 and 50 % chance of ‑3 (average ≈ 2).
+    /// Average decrement of 2.
     Average2,
 }