batch compress metas tested

Author: ananas-block

sdk-libs/compressed-token-sdk/src/instructions/batch_compress/account_metas.rs

@@ -4,67 +4,90 @@ use solana_pubkey::Pubkey;
 use crate::instructions::CTokenDefaultAccounts;
 
 /// Account metadata configuration for batch compress instruction
-#[derive(Debug, Default, Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct BatchCompressMetaConfig {
     pub fee_payer: Option<Pubkey>,
     pub authority: Option<Pubkey>,
-    pub token_pool_pda: Option<Pubkey>,
-    pub sender_token_account: Option<Pubkey>,
-    pub token_program: Option<Pubkey>,
-    pub merkle_tree: Option<Pubkey>,
+    pub token_pool_pda: Pubkey,
+    pub sender_token_account: Pubkey,
+    pub token_program: Pubkey,
+    pub merkle_tree: Pubkey,
     pub sol_pool_pda: Option<Pubkey>,
 }
 
 impl BatchCompressMetaConfig {
+    /// Create a new BatchCompressMetaConfig for direct invocation
     pub fn new(
         fee_payer: Pubkey,
         authority: Pubkey,
         token_pool_pda: Pubkey,
         sender_token_account: Pubkey,
         token_program: Pubkey,
         merkle_tree: Pubkey,
+        with_lamports: bool,
     ) -> Self {
+        let sol_pool_pda = if with_lamports {
+            unimplemented!("TODO hardcode sol pool pda")
+        } else {
+            None
+        };
         Self {
             fee_payer: Some(fee_payer),
             authority: Some(authority),
-            token_pool_pda: Some(token_pool_pda),
-            sender_token_account: Some(sender_token_account),
-            token_program: Some(token_program),
-            merkle_tree: Some(merkle_tree),
-            sol_pool_pda: None,
+            token_pool_pda,
+            sender_token_account,
+            token_program,
+            merkle_tree,
+            sol_pool_pda,
         }
     }
 
+    /// Create a new BatchCompressMetaConfig for client-side (CPI) usage
     pub fn new_client(
         token_pool_pda: Pubkey,
         sender_token_account: Pubkey,
         token_program: Pubkey,
         merkle_tree: Pubkey,
+        with_lamports: bool,
     ) -> Self {
+        let sol_pool_pda = if with_lamports {
+            unimplemented!("TODO hardcode sol pool pda")
+        } else {
+            None
+        };
         Self {
             fee_payer: None,
             authority: None,
-            token_pool_pda: Some(token_pool_pda),
-            sender_token_account: Some(sender_token_account),
-            token_program: Some(token_program),
-            merkle_tree: Some(merkle_tree),
-            sol_pool_pda: None,
+            token_pool_pda,
+            sender_token_account,
+            token_program,
+            merkle_tree,
+            sol_pool_pda,
         }
     }
-
-    pub fn with_sol_pool_pda(mut self, sol_pool_pda: Pubkey) -> Self {
-        self.sol_pool_pda = Some(sol_pool_pda);
-        self
-    }
 }
 
 /// Get the standard account metas for a batch compress instruction
 /// Matches the MintToInstruction account structure used by batch_compress
-pub fn get_batch_compress_instruction_account_metas(config: BatchCompressMetaConfig) -> Vec<AccountMeta> {
+pub fn get_batch_compress_instruction_account_metas(
+    config: BatchCompressMetaConfig,
+) -> Vec<AccountMeta> {
     let default_pubkeys = CTokenDefaultAccounts::default();
-    
+
+    // Calculate capacity based on whether fee_payer is provided
+    // Base accounts:   cpi_authority_pda + token_pool_pda + token_program + light_system_program +
+    //                  registered_program_pda + noop_program + account_compression_authority +
+    //                  account_compression_program + merkle_tree +
+    //                  self_program + system_program
+    let base_capacity = 10;
+
+    // Direct invoke accounts: fee_payer + authority + mint_placeholder + sol_pool_pda_or_placeholder
+    let fee_payer_capacity = if config.fee_payer.is_some() { 4 } else { 0 };
+
+    let total_capacity = base_capacity + fee_payer_capacity;
+
     // Start building the account metas to match MintToInstruction structure
-    let mut metas = Vec::new();
+    let mut metas = Vec::with_capacity(total_capacity);
 
     // Add fee_payer and authority if provided (for direct invoke)
     if let Some(fee_payer) = config.fee_payer {
@@ -78,51 +101,79 @@ pub fn get_batch_compress_instruction_account_metas(config: BatchCompressMetaCon
     }
 
     // cpi_authority_pda
-    metas.push(AccountMeta::new_readonly(default_pubkeys.cpi_authority_pda, false));
-    
-    // mint: Option<UncheckedAccount> - None for batch_compress, so we skip this account
-    
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.cpi_authority_pda,
+        false,
+    ));
+
+    // mint: Option<UncheckedAccount> - Always None for batch_compress, so we add a placeholder
+    if config.fee_payer.is_some() {
+        metas.push(AccountMeta::new_readonly(
+            default_pubkeys.compressed_token_program,
+            false,
+        ));
+    }
+
     // token_pool_pda (mut)
-    let token_pool_pda = config.token_pool_pda.expect("Missing token_pool_pda");
-    metas.push(AccountMeta::new(token_pool_pda, false));
-    
+    metas.push(AccountMeta::new(config.token_pool_pda, false));
+
     // token_program
-    let token_program = config.token_program.expect("Missing token_program");
-    metas.push(AccountMeta::new_readonly(token_program, false));
-    
+    metas.push(AccountMeta::new_readonly(config.token_program, false));
+
     // light_system_program
-    metas.push(AccountMeta::new_readonly(default_pubkeys.light_system_program, false));
-    
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.light_system_program,
+        false,
+    ));
+
     // registered_program_pda
-    metas.push(AccountMeta::new_readonly(default_pubkeys.registered_program_pda, false));
-    
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.registered_program_pda,
+        false,
+    ));
+
     // noop_program
-    metas.push(AccountMeta::new_readonly(default_pubkeys.noop_program, false));
-    
-    // account_compression_authority 
-    metas.push(AccountMeta::new_readonly(default_pubkeys.account_compression_authority, false));
-    
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.noop_program,
+        false,
+    ));
+
+    // account_compression_authority
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.account_compression_authority,
+        false,
+    ));
+
     // account_compression_program
-    metas.push(AccountMeta::new_readonly(default_pubkeys.account_compression_program, false));
-    
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.account_compression_program,
+        false,
+    ));
+
     // merkle_tree (mut)
-    let merkle_tree = config.merkle_tree.expect("Missing merkle_tree");
-    metas.push(AccountMeta::new(merkle_tree, false));
-    
+    metas.push(AccountMeta::new(config.merkle_tree, false));
+
     // self_program (compressed token program)
-    metas.push(AccountMeta::new_readonly(default_pubkeys.self_program, false));
-    
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.self_program,
+        false,
+    ));
+
     // system_program
-    metas.push(AccountMeta::new_readonly(default_pubkeys.system_program, false));
-    
-    // sol_pool_pda (optional, mut)
+    metas.push(AccountMeta::new_readonly(
+        default_pubkeys.system_program,
+        false,
+    ));
+
+    // sol_pool_pda (optional, mut) - add placeholder if None but fee_payer is present
     if let Some(sol_pool_pda) = config.sol_pool_pda {
         metas.push(AccountMeta::new(sol_pool_pda, false));
+    } else if config.fee_payer.is_some() {
+        metas.push(AccountMeta::new_readonly(
+            default_pubkeys.compressed_token_program,
+            false,
+        ));
     }
-    
-    // Remaining accounts: sender_token_account (first remaining account for batch_compress)
-    let sender_token_account = config.sender_token_account.expect("Missing sender_token_account");
-    metas.push(AccountMeta::new(sender_token_account, false));
 
     metas
 }

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

@@ -1,67 +1,73 @@
-use crate::{
-    account::CTokenAccount,
-    error::{Result, TokenSdkError},
-    instructions::transfer::account_metas::{
-        get_transfer_instruction_account_metas, TokenAccountsMetaConfig,
-    },
-    AnchorSerialize,
-};
-use light_compressed_token_types::{BatchCompressInstructionData, BATCH_COMPRESS};
+use borsh::BorshSerialize;
 use solana_instruction::Instruction;
 use solana_pubkey::Pubkey;
-#[derive()]
+
+use crate::error::{Result, TokenSdkError};
+use crate::instructions::batch_compress::account_metas::{BatchCompressMetaConfig, get_batch_compress_instruction_account_metas};
+use light_compressed_token_types::instruction::batch_compress::BatchCompressInstructionData;
+
+#[derive(Debug, Clone)]
 pub struct Recipient {
     pub pubkey: Pubkey,
     pub amount: u64,
 }
 
-pub struct CompressInputs {
+#[derive(Debug, Clone)]
+pub struct BatchCompressInputs {
     pub fee_payer: Pubkey,
     pub authority: Pubkey,
-    pub mint: Pubkey,
-    pub recipient: Pubkey,
+    pub token_pool_pda: Pubkey,
     pub sender_token_account: Pubkey,
+    pub token_program: Pubkey,
+    pub merkle_tree: Pubkey,
     pub recipients: Vec<Recipient>,
-    pub output_queue_pubkey: Pubkey,
-    pub token_pool_pda: Pubkey,
-    pub spl_token_program: Pubkey,
     pub lamports: Option<u64>,
+    pub token_pool_index: u8,
     pub token_pool_bump: u8,
+    pub sol_pool_pda: Option<Pubkey>,
 }
 
-pub fn batch_compress(inputs: CompressInputs) -> Result<Instruction> {
+pub fn create_batch_compress_instruction(inputs: BatchCompressInputs) -> Result<Instruction> {
     let mut pubkeys = Vec::with_capacity(inputs.recipients.len());
     let mut amounts = Vec::with_capacity(inputs.recipients.len());
+    
     inputs.recipients.iter().for_each(|recipient| {
         pubkeys.push(recipient.pubkey.to_bytes());
         amounts.push(recipient.amount);
     });
+
     // Create instruction data
     let instruction_data = BatchCompressInstructionData {
         pubkeys,
         amounts: Some(amounts),
         amount: None,
-        index: 0,
+        index: inputs.token_pool_index,
         lamports: inputs.lamports,
         bump: inputs.token_pool_bump,
     };
 
-    // TODO: calculate exact len.
-    let serialized = instruction_data
+    // Serialize instruction data  
+    let serialized_data = instruction_data
         .try_to_vec()
         .map_err(|_| TokenSdkError::SerializationError)?;
 
-    // Serialize instruction data
-    let mut data = Vec::with_capacity(8 + 4 + serialized.len()); // rough estimate
-    data.extend_from_slice(&BATCH_COMPRESS);
-    data.extend(u32::try_from(serialized.len()).unwrap().to_le_bytes());
-    data.extend(serialized);
-    solana_msg::msg!("meta config1 {:?}", meta_config);
-    let mut account_metas = get_transfer_instruction_account_metas(meta_config);
+    // Create account meta config for batch_compress (uses MintToInstruction accounts)
+    let meta_config = BatchCompressMetaConfig {
+        fee_payer: Some(inputs.fee_payer),
+        authority: Some(inputs.authority),
+        token_pool_pda: inputs.token_pool_pda,
+        sender_token_account: inputs.sender_token_account,
+        token_program: inputs.token_program,
+        merkle_tree: inputs.merkle_tree,
+        sol_pool_pda: inputs.sol_pool_pda,
+    };
+
+    // Get account metas that match MintToInstruction structure
+    let account_metas = get_batch_compress_instruction_account_metas(meta_config);
 
     Ok(Instruction {
-        program_id: Pubkey::from(COMPRESSED_TOKEN_PROGRAM_ID),
+        program_id: Pubkey::new_from_array(light_compressed_token_types::PROGRAM_ID),
         accounts: account_metas,
-        data,
+        data: serialized_data,
     })
 }

sdk-libs/compressed-token-sdk/src/instructions/batch_compress/mod.rs

@@ -2,4 +2,4 @@ pub mod account_metas;
 pub mod instruction;
 
 pub use account_metas::{BatchCompressMetaConfig, get_batch_compress_instruction_account_metas};
-pub use instruction::{BatchCompressConfig, create_batch_compress_instruction};
+pub use instruction::{Recipient, BatchCompressInputs, create_batch_compress_instruction};