[wip]: More fixes

Author: febo

interface/src/instruction.rs

@@ -2,8 +2,6 @@
 
 use pinocchio::program_error::ProgramError;
 
-use crate::error::TokenError;
-
 /// Instructions supported by the token program.
 #[repr(u8)]
 #[derive(Clone, Debug, PartialEq)]
@@ -510,21 +508,15 @@ pub enum AuthorityType {
     CloseAccount,
 }
 
-impl AuthorityType {
-    pub fn into(&self) -> u8 {
-        match self {
-            AuthorityType::MintTokens => 0,
-            AuthorityType::FreezeAccount => 1,
-            AuthorityType::AccountOwner => 2,
-            AuthorityType::CloseAccount => 3,
-        }
-    }
+impl TryFrom<u8> for AuthorityType {
+    type Error = ProgramError;
 
     #[inline(always)]
-    pub fn from(value: u8) -> Result<Self, ProgramError> {
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
+            // SAFETY: `value` is guaranteed to be in the range of the enum variants.
             0..=3 => Ok(unsafe { core::mem::transmute::<u8, AuthorityType>(value) }),
-            _ => Err(TokenError::InvalidInstruction.into()),
+            _ => Err(ProgramError::InvalidInstructionData),
         }
     }
 }

p-token/src/processor/mod.rs

@@ -1,10 +1,6 @@
-use core::{
-    mem::MaybeUninit,
-    slice::{from_raw_parts, from_raw_parts_mut},
-    str::from_utf8_unchecked,
-};
+use core::{slice::from_raw_parts, str::from_utf8_unchecked};
 use pinocchio::{
-    account_info::AccountInfo, memory::sol_memcpy, program_error::ProgramError, pubkey::Pubkey,
+    account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey, syscalls::sol_memcpy_,
     ProgramResult,
 };
 use spl_token_interface::{
@@ -71,9 +67,6 @@ pub use transfer::process_transfer;
 pub use transfer_checked::process_transfer_checked;
 pub use ui_amount_to_amount::process_ui_amount_to_amount;
 
-/// An uninitialized byte.
-const UNINIT_BYTE: MaybeUninit<u8> = MaybeUninit::uninit();
-
 /// Maximum number of digits in a formatted `u64`.
 ///
 /// The maximum number of digits is equal to the maximum number
@@ -164,41 +157,26 @@ fn try_ui_amount_into_amount(ui_amount: &str, decimals: u8) -> Result<u64, Progr
         return Err(ProgramError::InvalidArgument);
     }
 
-    let mut digits = [UNINIT_BYTE; MAX_FORMATTED_DIGITS];
-    // SAFETY: `digits` is an array of `MaybeUninit<u8>`, which has the same
-    // memory layout as `u8`.
-    let slice: &mut [u8] =
-        unsafe { from_raw_parts_mut(digits.as_mut_ptr() as *mut _, MAX_FORMATTED_DIGITS) };
+    let mut digits = [b'0'; MAX_FORMATTED_DIGITS];
 
     // SAFETY: the total length of `amount_str` and `after_decimal` is less than
     // `MAX_FORMATTED_DIGITS`.
     unsafe {
-        sol_memcpy(slice, amount_str.as_bytes(), length);
+        sol_memcpy_(digits.as_mut_ptr(), amount_str.as_ptr(), length as u64);
 
-        sol_memcpy(
-            &mut slice[length..],
-            after_decimal.as_bytes(),
-            after_decimal.len(),
+        sol_memcpy_(
+            digits.as_mut_ptr().add(length),
+            after_decimal.as_ptr(),
+            after_decimal.len() as u64,
         );
     }
 
-    let length = amount_str.len() + after_decimal.len();
     let remaining = decimals.saturating_sub(after_decimal.len());
-
-    // SAFETY: `digits` is an array of `MaybeUninit<u8>`, which has the same memory
-    // layout as `u8`.
-    let ptr = unsafe { digits.as_mut_ptr().add(length) };
-
-    for offset in 0..remaining {
-        // SAFETY: `ptr` is within the bounds of `digits`.
-        unsafe {
-            (ptr.add(offset) as *mut u8).write(b'0');
-        }
-    }
+    let length = amount_str.len() + after_decimal.len() + remaining;
 
     // SAFETY: `digits` only contains valid UTF-8 bytes.
     unsafe {
-        from_utf8_unchecked(from_raw_parts(digits.as_ptr() as _, length + remaining))
+        from_utf8_unchecked(from_raw_parts(digits.as_ptr(), length))
             .parse::<u64>()
             .map_err(|_| ProgramError::InvalidArgument)
     }

p-token/src/processor/set_authority.rs

@@ -125,12 +125,12 @@ impl SetAuthority<'_> {
         unsafe {
             match bytes.len() {
                 2 if *bytes.get_unchecked(1) == 0 => Ok(SetAuthority {
-                    authority_type: AuthorityType::from(*bytes.get_unchecked(0))?,
+                    authority_type: (*bytes.get_unchecked(0)).try_into()?,
                     new_authority: None,
                     _data: PhantomData,
                 }),
                 34 if *bytes.get_unchecked(1) == 1 => Ok(SetAuthority {
-                    authority_type: AuthorityType::from(*bytes.get_unchecked(0))?,
+                    authority_type: (*bytes.get_unchecked(0)).try_into()?,
                     new_authority: Some(&*(bytes.as_ptr().add(2) as *const Pubkey)),
                     _data: PhantomData,
                 }),

p-token/src/processor/shared/initialize_mint.rs

@@ -80,10 +80,10 @@ pub struct InitializeMint<'a> {
 impl InitializeMint<'_> {
     #[inline]
     pub fn try_from_bytes(bytes: &[u8]) -> Result<InitializeMint, ProgramError> {
-        // The minimum expected size of the instruction data.
-        // - decimals (1 byte)
-        // - mint_authority (32 bytes)
-        // - option + freeze_authority (1 byte + 32 bytes)
+        // The minimum expected size of the instruction data is either 34 or 66 bytes:
+        //   - decimals (1 byte)
+        //   - mint_authority (32 bytes)
+        //   - option + freeze_authority (1 byte + 32 bytes)
         if bytes.len() < 34 || (bytes[33] == 1 && bytes.len() < 66) {
             return Err(ProgramError::InvalidInstructionData);
         }