Use compiler hints

Author: febo

Cargo.lock

@@ -13,7 +13,7 @@ crate-type = ["rlib"]
 
 [dependencies]
 pinocchio = { workspace = true }
-pinocchio-pubkey = "0.3"
+pinocchio-pubkey = { version = "0.3", git = "https://github.com/anza-xyz/pinocchio.git", branch = "febo/pubkey-eq" }
 
 [dev-dependencies]
 strum = "0.27"

p-interface/Cargo.toml

@@ -10,5 +10,6 @@ pub const ID: Pubkey = pinocchio_pubkey::pubkey!("So1111111111111111111111111111
 
 #[inline(always)]
 pub fn is_native_mint(mint: &Pubkey) -> bool {
+    // Avoid using `pubkey_eq` since it increased CU consumption.
     mint == &ID
 }

p-interface/src/native_mint.rs

@@ -1,6 +1,10 @@
 use {
     super::{account_state::AccountState, COption, Initializable, Transmutable},
-    pinocchio::{hint::likely, program_error::ProgramError, pubkey::Pubkey},
+    pinocchio::{
+        hint::likely,
+        program_error::ProgramError,
+        pubkey::{pubkey_eq, Pubkey},
+    },
 };
 
 /// Incinerator address.
@@ -147,7 +151,7 @@ impl Account {
 
     #[inline(always)]
     pub fn is_owned_by_system_program_or_incinerator(&self) -> bool {
-        SYSTEM_PROGRAM_ID == self.owner || INCINERATOR_ID == self.owner
+        pubkey_eq(&SYSTEM_PROGRAM_ID, &self.owner) || pubkey_eq(&INCINERATOR_ID, &self.owner)
     }
 }
 

p-interface/src/state/account.rs

@@ -16,7 +16,7 @@ logging = []
 
 [dependencies]
 pinocchio = { workspace = true }
-pinocchio-log = { version = "0.5", default-features = false }
+pinocchio-log = { version = "0.5", default-features = false, git = "https://github.com/anza-xyz/pinocchio.git", branch = "febo/pubkey-eq" }
 pinocchio-token-interface = { version = "^0", path = "../p-interface" }
 
 [dev-dependencies]

p-token/Cargo.toml

@@ -1,8 +1,13 @@
 use {
     core::{slice::from_raw_parts, str::from_utf8_unchecked},
     pinocchio::{
-        account_info::AccountInfo, hint::unlikely, program_error::ProgramError, pubkey::Pubkey,
-        syscalls::sol_memcpy_, ProgramResult,
+        account_info::AccountInfo,
+        hint::likely,
+        hint::unlikely,
+        program_error::ProgramError,
+        pubkey::{pubkey_eq, Pubkey},
+        syscalls::sol_memcpy_,
+        ProgramResult,
     },
     pinocchio_token_interface::{
         error::TokenError,
@@ -79,7 +84,7 @@ const MAX_FORMATTED_DIGITS: usize = u8::MAX as usize + 2;
 /// Checks that the account is owned by the expected program.
 #[inline(always)]
 fn check_account_owner(account_info: &AccountInfo) -> ProgramResult {
-    if account_info.is_owned_by(&TOKEN_PROGRAM_ID) {
+    if likely(account_info.is_owned_by(&TOKEN_PROGRAM_ID)) {
         Ok(())
     } else {
         Err(ProgramError::IncorrectProgramId)
@@ -101,7 +106,7 @@ unsafe fn validate_owner(
     owner_account_info: &AccountInfo,
     signers: &[AccountInfo],
 ) -> ProgramResult {
-    if expected_owner != owner_account_info.key() {
+    if unlikely(!pubkey_eq(expected_owner, owner_account_info.key())) {
         return Err(TokenError::OwnerMismatch.into());
     }
 
@@ -121,7 +126,7 @@ unsafe fn validate_owner(
 
         for signer in signers.iter() {
             for (position, key) in multisig.signers[0..multisig.n as usize].iter().enumerate() {
-                if key == signer.key() && !matched[position] {
+                if pubkey_eq(key, signer.key()) && !matched[position] {
                     if !signer.is_signer() {
                         return Err(ProgramError::MissingRequiredSignature);
                     }

p-token/src/processor/mod.rs

@@ -1,7 +1,8 @@
 use {
     super::validate_owner,
     pinocchio::{
-        account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey, ProgramResult,
+        account_info::AccountInfo, hint::likely, program_error::ProgramError, pubkey::Pubkey,
+        ProgramResult,
     },
     pinocchio_token_interface::{
         error::TokenError,
@@ -22,7 +23,9 @@ pub fn process_set_authority(accounts: &[AccountInfo], instruction_data: &[u8])
             let authority_type = AuthorityType::try_from(*instruction_data.get_unchecked(0))?;
             let new_authority = if *instruction_data.get_unchecked(1) == 0 {
                 None
-            } else if *instruction_data.get_unchecked(1) == 1 && instruction_data.len() >= 34 {
+            } else if likely(*instruction_data.get_unchecked(1) == 1)
+                && instruction_data.len() >= 34
+            {
                 Some(&*(instruction_data.as_ptr().add(2) as *const Pubkey))
             } else {
                 return Err(TokenError::InvalidInstruction.into());

p-token/src/processor/set_authority.rs

@@ -1,6 +1,8 @@
 use {
     crate::processor::validate_owner,
-    pinocchio::{account_info::AccountInfo, program_error::ProgramError, ProgramResult},
+    pinocchio::{
+        account_info::AccountInfo, program_error::ProgramError, pubkey::pubkey_eq, ProgramResult,
+    },
     pinocchio_token_interface::{
         error::TokenError,
         state::{account::Account, load, load_mut, mint::Mint},
@@ -56,7 +58,7 @@ pub fn process_approve(
     }
 
     if let Some((mint_info, expected_decimals)) = expected_mint_info {
-        if mint_info.key() != &source_account.mint {
+        if !pubkey_eq(mint_info.key(), &source_account.mint) {
             return Err(TokenError::MintMismatch.into());
         }
 

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

@@ -1,6 +1,9 @@
 use {
     crate::processor::{check_account_owner, validate_owner},
-    pinocchio::{account_info::AccountInfo, program_error::ProgramError, ProgramResult},
+    pinocchio::{
+        account_info::AccountInfo, hint::likely, program_error::ProgramError, pubkey::pubkey_eq,
+        ProgramResult,
+    },
     pinocchio_token_interface::{
         error::TokenError,
         state::{account::Account, load_mut, mint::Mint},
@@ -42,7 +45,7 @@ pub fn process_burn(
         .checked_sub(amount)
         .ok_or(TokenError::InsufficientFunds)?;
 
-    if mint_info.key() != &source_account.mint {
+    if !pubkey_eq(mint_info.key(), &source_account.mint) {
         return Err(TokenError::MintMismatch.into());
     }
 
@@ -52,9 +55,9 @@ pub fn process_burn(
         }
     }
 
-    if !source_account.is_owned_by_system_program_or_incinerator() {
+    if likely(!source_account.is_owned_by_system_program_or_incinerator()) {
         match source_account.delegate() {
-            Some(delegate) if authority_info.key() == delegate => {
+            Some(delegate) if pubkey_eq(authority_info.key(), delegate) => {
                 // SAFETY: `authority_info` is not currently borrowed.
                 unsafe { validate_owner(delegate, authority_info, remaining)? };
 

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

@@ -1,6 +1,7 @@
 use {
     pinocchio::{
         account_info::AccountInfo,
+        hint::likely,
         program_error::ProgramError,
         pubkey::Pubkey,
         sysvars::{rent::Rent, Sysvar},
@@ -30,7 +31,9 @@ pub fn process_initialize_mint(
             let mint_authority = &*(instruction_data.as_ptr().add(1) as *const Pubkey);
             let freeze_authority = if *instruction_data.get_unchecked(33) == 0 {
                 None
-            } else if *instruction_data.get_unchecked(33) == 1 && instruction_data.len() >= 66 {
+            } else if likely(*instruction_data.get_unchecked(33) == 1)
+                && instruction_data.len() >= 66
+            {
                 Some(&*(instruction_data.as_ptr().add(34) as *const Pubkey))
             } else {
                 return Err(TokenError::InvalidInstruction.into());