test: CompressAndClose with cpi context

Author: ananas-block

sdk-libs/compressed-token-sdk/src/instructions/compress_and_close.rs

@@ -4,11 +4,12 @@ use crate::{
     instructions::{
         transfer2::{
             account_metas::Transfer2AccountsMetaConfig, create_transfer2_instruction,
-            Transfer2Inputs,
+            Transfer2Config, Transfer2Inputs,
         },
         CTokenDefaultAccounts,
     },
 };
+use light_compressed_account::instruction_data::cpi_context::CompressedCpiContext;
 use light_ctoken_types::state::{CompressedToken, ZExtensionStruct};
 use light_profiler::profile;
 use light_sdk::{
@@ -175,7 +176,7 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
             idx.source_index,
             idx.authority_index,
             idx.rent_recipient_index,
-            i as u8,  // Pass the index in the output array
+            i as u8, // Pass the index in the output array
         )?;
 
         token_accounts.push(token_account);
@@ -190,19 +191,37 @@ pub fn compress_and_close_ctoken_accounts_with_indices<'info>(
             is_writable: info.is_writable,
         });
     }
-    let meta_config = if cpi_context_pubkey.is_some() {
-        msg!("cpi_context_pubkey is not supported yet");
-        unimplemented!()
+    let (meta_config, transfer_config) = if let Some(cpi_context) = cpi_context_pubkey {
+        let cpi_context_config = CompressedCpiContext {
+            set_context: false,
+            first_set_context: false,
+            cpi_context_account_index: 0, // unused
+        };
+
+        (
+            Transfer2AccountsMetaConfig {
+                fee_payer: Some(fee_payer),
+                cpi_context: Some(cpi_context),
+                decompressed_accounts_only: false,
+                sol_pool_pda: None,
+                sol_decompression_recipient: None,
+                with_sol_pool: false,
+                packed_accounts: Some(packed_account_metas.to_vec()),
+            },
+            Transfer2Config::default().with_cpi_context(cpi_context, cpi_context_config),
+        )
     } else {
-        Transfer2AccountsMetaConfig::new(fee_payer, packed_account_metas.to_vec())
+        (
+            Transfer2AccountsMetaConfig::new(fee_payer, packed_account_metas.to_vec()),
+            Transfer2Config::default(),
+        )
     };
 
     // Create the transfer2 instruction with all CompressAndClose operations
     let inputs = Transfer2Inputs {
         meta_config,
         token_accounts,
-        //transfer_config: Transfer2Config::default()
-        //    .with_cpi_context(cpi_context_pubkey, cpi_context)
+        transfer_config,
         ..Default::default()
     };
 
@@ -226,7 +245,6 @@ pub fn compress_and_close_ctoken_accounts<'info>(
     fee_payer: Pubkey,
     with_rent_authority: bool,
     output_queue: AccountInfo<'info>,
-    cpi_context_pubkey: Option<Pubkey>,
     ctoken_solana_accounts: &[&AccountInfo<'info>],
     packed_accounts: &[AccountInfo<'info>],
 ) -> Result<Instruction, TokenSdkError> {
@@ -326,7 +344,7 @@ pub fn compress_and_close_ctoken_accounts<'info>(
     // Delegate to the with_indices version
     compress_and_close_ctoken_accounts_with_indices(
         fee_payer,
-        cpi_context_pubkey,
+        None,
         &indices_vec,
         packed_accounts_vec.as_slice(),
     )
@@ -361,7 +379,7 @@ impl AccountMetasVec for CompressAndCloseAccounts {
                 cpi_context: self.cpi_context,
                 ..Default::default()
             };
-            accounts.add_system_accounts(config)?;
+            accounts.add_system_accounts_small(config)?;
         }
         // Add both accounts in one operation for better performance
         accounts.pre_accounts.extend_from_slice(&[

sdk-libs/compressed-token-sdk/src/instructions/transfer2/instruction.rs

@@ -4,7 +4,6 @@ use light_ctoken_types::{
 };
 use light_profiler::profile;
 use solana_instruction::{AccountMeta, Instruction};
-use solana_msg::msg;
 use solana_pubkey::Pubkey;
 
 use crate::{
@@ -93,7 +92,6 @@ pub fn create_transfer2_instruction(inputs: Transfer2Inputs) -> Result<Instructi
             collected_compressions.push(*compression);
         }
         let (inputs, output) = token_account.into_inputs_and_outputs();
-        msg!("output {:?}", output);
         // Collect inputs directly (they're already in the right format)
         input_token_data_with_context.extend(inputs);
 
@@ -144,16 +142,6 @@ pub fn create_transfer2_instruction(inputs: Transfer2Inputs) -> Result<Instructi
         }
     }
 
-    // Moved assignment to account meta config
-    // Add tree accounts first
-    //for tree_pubkey in tree_pubkeys {
-    //     account_metas.push(AccountMeta::new(tree_pubkey, false));
-    // }
-    // Add packed accounts second
-    // for packed_pubkey in packed_pubkeys {
-    //     account_metas.push(AccountMeta::new(packed_pubkey, false));
-    // }
-    println!("account metas {:?}", account_metas);
     Ok(Instruction {
         program_id: Pubkey::from(COMPRESSED_TOKEN_PROGRAM_ID),
         accounts: account_metas,

sdk-libs/sdk-types/src/cpi_accounts_small.rs

@@ -57,6 +57,13 @@ impl<'a, T: AccountInfoTrait + Clone> CpiAccountsSmall<'a, T> {
             .ok_or(LightSdkTypesError::CpiAccountsIndexOutOfBounds(index))
     }
 
+    pub fn light_system_program(&self) -> Result<&'a T> {
+        let index = CompressionCpiAccountIndexSmall::LightSystemProgram as usize;
+        self.accounts
+            .get(index)
+            .ok_or(LightSdkTypesError::CpiAccountsIndexOutOfBounds(index))
+    }
+
     pub fn registered_program_pda(&self) -> Result<&'a T> {
         let index = CompressionCpiAccountIndexSmall::RegisteredProgramPda as usize;
         self.accounts

sdk-libs/token-client/src/instructions/create_mint.rs

@@ -43,7 +43,6 @@ pub async fn create_compressed_mint_instruction<R: Rpc + Indexer>(
 
     let output_queue = rpc.get_random_state_tree_info()?.queue;
 
-    // Derive compressed mint address using utility function
     let compressed_mint_address =
         derive_compressed_mint_address(&mint_seed.pubkey(), &address_tree_pubkey);
 

sdk-tests/sdk-token-test/src/lib.rs

@@ -6,9 +6,11 @@ use light_compressed_token_sdk::{instructions::Recipient, TokenAccountMeta, Vali
 use light_sdk::instruction::{PackedAddressTreeInfo, ValidityProof as LightValidityProof};
 
 mod ctoken_pda;
+pub mod mint_compressed_tokens_cpi_write;
 mod pda_ctoken;
 mod process_batch_compress_tokens;
 mod process_compress_and_close_cpi;
+mod process_compress_and_close_cpi_context;
 mod process_compress_and_close_cpi_indices;
 mod process_compress_full_and_close;
 mod process_compress_tokens;
@@ -63,7 +65,10 @@ use crate::{
     ctoken_pda::*, process_create_compressed_account::deposit_tokens,
     process_four_transfer2::FourTransfer2Params, process_update_deposit::process_update_deposit,
 };
-
+use crate::{
+    mint_compressed_tokens_cpi_write::MintCompressedTokensCpiWriteParams,
+    process_compress_and_close_cpi_context::process_compress_and_close_cpi_context,
+};
 #[program]
 pub mod sdk_token_test {
 
@@ -112,6 +117,20 @@ pub mod sdk_token_test {
         process_compress_and_close_cpi(ctx, with_rent_authority, system_accounts_offset)
     }
 
+    /// Process compress_and_close using the new CompressAndClose mode
+    /// Compress and close using the higher-level SDK function
+    /// This uses compress_and_close_ctoken_accounts which handles all index discovery
+    pub fn compress_and_close_cpi_with_cpi_context<'info>(
+        ctx: Context<'_, '_, '_, 'info, Generic<'info>>,
+        indices: Vec<
+            light_compressed_token_sdk::instructions::compress_and_close::CompressAndCloseIndices,
+        >,
+        system_accounts_offset: u8,
+        params: MintCompressedTokensCpiWriteParams,
+    ) -> Result<()> {
+        process_compress_and_close_cpi_context(ctx, indices, system_accounts_offset, params)
+    }
+
     /// Compress and close with manual indices
     /// This atomically compresses tokens and closes the account in a single instruction
     pub fn compress_and_close_cpi_indices<'info>(

sdk-tests/sdk-token-test/src/mint_compressed_tokens_cpi_write.rs

@@ -0,0 +1,77 @@
+use anchor_lang::{prelude::*, solana_program::program::invoke};
+use light_compressed_token_sdk::instructions::{
+    mint_action::{MintActionCpiWriteAccounts, MintActionType},
+    mint_action_cpi_write, MintActionInputsCpiWrite, MintToRecipient,
+};
+use light_ctoken_types::instructions::mint_action::CompressedMintWithContext;
+use light_sdk::cpi::CpiAccountsSmall;
+
+use crate::Generic;
+
+#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct MintCompressedTokensCpiWriteParams {
+    pub compressed_mint_with_context: CompressedMintWithContext,
+    pub recipients: Vec<MintToRecipient>,
+    pub cpi_context: light_ctoken_types::instructions::mint_action::CpiContext,
+    pub cpi_context_pubkey: Pubkey,
+}
+
+/// Process minting compressed tokens to an existing mint using CPI write
+/// This sets up the CPI context for subsequent operations
+pub fn process_mint_compressed_tokens_cpi_write<'info>(
+    ctx: &Context<'_, '_, '_, 'info, Generic<'info>>,
+    params: MintCompressedTokensCpiWriteParams,
+    token_program_cpi_authority: &AccountInfo<'info>,
+    cpi_accounts: &CpiAccountsSmall<'_, 'info>,
+) -> Result<()> {
+    msg!("Minting compressed tokens with CPI write");
+
+    let actions = vec![MintActionType::MintTo {
+        recipients: params.recipients,
+        lamports: None,
+        token_account_version: 2,
+    }];
+
+    let mint_action_inputs = MintActionInputsCpiWrite {
+        compressed_mint_inputs: params.compressed_mint_with_context,
+        mint_seed: None,    // Not needed for existing mint
+        mint_bump: None,    // Not needed for existing mint
+        create_mint: false, // Using existing mint
+        authority: ctx.accounts.signer.key(),
+        payer: ctx.accounts.signer.key(),
+        actions,
+        input_queue: None,
+        cpi_context: params.cpi_context,
+        cpi_context_pubkey: *cpi_accounts.cpi_context().unwrap().key,
+    };
+    msg!("mint_action_inputs {:?}", mint_action_inputs);
+
+    let mint_action_instruction = mint_action_cpi_write(mint_action_inputs).unwrap();
+
+    let mint_action_account_infos = MintActionCpiWriteAccounts {
+        light_system_program: cpi_accounts.light_system_program().unwrap(),
+        mint_signer: None, // No mint signer for existing mint
+        authority: ctx.accounts.signer.as_ref(),
+        fee_payer: ctx.accounts.signer.as_ref(),
+        cpi_authority_pda: token_program_cpi_authority,
+        cpi_context: cpi_accounts.cpi_context().unwrap(),
+        cpi_signer: crate::LIGHT_CPI_SIGNER,
+        recipient_token_accounts: vec![],
+    };
+    msg!(
+        "mint_action_account_infos.to_account_infos() {:?}",
+        mint_action_account_infos
+            .to_account_infos()
+            .iter()
+            .map(|x| x.key)
+            .collect::<Vec<_>>()
+    );
+    invoke(
+        &mint_action_instruction,
+        &mint_action_account_infos.to_account_infos(),
+    )?;
+
+    msg!("Minting completed, CPI context populated");
+
+    Ok(())
+}

sdk-tests/sdk-token-test/src/process_compress_and_close_cpi.rs

@@ -1,7 +1,7 @@
 use crate::OneCTokenAccount;
 use anchor_lang::{prelude::*, solana_program::program::invoke};
 use light_compressed_token_sdk::instructions::compress_and_close_ctoken_accounts;
-use light_sdk::cpi::CpiAccounts;
+use light_sdk::cpi::CpiAccountsSmall;
 use light_sdk_types::CpiAccountsConfig;
 
 /// Process compress_and_close operation using the higher-level compress_and_close_ctoken_accounts function
@@ -17,8 +17,11 @@ pub fn process_compress_and_close_cpi<'info>(
         .remaining_accounts
         .split_at(system_accounts_offset as usize);
 
-    let cpi_accounts =
-        CpiAccounts::new_with_config(ctx.accounts.signer.as_ref(), system_account_infos, config);
+    let cpi_accounts = CpiAccountsSmall::new_with_config(
+        ctx.accounts.signer.as_ref(),
+        system_account_infos,
+        config,
+    );
     // Use the higher-level compress_and_close_ctoken_accounts function
     // This function handles:
     // - Deserializing the compressed token accounts
@@ -29,9 +32,8 @@ pub fn process_compress_and_close_cpi<'info>(
         *ctx.accounts.signer.key,                          // fee_payer
         with_rent_authority, // whether to use rent authority from extension
         ctx.accounts.output_queue.to_account_info(), // output queue where compressed accounts will be stored
-        None, // cpi_context_pubkey (not used in this example)
         &[&ctx.accounts.ctoken_account.to_account_info()], // slice of ctoken account infos
-        cpi_accounts.tree_accounts().unwrap(), // packed accounts for the instruction
+        cpi_accounts.tree_accounts().unwrap(),       // packed accounts for the instruction
     )
     .map_err(|_| ProgramError::InvalidInstructionData)?;
 

sdk-tests/sdk-token-test/src/process_compress_and_close_cpi_context.rs

@@ -0,0 +1,70 @@
+use crate::{
+    mint_compressed_tokens_cpi_write::{
+        process_mint_compressed_tokens_cpi_write, MintCompressedTokensCpiWriteParams,
+    },
+    Generic,
+};
+use anchor_lang::{prelude::*, solana_program::program::invoke};
+use light_compressed_token_sdk::instructions::compress_and_close::{
+    compress_and_close_ctoken_accounts_with_indices, CompressAndCloseIndices,
+};
+use light_sdk_types::{CpiAccountsConfig, CpiAccountsSmall};
+
+/// Process compress_and_close operation using the new CompressAndClose mode with manual indices
+/// This combines token compression and account closure in a single atomic transaction
+pub fn process_compress_and_close_cpi_context<'info>(
+    ctx: Context<'_, '_, '_, 'info, Generic<'info>>,
+    indices: Vec<CompressAndCloseIndices>,
+    system_accounts_offset: u8,
+    params: MintCompressedTokensCpiWriteParams,
+) -> Result<()> {
+    // Parse CPI accounts following the established pattern
+    let config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
+    let (_token_account_infos, system_account_infos) = ctx
+        .remaining_accounts
+        .split_at(system_accounts_offset as usize);
+
+    let cpi_accounts = CpiAccountsSmall::new_with_config(
+        ctx.accounts.signer.as_ref(),
+        system_account_infos,
+        config,
+    );
+
+    process_mint_compressed_tokens_cpi_write(
+        &ctx,
+        params,
+        &_token_account_infos[1], // ctoken cpi authority
+        &cpi_accounts,
+    )?;
+
+    // Get the tree accounts (packed accounts) from CPI accounts
+    let packed_accounts = cpi_accounts
+        .tree_accounts()
+        .map_err(|e| ProgramError::Custom(e.into()))?;
+    msg!(
+        "packed_accounts {:?}",
+        packed_accounts
+            .iter()
+            .map(|x| { x.key })
+            .collect::<Vec<_>>()
+    );
+    // Use the SDK's compress_and_close function with the provided indices
+    let instruction = compress_and_close_ctoken_accounts_with_indices(
+        *ctx.accounts.signer.key,
+        Some(*cpi_accounts.cpi_context().unwrap().key), // Use the CPI context from params
+        &indices,
+        &packed_accounts[1..], // skip cpi context account
+    )
+    .map_err(ProgramError::from)?;
+
+    // Execute the single instruction that handles both compression and closure
+    let account_infos = [
+        &[cpi_accounts.fee_payer().clone()][..],
+        ctx.remaining_accounts,
+    ]
+    .concat();
+
+    invoke(&instruction, account_infos.as_slice())?;
+
+    Ok(())
+}

sdk-tests/sdk-token-test/src/process_compress_and_close_cpi_indices.rs

@@ -3,7 +3,7 @@ use anchor_lang::{prelude::*, solana_program::program::invoke};
 use light_compressed_token_sdk::instructions::compress_and_close::{
     compress_and_close_ctoken_accounts_with_indices, CompressAndCloseIndices,
 };
-use light_sdk::cpi::CpiAccounts;
+use light_sdk::cpi::CpiAccountsSmall;
 use light_sdk_types::CpiAccountsConfig;
 
 /// Process compress_and_close operation using the new CompressAndClose mode with manual indices
@@ -19,8 +19,11 @@ pub fn process_compress_and_close_cpi_indices<'info>(
         .remaining_accounts
         .split_at(system_accounts_offset as usize);
 
-    let cpi_accounts =
-        CpiAccounts::new_with_config(ctx.accounts.signer.as_ref(), system_account_infos, config);
+    let cpi_accounts = CpiAccountsSmall::new_with_config(
+        ctx.accounts.signer.as_ref(),
+        system_account_infos,
+        config,
+    );
 
     // Get the tree accounts (packed accounts) from CPI accounts
     let packed_accounts = cpi_accounts