fix: top up or rent transfer mint to ctoken

Author: ananas-block

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

@@ -21,7 +21,7 @@ pub fn process_mint_to_ctoken_action(
     validated_accounts: &MintActionAccounts,
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
     mint: Pubkey,
-) -> Result<(), ProgramError> {
+) -> Result<Option<(u8, u64)>, ProgramError> {
     check_authority(
         compressed_mint.base.mint_authority,
         validated_accounts.authority.key(),
@@ -54,10 +54,12 @@ pub fn process_mint_to_ctoken_action(
         token_account_info,
         packed_accounts,
     );
-    // For mint_to_ctoken, we don't need to handle lamport transfers
-    // as there's no compressible extension on the target account
-    compress_or_decompress_ctokens(inputs)?;
-    Ok(())
+
+    // Capture top-up lamport amount if compressible extension present
+    let transfer_amount = compress_or_decompress_ctokens(inputs)?;
+
+    // Return account index and amount if there's a transfer needed
+    Ok(transfer_amount.map(|amount| (action.recipient.account_index, amount)))
 }
 
 #[profile]

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

@@ -1,5 +1,6 @@
 use anchor_compressed_token::ErrorCode;
 use anchor_lang::prelude::ProgramError;
+use arrayvec::ArrayVec;
 use light_account_checks::packed_accounts::ProgramPackedAccounts;
 use light_compressed_account::instruction_data::data::ZOutputCompressedAccountWithPackedContextMut;
 use light_ctoken_types::{
@@ -9,16 +10,23 @@ use light_ctoken_types::{
 };
 use light_program_profiler::profile;
 use pinocchio::account_info::AccountInfo;
+use spl_pod::solana_msg::msg;
 
-use crate::mint_action::{
-    accounts::MintActionAccounts,
-    check_authority,
-    mint_to::process_mint_to_compressed_action,
-    mint_to_ctoken::process_mint_to_ctoken_action,
-    queue_indices::QueueIndices,
-    update_metadata::{
-        process_remove_metadata_key_action, process_update_metadata_authority_action,
-        process_update_metadata_field_action,
+use crate::{
+    mint_action::{
+        accounts::MintActionAccounts,
+        check_authority,
+        mint_to::process_mint_to_compressed_action,
+        mint_to_ctoken::process_mint_to_ctoken_action,
+        queue_indices::QueueIndices,
+        update_metadata::{
+            process_remove_metadata_key_action, process_update_metadata_authority_action,
+            process_update_metadata_field_action,
+        },
+    },
+    shared::{
+        convert_program_error,
+        transfer_lamports::{multi_transfer_lamports, Transfer},
     },
 };
 
@@ -35,6 +43,9 @@ pub fn process_actions<'a>(
     packed_accounts: &ProgramPackedAccounts<'_, AccountInfo>,
     compressed_mint: &mut CompressedMint,
 ) -> Result<(), ProgramError> {
+    // Array to accumulate transfer amounts by account index (max 40 packed accounts)
+    let mut transfer_map = [0u64; 40];
+
     // Start metadata authority with same value as mint authority
     for action in parsed_instruction_data.actions.iter() {
         match action {
@@ -80,13 +91,27 @@ pub fn process_actions<'a>(
                 // compressed_mint.metadata.spl_mint_initialized = true;
             }
             ZAction::MintToCToken(mint_to_ctoken_action) => {
-                process_mint_to_ctoken_action(
+                let transfer = process_mint_to_ctoken_action(
                     mint_to_ctoken_action,
                     compressed_mint,
                     validated_accounts,
                     packed_accounts,
                     parsed_instruction_data.mint.metadata.mint,
                 )?;
+
+                // Accumulate transfer amount if present (deduplication happens here)
+                if let Some((account_index, amount)) = transfer {
+                    if account_index as usize > 40 {
+                        msg!(
+                            "Too many compression transfers: {}, max 40 allowed",
+                            account_index
+                        );
+                        return Err(ErrorCode::TooManyCompressionTransfers.into());
+                    }
+                    transfer_map[account_index as usize] = transfer_map[account_index as usize]
+                        .checked_add(amount)
+                        .ok_or(ProgramError::ArithmeticOverflow)?;
+                }
             }
             ZAction::UpdateMetadataField(update_metadata_action) => {
                 process_update_metadata_field_action(
@@ -112,5 +137,37 @@ pub fn process_actions<'a>(
         }
     }
 
+    // Build transfers array from deduplicated map
+    let transfers: ArrayVec<Transfer, 40> = transfer_map
+        .iter()
+        .enumerate()
+        .filter_map(|(index, &amount)| {
+            if amount != 0 {
+                Some((index as u8, amount))
+            } else {
+                None
+            }
+        })
+        .map(|(index, amount)| {
+            Ok(Transfer {
+                account: packed_accounts.get_u8(index, "transfer account")?,
+                amount,
+            })
+        })
+        .collect::<Result<ArrayVec<Transfer, 40>, ProgramError>>()?;
+
+    // Execute transfers if any exist
+    if !transfers.is_empty() {
+        let fee_payer = validated_accounts
+            .executing
+            .as_ref()
+            .and_then(|exec| Some(exec.system.fee_payer))
+            .ok_or_else(|| {
+                msg!("Fee payer required for compressible token account top-ups");
+                ProgramError::NotEnoughAccountKeys
+            })?;
+        multi_transfer_lamports(fee_payer, &transfers).map_err(convert_program_error)?;
+    }
+
     Ok(())
 }