refactor: transfer2 add hotpath spl -> ctoken transfer

Author: ananas-block

Cargo.lock

@@ -45,21 +45,17 @@ impl CompressedToken {
     /// CompressedToken layout: mint (32 bytes) + owner (32 bytes) + amount (8 bytes)
     pub fn amount_from_slice(data: &[u8]) -> Result<u64, ZeroCopyError> {
         const AMOUNT_OFFSET: usize = 64; // 32 (mint) + 32 (owner)
-        
+
         if data.len() < AMOUNT_OFFSET + 8 {
             return Err(ZeroCopyError::Size);
         }
-        
+
         let amount_bytes = &data[AMOUNT_OFFSET..AMOUNT_OFFSET + 8];
-        let amount = u64::from_le_bytes(
-            amount_bytes
-                .try_into()
-                .map_err(|_| ZeroCopyError::Size)?
-        );
-        
+        let amount = u64::from_le_bytes(amount_bytes.try_into().map_err(|_| ZeroCopyError::Size)?);
+
         Ok(amount)
     }
-    
+
     /// Extract amount from an AccountInfo
     #[cfg(feature = "solana")]
     pub fn amount_from_account_info(
@@ -200,6 +196,8 @@ impl<'a> ZeroCopyAt<'a> for CompressedTokenMeta {
 impl<'a> ZeroCopyAtMut<'a> for CompressedTokenMeta {
     type ZeroCopyAtMut = ZCompressedTokenMetaMut<'a>;
 
+    #[profile]
+    #[inline(always)]
     fn zero_copy_at_mut(
         bytes: &'a mut [u8],
     ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), ZeroCopyError> {
@@ -481,6 +479,8 @@ impl<'a> ZeroCopyAt<'a> for CompressedToken {
 impl<'a> ZeroCopyAtMut<'a> for CompressedToken {
     type ZeroCopyAtMut = ZCompressedTokenMut<'a>;
 
+    #[profile]
+    #[inline(always)]
     fn zero_copy_at_mut(
         bytes: &'a mut [u8],
     ) -> Result<(Self::ZeroCopyAtMut, &'a mut [u8]), ZeroCopyError> {

program-libs/ctoken-types/src/state/solana_ctoken.rs

@@ -37,6 +37,7 @@ spl-token-2022 = { workspace = true }
 light-zero-copy = { workspace = true }
 zerocopy = { workspace = true }
 light-ctoken-types = { workspace = true, features = ["anchor"] }
+pinocchio-pubkey = { workspace = true }
 
 [target.'cfg(not(target_os = "solana"))'.dependencies]
 solana-sdk = { workspace = true }

programs/compressed-token/anchor/Cargo.toml

@@ -32,6 +32,7 @@ pub fn check_spl_token_pool_derivation_with_index(
     }
 }
 
+#[inline(always)]
 pub fn is_valid_token_pool_pda(
     mint_bytes: &[u8],
     token_pool_pubkey: &Pubkey,
@@ -40,9 +41,8 @@ pub fn is_valid_token_pool_pda(
 ) -> Result<bool> {
     let pool_index = if pool_index[0] == 0 { &[] } else { pool_index };
     let pda = if let Some(bump) = bump {
-        let seeds = [POOL_SEED, mint_bytes, pool_index, &[bump]];
-        Pubkey::create_program_address(&seeds[..], &crate::ID)
-            .map_err(|_| crate::ErrorCode::NoMatchingBumpFound)?
+        let seeds = [POOL_SEED, mint_bytes, pool_index];
+        pinocchio_pubkey::derive_address(&seeds, Some(bump), &crate::ID.to_bytes()).into()
     } else {
         let seeds = [POOL_SEED, mint_bytes, pool_index];
         Pubkey::find_program_address(&seeds[..], &crate::ID).0

programs/compressed-token/anchor/src/spl_compression.rs

@@ -2,13 +2,15 @@ use anchor_compressed_token::ErrorCode;
 use anchor_lang::prelude::ProgramError;
 use light_account_checks::AccountInfoTrait;
 use light_ctoken_types::state::{CompressedToken, ZCompressedTokenMut, ZExtensionStructMut};
+use light_profiler::profile;
 use light_zero_copy::traits::ZeroCopyAtMut;
 use pinocchio::account_info::AccountInfo;
 use spl_token_2022::state::AccountState;
 
 use super::accounts::CloseTokenAccountAccounts;
 
 /// Process the close token account instruction
+#[profile]
 pub fn process_close_token_account(
     account_infos: &[AccountInfo],
     _instruction_data: &[u8],
@@ -27,6 +29,7 @@ pub fn process_close_token_account(
     Ok(())
 }
 
+#[profile]
 pub fn validate_token_account(
     accounts: &CloseTokenAccountAccounts,
     compressed_token: &ZCompressedTokenMut<'_>,

programs/compressed-token/program/src/close_token_account/processor.rs

@@ -55,7 +55,7 @@ pub fn process_mint_to_decompressed_action(
         None, // No authority needed for decompression
         None,
         amount,
-        mint.into(),
+        &mint.into(),
         token_account_info,
         None,
         &ZCompressionMode::Decompress,

programs/compressed-token/program/src/mint_action/actions/mint_to_decompressed.rs

@@ -1,10 +1,12 @@
 use anchor_lang::solana_program::program_error::ProgramError;
 use light_account_checks::checks::check_signer;
 use light_ctoken_types::state::ZCompressedTokenMut;
+use light_profiler::profile;
 use pinocchio::account_info::AccountInfo;
 
 /// Verify owner or delegate signer authorization for token operations
 /// Returns the delegate account info if delegate is used, None otherwise
+#[profile]
 pub fn verify_owner_or_delegate_signer<'a>(
     owner_account: &'a AccountInfo,
     delegate_account: Option<&'a AccountInfo>,
@@ -48,6 +50,7 @@ pub fn verify_owner_or_delegate_signer<'a>(
 }
 
 /// Verify and update token account authority using zero-copy compressed token format
+#[profile]
 pub fn verify_and_update_token_account_authority_with_compressed_token(
     compressed_token: &mut ZCompressedTokenMut,
     authority_account: &AccountInfo,

programs/compressed-token/program/src/shared/owner_validation.rs

@@ -1,6 +1,7 @@
 use anchor_compressed_token::ErrorCode;
 use anchor_lang::solana_program::program_error::ProgramError;
 use light_account_checks::packed_accounts::ProgramPackedAccounts;
+use light_profiler::profile;
 use light_sdk_types::ACCOUNT_COMPRESSION_PROGRAM_ID;
 use pinocchio::{account_info::AccountInfo, pubkey::Pubkey};
 use spl_pod::solana_msg::msg;
@@ -25,6 +26,8 @@ pub struct Transfer2Accounts<'info> {
 
 impl<'info> Transfer2Accounts<'info> {
     /// Validate and parse accounts from the instruction accounts slice
+    #[profile]
+    #[inline(always)]
     pub fn validate_and_parse(
         accounts: &'info [AccountInfo],
         config: &Transfer2Config,
@@ -67,6 +70,7 @@ impl<'info> Transfer2Accounts<'info> {
 
     /// Calculate static accounts count after skipping index 0 (system accounts only)
     /// Returns the count of fixed accounts based on optional features
+    #[profile]
     #[inline(always)]
     pub fn static_accounts_count(&self) -> Result<usize, ProgramError> {
         let system = self
@@ -86,6 +90,7 @@ impl<'info> Transfer2Accounts<'info> {
     /// Extract CPI accounts slice for light-system-program invocation
     /// Includes static accounts + tree accounts based on highest tree index
     /// Returns (cpi_accounts_slice, tree_accounts)
+    #[profile]
     #[inline(always)]
     pub fn cpi_accounts(
         &self,
@@ -116,6 +121,8 @@ impl<'info> Transfer2Accounts<'info> {
 
 // TODO: unit test.
 /// Extract tree accounts by finding the highest tree index and using it as closing offset
+#[profile]
+#[inline(always)]
 pub fn extract_tree_accounts<'info>(
     packed_accounts: &'info ProgramPackedAccounts<'info, AccountInfo>,
 ) -> Vec<&'info Pubkey> {

programs/compressed-token/program/src/transfer2/accounts.rs

@@ -1,12 +1,15 @@
 use arrayvec::ArrayVec;
 use light_compressed_account::instruction_data::with_readonly::InstructionDataInvokeCpiWithReadOnlyConfig;
 use light_ctoken_types::instructions::transfer2::ZCompressedTokenInstructionDataTransfer2;
+use light_profiler::profile;
 
 use crate::shared::cpi_bytes_size::{
     allocate_invoke_with_read_only_cpi_bytes, cpi_bytes_config, CpiConfigInput,
 };
 
 /// Build CPI configuration from instruction data
+#[profile]
+#[inline(always)]
 pub fn allocate_cpi_bytes(
     inputs: &ZCompressedTokenInstructionDataTransfer2,
 ) -> (Vec<u8>, InstructionDataInvokeCpiWithReadOnlyConfig) {

programs/compressed-token/program/src/transfer2/cpi.rs

@@ -4,6 +4,7 @@ use light_compressed_account::pubkey::AsPubkey;
 use light_ctoken_types::instructions::transfer2::{
     ZCompressedTokenInstructionDataTransfer2, ZCompression, ZCompressionMode,
 };
+use light_profiler::profile;
 use pinocchio::account_info::AccountInfo;
 use spl_pod::solana_msg::msg;
 
@@ -19,6 +20,7 @@ const SPL_TOKEN_2022_ID: &[u8; 32] = &spl_token_2022::ID.to_bytes();
 const ID: &[u8; 32] = &LIGHT_CPI_SIGNER.program_id;
 
 /// Process native compressions/decompressions with token accounts
+#[profile]
 pub fn process_token_compression(
     inputs: &ZCompressedTokenInstructionDataTransfer2,
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
@@ -75,6 +77,8 @@ pub fn process_token_compression(
 }
 
 /// Validate compression fields based on compression mode
+#[profile]
+#[inline(always)]
 pub(crate) fn validate_compression_mode_fields(
     compression: &ZCompression,
 ) -> Result<(), ProgramError> {