first draft, tests are red

Author: ananas-block

Cargo.lock

@@ -19,10 +19,7 @@ test-sbf = []
 default = []
 
 [dependencies]
-light-compressed-token-sdk = { workspace = true }
-light-sdk = { workspace = true }
-solana-program = { workspace = true }
-light-macros = { workspace = true }
+light-compressed-token-sdk = { workspace = true, features = ["anchor"] }
 anchor-lang = { workspace = true }
 
 [dev-dependencies]
@@ -32,6 +29,7 @@ tokio = { workspace = true }
 serial_test = { workspace = true }
 solana-sdk = { workspace = true }
 anchor-spl = { workspace = true }
+light-sdk = { workspace = true }
 
 [lints.rust.unexpected_cfgs]
 level = "allow"

program-tests/sdk-token-test/Cargo.toml

@@ -1,8 +1,9 @@
 #![allow(unexpected_cfgs)]
 
 use anchor_lang::{prelude::*, solana_program::program::invoke, Discriminator};
-use light_compressed_token_sdk::cpi::{
-    create_compressed_token_instruction, CpiAccounts, CpiInputs,
+use light_compressed_token_sdk::{
+    cpi::{create_compressed_token_instruction, CpiAccounts, CpiInputs},
+    InputTokenDataWithContext, ValidityProof,
 };
 
 declare_id!("5p1t1GAaKtK1FKCh5Hd2Gu8JCu3eREhJm4Q2qYfTEPYK");
@@ -15,8 +16,8 @@ pub mod sdk_token_test {
     pub fn compress<'info>(
         ctx: Context<'_, '_, '_, 'info, Generic<'info>>,
         output_tree_index: u8,
-        recipient: Pubkey,
-        mint: Pubkey, // TODO: deserialize from token account.
+        recipient: Pubkey, // TODO: make recpient pda
+        mint: Pubkey,      // TODO: deserialize from token account.
         amount: u64,
     ) -> Result<()> {
         let light_cpi_accounts =
@@ -40,49 +41,67 @@ pub mod sdk_token_test {
         Ok(())
     }
 
-    // pub fn transfer<'info>(
-    //     ctx: Context<'_, '_, '_, 'info, UpdateNestedData<'info>>,
-    //     proof: ValidityProof,
-    //     my_compressed_account: MyCompressedAccount,
-    //     account_meta: CompressedAccountMeta,
-    //     nested_data: NestedData,
-    // ) -> Result<()> {
-    //     let mut my_compressed_account = LightAccount::<'_, MyCompressedAccount>::new_mut(
-    //         &crate::ID,
-    //         &account_meta,
-    //         my_compressed_account,
-    //     )
-    //     .map_err(ProgramError::from)?;
-
-    //     my_compressed_account.nested = nested_data;
-
-    //     let light_cpi_accounts = CpiAccounts::new(
-    //         ctx.accounts.signer.as_ref(),
-    //         ctx.remaining_accounts,
-    //         crate::LIGHT_CPI_SIGNER,
-    //     );
-
-    //     let cpi_inputs = CpiInputs::new(
-    //         proof,
-    //         vec![my_compressed_account
-    //             .to_account_info()
-    //             .map_err(ProgramError::from)?],
-    //     );
-
-    //     cpi_inputs
-    //         .invoke_light_system_program(light_cpi_accounts)
-    //         .map_err(ProgramError::from)?;
-
-    //     Ok(())
-    // }
-
-    // pub fn decompress<'info>(
-    //     ctx: Context<'_, '_, '_, 'info, WithoutCompressedAccount<'info>>,
-    //     name: String,
-    // ) -> Result<()> {
-    //     ctx.accounts.my_regular_account.name = name;
-    //     Ok(())
-    // }
+    pub fn transfer<'info>(
+        ctx: Context<'_, '_, '_, 'info, Generic<'info>>,
+        validity_proof: ValidityProof,
+        token_data: Vec<InputTokenDataWithContext>,
+        output_tree_index: u8,
+        mint: Pubkey,
+        recipient: Pubkey,
+    ) -> Result<()> {
+        let mut token_account = light_compressed_token_sdk::account::CTokenAccount::new(
+            mint,
+            ctx.accounts.signer.key(), // TODO: reconsider whether this makes sense
+            token_data,
+            output_tree_index,
+        );
+        // None is the same output_tree_index as token account
+        let recipient_token_account = token_account.transfer(&recipient, 10, None).unwrap();
+
+        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);
+
+        // 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();
+
+        // TODO: make invoke_signed
+        invoke(&instruction, account_infos.as_slice())?;
+
+        Ok(())
+    }
+
+    pub fn decompress<'info>(
+        ctx: Context<'_, '_, '_, 'info, Generic<'info>>,
+        validity_proof: ValidityProof,
+        token_data: Vec<InputTokenDataWithContext>,
+        output_tree_index: u8,
+        mint: Pubkey,
+    ) -> Result<()> {
+        let mut token_account = light_compressed_token_sdk::account::CTokenAccount::new(
+            mint,
+            ctx.accounts.signer.key(), // TODO: reconsider whether this makes sense
+            token_data,
+            output_tree_index,
+        );
+        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);
+
+        // 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();
+        // TODO: make invoke_signed
+        invoke(&instruction, account_infos.as_slice())?;
+
+        Ok(())
+    }
 }
 
 #[derive(Accounts)]

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

@@ -1,14 +1,25 @@
 // #![cfg(feature = "test-sbf")]
 
-use anchor_lang::AccountDeserialize;
+use anchor_lang::{AccountDeserialize, InstructionData};
 use anchor_spl::token::TokenAccount;
+use light_compressed_token_sdk::{
+    instruction::{get_transfer_instruction_account_metas, TokenAccountsMetaConfig},
+    token_pool::get_token_pool_pda,
+};
 use light_program_test::{LightProgramTest, ProgramTestConfig, Rpc};
-use light_test_utils::spl::{create_mint_helper, create_token_account, mint_spl_tokens};
-use solana_sdk::{signature::Keypair, signer::Signer};
+use light_sdk::instruction::PackedAccounts;
+use light_test_utils::{
+    spl::{create_mint_helper, create_token_account, mint_spl_tokens},
+    RpcError,
+};
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signature::{Keypair, Signature, Signer},
+};
 
-//#[serial]
 #[tokio::test]
-async fn test_create_token_account_and_mint() {
+async fn test_compress_spl_tokens() {
     // Initialize the test environment
     let mut rpc = LightProgramTest::new(ProgramTestConfig::new(
         false,
@@ -49,7 +60,7 @@ async fn test_create_token_account_and_mint() {
 
     println!("Minted {} tokens to account", mint_amount);
 
-    // Verify the token account has the correct balance
+    // Verify the token account has the correct balance before compression
     let token_account_data = rpc
         .get_account(token_account_keypair.pubkey())
         .await
@@ -63,5 +74,78 @@ async fn test_create_token_account_and_mint() {
     assert_eq!(token_account.mint, mint_pubkey);
     assert_eq!(token_account.owner, payer.pubkey());
 
-    println!("Test completed successfully!");
+    println!("Verified token account balance before compression");
+
+    // Now compress the SPL tokens
+    let compress_amount = 500_000; // Compress half of the tokens
+    let recipient = payer.pubkey(); // Compress to the same owner
+
+    compress_spl_tokens(
+        &mut rpc,
+        &payer,
+        recipient,
+        mint_pubkey,
+        compress_amount,
+        token_account_keypair.pubkey(),
+    )
+    .await
+    .unwrap();
+
+    println!("Compressed {} tokens successfully", compress_amount);
+
+    // TODO: Add verification of compressed token accounts
+    // This would require checking the compressed account state tree
+    // and verifying the token balance was reduced in the SPL account
+
+    println!("Compression test completed successfully!");
+}
+
+async fn compress_spl_tokens(
+    rpc: &mut LightProgramTest,
+    payer: &Keypair,
+    recipient: Pubkey,
+    mint: Pubkey,
+    amount: u64,
+    token_account: Pubkey,
+) -> 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,
+    );
+    remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
+    // Add the token account to pre_accounts for the compression
+    remaining_accounts
+        .add_pre_accounts_metas(get_transfer_instruction_account_metas(config).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: [
+            vec![AccountMeta::new(payer.pubkey(), true)],
+            remaining_accounts,
+        ]
+        .concat(),
+        data: sdk_token_test::instruction::Compress {
+            output_tree_index,
+            recipient,
+            mint,
+            amount,
+        }
+        .data(),
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
+        .await
 }

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

@@ -18,7 +18,7 @@ thiserror = { workspace = true }
 borsh = { workspace = true }
 
 # Solana dependencies
-solana-pubkey = { workspace = true }
+solana-pubkey = { workspace = true, features = ["sha2", "curve25519"] }
 solana-instruction = { workspace = true }
 solana-account-info = { workspace = true }
 solana-cpi = { workspace = true }

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

@@ -2,6 +2,9 @@ pub mod account;
 pub mod cpi;
 pub mod error;
 pub mod instruction;
+pub mod token_pool;
+
+pub use light_compressed_token_types::*;
 
 // Conditional anchor re-exports
 #[cfg(feature = "anchor")]

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

@@ -0,0 +1,20 @@
+use light_compressed_token_types::constants::{POOL_SEED, PROGRAM_ID};
+use solana_pubkey::Pubkey;
+
+pub fn get_token_pool_pda(mint: &Pubkey) -> Pubkey {
+    get_token_pool_pda_with_index(mint, 0)
+}
+
+pub fn find_token_pool_pda_with_index(mint: &Pubkey, token_pool_index: u8) -> (Pubkey, u8) {
+    let seeds = &[POOL_SEED, mint.as_ref(), &[token_pool_index]];
+    let seeds = if token_pool_index == 0 {
+        &seeds[..2]
+    } else {
+        &seeds[..]
+    };
+    Pubkey::find_program_address(seeds, &Pubkey::from(PROGRAM_ID))
+}
+
+pub fn get_token_pool_pda_with_index(mint: &Pubkey, token_pool_index: u8) -> Pubkey {
+    find_token_pool_pda_with_index(mint, token_pool_index).0
+}

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

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [features]
-anchor = ["anchor-lang"]
+anchor = ["anchor-lang", "light-compressed-account/anchor"]
 
 [dependencies]
 borsh = { workspace = true }

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

@@ -1,10 +1,7 @@
-#[cfg(feature = "anchor")]
-use anchor_lang::{AnchorDeserialize, AnchorSerialize};
-#[cfg(not(feature = "anchor"))]
-use borsh::{BorshDeserialize as AnchorDeserialize, BorshSerialize as AnchorSerialize};
+use crate::{AnchorDeserialize, AnchorSerialize};
 
 #[derive(Debug, Copy, Clone, AnchorSerialize, AnchorDeserialize)]
 pub struct CpiSigner {
     pub program_id: [u8; 32],
     pub bump: u8,
-}
+}

sdk-libs/compressed-token-types/src/cpi_signer.rs

@@ -40,6 +40,10 @@ impl PackedAccounts {
         self.pre_accounts.push(account_meta);
     }
 
+    pub fn add_pre_accounts_metas(&mut self, account_metas: &[AccountMeta]) {
+        self.pre_accounts.extend_from_slice(account_metas);
+    }
+
     pub fn add_system_accounts(&mut self, config: SystemAccountMetaConfig) {
         self.system_accounts
             .extend(get_light_system_account_metas(config));