Few more instructions

Author: febo

README.md

@@ -12,6 +12,9 @@
   <a href="https://github.com/febo/p-token/actions/workflows/main.yml"><img src="https://img.shields.io/github/actions/workflow/status/febo/p-token/main.yml?logo=GitHub" /></a>
 </p>
 
+> [!WARNING]
+> The program is not yet fully-optimized. There are still opportunities to improve the compute units consumption.
+
 ## Overview
 
 This repository contains a **proof-of-concept** of a reimplementation of the SPL Token program, one of the most used programs on Solana, using [`pinocchio`](https://github.com/febo/pinocchio). The purpose is to have an implementation that optimizes the compute units, while being fully compatible with the original implementation &mdash; i.e., support the exact same instruction and account layouts as SPL Token, byte for byte.
@@ -22,7 +25,7 @@ This repository contains a **proof-of-concept** of a reimplementation of the SPL
 |----------------------------|-----------|----------------|------------------|
 | `InitializeMint`           | ✅        | 370            | 2967             |
 | `InitializeAccount`        | ✅        | 406            | 4527             |
-| `InitializeMultisig`       | ✅        | 431            | 2973              |
+| `InitializeMultisig`       | ✅        | 431            | 2973             |
 | `Transfer`                 | ✅        | 161            | 4645             |
 | `Approve`                  | ✅        | 123            | 2904             |
 | `Revoke`                   | ✅        | 88             | 2677             |
@@ -32,15 +35,15 @@ This repository contains a **proof-of-concept** of a reimplementation of the SPL
 | `CloseAccount`             | ✅        | 162            | 2916             |
 | `FreezeAccount`            | ✅        | 128            | 4265             |
 | `ThawAccount`              | ✅        | 129            | 4267             |
-| `TransferChecked`          |           |                |                  |
-| `ApproveChecked`           |           |                |                  |
-| `MintToChecked`            |           |                |                  |
-| `BurnChecked`              |           |                |                  |
-| `InitializeAccount2`       |           |                |                  |
+| `TransferChecked`          | ✅        | 275            | 6201             |
+| `ApproveChecked`           | ✅        | 222            | 4459             |
+| `MintToChecked`            | ✅        | 218            | 4546             |
+| `BurnChecked`              | ✅        | 201            | 4755             |
+| `InitializeAccount2`       | ✅        | 431            | 4388             |
 | `SyncNative`               |           |                |                  |
-| `InitializeAccount3`       |           |                |                  |
-| `InitializeMultisig2`      |           |                |                  |
-| `InitializeMint2`          |           |                |                  |
+| `InitializeAccount3`       | ✅        | 566            | 4240             |
+| `InitializeMultisig2`      | ✅        | 601            | 2826             |
+| `InitializeMint2`          | ✅        | 529            | 2827             |
 | `GetAccountDataSize`       |           |                |                  |
 | `InitializeImmutableOwner` |           |                |                  |
 | `AmountToUiAmount`         |           |                |                  |

program/src/entrypoint.rs

@@ -5,17 +5,25 @@ use pinocchio::{
 
 use crate::processor::{
     approve::process_approve,
+    approve_checked::{process_approve_checked, ApproveChecked},
     burn::process_burn,
+    burn_checked::{process_burn_checked, BurnChecked},
     close_account::process_close_account,
     freeze_account::process_freeze_account,
     initialize_account::process_initialize_account,
+    initialize_account2::process_initialize_account2,
+    initialize_account3::process_initialize_account3,
     initialize_mint::{process_initialize_mint, InitializeMint},
+    initialize_mint2::process_initialize_mint2,
     initialize_multisig::process_initialize_multisig,
+    initialize_multisig2::process_initialize_multisig2,
     mint_to::process_mint_to,
+    mint_to_checked::{process_mint_to_checked, MintToChecked},
     revoke::process_revoke,
     set_authority::{process_set_authority, SetAuthority},
     thaw_account::process_thaw_account,
     transfer::process_transfer,
+    transfer_checked::{process_transfer_checked, TransferChecked},
 };
 
 entrypoint!(process_instruction);
@@ -33,6 +41,7 @@ pub fn process_instruction(
             pinocchio::msg!("Instruction: InitializeMint");
 
             let instruction = InitializeMint::try_from_bytes(data)?;
+
             process_initialize_mint(accounts, &instruction, true)
         }
         // 1 - InitializeAccount
@@ -133,13 +142,85 @@ pub fn process_instruction(
 
             process_freeze_account(program_id, accounts)
         }
-        // 10 - ThawAccount
+        // 11 - ThawAccount
         Some((&11, _)) => {
             #[cfg(feature = "logging")]
             pinocchio::msg!("Instruction: ThawAccount");
 
             process_thaw_account(program_id, accounts)
         }
+        // 12 - TransferChecked
+        Some((&12, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: TransferChecked");
+
+            let args = TransferChecked::try_from_bytes(data)?;
+
+            process_transfer_checked(program_id, accounts, args.amount(), args.decimals())
+        }
+        // 13 - ApproveChecked
+        Some((&13, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: ApproveChecked");
+
+            let args = ApproveChecked::try_from_bytes(data)?;
+
+            process_approve_checked(program_id, accounts, args.amount(), args.decimals())
+        }
+        // 14 - MintToChecked
+        Some((&14, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: MintToChecked");
+
+            let args = MintToChecked::try_from_bytes(data)?;
+
+            process_mint_to_checked(program_id, accounts, args.amount(), args.decimals())
+        }
+        // 15 - BurnChecked
+        Some((&15, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: BurnChecked");
+
+            let args = BurnChecked::try_from_bytes(data)?;
+
+            process_burn_checked(program_id, accounts, args.amount(), args.decimals())
+        }
+        // 16 - InitializeAccount2
+        Some((&16, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: InitializeAccount2");
+
+            let owner = unsafe { &*(data.as_ptr() as *const Pubkey) };
+
+            process_initialize_account2(program_id, accounts, owner)
+        }
+        // 18 - InitializeAccount3
+        Some((&18, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: InitializeAccount3");
+
+            let owner = unsafe { &*(data.as_ptr() as *const Pubkey) };
+
+            process_initialize_account3(program_id, accounts, owner)
+        }
+        // 19 - InitializeMultisig2
+        Some((&19, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: InitializeMultisig2");
+
+            let m = data.first().ok_or(ProgramError::InvalidInstructionData)?;
+
+            process_initialize_multisig2(accounts, *m)
+        }
+        // 20 - InitializeMint2
+        Some((&20, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: InitializeMint2");
+
+            let instruction = InitializeMint::try_from_bytes(data)?;
+
+            process_initialize_mint2(accounts, &instruction)
+        }
         _ => Err(ProgramError::InvalidInstructionData),
     }
 }

program/src/processor/approve_checked.rs

@@ -0,0 +1,47 @@
+use std::marker::PhantomData;
+
+use pinocchio::{
+    account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+};
+
+use super::approve::process_approve;
+
+#[inline(always)]
+pub fn process_approve_checked(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    amount: u64,
+    decimals: u8,
+) -> ProgramResult {
+    process_approve(program_id, accounts, amount, Some(decimals))
+}
+
+pub struct ApproveChecked<'a> {
+    raw: *const u8,
+
+    _data: PhantomData<&'a [u8]>,
+}
+
+impl ApproveChecked<'_> {
+    pub fn try_from_bytes(bytes: &[u8]) -> Result<ApproveChecked, ProgramError> {
+        if bytes.len() != 9 {
+            return Err(ProgramError::InvalidInstructionData);
+        }
+
+        Ok(ApproveChecked {
+            raw: bytes.as_ptr(),
+            _data: PhantomData,
+        })
+    }
+
+    pub fn amount(&self) -> u64 {
+        unsafe {
+            let amount = self.raw as *const u64;
+            amount.read_unaligned()
+        }
+    }
+
+    pub fn decimals(&self) -> u8 {
+        unsafe { *self.raw.add(8) }
+    }
+}

program/src/processor/burn_checked.rs

@@ -0,0 +1,47 @@
+use std::marker::PhantomData;
+
+use pinocchio::{
+    account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+};
+
+use super::burn::process_burn;
+
+#[inline(always)]
+pub fn process_burn_checked(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    amount: u64,
+    decimals: u8,
+) -> ProgramResult {
+    process_burn(program_id, accounts, amount, Some(decimals))
+}
+
+pub struct BurnChecked<'a> {
+    raw: *const u8,
+
+    _data: PhantomData<&'a [u8]>,
+}
+
+impl BurnChecked<'_> {
+    pub fn try_from_bytes(bytes: &[u8]) -> Result<BurnChecked, ProgramError> {
+        if bytes.len() != 9 {
+            return Err(ProgramError::InvalidInstructionData);
+        }
+
+        Ok(BurnChecked {
+            raw: bytes.as_ptr(),
+            _data: PhantomData,
+        })
+    }
+
+    pub fn amount(&self) -> u64 {
+        unsafe {
+            let amount = self.raw as *const u64;
+            amount.read_unaligned()
+        }
+    }
+
+    pub fn decimals(&self) -> u8 {
+        unsafe { *self.raw.add(8) }
+    }
+}

program/src/processor/initialize_account2.rs

@@ -0,0 +1,12 @@
+use pinocchio::{account_info::AccountInfo, pubkey::Pubkey, ProgramResult};
+
+use super::initialize_account::process_initialize_account;
+
+#[inline(always)]
+pub fn process_initialize_account2(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    owner: &Pubkey,
+) -> ProgramResult {
+    process_initialize_account(program_id, accounts, Some(owner), true)
+}

program/src/processor/initialize_account3.rs

@@ -0,0 +1,12 @@
+use pinocchio::{account_info::AccountInfo, pubkey::Pubkey, ProgramResult};
+
+use super::initialize_account::process_initialize_account;
+
+#[inline(always)]
+pub fn process_initialize_account3(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    owner: &Pubkey,
+) -> ProgramResult {
+    process_initialize_account(program_id, accounts, Some(owner), false)
+}

program/src/processor/initialize_mint.rs

@@ -1,12 +1,11 @@
-use bytemuck::{Pod, Zeroable};
 use pinocchio::{
     account_info::AccountInfo,
     program_error::ProgramError,
-    pubkey::{Pubkey, PUBKEY_BYTES},
+    pubkey::Pubkey,
     sysvars::{rent::Rent, Sysvar},
     ProgramResult,
 };
-use std::mem::size_of;
+use std::{marker::PhantomData, mem::size_of};
 use token_interface::{
     error::TokenError,
     state::{mint::Mint, PodCOption},
@@ -52,17 +51,18 @@ pub fn process_initialize_mint(
 
     // Initialize the mint.
 
-    mint.mint_authority = PodCOption::from(Some(args.data.mint_authority));
-    mint.decimals = args.data.decimals;
+    mint.mint_authority = PodCOption::from(Some(*args.mint_authority()));
+    mint.decimals = args.decimals();
     mint.is_initialized = true.into();
 
-    if let Some(freeze_authority) = args.freeze_authority {
+    if let Some(freeze_authority) = args.freeze_authority() {
         mint.freeze_authority = PodCOption::from(Some(*freeze_authority));
     }
 
     Ok(())
 }
 
+/*
 /// Instruction data for the `InitializeMint` instruction.
 pub struct InitializeMint<'a> {
     pub data: &'a MintData,
@@ -107,3 +107,45 @@ pub struct MintData {
     /// The authority/multisignature to mint tokens.
     pub mint_authority: Pubkey,
 }
+*/
+/// Instruction data for the `InitializeMint2` instruction.
+pub struct InitializeMint<'a> {
+    raw: *const u8,
+
+    _data: PhantomData<&'a [u8]>,
+}
+
+impl InitializeMint<'_> {
+    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)
+        if bytes.len() < 34 {
+            return Err(ProgramError::InvalidInstructionData);
+        }
+
+        Ok(InitializeMint {
+            raw: bytes.as_ptr(),
+            _data: PhantomData,
+        })
+    }
+
+    pub fn decimals(&self) -> u8 {
+        unsafe { *self.raw }
+    }
+
+    pub fn mint_authority(&self) -> &Pubkey {
+        unsafe { &*(self.raw.add(1) as *const Pubkey) }
+    }
+
+    pub fn freeze_authority(&self) -> Option<&Pubkey> {
+        unsafe {
+            if *self.raw.add(33) == 0 {
+                Option::None
+            } else {
+                Option::Some(&*(self.raw.add(34) as *const Pubkey))
+            }
+        }
+    }
+}

program/src/processor/initialize_mint2.rs

@@ -0,0 +1,7 @@
+use pinocchio::{account_info::AccountInfo, ProgramResult};
+
+use super::initialize_mint::{process_initialize_mint, InitializeMint};
+
+pub fn process_initialize_mint2(accounts: &[AccountInfo], args: &InitializeMint) -> ProgramResult {
+    process_initialize_mint(accounts, args, false)
+}

program/src/processor/initialize_multisig2.rs

@@ -0,0 +1,7 @@
+use pinocchio::{account_info::AccountInfo, ProgramResult};
+
+use super::initialize_multisig::process_initialize_multisig;
+
+pub fn process_initialize_multisig2(accounts: &[AccountInfo], m: u8) -> ProgramResult {
+    process_initialize_multisig(accounts, m, false)
+}