mint to spl works

Author: ananas-block

Cargo.lock

@@ -26,6 +26,7 @@ members = [
     "sdk-libs/photon-api",
     "sdk-libs/program-test",
     "sdk-libs/compressed-token-types",
+    "sdk-libs/compressed-token-sdk",
     "xtask",
     "examples/anchor/token-escrow",
     # "examples/anchor/name-service-without-macros",
@@ -41,6 +42,7 @@ members = [
     # Issue is that anchor discriminator now returns a slice instead of an array
     "program-tests/sdk-anchor-test/programs/sdk-anchor-test",
     "program-tests/sdk-test",
+    "program-tests/sdk-token-test",
     "program-tests/sdk-pinocchio-test",
     "program-tests/create-address-test-program",
     "program-tests/utils",
@@ -181,6 +183,7 @@ light-compressed-token = { path = "programs/compressed-token", version = "1.2.0"
     "cpi",
 ] }
 light-compressed-token-types = { path = "sdk-libs/compressed-token-types", name = "light-compressed-token-types" }
+light-compressed-token-sdk = { path = "sdk-libs/compressed-token-sdk" }
 light-system-program-anchor = { path = "anchor-programs/system", version = "1.2.0", features = [
     "cpi",
 ] }

Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "sdk-token-test"
+version = "1.0.0"
+description = "Test program using compressed token SDK"
+repository = "https://github.com/Lightprotocol/light-protocol"
+license = "Apache-2.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "sdk_token_test"
+
+[features]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+test-sbf = []
+default = []
+
+[dependencies]
+light-compressed-token-sdk = { workspace = true }
+light-sdk = { 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]
+level = "allow"
+check-cfg = [
+    'cfg(target_os, values("solana"))',
+    'cfg(feature, values("frozen-abi", "no-entrypoint"))',
+]

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

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

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

@@ -0,0 +1,18 @@
+// 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(())
+// }

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

@@ -0,0 +1,64 @@
+// #![cfg(feature = "test-sbf")]
+
+use anchor_lang::AccountDeserialize;
+use anchor_spl::token::TokenAccount;
+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};
+
+//#[serial]
+#[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 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 = 1_000_000; // 1000 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);
+
+    // Verify the token account has the correct balance
+    let token_account_data = rpc
+        .get_account(token_account_keypair.pubkey())
+        .await
+        .unwrap()
+        .unwrap();
+
+    let token_account =
+        TokenAccount::try_deserialize(&mut token_account_data.data.as_slice()).unwrap();
+
+    assert_eq!(token_account.amount, mint_amount);
+    assert_eq!(token_account.mint, mint_pubkey);
+    assert_eq!(token_account.owner, payer.pubkey());
+
+    println!("Test completed successfully!");
+}

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

@@ -0,0 +1,23 @@
+[package]
+name = "light-compressed-token-sdk"
+version = { workspace = true }
+edition = { workspace = true }
+
+[features]
+
+anchor = ["anchor-lang", "light-compressed-token-types/anchor"]
+
+[dependencies]
+# Light Protocol dependencies
+light-compressed-token-types = { workspace = true }
+light-macros = { workspace = true }
+thiserror = { workspace = true }
+# Serialization
+borsh = { workspace = true }
+
+# Solana dependencies
+solana-pubkey = { workspace = true }
+solana-instruction = { workspace = true }
+
+# Optional Anchor dependency
+anchor-lang = { workspace = true, optional = true }

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

@@ -0,0 +1,143 @@
+use std::ops::Deref;
+
+use crate::error::CTokenSdkError;
+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)]
+pub struct CTokenAccount {
+    inputs: Vec<InputTokenDataWithContext>,
+    output: PackedTokenTransferOutputData,
+    compression_amount: Option<u64>,
+    is_compress: bool,
+    is_decompress: bool,
+}
+
+impl CTokenAccount {
+    pub fn new(
+        owner: Pubkey,
+        token_data: Vec<InputTokenDataWithContext>,
+        output_merkle_tree_index: u8,
+    ) -> Self {
+        let amount = token_data.iter().map(|data| data.amount).sum();
+        let lamports = token_data.iter().map(|data| data.lamports).sum();
+        let output = PackedTokenTransferOutputData {
+            owner: owner.to_bytes(),
+            amount,
+            lamports,
+            tlv: None,
+            merkle_tree_index: output_merkle_tree_index,
+        };
+        Self {
+            inputs: token_data,
+            output,
+            compression_amount: None,
+            is_compress: false,
+            is_decompress: false,
+        }
+    }
+
+    pub fn new_empty(owner: Pubkey, output_merkle_tree_index: u8) -> Self {
+        Self {
+            inputs: vec![],
+            output: PackedTokenTransferOutputData {
+                owner: owner.to_bytes(),
+                amount: 0,
+                lamports: None,
+                tlv: None,
+                merkle_tree_index: output_merkle_tree_index,
+            },
+            compression_amount: None,
+            is_compress: false,
+            is_decompress: false,
+        }
+    }
+
+    pub fn transfer(
+        &mut self,
+        recipient: &Pubkey,
+        amount: u64,
+        output_merkle_tree_index: Option<u8>,
+    ) -> Result<Self, CTokenSdkError> {
+        if amount > self.output.amount {
+            return Err(CTokenSdkError::InsufficientBalance);
+        }
+        // TODO: skip outputs with zero amount when creating the instruction data.
+        self.output.amount -= amount;
+        let merkle_tree_index = output_merkle_tree_index.unwrap_or(self.output.merkle_tree_index);
+
+        Ok(Self {
+            compression_amount: None,
+            is_compress: false,
+            is_decompress: false,
+            inputs: vec![],
+            output: PackedTokenTransferOutputData {
+                owner: recipient.to_bytes(),
+                amount,
+                lamports: None,
+                tlv: None,
+                merkle_tree_index,
+            },
+        })
+    }
+
+    pub fn compress(&mut self, amount: u64) -> Result<(), CTokenSdkError> {
+        self.output.amount += amount;
+        self.is_compress = true;
+
+        match self.compression_amount.as_mut() {
+            Some(amount_ref) => *amount_ref += amount,
+            None => self.compression_amount = Some(amount),
+        }
+        Ok(())
+    }
+
+    pub fn decompress(&mut self, amount: u64) -> Result<(), CTokenSdkError> {
+        self.output.amount -= amount;
+        self.is_decompress = true;
+
+        match self.compression_amount.as_mut() {
+            Some(amount_ref) => *amount_ref -= amount,
+            None => self.compression_amount = Some(amount),
+        }
+        Ok(())
+    }
+
+    /// Consumes token account for instruction creation.
+    pub fn into_inputs_and_outputs(
+        self,
+    ) -> (
+        Vec<InputTokenDataWithContext>,
+        PackedTokenTransferOutputData,
+    ) {
+        (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 {
+    type Target = PackedTokenTransferOutputData;
+
+    fn deref(&self) -> &Self::Target {
+        &self.output
+    }
+}

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

@@ -0,0 +1,8 @@
+use thiserror::Error;
+
+/// Error type for the Light Compressed Token SDK
+#[derive(Debug, Error)]
+pub enum CTokenSdkError {
+    #[error("Insufficient balance")]
+    InsufficientBalance,
+}

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

@@ -0,0 +1,4 @@
+pub mod token_accounts;
+
+// Re-export all instruction utilities
+pub use token_accounts::*;