stash approve impl, refactored account_infos to be more generic

Author: ananas-block

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

@@ -1,21 +1,25 @@
 #![allow(unexpected_cfgs)]
 
 use anchor_lang::{prelude::*, solana_program::program::invoke, Discriminator};
+use light_compressed_token_sdk::instructions::transfer::instruction::DecompressInputs;
+use light_compressed_token_sdk::instructions::Recipient;
 use light_compressed_token_sdk::{
     account::CTokenAccount,
-    cpi_account_infos::TransferAccountInfos,
-    instructions::transfer::instruction::{
-        compress, decompress, transfer, CompressInputs, TransferInputs,
+    instructions::{
+        batch_compress::{create_batch_compress_instruction, BatchCompressInputs},
+        transfer::{
+            instruction::{compress, decompress, transfer, CompressInputs, TransferInputs},
+            TransferAccountInfos,
+        },
     },
     TokenAccountMeta, ValidityProof,
 };
+
 declare_id!("5p1t1GAaKtK1FKCh5Hd2Gu8JCu3eREhJm4Q2qYfTEPYK");
 
 #[program]
 pub mod sdk_token_test {
 
-    use light_compressed_token_sdk::instructions::transfer::instruction::DecompressInputs;
-
     use super::*;
 
     pub fn compress_tokens<'info>(
@@ -137,6 +141,57 @@ pub mod sdk_token_test {
 
         Ok(())
     }
+
+    pub fn batch_compress_tokens<'info>(
+        ctx: Context<'_, '_, '_, 'info, Generic<'info>>,
+        recipients: Vec<Recipient>,
+        _output_tree_index: u8,
+        _mint: Pubkey,
+        token_pool_index: u8,
+        token_pool_bump: u8,
+    ) -> Result<()> {
+        let light_cpi_accounts = TransferAccountInfos::new_compress(
+            ctx.accounts.signer.as_ref(),
+            ctx.accounts.signer.as_ref(),
+            ctx.remaining_accounts,
+        );
+
+        // Convert local Recipient to SDK Recipient
+        let sdk_recipients: Vec<
+            light_compressed_token_sdk::instructions::batch_compress::Recipient,
+        > = recipients
+            .into_iter()
+            .map(
+                |r| light_compressed_token_sdk::instructions::batch_compress::Recipient {
+                    pubkey: r.pubkey,
+                    amount: r.amount,
+                },
+            )
+            .collect();
+
+        let batch_compress_inputs = BatchCompressInputs {
+            fee_payer: *ctx.accounts.signer.key,
+            authority: *ctx.accounts.signer.key,
+            token_pool_pda: *light_cpi_accounts.token_pool_pda().unwrap().key,
+            sender_token_account: *light_cpi_accounts.sender_token_account().unwrap().key,
+            token_program: *light_cpi_accounts.spl_token_program().unwrap().key,
+            merkle_tree: *light_cpi_accounts.tree_accounts().unwrap()[0].key,
+            recipients: sdk_recipients,
+            lamports: None,
+            token_pool_index,
+            token_pool_bump,
+            sol_pool_pda: None,
+        };
+
+        let instruction =
+            create_batch_compress_instruction(batch_compress_inputs).map_err(ProgramError::from)?;
+        msg!("batch compress instruction {:?}", instruction);
+        let account_infos = light_cpi_accounts.to_account_infos();
+
+        invoke(&instruction, account_infos.as_slice())?;
+
+        Ok(())
+    }
 }
 
 #[derive(Accounts)]

program-tests/sdk-token-test/tests/test.rs

@@ -3,8 +3,13 @@
 use anchor_lang::{AccountDeserialize, InstructionData};
 use anchor_spl::token::TokenAccount;
 use light_compressed_token_sdk::{
-    instructions::transfer::account_metas::{
-        get_transfer_instruction_account_metas, TokenAccountsMetaConfig,
+    instructions::{
+        batch_compress::{
+            get_batch_compress_instruction_account_metas, BatchCompressMetaConfig, Recipient,
+        },
+        transfer::account_metas::{
+            get_transfer_instruction_account_metas, TokenAccountsMetaConfig,
+        },
     },
     token_pool::get_token_pool_pda,
     TokenAccountMeta, SPL_TOKEN_PROGRAM_ID,
@@ -447,3 +452,170 @@ async fn decompress_compressed_tokens(
     rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
         .await
 }
+
+#[tokio::test]
+async fn test_batch_compress() {
+    // Initialize the test environment
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(
+        false,
+        Some(vec![("sdk_token_test", sdk_token_test::ID)]),
+    ))
+    .await
+    .unwrap();
+
+    let payer = rpc.get_payer().insecure_clone();
+
+    // Create a mint
+    let mint_pubkey = create_mint_helper(&mut rpc, &payer).await;
+    println!("Created mint: {}", mint_pubkey);
+
+    // Create a token account
+    let token_account_keypair = Keypair::new();
+
+    create_token_account(&mut rpc, &mint_pubkey, &token_account_keypair, &payer)
+        .await
+        .unwrap();
+
+    println!("Created token account: {}", token_account_keypair.pubkey());
+
+    // Mint some tokens to the account
+    let mint_amount = 2_000_000; // 2000 tokens with 6 decimals
+
+    mint_spl_tokens(
+        &mut rpc,
+        &mint_pubkey,
+        &token_account_keypair.pubkey(),
+        &payer.pubkey(), // owner
+        &payer,          // mint authority
+        mint_amount,
+        false, // not token22
+    )
+    .await
+    .unwrap();
+
+    println!("Minted {} tokens to account", mint_amount);
+
+    // Create multiple recipients for batch compression
+    let recipient1 = Keypair::new().pubkey();
+    let recipient2 = Keypair::new().pubkey();
+    let recipient3 = Keypair::new().pubkey();
+
+    let recipients = vec![
+        Recipient {
+            pubkey: recipient1,
+            amount: 100_000,
+        },
+        Recipient {
+            pubkey: recipient2,
+            amount: 200_000,
+        },
+        Recipient {
+            pubkey: recipient3,
+            amount: 300_000,
+        },
+    ];
+
+    let total_batch_amount: u64 = recipients.iter().map(|r| r.amount).sum();
+
+    // Perform batch compression
+    batch_compress_spl_tokens(
+        &mut rpc,
+        &payer,
+        recipients,
+        mint_pubkey,
+        token_account_keypair.pubkey(),
+    )
+    .await
+    .unwrap();
+
+    println!(
+        "Batch compressed {} tokens to {} recipients successfully",
+        total_batch_amount, 3
+    );
+
+    // Verify each recipient received their compressed tokens
+    for (i, recipient) in [recipient1, recipient2, recipient3].iter().enumerate() {
+        let compressed_accounts = rpc
+            .indexer()
+            .unwrap()
+            .get_compressed_token_accounts_by_owner(recipient, None, None)
+            .await
+            .unwrap()
+            .value
+            .items;
+
+        assert!(
+            !compressed_accounts.is_empty(),
+            "Recipient {} should have compressed tokens",
+            i + 1
+        );
+
+        let compressed_account = &compressed_accounts[0];
+        assert_eq!(compressed_account.token.owner, *recipient);
+        assert_eq!(compressed_account.token.mint, mint_pubkey);
+
+        let expected_amount = match i {
+            0 => 100_000,
+            1 => 200_000,
+            2 => 300_000,
+            _ => unreachable!(),
+        };
+        assert_eq!(compressed_account.token.amount, expected_amount);
+
+        println!(
+            "Verified recipient {} received {} compressed tokens",
+            i + 1,
+            compressed_account.token.amount
+        );
+    }
+
+    println!("Batch compression test completed successfully!");
+}
+
+async fn batch_compress_spl_tokens(
+    rpc: &mut LightProgramTest,
+    payer: &Keypair,
+    recipients: Vec<Recipient>,
+    mint: Pubkey,
+    token_account: Pubkey,
+) -> Result<Signature, RpcError> {
+    let mut remaining_accounts = PackedAccounts::default();
+    let token_pool_pda = get_token_pool_pda(&mint);
+    println!("token_pool_pda {:?}", token_pool_pda);
+    // Use batch compress account metas
+    let config = BatchCompressMetaConfig::new_client(
+        token_pool_pda,
+        token_account,
+        SPL_TOKEN_PROGRAM_ID.into(),
+        rpc.get_random_state_tree_info().unwrap().tree,
+        false, // with_lamports
+    );
+
+    remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
+    let metas = get_batch_compress_instruction_account_metas(config);
+    remaining_accounts.add_pre_accounts_metas(metas.as_slice());
+
+    let output_tree_index = rpc
+        .get_random_state_tree_info()
+        .unwrap()
+        .pack_output_tree_index(&mut remaining_accounts)
+        .unwrap();
+
+    let (remaining_accounts, _, _) = remaining_accounts.to_account_metas();
+
+    let instruction = Instruction {
+        program_id: sdk_token_test::ID,
+        accounts: [remaining_accounts].concat(),
+        data: sdk_token_test::instruction::BatchCompressTokens {
+            recipients,
+            _output_tree_index: output_tree_index,
+            _mint: mint,
+            token_pool_index: 0,  // Default pool index
+            token_pool_bump: 255, // Default bump
+        }
+        .data(),
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
+        .await
+}

sdk-libs/compressed-token-sdk/src/account.rs

@@ -93,6 +93,45 @@ impl CTokenAccount {
         })
     }
 
+    /// Approves a delegate for a specified amount of tokens.
+    /// Similar to transfer, this deducts the amount from the current account
+    /// and returns a new CTokenAccount that represents the delegated portion.
+    /// The original account balance is reduced by the delegated amount.
+    pub fn approve(
+        &mut self,
+        _delegate: &Pubkey,
+        amount: u64,
+        output_merkle_tree_index: Option<u8>,
+    ) -> Result<Self, TokenSdkError> {
+        if amount > self.output.amount {
+            return Err(TokenSdkError::InsufficientBalance);
+        }
+        
+        // Deduct the delegated amount from current account
+        self.output.amount -= amount;
+        let merkle_tree_index = output_merkle_tree_index.unwrap_or(self.output.merkle_tree_index);
+
+        self.method_used = true;
+        
+        // Create a new delegated account with the specified delegate
+        // Note: In the actual instruction, this will create the proper delegation structure
+        Ok(Self {
+            compression_amount: None,
+            is_compress: false,
+            is_decompress: false,
+            inputs: vec![],
+            output: PackedTokenTransferOutputData {
+                owner: self.output.owner,  // Owner remains the same, but delegate is set
+                amount,
+                lamports: None,
+                tlv: None,
+                merkle_tree_index,
+            },
+            mint: self.mint,
+            method_used: true,
+        })
+    }
+
     // TODO: consider this might be confusing because it must not be used in combination with fn compress()
     pub fn compress(&mut self, amount: u64) -> Result<(), TokenSdkError> {
         self.output.amount += amount;