compress works

Author: ananas-block

Cargo.lock

@@ -20,9 +20,6 @@ pub mod sdk_token_test {
         mint: Pubkey,      // TODO: deserialize from token account.
         amount: u64,
     ) -> Result<()> {
-        let light_cpi_accounts =
-            CpiAccounts::new(ctx.accounts.signer.as_ref(), ctx.remaining_accounts);
-
         let mut token_account = light_compressed_token_sdk::account::CTokenAccount::new_empty(
             mint,
             recipient,
@@ -32,10 +29,29 @@ pub mod sdk_token_test {
 
         let cpi_inputs = CpiInputs::new_compress(vec![token_account]);
 
+        let light_cpi_accounts = CpiAccounts::new_compress(
+            ctx.accounts.signer.as_ref(),
+            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(())
@@ -60,8 +76,11 @@ pub mod sdk_token_test {
 
         let cpi_inputs =
             CpiInputs::new(vec![token_account, recipient_token_account], validity_proof);
-        let light_cpi_accounts =
-            CpiAccounts::new(ctx.accounts.signer.as_ref(), ctx.remaining_accounts);
+        let light_cpi_accounts = CpiAccounts::new(
+            ctx.accounts.signer.as_ref(),
+            ctx.accounts.signer.as_ref(),
+            ctx.remaining_accounts,
+        );
 
         // TODO: add to program error conversion
         let instruction =
@@ -90,13 +109,18 @@ pub mod sdk_token_test {
         token_account.decompress(10).unwrap();
 
         let cpi_inputs = CpiInputs::new(vec![token_account], validity_proof);
-        let light_cpi_accounts =
-            CpiAccounts::new(ctx.accounts.signer.as_ref(), ctx.remaining_accounts);
+        let light_cpi_accounts = CpiAccounts::new_decompress(
+            ctx.accounts.signer.as_ref(),
+            ctx.accounts.signer.as_ref(),
+            ctx.remaining_accounts,
+        );
 
         // 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);
         // TODO: make invoke_signed
         invoke(&instruction, account_infos.as_slice())?;
 

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

@@ -21,7 +21,7 @@ use solana_sdk::{
 #[tokio::test]
 async fn test_compress_spl_tokens() {
     // Initialize the test environment
-    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(
         false,
         Some(vec![("sdk_token_test", sdk_token_test::ID)]),
     ))
@@ -118,9 +118,10 @@ async fn compress_spl_tokens(
         false,
     );
     remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
+    let metas = get_transfer_instruction_account_metas(config);
+    println!("metas {:?}", metas.to_vec());
     // Add the token account to pre_accounts for the compression
-    remaining_accounts
-        .add_pre_accounts_metas(get_transfer_instruction_account_metas(config).as_slice());
+    remaining_accounts.add_pre_accounts_metas(metas.as_slice());
 
     let output_tree_index = rpc
         .get_random_state_tree_info()
@@ -129,14 +130,11 @@ async fn compress_spl_tokens(
         .unwrap();
 
     let (remaining_accounts, _, _) = remaining_accounts.to_account_metas();
+    println!("remaining_accounts {:?}", remaining_accounts.to_vec());
 
     let instruction = Instruction {
         program_id: sdk_token_test::ID,
-        accounts: [
-            vec![AccountMeta::new(payer.pubkey(), true)],
-            remaining_accounts,
-        ]
-        .concat(),
+        accounts: [remaining_accounts].concat(),
         data: sdk_token_test::instruction::Compress {
             output_tree_index,
             recipient,

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

@@ -16,7 +16,7 @@ light-macros = { workspace = true }
 thiserror = { workspace = true }
 # Serialization
 borsh = { workspace = true }
-
+solana-msg = { workspace = true }
 # Solana dependencies
 solana-pubkey = { workspace = true, features = ["sha2", "curve25519"] }
 solana-instruction = { workspace = true }

sdk-libs/compressed-token-sdk/Cargo.toml

@@ -1,3 +1,4 @@
+use anchor_lang::Key;
 use light_compressed_token_types::{
     constants::{
         ACCOUNT_COMPRESSION_PROGRAM_ID, CPI_AUTHORITY_PDA, LIGHT_SYSTEM_PROGRAM_ID,
@@ -27,10 +28,7 @@ pub fn to_compressed_token_account_metas(
 
     // authority (signer)
     account_metas.push(AccountMeta {
-        pubkey: *cpi_accounts
-            .authority()
-            .map_err(|_| TokenSdkError::CpiError("Missing authority".to_string()))?
-            .key,
+        pubkey: *cpi_accounts.authority().key,
         is_signer: true,
         is_writable: false,
     });
@@ -51,6 +49,7 @@ pub fn to_compressed_token_account_metas(
 
     // registered_program_pda
     account_metas.push(AccountMeta {
+        // TODO: hardcode
         pubkey: *cpi_accounts
             .registered_program_pda()
             .map_err(|_| TokenSdkError::CpiError("Missing registered program PDA".to_string()))?
@@ -89,12 +88,14 @@ pub fn to_compressed_token_account_metas(
         is_signer: false,
         is_writable: false,
     });
+    solana_msg::msg!("cpi_accounts.config() {:?}", cpi_accounts.config());
 
     // token_pool_pda - if not configured, use compressed token program ID (like anchor does for None)
-    if cpi_accounts.config().token_pool_pda {
+    if cpi_accounts.config().is_compress_or_decompress() {
         let account = cpi_accounts
-            .sol_pool_pda()
+            .token_pool_pda()
             .map_err(|_| TokenSdkError::CpiError("Missing token pool PDA".to_string()))?;
+        solana_msg::msg!("token_pool_pda {}", account.key);
         account_metas.push(AccountMeta {
             pubkey: *account.key,
             is_signer: false,
@@ -108,9 +109,9 @@ pub fn to_compressed_token_account_metas(
             is_writable: false,
         });
     }
-
+    solana_msg::msg!("cpi_accounts.config() {:?}", cpi_accounts.config());
     // compress_or_decompress_token_account - if not configured, use compressed token program ID
-    if cpi_accounts.config().compress_or_decompress_token_account {
+    if cpi_accounts.config().is_compress_or_decompress() {
         let account = cpi_accounts.decompression_recipient().map_err(|_| {
             TokenSdkError::CpiError("Missing compress/decompress account".to_string())
         })?;
@@ -128,40 +129,41 @@ pub fn to_compressed_token_account_metas(
         });
     }
 
-    // token_program - if not configured, use compressed token program ID
-    if cpi_accounts.config().cpi_context {
-        let account = cpi_accounts
-            .cpi_context()
-            .map_err(|_| TokenSdkError::CpiError("Missing token program".to_string()))?;
-        account_metas.push(AccountMeta {
-            pubkey: *account.key,
-            is_signer: false,
-            is_writable: false,
-        });
-    } else {
-        // Anchor represents None optional accounts as the program ID being invoked
-        account_metas.push(AccountMeta {
-            pubkey: Pubkey::from(COMPRESSED_TOKEN_PROGRAM_ID),
-            is_signer: false,
-            is_writable: false,
-        });
-    }
-
+    // // token_program - if not configured, use compressed token program ID
+    // if cpi_accounts.config().cpi_context {
+    //     let account = cpi_accounts
+    //         .cpi_context()
+    //         .map_err(|_| TokenSdkError::CpiError("Missing token program".to_string()))?;
+    //     account_metas.push(AccountMeta {
+    //         pubkey: *account.key,
+    //         is_signer: false,
+    //         is_writable: false,
+    //     });
+    // } else {
+    //     // Anchor represents None optional accounts as the program ID being invoked
+    //     account_metas.push(AccountMeta {
+    //         pubkey: Pubkey::from(COMPRESSED_TOKEN_PROGRAM_ID),
+    //         is_signer: false,
+    //         is_writable: false,
+    //     });
+    // }
+    account_metas.push(AccountMeta {
+        pubkey: cpi_accounts.spl_token_program().unwrap().key(),
+        is_signer: false,
+        is_writable: false,
+    });
     // system_program (always last according to TransferInstruction definition)
     account_metas.push(AccountMeta {
         pubkey: Pubkey::default(), // System program ID
         is_signer: false,
         is_writable: false,
     });
 
-    // Add any remaining tree accounts
-    let system_len = account_metas.len();
-    let tree_accounts = cpi_accounts
-        .account_infos()
-        .get(system_len..)
-        .unwrap_or(&[]);
+    // TODO: implement error conversion
+    let tree_accounts = cpi_accounts.tree_accounts().unwrap_or_default();
 
     for account in tree_accounts {
+        solana_msg::msg!("tree account: {}", account.key);
         account_metas.push(AccountMeta {
             pubkey: *account.key,
             is_signer: false,

sdk-libs/compressed-token-sdk/src/cpi/accounts.rs

@@ -3,7 +3,7 @@ use light_compressed_token_types::{
     constants::{PROGRAM_ID as COMPRESSED_TOKEN_PROGRAM_ID, TRANSFER},
     cpi_accounts::CpiAccounts,
     instruction::transfer::CompressedTokenInstructionDataTransfer,
-    AnchorSerialize, CompressedCpiContext,
+    CompressedCpiContext,
 };
 use solana_account_info::AccountInfo;
 use solana_instruction::Instruction;
@@ -13,6 +13,7 @@ use crate::{
     account::CTokenAccount,
     cpi::accounts::to_compressed_token_account_metas,
     error::{Result, TokenSdkError},
+    AnchorSerialize,
 };
 
 /// CPI inputs for compressed token operations
@@ -53,9 +54,31 @@ pub fn create_compressed_token_instruction(
         .token_accounts
         .iter()
         .any(|acc| acc.is_compress());
+    let is_decompress = cpi_inputs
+        .token_accounts
+        .iter()
+        .any(|acc| acc.is_decompress());
     let mint = *cpi_inputs.token_accounts[0].mint();
     let compress_or_decompress_amount: Option<u64> =
         Some(cpi_inputs.token_accounts.iter().map(|acc| acc.amount).sum());
+
+    // Check 1: cpi accounts must be decompress or compress consistent with accounts
+    if (is_compress && !cpi_accounts.config().compress)
+        || (is_decompress && !cpi_accounts.config().decompress)
+    {
+        return Err(TokenSdkError::InconsistentCompressDecompressState);
+    }
+
+    // Check 2: there can only be compress or decompress not both
+    if is_compress && is_decompress {
+        return Err(TokenSdkError::BothCompressAndDecompress);
+    }
+
+    // Check 3: compress_or_decompress_amount must be Some
+    if compress_or_decompress_amount.is_none() {
+        return Err(TokenSdkError::InvalidCompressDecompressAmount);
+    }
+
     // Extract input and output data from token accounts
     let mut input_token_data_with_context = Vec::new();
     let mut output_compressed_accounts = Vec::new();

sdk-libs/compressed-token-sdk/src/cpi/invoke.rs

@@ -12,7 +12,11 @@ pub enum TokenSdkError {
     CpiError(String),
     #[error("Cannot compress and decompress")]
     CannotCompressAndDecompress,
+    #[error("Inconsistent compress/decompress state")]
+    InconsistentCompressDecompressState,
+    #[error("Both compress and decompress specified")]
+    BothCompressAndDecompress,
+    #[error("Invalid compress/decompress amount")]
+    InvalidCompressDecompressAmount,
 }
 
-// Keep old error type for backwards compatibility
-pub type CTokenSdkError = TokenSdkError;