More instructions

Author: febo

Cargo.lock

@@ -16,5 +16,7 @@ repository = "https://github.com/febo/token"
 
 [workspace.dependencies]
 bytemuck = { version="1.18.0", features=["derive"] }
-pinocchio = { git = "https://github.com/febo/pinocchio.git", branch = "febo/floating" }
-pinocchio-pubkey = { git = "https://github.com/febo/pinocchio.git", branch = "febo/floating" }
+pinocchio = { git = "https://github.com/febo/pinocchio.git", branch = "tweaks" }
+pinocchio-pubkey = { git = "https://github.com/febo/pinocchio.git", branch = "tweaks" }
+#pinocchio = { version = "^0", path = "/Users/febo/Developer/febo/pinocchio/sdk/pinocchio" }
+#pinocchio-pubkey = { version = "^0", path = "/Users/febo/Developer/febo/pinocchio/sdk/pubkey" }

Cargo.toml

@@ -20,18 +20,18 @@ This repository contains a **proof-of-concept** of a reimplementation of the SPL
 
 | Instruction                | Completed | CU (`p-token`) | CU (`spl-token`) |
 |----------------------------|-----------|----------------|------------------|
-| `InitializeMint`           | ✅        | 396            | 2967             |
-| `InitializeAccount`        | ✅        | 444            | 4527             |
-| `InitializeMultisig`       |           |                |                  |
+| `InitializeMint`           | ✅        | 370            | 2967             |
+| `InitializeAccount`        | ✅        | 406            | 4527             |
+| `InitializeMultisig`       | ✅        | 431            | 2973              |
 | `Transfer`                 | ✅        | 161            | 4645             |
-| `Approve`                  |           |                |                  |
-| `Revoke`                   |           |                |                  |
-| `SetAuthority`             |           |                |                  |
+| `Approve`                  | ✅        | 123            | 2904             |
+| `Revoke`                   | ✅        | 88             | 2677             |
+| `SetAuthority`             | ✅        | 137            | 3167             |
 | `MintTo`                   | ✅        | 160            | 4538             |
-| `Burn`                     |           |                |                  |
-| `CloseAccount`             |           |                |                  |
-| `FreezeAccount`            |           |                |                  |
-| `ThawAccount`              |           |                |                  |
+| `Burn`                     | ✅        | 158            | 4753             |
+| `CloseAccount`             | ✅        | 162            | 2916             |
+| `FreezeAccount`            | ✅        | 128            | 4265             |
+| `ThawAccount`              | ✅        | 129            | 4267             |
 | `TransferChecked`          |           |                |                  |
 | `ApproveChecked`           |           |                |                  |
 | `MintToChecked`            |           |                |                  |

README.md

@@ -1,8 +1,8 @@
 //! Instruction types
 
-use pinocchio::{program_error::ProgramError, pubkey::Pubkey};
+use pinocchio::pubkey::Pubkey;
 
-use crate::{error::TokenError, state::PodCOption};
+use crate::state::PodCOption;
 
 /// Instructions supported by the token program.
 #[repr(C)]
@@ -506,13 +506,13 @@ impl AuthorityType {
         }
     }
 
-    pub fn from(index: u8) -> Result<Self, ProgramError> {
+    pub fn from(index: u8) -> Self {
         match index {
-            0 => Ok(AuthorityType::MintTokens),
-            1 => Ok(AuthorityType::FreezeAccount),
-            2 => Ok(AuthorityType::AccountOwner),
-            3 => Ok(AuthorityType::CloseAccount),
-            _ => Err(TokenError::InvalidInstruction.into()),
+            0 => AuthorityType::MintTokens,
+            1 => AuthorityType::FreezeAccount,
+            2 => AuthorityType::AccountOwner,
+            3 => AuthorityType::CloseAccount,
+            _ => panic!("invalid authority type: {index}"),
         }
     }
 }

interface/src/instruction.rs

@@ -2,3 +2,7 @@ pub mod error;
 pub mod instruction;
 pub mod native_mint;
 pub mod state;
+
+pub mod program {
+    pinocchio_pubkey::declare_id!("11111111111111111111111111111111");
+}

interface/src/lib.rs

@@ -37,6 +37,9 @@ pub struct Account {
 }
 
 impl Account {
+    /// Size of the `Account` account.
+    pub const LEN: usize = core::mem::size_of::<Self>();
+
     #[inline]
     pub fn is_initialized(&self) -> bool {
         self.state != AccountState::Uninitialized as u8

interface/src/state/account.rs

@@ -25,3 +25,8 @@ pub struct Mint {
     /// Optional authority to freeze token accounts.
     pub freeze_authority: PodCOption<Pubkey>,
 }
+
+impl Mint {
+    /// Size of the `Mint` account.
+    pub const LEN: usize = core::mem::size_of::<Self>();
+}

interface/src/state/mint.rs

@@ -4,7 +4,7 @@ use bytemuck::{Pod, Zeroable};
 
 pub mod account;
 pub mod mint;
-pub mod multisignature;
+pub mod multisig;
 
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
@@ -40,6 +40,13 @@ impl<T: Default + PartialEq + Pod + Sized> PodCOption<T> {
 
     pub const SOME: [u8; 4] = [1, 0, 0, 0];
 
+    pub fn some(value: T) -> Self {
+        Self {
+            tag: [1, 0, 0, 0],
+            value,
+        }
+    }
+
     /// Returns `true` if the option is a `None` value.
     #[inline]
     pub fn is_none(&self) -> bool {

interface/src/state/mod.rs

@@ -24,4 +24,9 @@ pub struct Multisig {
 
 impl Multisig {
     pub const LEN: usize = core::mem::size_of::<Multisig>();
+
+    /// Utility function that checks index is between [`MIN_SIGNERS`] and [`MAX_SIGNERS`].
+    pub fn is_valid_signer_index(index: usize) -> bool {
+        (MIN_SIGNERS..=MAX_SIGNERS).contains(&index)
+    }
 }

interface/src/state/multisignature.rs renamed to interface/src/state/multisig.rs

@@ -4,9 +4,17 @@ use pinocchio::{
 };
 
 use crate::processor::{
+    approve::process_approve,
+    burn::process_burn,
+    close_account::process_close_account,
+    freeze_account::process_freeze_account,
     initialize_account::process_initialize_account,
     initialize_mint::{process_initialize_mint, InitializeMint},
+    initialize_multisig::process_initialize_multisig,
     mint_to::process_mint_to,
+    revoke::process_revoke,
+    set_authority::{process_set_authority, SetAuthority},
+    thaw_account::process_thaw_account,
     transfer::process_transfer,
 };
 
@@ -34,6 +42,15 @@ pub fn process_instruction(
 
             process_initialize_account(program_id, accounts, None, true)
         }
+        // 2 - InitializeMultisig
+        Some((&2, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: InitializeMultisig");
+
+            let m = data.first().ok_or(ProgramError::InvalidInstructionData)?;
+
+            process_initialize_multisig(accounts, *m, true)
+        }
         // 3 - Transfer
         Some((&3, data)) => {
             #[cfg(feature = "logging")]
@@ -46,6 +63,38 @@ pub fn process_instruction(
 
             process_transfer(program_id, accounts, amount, None)
         }
+        // 4 - Approve
+        Some((&4, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: Approve");
+
+            let amount = u64::from_le_bytes(
+                data.try_into()
+                    .map_err(|_error| ProgramError::InvalidInstructionData)?,
+            );
+
+            process_approve(program_id, accounts, amount, None)
+        }
+        // 5 - Revoke
+        Some((&5, _)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: Revoke");
+
+            process_revoke(program_id, accounts)
+        }
+        // 6 - SetAuthority
+        Some((&6, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: SetAuthority");
+
+            let instruction = SetAuthority::try_from_bytes(data)?;
+            process_set_authority(
+                program_id,
+                accounts,
+                instruction.authority_type,
+                instruction.new_authority,
+            )
+        }
         // 7 - InitializeMint
         Some((&7, data)) => {
             #[cfg(feature = "logging")]
@@ -58,6 +107,39 @@ pub fn process_instruction(
 
             process_mint_to(program_id, accounts, amount, None)
         }
+        // 8 - Burn
+        Some((&8, data)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: Burn");
+
+            let amount = u64::from_le_bytes(
+                data.try_into()
+                    .map_err(|_error| ProgramError::InvalidInstructionData)?,
+            );
+
+            process_burn(program_id, accounts, amount, None)
+        }
+        // 9 - CloseAccount
+        Some((&9, _)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: CloseAccount");
+
+            process_close_account(program_id, accounts)
+        }
+        // 10 - FreezeAccount
+        Some((&10, _)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: FreezeAccount");
+
+            process_freeze_account(program_id, accounts)
+        }
+        // 10 - ThawAccount
+        Some((&11, _)) => {
+            #[cfg(feature = "logging")]
+            pinocchio::msg!("Instruction: ThawAccount");
+
+            process_thaw_account(program_id, accounts)
+        }
         _ => Err(ProgramError::InvalidInstructionData),
     }
 }