[wip]: Fix review comments

Author: febo

interface/src/instruction.rs

@@ -1,9 +1,9 @@
 use pinocchio::pubkey::Pubkey;
 
-use super::{account_state::AccountState, COption, Initializable, RawType};
+use super::{account_state::AccountState, COption, Initializable, Transmutable};
 
 /// Incinerator address.
-const INCINERATOR_ID: Pubkey =
+pub const INCINERATOR_ID: Pubkey =
     pinocchio_pubkey::pubkey!("1nc1nerator11111111111111111111111111111111");
 
 /// System program id.
@@ -140,7 +140,7 @@ impl Account {
     }
 }
 
-impl RawType for Account {
+impl Transmutable for Account {
     const LEN: usize = core::mem::size_of::<Account>();
 }
 

interface/src/state/account.rs

@@ -1,6 +1,6 @@
 use pinocchio::pubkey::Pubkey;
 
-use super::{COption, Initializable, RawType};
+use super::{COption, Initializable, Transmutable};
 
 /// Internal representation of a mint data.
 #[repr(C)]
@@ -38,8 +38,8 @@ impl Mint {
     }
 
     #[inline(always)]
-    pub fn set_initialized(&mut self, value: bool) {
-        self.is_initialized = value as u8;
+    pub fn set_initialized(&mut self) {
+        self.is_initialized = 1;
     }
 
     #[inline(always)]
@@ -83,7 +83,7 @@ impl Mint {
     }
 }
 
-impl RawType for Mint {
+impl Transmutable for Mint {
     /// The length of the `Mint` account data.
     const LEN: usize = core::mem::size_of::<Mint>();
 }

interface/src/state/mint.rs

@@ -8,11 +8,11 @@ pub mod multisig;
 /// Type alias for fields represented as `COption`.
 pub type COption<T> = ([u8; 4], T);
 
-/// Marker trait for types that can cast from a raw pointer.
+/// Marker trait for types that can be cast from a raw pointer.
 ///
 /// It is up to the type implementing this trait to guarantee that the cast is safe,
-/// i.e., that the fields of the type are well aligned and there are no padding bytes.
-pub trait RawType {
+/// i.e., the fields of the type are well aligned and there are no padding bytes.
+pub trait Transmutable {
     /// The length of the type.
     ///
     /// This must be equal to the size of each individual field in the type.
@@ -31,7 +31,7 @@ pub trait Initializable {
 ///
 /// The caller must ensure that `bytes` contains a valid representation of `T`.
 #[inline(always)]
-pub unsafe fn load<T: Initializable + RawType>(bytes: &[u8]) -> Result<&T, ProgramError> {
+pub unsafe fn load<T: Initializable + Transmutable>(bytes: &[u8]) -> Result<&T, ProgramError> {
     load_unchecked(bytes).and_then(|t: &T| {
         // checks if the data is initialized
         if t.is_initialized() {
@@ -50,7 +50,7 @@ pub unsafe fn load<T: Initializable + RawType>(bytes: &[u8]) -> Result<&T, Progr
 ///
 /// The caller must ensure that `bytes` contains a valid representation of `T`.
 #[inline(always)]
-pub unsafe fn load_unchecked<T: RawType>(bytes: &[u8]) -> Result<&T, ProgramError> {
+pub unsafe fn load_unchecked<T: Transmutable>(bytes: &[u8]) -> Result<&T, ProgramError> {
     if bytes.len() != T::LEN {
         return Err(ProgramError::InvalidAccountData);
     }
@@ -63,7 +63,7 @@ pub unsafe fn load_unchecked<T: RawType>(bytes: &[u8]) -> Result<&T, ProgramErro
 ///
 /// The caller must ensure that `bytes` contains a valid representation of `T`.
 #[inline(always)]
-pub unsafe fn load_mut<T: Initializable + RawType>(
+pub unsafe fn load_mut<T: Initializable + Transmutable>(
     bytes: &mut [u8],
 ) -> Result<&mut T, ProgramError> {
     load_mut_unchecked(bytes).and_then(|t: &mut T| {
@@ -84,7 +84,9 @@ pub unsafe fn load_mut<T: Initializable + RawType>(
 ///
 /// The caller must ensure that `bytes` contains a valid representation of `T`.
 #[inline(always)]
-pub unsafe fn load_mut_unchecked<T: RawType>(bytes: &mut [u8]) -> Result<&mut T, ProgramError> {
+pub unsafe fn load_mut_unchecked<T: Transmutable>(
+    bytes: &mut [u8],
+) -> Result<&mut T, ProgramError> {
     if bytes.len() != T::LEN {
         return Err(ProgramError::InvalidAccountData);
     }

interface/src/state/mod.rs

@@ -1,12 +1,12 @@
 use pinocchio::pubkey::Pubkey;
 
-use super::{Initializable, RawType};
+use super::{Initializable, Transmutable};
 
 /// Minimum number of multisignature signers (min N)
-pub const MIN_SIGNERS: usize = 1;
+pub const MIN_SIGNERS: u8 = 1;
 
 /// Maximum number of multisignature signers (max N)
-pub const MAX_SIGNERS: usize = 11;
+pub const MAX_SIGNERS: u8 = 11;
 
 /// Multisignature data.
 #[repr(C)]
@@ -21,12 +21,12 @@ pub struct Multisig {
     is_initialized: u8,
 
     /// Signer public keys
-    pub signers: [Pubkey; MAX_SIGNERS],
+    pub signers: [Pubkey; MAX_SIGNERS as usize],
 }
 
 impl Multisig {
     /// Utility function that checks index is between [`MIN_SIGNERS`] and [`MAX_SIGNERS`].
-    pub fn is_valid_signer_index(index: usize) -> bool {
+    pub fn is_valid_signer_index(index: u8) -> bool {
         (MIN_SIGNERS..=MAX_SIGNERS).contains(&index)
     }
 
@@ -36,7 +36,7 @@ impl Multisig {
     }
 }
 
-impl RawType for Multisig {
+impl Transmutable for Multisig {
     /// The length of the `Mint` account data.
     const LEN: usize = core::mem::size_of::<Multisig>();
 }

interface/src/state/multisig.rs

@@ -2,6 +2,7 @@ use pinocchio::{
     account_info::AccountInfo, default_panic_handler, no_allocator, program_entrypoint,
     program_error::ProgramError, pubkey::Pubkey, ProgramResult,
 };
+use spl_token_interface::instruction::TokenInstruction;
 
 use crate::processor::*;
 
@@ -36,52 +37,53 @@ pub fn process_instruction(
     let (discriminator, instruction_data) = instruction_data
         .split_first()
         .ok_or(ProgramError::InvalidInstructionData)?;
+    let instruction = TokenInstruction::try_from(*discriminator)?;
 
-    match *discriminator {
+    match instruction {
         // 0 - InitializeMint
-        0 => {
+        TokenInstruction::InitializeMint => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeMint");
 
-            process_initialize_mint(accounts, instruction_data, true)
+            process_initialize_mint(accounts, instruction_data)
         }
 
         // 3 - Transfer
-        3 => {
+        TokenInstruction::Transfer => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: Transfer");
 
             process_transfer(accounts, instruction_data)
         }
         // 7 - MintTo
-        7 => {
+        TokenInstruction::MintTo => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: MintTo");
 
             process_mint_to(accounts, instruction_data)
         }
         // 9 - CloseAccount
-        9 => {
+        TokenInstruction::CloseAccount => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: CloseAccount");
 
             process_close_account(accounts)
         }
         // 18 - InitializeAccount3
-        18 => {
+        TokenInstruction::InitializeAccount3 => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeAccount3");
 
             process_initialize_account3(accounts, instruction_data)
         }
         // 20 - InitializeMint2
-        20 => {
+        TokenInstruction::InitializeMint2 => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeMint2");
 
             process_initialize_mint2(accounts, instruction_data)
         }
-        _ => process_remaining_instruction(accounts, instruction_data, *discriminator),
+        _ => process_remaining_instruction(accounts, instruction_data, instruction),
     }
 }
 
@@ -93,137 +95,137 @@ pub fn process_instruction(
 fn process_remaining_instruction(
     accounts: &[AccountInfo],
     instruction_data: &[u8],
-    discriminator: u8,
+    instruction: TokenInstruction,
 ) -> ProgramResult {
-    match discriminator {
+    match instruction {
         // 1 - InitializeAccount
-        1 => {
+        TokenInstruction::InitializeAccount => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeAccount");
 
             process_initialize_account(accounts)
         }
         // 2 - InitializeMultisig
-        2 => {
+        TokenInstruction::InitializeMultisig => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeMultisig");
 
             process_initialize_multisig(accounts, instruction_data)
         }
         // 4 - Approve
-        4 => {
+        TokenInstruction::Approve => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: Approve");
 
             process_approve(accounts, instruction_data)
         }
         // 5 - Revoke
-        5 => {
+        TokenInstruction::Revoke => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: Revoke");
 
             process_revoke(accounts, instruction_data)
         }
         // 6 - SetAuthority
-        6 => {
+        TokenInstruction::SetAuthority => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: SetAuthority");
 
             process_set_authority(accounts, instruction_data)
         }
         // 8 - Burn
-        8 => {
+        TokenInstruction::Burn => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: Burn");
 
             process_burn(accounts, instruction_data)
         }
         // 10 - FreezeAccount
-        10 => {
+        TokenInstruction::FreezeAccount => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: FreezeAccount");
 
             process_freeze_account(accounts)
         }
         // 11 - ThawAccount
-        11 => {
+        TokenInstruction::ThawAccount => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: ThawAccount");
 
             process_thaw_account(accounts)
         }
         // 12 - TransferChecked
-        12 => {
+        TokenInstruction::TransferChecked => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: TransferChecked");
 
             process_transfer_checked(accounts, instruction_data)
         }
         // 13 - ApproveChecked
-        13 => {
+        TokenInstruction::ApproveChecked => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: ApproveChecked");
 
             process_approve_checked(accounts, instruction_data)
         }
         // 14 - MintToChecked
-        14 => {
+        TokenInstruction::MintToChecked => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: MintToChecked");
 
             process_mint_to_checked(accounts, instruction_data)
         }
         // 15 - BurnChecked
-        15 => {
+        TokenInstruction::BurnChecked => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: BurnChecked");
 
             process_burn_checked(accounts, instruction_data)
         }
         // 16 - InitializeAccount2
-        16 => {
+        TokenInstruction::InitializeAccount2 => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeAccount2");
 
             process_initialize_account2(accounts, instruction_data)
         }
         // 17 - SyncNative
-        17 => {
+        TokenInstruction::SyncNative => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: SyncNative");
 
             process_sync_native(accounts)
         }
         // 19 - InitializeMultisig2
-        19 => {
+        TokenInstruction::InitializeMultisig2 => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeMultisig2");
 
             process_initialize_multisig2(accounts, instruction_data)
         }
         // 21 - GetAccountDataSize
-        21 => {
+        TokenInstruction::GetAccountDataSize => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: GetAccountDataSize");
 
             process_get_account_data_size(accounts)
         }
         // 22 - InitializeImmutableOwner
-        22 => {
+        TokenInstruction::InitializeImmutableOwner => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: InitializeImmutableOwner");
 
             process_initialize_immutable_owner(accounts)
         }
         // 23 - AmountToUiAmount
-        23 => {
+        TokenInstruction::AmountToUiAmount => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: AmountToUiAmount");
 
             process_amount_to_ui_amount(accounts, instruction_data)
         }
         // 24 - UiAmountToAmount
-        24 => {
+        TokenInstruction::UiAmountToAmount => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: UiAmountToAmount");
 

p-token/src/entrypoint.rs

@@ -4,16 +4,16 @@ use super::shared;
 
 #[inline(always)]
 pub fn process_approve_checked(accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResult {
-    let (amount, decimals) = instruction_data.split_at(core::mem::size_of::<u64>());
-    let amount = u64::from_le_bytes(
-        amount
-            .try_into()
-            .map_err(|_error| ProgramError::InvalidInstructionData)?,
-    );
+    // expected u64 (8) + u8 (1)
+    let (amount, decimals) = if instruction_data.len() == 9 {
+        let (amount, decimals) = instruction_data.split_at(core::mem::size_of::<u64>());
+        (
+            u64::from_le_bytes(amount.try_into().unwrap()),
+            decimals.first().copied(),
+        )
+    } else {
+        return Err(ProgramError::InvalidInstructionData);
+    };
 
-    shared::approve::process_approve(
-        accounts,
-        amount,
-        Some(*decimals.first().ok_or(ProgramError::InvalidAccountData)?),
-    )
+    shared::approve::process_approve(accounts, amount, decimals)
 }