add c-token rust client helpers

Author: SwenSchaeferjohann

Cargo.lock

@@ -22,6 +22,7 @@ members = [
     "sdk-libs/macros",
     "sdk-libs/sdk",
     "sdk-libs/compressed-token-sdk",
+    "sdk-libs/compressed-token-client",
     "sdk-libs/photon-api",
     "sdk-libs/program-test",
     "xtask",
@@ -163,6 +164,10 @@ account-compression = { path = "programs/account-compression", version = "1.2.0"
 light-compressed-token = { path = "programs/compressed-token", version = "1.2.0", features = [
     "cpi",
 ] }
+light-compressed-token-client = { path = "sdk-libs/compressed-token-client", version = "0.1.0" }
+light-system-program = { path = "anchor-programs/system", version = "1.2.0", features = [
+    "cpi",
+] }
 light-system-program-anchor = { path = "anchor-programs/system", version = "1.2.0", features = [
     "cpi",
 ] }

Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "light-compressed-token-client"
+version = "0.1.0"
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/lightprotocol/light-protocol"
+description = "Client library for Light Protocol Compressed Token Program"
+
+[features]
+default = []
+
+[dependencies]
+# Light Protocol dependencies
+light-compressed-token = { workspace = true }
+light-compressed-account = { workspace = true, features = ["anchor"] }
+light-system-program-anchor = { workspace = true }
+account-compression = { workspace = true }
+
+# Solana dependencies
+solana-sdk = { workspace = true }
+solana-pubkey = { workspace = true }
+solana-instruction = { workspace = true }
+solana-program = { workspace = true }
+solana-transaction = { workspace = true }
+solana-signature = { workspace = true }
+solana-hash = { workspace = true }
+solana-account = { workspace = true }
+
+# Anchor
+anchor-lang = { workspace = true }
+anchor-spl = { workspace = true }
+
+# External dependencies
+borsh = { workspace = true }
+num-bigint = { workspace = true }
+num-traits = { workspace = true }
+thiserror = { workspace = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["rt", "macros"] } 

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

@@ -0,0 +1,86 @@
+# Light Compressed Token Client
+
+A Rust client library for interacting with the Compressed Token Program on Solana.
+
+## Overview
+
+- **Compress**: Compress SPL tokens to a recipient.
+- **Decompress**: Decompress compressed tokens back to an SPL token account
+- **Batch Compress**: Compress SPL tokens to multiple recipients in a single instruction.
+
+## Installation
+
+Add to your `Cargo.toml`:
+
+```toml
+[dependencies]
+light-compressed-token-client = "0.1.0"
+```
+
+## Usage
+
+### Compress to one recipient
+
+```rust
+use light_compressed_token_client::{compress, CompressParams};
+use solana_pubkey::Pubkey;
+
+let instruction = compress(
+    payer,
+    owner,
+    source_token_account,
+    mint,
+    1000, // amount
+    recipient,
+    output_state_tree,
+)?;
+```
+
+### Compress to multiple recipients
+
+```rust
+use light_compressed_token_client::batch_compress;
+
+// Compress to multiple recipients
+let recipients = vec![
+    (recipient1, 500),
+    (recipient2, 300),
+    (recipient3, 200),
+];
+
+let instruction = batch_compress(
+    payer,
+    owner,
+    source_token_account,
+    mint,
+    recipients,
+    output_state_tree,
+)?;
+```
+
+### Decompress to SPL token account.
+
+```rust
+use light_compressed_token_client::{DecompressParams, create_decompress_instruction};
+
+let params = DecompressParams {
+    payer,
+    input_compressed_token_accounts: vec![(account, token_data, merkle_context)],
+    to_address: destination_token_account, // SPL token account, eg ATA.
+    amount: 1000,
+    recent_input_state_root_indices: vec![Some(0)], // fetch via get_validity_proof
+    recent_validity_proof: Some(proof),  // fetch via get_validity_proof
+    output_state_tree: Some(state_tree),
+    token_program_id: None, // defaults to SPL Token
+};
+
+let instruction = create_decompress_instruction(params)?;
+```
+
+## Features
+
+- Supports SPL-token and Token-22 mints.
+
+## License
+
+Apache-2.0

sdk-libs/compressed-token-client/README.md

@@ -0,0 +1,135 @@
+//! Example demonstrating basic usage of the compressed-token-client library
+
+use light_compressed_token_client::{
+    batch_compress, compress, create_decompress_instruction, AccountState, CompressedAccount,
+    DecompressParams, MerkleContext, TokenData, TreeType,
+};
+use solana_sdk::pubkey::Pubkey;
+
+fn main() {
+    // Example 1: Simple compression
+    simple_compress_example();
+
+    // Example 2: Batch compression
+    batch_compress_example();
+
+    // Example 3: Decompression
+    decompress_example();
+}
+
+fn simple_compress_example() {
+    println!("=== Simple Compress Example ===");
+
+    let payer = Pubkey::new_unique();
+    let owner = Pubkey::new_unique();
+    let source_token_account = Pubkey::new_unique();
+    let mint = Pubkey::new_unique();
+    let recipient = Pubkey::new_unique();
+    let output_state_tree = Pubkey::new_unique();
+
+    let instruction = compress(
+        payer,
+        owner,
+        source_token_account,
+        mint,
+        1000, // amount
+        recipient,
+        output_state_tree,
+    )
+    .expect("Failed to create compress instruction");
+
+    println!("Created compress instruction:");
+    println!("  Program ID: {}", instruction.program_id);
+    println!("  Accounts: {} total", instruction.accounts.len());
+    println!();
+}
+
+fn batch_compress_example() {
+    println!("=== Batch Compress Example ===");
+
+    let payer = Pubkey::new_unique();
+    let owner = Pubkey::new_unique();
+    let source_token_account = Pubkey::new_unique();
+    let mint = Pubkey::new_unique();
+    let output_state_tree = Pubkey::new_unique();
+
+    let recipients = vec![
+        (Pubkey::new_unique(), 500),
+        (Pubkey::new_unique(), 300),
+        (Pubkey::new_unique(), 200),
+    ];
+
+    let _instruction = batch_compress(
+        payer,
+        owner,
+        source_token_account,
+        mint,
+        recipients.clone(),
+        output_state_tree,
+    )
+    .expect("Failed to create batch compress instruction");
+
+    println!(
+        "Created batch compress instruction for {} recipients:",
+        recipients.len()
+    );
+    for (recipient, amount) in recipients {
+        println!("  {} -> {} tokens", recipient, amount);
+    }
+    println!();
+}
+
+fn decompress_example() {
+    println!("=== Decompress Example ===");
+
+    let payer = Pubkey::new_unique();
+    let owner = Pubkey::new_unique();
+    let mint = Pubkey::new_unique();
+    let destination_token_account = Pubkey::new_unique();
+    let merkle_tree = Pubkey::new_unique();
+    let queue = Pubkey::new_unique();
+
+    // Create mock compressed account data
+    let compressed_account = CompressedAccount {
+        owner: light_compressed_token_client::PROGRAM_ID,
+        lamports: 0,
+        data: None,
+        address: None,
+    };
+
+    let token_data = TokenData {
+        mint,
+        owner,
+        amount: 1000,
+        delegate: None,
+        state: AccountState::Initialized,
+        tlv: None,
+    };
+
+    let merkle_context = MerkleContext {
+        merkle_tree_pubkey: merkle_tree,
+        queue_pubkey: queue,
+        leaf_index: 0,
+        prove_by_index: false,
+        tree_type: TreeType::StateV2,
+    };
+
+    let params = DecompressParams {
+        payer,
+        input_compressed_token_accounts: vec![(compressed_account, token_data, merkle_context)],
+        to_address: destination_token_account,
+        amount: 500,
+        recent_input_state_root_indices: vec![Some(0)],
+        recent_validity_proof: None,
+        output_state_tree: Some(merkle_tree),
+        token_program_id: None,
+    };
+
+    let instruction =
+        create_decompress_instruction(params).expect("Failed to create decompress instruction");
+
+    println!("Created decompress instruction:");
+    println!("  Program ID: {}", instruction.program_id);
+    println!("  Decompressing 500 tokens (500 remain compressed)");
+    println!();
+}