decompress test works

Author: ananas-block

Cargo.lock

@@ -34,24 +34,12 @@ pub mod sdk_token_test {
             ctx.accounts.signer.as_ref(),
             ctx.remaining_accounts,
         );
-        msg!(
-            "light_cpi_accounts config {:?}",
-            light_cpi_accounts.config()
-        );
-        msg!(
-            "light_cpi_accounts config is_compress_or_decompress {:?}",
-            light_cpi_accounts.config().is_compress_or_decompress()
-        );
-        msg!(
-            "ctx.remaining_accounts len {:?}",
-            ctx.remaining_accounts.len()
-        );
+
         // TODO: add to program error conversion
         let instruction =
             create_compressed_token_instruction(cpi_inputs, &light_cpi_accounts).unwrap();
         let account_infos = light_cpi_accounts.to_account_infos();
-        msg!("account_infos {:?}", account_infos);
-        msg!("instruction {:?}", instruction);
+
         invoke(&instruction, account_infos.as_slice())?;
 
         Ok(())
@@ -85,7 +73,7 @@ pub mod sdk_token_test {
         // TODO: add to program error conversion
         let instruction =
             create_compressed_token_instruction(cpi_inputs, &light_cpi_accounts).unwrap();
-        msg!("instruction created {:?}", instruction);
+
         let account_infos = light_cpi_accounts.to_account_infos();
 
         // TODO: make invoke_signed
@@ -120,8 +108,7 @@ pub mod sdk_token_test {
         let instruction =
             create_compressed_token_instruction(cpi_inputs, &light_cpi_accounts).unwrap();
         let account_infos = light_cpi_accounts.to_account_infos();
-        msg!("account_infos {:?}", account_infos);
-        msg!("instruction {:?}", instruction);
+
         // TODO: make invoke_signed
         invoke(&instruction, account_infos.as_slice())?;
 

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

@@ -180,7 +180,99 @@ async fn test() {
     assert_eq!(recipient_amount, transfer_amount);
     println!("Verified recipient balance: {}", recipient_amount);
 
-    println!("Compression and transfer test completed successfully!");
+    // Now decompress some tokens from the recipient back to SPL token account
+    let decompress_token_account_keypair = Keypair::new();
+    let decompress_amount = 10; // Decompress a small amount
+    rpc.airdrop_lamports(&transfer_recipient.pubkey(), 10_000_000_000)
+        .await
+        .unwrap();
+    // Create a new SPL token account for decompression
+    create_token_account(
+        &mut rpc,
+        &mint_pubkey,
+        &decompress_token_account_keypair,
+        &transfer_recipient,
+    )
+    .await
+    .unwrap();
+
+    println!(
+        "Created decompress token account: {}",
+        decompress_token_account_keypair.pubkey()
+    );
+
+    // Get the recipient's compressed token account after transfer
+    let recipient_compressed_accounts = rpc
+        .indexer()
+        .unwrap()
+        .get_compressed_token_accounts_by_owner(&transfer_recipient.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    let recipient_compressed_account = &recipient_compressed_accounts[0];
+
+    // Decompress tokens from recipient's compressed account to SPL token account
+    decompress_compressed_tokens(
+        &mut rpc,
+        &transfer_recipient,
+        recipient_compressed_account,
+        decompress_token_account_keypair.pubkey(),
+        decompress_amount,
+    )
+    .await
+    .unwrap();
+
+    println!(
+        "Decompressed {} tokens from recipient successfully",
+        decompress_amount
+    );
+
+    // Verify the decompression worked
+    let decompress_token_account_data = rpc
+        .get_account(decompress_token_account_keypair.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+
+    let decompress_token_account =
+        TokenAccount::try_deserialize(&mut decompress_token_account_data.data.as_slice()).unwrap();
+
+    // Assert the SPL token account has the decompressed amount
+    assert_eq!(decompress_token_account.amount, decompress_amount);
+    assert_eq!(decompress_token_account.mint, mint_pubkey);
+    assert_eq!(decompress_token_account.owner, transfer_recipient.pubkey());
+
+    println!(
+        "Verified SPL token account after decompression: amount={}",
+        decompress_token_account.amount
+    );
+
+    // Verify the compressed account balance was reduced
+    let updated_recipient_accounts = rpc
+        .indexer()
+        .unwrap()
+        .get_compressed_token_accounts_by_owner(&transfer_recipient.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    if !updated_recipient_accounts.is_empty() {
+        let updated_recipient_account = &updated_recipient_accounts[0];
+        let remaining_compressed_amount = updated_recipient_account.token.amount;
+        assert_eq!(
+            remaining_compressed_amount,
+            transfer_amount - decompress_amount
+        );
+        println!(
+            "Verified remaining compressed balance: {}",
+            remaining_compressed_amount
+        );
+    }
+
+    println!("Compression, transfer, and decompress test completed successfully!");
 }
 
 async fn compress_spl_tokens(
@@ -193,13 +285,7 @@ async fn compress_spl_tokens(
 ) -> Result<Signature, RpcError> {
     let mut remaining_accounts = PackedAccounts::default();
     let token_pool_pda = get_token_pool_pda(&mint);
-    let config = TokenAccountsMetaConfig::compress(
-        payer.pubkey(),
-        payer.pubkey(),
-        token_pool_pda,
-        token_account,
-        false,
-    );
+    let config = TokenAccountsMetaConfig::compress(token_pool_pda, token_account, false);
     remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
     let metas = get_transfer_instruction_account_metas(config);
     println!("metas {:?}", metas.to_vec());
@@ -238,7 +324,7 @@ async fn transfer_compressed_tokens(
     compressed_account: &CompressedTokenAccount,
 ) -> Result<Signature, RpcError> {
     let mut remaining_accounts = PackedAccounts::default();
-    let config = TokenAccountsMetaConfig::new(payer.pubkey(), payer.pubkey());
+    let config = TokenAccountsMetaConfig::new();
     remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
     let metas = get_transfer_instruction_account_metas(config);
     remaining_accounts.add_pre_accounts_metas(metas.as_slice());
@@ -297,3 +383,72 @@ async fn transfer_compressed_tokens(
     rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
         .await
 }
+
+async fn decompress_compressed_tokens(
+    rpc: &mut LightProgramTest,
+    payer: &Keypair,
+    compressed_account: &CompressedTokenAccount,
+    decompress_token_account: Pubkey,
+    decompress_amount: u64,
+) -> Result<Signature, RpcError> {
+    let mut remaining_accounts = PackedAccounts::default();
+    let token_pool_pda = get_token_pool_pda(&compressed_account.token.mint);
+    let config =
+        TokenAccountsMetaConfig::decompress(token_pool_pda, decompress_token_account, false);
+    remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
+    let metas = get_transfer_instruction_account_metas(config);
+    remaining_accounts.add_pre_accounts_metas(metas.as_slice());
+
+    // Get validity proof from RPC
+    let rpc_result = rpc
+        .get_validity_proof(vec![compressed_account.account.hash], vec![], None)
+        .await?
+        .value;
+
+    let packed_tree_info = rpc_result.pack_tree_infos(&mut remaining_accounts);
+    let output_tree_index = packed_tree_info
+        .state_trees
+        .as_ref()
+        .unwrap()
+        .output_tree_index;
+
+    // Use the tree info from the validity proof result
+    let tree_info = packed_tree_info
+        .state_trees
+        .as_ref()
+        .unwrap()
+        .packed_tree_infos[0];
+
+    // Create input token data
+    let token_data = vec![InputTokenDataWithContext {
+        amount: compressed_account.token.amount,
+        delegate_index: None,
+        merkle_context: PackedMerkleContext {
+            merkle_tree_pubkey_index: tree_info.merkle_tree_pubkey_index,
+            nullifier_queue_pubkey_index: tree_info.queue_pubkey_index,
+            leaf_index: tree_info.leaf_index,
+            proof_by_index: tree_info.prove_by_index,
+        },
+        root_index: tree_info.root_index,
+        lamports: None,
+        tlv: None,
+    }];
+
+    let (remaining_accounts, _, _) = remaining_accounts.to_account_metas();
+    println!(" remaining_accounts: {:?}", remaining_accounts);
+
+    let instruction = Instruction {
+        program_id: sdk_token_test::ID,
+        accounts: [remaining_accounts].concat(),
+        data: sdk_token_test::instruction::Decompress {
+            validity_proof: rpc_result.proof,
+            token_data,
+            output_tree_index,
+            mint: compressed_account.token.mint,
+        }
+        .data(),
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
+        .await
+}

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

@@ -4,9 +4,6 @@ use crate::error::TokenSdkError;
 use light_compressed_token_types::{InputTokenDataWithContext, PackedTokenTransferOutputData};
 use solana_pubkey::Pubkey;
 
-/// Compress, decompress, new
-/// Questions:
-/// 1. do we need to implement compress?
 #[derive(Debug, PartialEq, Clone)]
 pub struct CTokenAccount {
     inputs: Vec<InputTokenDataWithContext>,
@@ -137,6 +134,10 @@ impl CTokenAccount {
         self.compression_amount
     }
 
+    pub fn owner(&self) -> Pubkey {
+        Pubkey::new_from_array(self.owner)
+    }
+
     /// Consumes token account for instruction creation.
     pub fn into_inputs_and_outputs(
         self,
@@ -146,23 +147,6 @@ impl CTokenAccount {
     ) {
         (self.inputs, self.output)
     }
-
-    //     /// 1. Serializes the account data and sets the output data hash.
-    //     /// 2. Returns CompressedAccountInfo.
-    //     ///
-    //     /// Note this is an expensive operation
-    //     /// that should only be called once per instruction.
-    //     pub fn to_account_info(mut self) -> Result<CompressedAccountInfo, LightSdkError> {
-    //         if let Some(output) = self.account_info.output.as_mut() {
-    //             output.data_hash = self.account.hash::<Poseidon>()?;
-    //             output.data = self
-    //                 .account
-    //                 .try_to_vec()
-    //                 .map_err(|_| LightSdkError::Borsh)?;
-    //         }
-    //         Ok(self.account_info)
-    //     }
-    // }
 }
 
 impl Deref for CTokenAccount {

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

@@ -7,7 +7,6 @@ use light_compressed_token_types::{
 };
 use solana_account_info::AccountInfo;
 use solana_instruction::Instruction;
-use solana_msg::msg;
 use solana_pubkey::Pubkey;
 
 use crate::{
@@ -18,12 +17,25 @@ use crate::{
 };
 
 /// CPI inputs for compressed token operations
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct CpiInputs {
     pub token_accounts: Vec<CTokenAccount>,
     pub validity_proof: ValidityProof,
     pub cpi_context: Option<CompressedCpiContext>,
     pub with_transaction_hash: bool,
+    pub filter_zero_amount_outputs: bool,
+}
+
+impl Default for CpiInputs {
+    fn default() -> Self {
+        Self {
+            token_accounts: Vec::new(),
+            validity_proof: ValidityProof::default(),
+            cpi_context: None,
+            with_transaction_hash: false,
+            filter_zero_amount_outputs: true,
+        }
+    }
 }
 
 impl CpiInputs {
@@ -59,6 +71,7 @@ pub fn create_compressed_token_instruction(
         .token_accounts
         .iter()
         .any(|acc| acc.is_decompress());
+
     let mint = *cpi_inputs.token_accounts[0].mint();
     let mut compress_or_decompress_amount: Option<u64> = None;
     for acc in cpi_inputs.token_accounts.iter() {
@@ -96,14 +109,12 @@ pub fn create_compressed_token_instruction(
     for token_account in cpi_inputs.token_accounts {
         let (inputs, output) = token_account.into_inputs_and_outputs();
         input_token_data_with_context.extend(inputs);
-        output_compressed_accounts.push(output);
+        if output.amount == 0 && cpi_inputs.filter_zero_amount_outputs {
+        } else {
+            output_compressed_accounts.push(output);
+        }
     }
-    msg!("inputs {:?}", input_token_data_with_context);
-    msg!("outputs {:?}", output_compressed_accounts);
-    msg!(
-        "compress_or_decompress_amount {:?}",
-        compress_or_decompress_amount
-    );
+
     // Create instruction data
     let instruction_data = CompressedTokenInstructionDataTransfer {
         proof: cpi_inputs.validity_proof.into(),
@@ -117,7 +128,7 @@ pub fn create_compressed_token_instruction(
         delegated_transfer: None, // TODO: support in separate pr
         lamports_change_account_merkle_tree_index: None, // TODO: support in separate pr
     };
-    msg!("instruction_data {:?}", instruction_data);
+
     // TODO: calculate exact len.
     let serialized = instruction_data
         .try_to_vec()