stash cpi accounts unit tested

Author: ananas-block

Cargo.lock

@@ -21,14 +21,16 @@ default = []
 [dependencies]
 light-compressed-token-sdk = { workspace = true }
 light-sdk = { workspace = true }
+solana-program = { workspace = true }
+light-macros = { workspace = true }
+anchor-lang = { workspace = true }
 
 [dev-dependencies]
 light-program-test = { workspace = true, features = ["devenv"] }
 light-test-utils = { workspace = true }
 tokio = { workspace = true }
 serial_test = { workspace = true }
 solana-sdk = { workspace = true }
-anchor-lang = { workspace = true }
 anchor-spl = { workspace = true }
 
 [lints.rust.unexpected_cfgs]

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

@@ -1,18 +1,92 @@
-// use light_macros::pubkey;
-// use light_sdk::{cpi::CpiSigner, derive_light_cpi_signer};
-// use solana_program::{
-//     account_info::AccountInfo, entrypoint, program_error::ProgramError, pubkey::Pubkey,
-// };
-
-// pub const ID: Pubkey = pubkey!("5p1t1GAaKtK1FKCh5Hd2Gu8JCu3eREhJm4Q2qYfTEPYK");
-// pub const LIGHT_CPI_SIGNER: CpiSigner
-// entrypoint!(process_instruction);
-
-// pub fn process_instruction(
-//     _program_id: &Pubkey,
-//     _accounts: &[AccountInfo],
-//     _instruction_data: &[u8],
-// ) -> Result<(), ProgramError> {
-//     // Empty program for now
-//     Ok(())
-// }
+#![allow(unexpected_cfgs)]
+
+use anchor_lang::{prelude::*, solana_program::program::invoke, Discriminator};
+use light_compressed_token_sdk::cpi::{
+    create_compressed_token_instruction, CpiAccounts, CpiInputs,
+};
+
+declare_id!("5p1t1GAaKtK1FKCh5Hd2Gu8JCu3eREhJm4Q2qYfTEPYK");
+
+#[program]
+pub mod sdk_token_test {
+
+    use super::*;
+
+    pub fn compress<'info>(
+        ctx: Context<'_, '_, '_, 'info, Generic<'info>>,
+        output_tree_index: u8,
+        recipient: Pubkey,
+        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,
+            output_tree_index,
+        );
+        token_account.compress(amount).unwrap();
+
+        let cpi_inputs = CpiInputs::new_compress(vec![token_account]);
+
+        // 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();
+        invoke(&instruction, account_infos.as_slice())?;
+
+        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(())
+    // }
+}
+
+#[derive(Accounts)]
+pub struct Generic<'info> {
+    #[account(mut)]
+    pub signer: Signer<'info>,
+}

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

@@ -10,9 +10,12 @@ use solana_sdk::{signature::Keypair, signer::Signer};
 #[tokio::test]
 async fn test_create_token_account_and_mint() {
     // Initialize the test environment
-    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(false, None))
-        .await
-        .unwrap();
+    let mut rpc = LightProgramTest::new(ProgramTestConfig::new(
+        false,
+        Some(vec![("sdk_token_test", sdk_token_test::ID)]),
+    ))
+    .await
+    .unwrap();
 
     let payer = rpc.get_payer().insecure_clone();
 

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

@@ -10,6 +10,8 @@ anchor = ["anchor-lang", "light-compressed-token-types/anchor"]
 [dependencies]
 # Light Protocol dependencies
 light-compressed-token-types = { workspace = true }
+light-compressed-account = { workspace = true }
+light-sdk = { workspace = true }
 light-macros = { workspace = true }
 thiserror = { workspace = true }
 # Serialization
@@ -18,6 +20,13 @@ borsh = { workspace = true }
 # Solana dependencies
 solana-pubkey = { workspace = true }
 solana-instruction = { workspace = true }
+solana-account-info = { workspace = true }
+solana-cpi = { workspace = true }
 
 # Optional Anchor dependency
 anchor-lang = { workspace = true, optional = true }
+
+[dev-dependencies]
+light-account-checks = { workspace = true, features = ["test-only", "solana"] }
+light-compressed-token = { workspace = true }
+anchor-lang = { workspace = true }

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

@@ -1,23 +1,25 @@
 use std::ops::Deref;
 
-use crate::error::CTokenSdkError;
+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)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct CTokenAccount {
     inputs: Vec<InputTokenDataWithContext>,
     output: PackedTokenTransferOutputData,
     compression_amount: Option<u64>,
     is_compress: bool,
     is_decompress: bool,
+    mint: Pubkey,
 }
 
 impl CTokenAccount {
     pub fn new(
+        mint: Pubkey,
         owner: Pubkey,
         token_data: Vec<InputTokenDataWithContext>,
         output_merkle_tree_index: u8,
@@ -37,10 +39,11 @@ impl CTokenAccount {
             compression_amount: None,
             is_compress: false,
             is_decompress: false,
+            mint,
         }
     }
 
-    pub fn new_empty(owner: Pubkey, output_merkle_tree_index: u8) -> Self {
+    pub fn new_empty(mint: Pubkey, owner: Pubkey, output_merkle_tree_index: u8) -> Self {
         Self {
             inputs: vec![],
             output: PackedTokenTransferOutputData {
@@ -53,6 +56,7 @@ impl CTokenAccount {
             compression_amount: None,
             is_compress: false,
             is_decompress: false,
+            mint,
         }
     }
 
@@ -61,9 +65,9 @@ impl CTokenAccount {
         recipient: &Pubkey,
         amount: u64,
         output_merkle_tree_index: Option<u8>,
-    ) -> Result<Self, CTokenSdkError> {
+    ) -> Result<Self, TokenSdkError> {
         if amount > self.output.amount {
-            return Err(CTokenSdkError::InsufficientBalance);
+            return Err(TokenSdkError::InsufficientBalance);
         }
         // TODO: skip outputs with zero amount when creating the instruction data.
         self.output.amount -= amount;
@@ -81,12 +85,16 @@ impl CTokenAccount {
                 tlv: None,
                 merkle_tree_index,
             },
+            mint: self.mint,
         })
     }
 
-    pub fn compress(&mut self, amount: u64) -> Result<(), CTokenSdkError> {
+    pub fn compress(&mut self, amount: u64) -> Result<(), TokenSdkError> {
         self.output.amount += amount;
         self.is_compress = true;
+        if self.is_decompress {
+            return Err(TokenSdkError::CannotCompressAndDecompress);
+        }
 
         match self.compression_amount.as_mut() {
             Some(amount_ref) => *amount_ref += amount,
@@ -95,17 +103,36 @@ impl CTokenAccount {
         Ok(())
     }
 
-    pub fn decompress(&mut self, amount: u64) -> Result<(), CTokenSdkError> {
+    pub fn decompress(&mut self, amount: u64) -> Result<(), TokenSdkError> {
+        if self.is_compress {
+            return Err(TokenSdkError::CannotCompressAndDecompress);
+        }
+        if self.output.amount < amount {
+            return Err(TokenSdkError::InsufficientBalance);
+        }
         self.output.amount -= amount;
+
         self.is_decompress = true;
 
         match self.compression_amount.as_mut() {
-            Some(amount_ref) => *amount_ref -= amount,
+            Some(amount_ref) => *amount_ref += amount,
             None => self.compression_amount = Some(amount),
         }
         Ok(())
     }
 
+    pub fn is_compress(&self) -> bool {
+        self.is_compress
+    }
+
+    pub fn is_decompress(&self) -> bool {
+        self.is_decompress
+    }
+
+    pub fn mint(&self) -> &Pubkey {
+        &self.mint
+    }
+
     /// Consumes token account for instruction creation.
     pub fn into_inputs_and_outputs(
         self,