PodSliceError ergonomics change

Author: grod220

Cargo.lock

@@ -18,6 +18,7 @@ bytemuck_derive = { version = "1.10.1" }
 num-derive = "0.4"
 num_enum = "0.7"
 num-traits = "0.2"
+pinocchio = "0.9.2"
 serde = { version = "1.0.228", optional = true }
 solana-program-error = "3.0.0"
 solana-program-option = "3.0.0"

pod/Cargo.toml

@@ -1,6 +1,7 @@
 //! wrappers for `bytemuck` functions
 
-use {bytemuck::Pod, solana_program_error::ProgramError};
+use crate::error::PodSliceError;
+use bytemuck::Pod;
 
 /// On-chain size of a `Pod` type
 pub const fn pod_get_packed_len<T: Pod>() -> usize {
@@ -13,38 +14,38 @@ pub fn pod_bytes_of<T: Pod>(t: &T) -> &[u8] {
 }
 
 /// Convert a slice of bytes into a `Pod` (zero copy)
-pub fn pod_from_bytes<T: Pod>(bytes: &[u8]) -> Result<&T, ProgramError> {
-    bytemuck::try_from_bytes(bytes).map_err(|_| ProgramError::InvalidArgument)
+pub fn pod_from_bytes<T: Pod>(bytes: &[u8]) -> Result<&T, PodSliceError> {
+    bytemuck::try_from_bytes(bytes).map_err(PodSliceError::from)
 }
 
 /// Maybe convert a slice of bytes into a `Pod` (zero copy)
 ///
 /// Returns `None` if the slice is empty, or else `Err` if input length is not
 /// equal to `pod_get_packed_len::<T>()`.
 /// This function exists primarily because `Option<T>` is not a `Pod`.
-pub fn pod_maybe_from_bytes<T: Pod>(bytes: &[u8]) -> Result<Option<&T>, ProgramError> {
+pub fn pod_maybe_from_bytes<T: Pod>(bytes: &[u8]) -> Result<Option<&T>, PodSliceError> {
     if bytes.is_empty() {
         Ok(None)
     } else {
         bytemuck::try_from_bytes(bytes)
             .map(Some)
-            .map_err(|_| ProgramError::InvalidArgument)
+            .map_err(PodSliceError::from)
     }
 }
 
 /// Convert a slice of bytes into a mutable `Pod` (zero copy)
-pub fn pod_from_bytes_mut<T: Pod>(bytes: &mut [u8]) -> Result<&mut T, ProgramError> {
-    bytemuck::try_from_bytes_mut(bytes).map_err(|_| ProgramError::InvalidArgument)
+pub fn pod_from_bytes_mut<T: Pod>(bytes: &mut [u8]) -> Result<&mut T, PodSliceError> {
+    bytemuck::try_from_bytes_mut(bytes).map_err(PodSliceError::from)
 }
 
 /// Convert a slice of bytes into a `Pod` slice (zero copy)
-pub fn pod_slice_from_bytes<T: Pod>(bytes: &[u8]) -> Result<&[T], ProgramError> {
-    bytemuck::try_cast_slice(bytes).map_err(|_| ProgramError::InvalidArgument)
+pub fn pod_slice_from_bytes<T: Pod>(bytes: &[u8]) -> Result<&[T], PodSliceError> {
+    bytemuck::try_cast_slice(bytes).map_err(PodSliceError::from)
 }
 
 /// Convert a slice of bytes into a mutable `Pod` slice (zero copy)
-pub fn pod_slice_from_bytes_mut<T: Pod>(bytes: &mut [u8]) -> Result<&mut [T], ProgramError> {
-    bytemuck::try_cast_slice_mut(bytes).map_err(|_| ProgramError::InvalidArgument)
+pub fn pod_slice_from_bytes_mut<T: Pod>(bytes: &mut [u8]) -> Result<&mut [T], PodSliceError> {
+    bytemuck::try_cast_slice_mut(bytes).map_err(PodSliceError::from)
 }
 
 /// Convert a `Pod` slice into a single slice of bytes

pod/src/bytemuck.rs

@@ -1,5 +1,7 @@
 //! Error types
+use pinocchio::program_error::ProgramError as PinocchioProgramError;
 use {
+    bytemuck::PodCastError,
     solana_program_error::{ProgramError, ToStr},
     std::num::TryFromIntError,
 };
@@ -25,6 +27,12 @@ pub enum PodSliceError {
     /// Provided byte buffer too large for expected type
     #[error("Provided byte buffer too large for expected type")]
     BufferTooLarge,
+    /// An invalid argument was provided
+    #[error("An invalid argument was provided")]
+    InvalidArgument,
+    /// A `PodCast` operation from `bytemuck` failed
+    #[error("A `PodCast` operation from `bytemuck` failed")]
+    PodCast,
     /// An integer conversion failed because the value was out of range for the target type
     #[error("An integer conversion failed because the value was out of range for the target type")]
     ValueOutOfRange,
@@ -42,13 +50,64 @@ impl ToStr for PodSliceError {
             PodSliceError::CalculationFailure => "Error in checked math operation",
             PodSliceError::BufferTooSmall => "Provided byte buffer too small for expected type",
             PodSliceError::BufferTooLarge => "Provided byte buffer too large for expected type",
-            PodSliceError::ValueOutOfRange => "An integer conversion failed because the value was out of range for the target type"
+            PodSliceError::InvalidArgument => "An invalid argument was provided",
+            PodSliceError::PodCast => "A `PodCast` operation from `bytemuck` failed",
+            PodSliceError::ValueOutOfRange => "An integer conversion failed because the value was out of range for the target type",
         }
     }
 }
 
+impl From<PodCastError> for PodSliceError {
+    fn from(_: PodCastError) -> Self {
+        PodSliceError::PodCast
+    }
+}
+
 impl From<TryFromIntError> for PodSliceError {
     fn from(_: TryFromIntError) -> Self {
         PodSliceError::ValueOutOfRange
     }
 }
+
+impl From<PodSliceError> for PinocchioProgramError {
+    fn from(e: PodSliceError) -> Self {
+        let solana_err: ProgramError = e.into();
+        u64::from(solana_err).into()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::list::ListView;
+    use pinocchio::program_error::ProgramError as PinocchioProgramError;
+
+    fn raises_solana_err() -> Result<(), ProgramError> {
+        ListView::<u8>::size_of(usize::MAX)?; // raises err
+        Ok(())
+    }
+
+    fn raises_pino_err() -> Result<(), PinocchioProgramError> {
+        ListView::<u8>::size_of(usize::MAX)?; // raises err
+        Ok(())
+    }
+
+    #[test]
+    fn test_from_pod_slice_error_for_solana_program_error() {
+        let result = raises_solana_err();
+        assert!(result.is_err());
+        let solana_err = result.unwrap_err();
+        let expected_err: ProgramError = PodSliceError::CalculationFailure.into();
+        assert_eq!(solana_err, expected_err);
+    }
+
+    #[test]
+    fn test_from_pod_slice_error_for_pinocchio_program_error() {
+        let result = raises_pino_err();
+        assert!(result.is_err());
+        let pinocchio_err = result.unwrap_err();
+        let expected_solana_err: ProgramError = PodSliceError::CalculationFailure.into();
+        let expected_pinocchio_err: PinocchioProgramError = u64::from(expected_solana_err).into();
+        assert_eq!(pinocchio_err, expected_pinocchio_err);
+    }
+}

pod/src/error.rs

@@ -1,7 +1,6 @@
 use {
-    crate::{list::ListView, pod_length::PodLength},
+    crate::{error::PodSliceError, list::ListView, pod_length::PodLength},
     bytemuck::Pod,
-    solana_program_error::ProgramError,
     std::ops::Deref,
 };
 
@@ -17,12 +16,12 @@ pub trait List: Deref<Target = [Self::Item]> {
     fn capacity(&self) -> usize;
 
     /// Returns the number of **bytes currently occupied** by the live elements
-    fn bytes_used(&self) -> Result<usize, ProgramError> {
+    fn bytes_used(&self) -> Result<usize, PodSliceError> {
         ListView::<Self::Item, Self::Length>::size_of(self.len())
     }
 
     /// Returns the number of **bytes reserved** by the entire backing buffer.
-    fn bytes_allocated(&self) -> Result<usize, ProgramError> {
+    fn bytes_allocated(&self) -> Result<usize, PodSliceError> {
         ListView::<Self::Item, Self::Length>::size_of(self.capacity())
     }
 }

pod/src/list/list_trait.rs

@@ -11,7 +11,6 @@ use {
         primitives::PodU32,
     },
     bytemuck::Pod,
-    solana_program_error::ProgramError,
     std::{
         marker::PhantomData,
         mem::{align_of, size_of},
@@ -51,17 +50,17 @@ struct Layout {
 impl<T: Pod, L: PodLength> ListView<T, L> {
     /// Calculate the total byte size for a `ListView` holding `num_items`.
     /// This includes the length prefix, padding, and data.
-    pub fn size_of(num_items: usize) -> Result<usize, ProgramError> {
+    pub fn size_of(num_items: usize) -> Result<usize, PodSliceError> {
         let header_padding = Self::header_padding()?;
         size_of::<T>()
             .checked_mul(num_items)
             .and_then(|curr| curr.checked_add(size_of::<L>()))
             .and_then(|curr| curr.checked_add(header_padding))
-            .ok_or_else(|| PodSliceError::CalculationFailure.into())
+            .ok_or(PodSliceError::CalculationFailure)
     }
 
     /// Unpack a read-only buffer into a `ListViewReadOnly`
-    pub fn unpack(buf: &[u8]) -> Result<ListViewReadOnly<T, L>, ProgramError> {
+    pub fn unpack(buf: &[u8]) -> Result<ListViewReadOnly<T, L>, PodSliceError> {
         let layout = Self::calculate_layout(buf.len())?;
 
         // Slice the buffer to get the length prefix and the data.
@@ -79,7 +78,7 @@ impl<T: Pod, L: PodLength> ListView<T, L> {
         let capacity = data.len();
 
         if (*length).into() > capacity {
-            return Err(PodSliceError::BufferTooSmall.into());
+            return Err(PodSliceError::BufferTooSmall);
         }
 
         Ok(ListViewReadOnly {
@@ -90,24 +89,24 @@ impl<T: Pod, L: PodLength> ListView<T, L> {
     }
 
     /// Unpack the mutable buffer into a mutable `ListViewMut`
-    pub fn unpack_mut(buf: &mut [u8]) -> Result<ListViewMut<T, L>, ProgramError> {
+    pub fn unpack_mut(buf: &mut [u8]) -> Result<ListViewMut<T, L>, PodSliceError> {
         let view = Self::build_mut_view(buf)?;
         if (*view.length).into() > view.capacity {
-            return Err(PodSliceError::BufferTooSmall.into());
+            return Err(PodSliceError::BufferTooSmall);
         }
         Ok(view)
     }
 
     /// Initialize a buffer: sets `length = 0` and returns a mutable `ListViewMut`.
-    pub fn init(buf: &mut [u8]) -> Result<ListViewMut<T, L>, ProgramError> {
+    pub fn init(buf: &mut [u8]) -> Result<ListViewMut<T, L>, PodSliceError> {
         let view = Self::build_mut_view(buf)?;
         *view.length = L::try_from(0)?;
         Ok(view)
     }
 
     /// Internal helper to build a mutable view without validation or initialization.
     #[inline]
-    fn build_mut_view(buf: &mut [u8]) -> Result<ListViewMut<T, L>, ProgramError> {
+    fn build_mut_view(buf: &mut [u8]) -> Result<ListViewMut<T, L>, PodSliceError> {
         let layout = Self::calculate_layout(buf.len())?;
 
         // Split the buffer to get the length prefix and the data.
@@ -133,13 +132,13 @@ impl<T: Pod, L: PodLength> ListView<T, L> {
 
     /// Calculate the byte ranges for the length and data sections of the buffer
     #[inline]
-    fn calculate_layout(buf_len: usize) -> Result<Layout, ProgramError> {
+    fn calculate_layout(buf_len: usize) -> Result<Layout, PodSliceError> {
         let len_field_end = size_of::<L>();
         let header_padding = Self::header_padding()?;
         let data_start = len_field_end.saturating_add(header_padding);
 
         if buf_len < data_start {
-            return Err(PodSliceError::BufferTooSmall.into());
+            return Err(PodSliceError::BufferTooSmall);
         }
 
         Ok(Layout {
@@ -153,10 +152,10 @@ impl<T: Pod, L: PodLength> ListView<T, L> {
     /// The goal is to ensure that the data field `T` starts at a memory offset
     /// that is a multiple of its alignment requirement.
     #[inline]
-    fn header_padding() -> Result<usize, ProgramError> {
+    fn header_padding() -> Result<usize, PodSliceError> {
         // Enforce that the length prefix type `L` itself does not have alignment requirements
         if align_of::<L>() != 1 {
-            return Err(ProgramError::InvalidArgument);
+            return Err(PodSliceError::InvalidArgument);
         }
 
         let length_size = size_of::<L>();
@@ -240,12 +239,12 @@ mod tests {
         // Case 1: Multiplication overflows.
         // `size_of::<u16>() * usize::MAX` will overflow.
         let err = ListView::<u16, PodU32>::size_of(usize::MAX).unwrap_err();
-        assert_eq!(err, PodSliceError::CalculationFailure.into());
+        assert_eq!(err, PodSliceError::CalculationFailure);
 
         // Case 2: Multiplication does not overflow, but subsequent addition does.
         // `size_of::<u8>() * usize::MAX` does not overflow, but adding `size_of<L>` will.
         let err = ListView::<u8, PodU32>::size_of(usize::MAX).unwrap_err();
-        assert_eq!(err, PodSliceError::CalculationFailure.into());
+        assert_eq!(err, PodSliceError::CalculationFailure);
     }
 
     #[test]
@@ -271,13 +270,13 @@ mod tests {
         let mut buf = [0u8; 100];
 
         let err_size_of = ListView::<u8, TestPodU32>::size_of(10).unwrap_err();
-        assert_eq!(err_size_of, ProgramError::InvalidArgument);
+        assert_eq!(err_size_of, PodSliceError::InvalidArgument);
 
         let err_unpack = ListView::<u8, TestPodU32>::unpack(&buf).unwrap_err();
-        assert_eq!(err_unpack, ProgramError::InvalidArgument);
+        assert_eq!(err_unpack, PodSliceError::InvalidArgument);
 
         let err_init = ListView::<u8, TestPodU32>::init(&mut buf).unwrap_err();
-        assert_eq!(err_init, ProgramError::InvalidArgument);
+        assert_eq!(err_init, PodSliceError::InvalidArgument);
     }
 
     #[test]
@@ -445,10 +444,10 @@ mod tests {
         let mut buf = vec![0u8; header_size - 1]; // 7 bytes
 
         let err = ListView::<u64, PodU32>::unpack(&buf).unwrap_err();
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err, PodSliceError::BufferTooSmall);
 
         let err = ListView::<u64, PodU32>::unpack_mut(&mut buf).unwrap_err();
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err, PodSliceError::BufferTooSmall);
     }
 
     #[test]
@@ -465,10 +464,10 @@ mod tests {
         buf[0..len_size].copy_from_slice(bytemuck::bytes_of(&pod_len));
 
         let err = ListView::<u32, PodU32>::unpack(&buf).unwrap_err();
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err, PodSliceError::BufferTooSmall);
 
         let err = ListView::<u32, PodU32>::unpack_mut(&mut buf).unwrap_err();
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err, PodSliceError::BufferTooSmall);
     }
 
     #[test]
@@ -482,20 +481,20 @@ mod tests {
         // bytemuck::try_cast_slice returns an alignment error, which we map to InvalidArgument
 
         let err = ListView::<u32, PodU32>::unpack(&buf).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidArgument);
+        assert_eq!(err, PodSliceError::PodCast);
 
         let err = ListView::<u32, PodU32>::unpack_mut(&mut buf).unwrap_err();
-        assert_eq!(err, ProgramError::InvalidArgument);
+        assert_eq!(err, PodSliceError::PodCast);
     }
 
     #[test]
     fn test_unpack_empty_buffer() {
         let mut buf = [];
         let err = ListView::<u32, PodU32>::unpack(&buf).unwrap_err();
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err, PodSliceError::BufferTooSmall);
 
         let err = ListView::<u32, PodU32>::unpack_mut(&mut buf).unwrap_err();
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err, PodSliceError::BufferTooSmall);
     }
 
     #[test]
@@ -562,12 +561,12 @@ mod tests {
         // Header requires 4 bytes (size_of<PodU32>)
         let mut buf = vec![0u8; 3];
         let err = ListView::<u32, PodU32>::init(&mut buf).unwrap_err();
-        assert_eq!(err, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err, PodSliceError::BufferTooSmall);
 
         // With padding, header requires 8 bytes (4 for len, 4 for pad)
         let mut buf_padded = vec![0u8; 7];
         let err_padded = ListView::<u64, PodU32>::init(&mut buf_padded).unwrap_err();
-        assert_eq!(err_padded, PodSliceError::BufferTooSmall.into());
+        assert_eq!(err_padded, PodSliceError::BufferTooSmall);
     }
 
     #[test]