token transfer works

Author: ananas-block

Cargo.lock

@@ -30,6 +30,8 @@ serial_test = { workspace = true }
 solana-sdk = { workspace = true }
 anchor-spl = { workspace = true }
 light-sdk = { workspace = true }
+light-compressed-account = { workspace = true, features = ["anchor"] }
+light-client = { workspace = true }
 
 [lints.rust.unexpected_cfgs]
 level = "allow"

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

@@ -85,6 +85,7 @@ pub mod sdk_token_test {
         // TODO: add to program error conversion
         let instruction =
             create_compressed_token_instruction(cpi_inputs, &light_cpi_accounts).unwrap();
+        msg!("instruction created {:?}", instruction);
         let account_infos = light_cpi_accounts.to_account_infos();
 
         // TODO: make invoke_signed

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

@@ -5,21 +5,24 @@ use anchor_spl::token::TokenAccount;
 use light_compressed_token_sdk::{
     instruction::{get_transfer_instruction_account_metas, TokenAccountsMetaConfig},
     token_pool::get_token_pool_pda,
+    InputTokenDataWithContext, PackedMerkleContext,
 };
-use light_program_test::{LightProgramTest, ProgramTestConfig, Rpc};
+use light_program_test::{Indexer, LightProgramTest, ProgramTestConfig, Rpc};
 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},
+    instruction::Instruction,
     pubkey::Pubkey,
     signature::{Keypair, Signature, Signer},
 };
 
+use light_client::indexer::CompressedTokenAccount;
+
 #[tokio::test]
-async fn test_compress_spl_tokens() {
+async fn test() {
     // Initialize the test environment
     let mut rpc = LightProgramTest::new(ProgramTestConfig::new_v2(
         false,
@@ -78,12 +81,16 @@ async fn test_compress_spl_tokens() {
 
     // Now compress the SPL tokens
     let compress_amount = 500_000; // Compress half of the tokens
-    let recipient = payer.pubkey(); // Compress to the same owner
+    let compression_recipient = payer.pubkey(); // Compress to the same owner
+
+    // Declare transfer parameters early
+    let transfer_recipient = Keypair::new();
+    let transfer_amount = 10;
 
     compress_spl_tokens(
         &mut rpc,
         &payer,
-        recipient,
+        compression_recipient,
         mint_pubkey,
         compress_amount,
         token_account_keypair.pubkey(),
@@ -93,11 +100,87 @@ async fn test_compress_spl_tokens() {
 
     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
+    // Get the compressed token account from indexer
+    let compressed_accounts = rpc
+        .indexer()
+        .unwrap()
+        .get_compressed_token_accounts_by_owner(&payer.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    let compressed_account = &compressed_accounts[0];
+
+    // Assert the compressed token account properties
+    assert_eq!(compressed_account.token.owner, payer.pubkey());
+    assert_eq!(compressed_account.token.mint, mint_pubkey);
+
+    // Verify the token amount (should match the compressed amount)
+    let amount = compressed_account.token.amount;
+    assert_eq!(amount, compress_amount);
+
+    println!(
+        "Verified compressed token account: owner={}, mint={}, amount={}",
+        payer.pubkey(),
+        mint_pubkey,
+        amount
+    );
+    println!("compressed_account {:?}", compressed_account);
+    // Now transfer some compressed tokens to a recipient
+    transfer_compressed_tokens(
+        &mut rpc,
+        &payer,
+        transfer_recipient.pubkey(),
+        compressed_account,
+    )
+    .await
+    .unwrap();
+
+    println!(
+        "Transferred {} compressed tokens to recipient successfully",
+        transfer_amount
+    );
+
+    // Verify the transfer by checking both sender and recipient accounts
+    let updated_accounts = rpc
+        .indexer()
+        .unwrap()
+        .get_compressed_token_accounts_by_owner(&payer.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    let recipient_accounts = rpc
+        .indexer()
+        .unwrap()
+        .get_compressed_token_accounts_by_owner(&transfer_recipient.pubkey(), None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    // Sender should have (compress_amount - transfer_amount) remaining
+    if !updated_accounts.is_empty() {
+        let sender_account = &updated_accounts[0];
+        let sender_amount = sender_account.token.amount;
+        assert_eq!(sender_amount, compress_amount - transfer_amount);
+        println!("Verified sender remaining balance: {}", sender_amount);
+    }
+
+    // Recipient should have transfer_amount
+    assert!(
+        !recipient_accounts.is_empty(),
+        "Recipient should have compressed token account"
+    );
+    let recipient_account = &recipient_accounts[0];
+    assert_eq!(recipient_account.token.owner, transfer_recipient.pubkey());
+    let recipient_amount = recipient_account.token.amount;
+    assert_eq!(recipient_amount, transfer_amount);
+    println!("Verified recipient balance: {}", recipient_amount);
 
-    println!("Compression test completed successfully!");
+    println!("Compression and transfer test completed successfully!");
 }
 
 async fn compress_spl_tokens(
@@ -147,3 +230,70 @@ async fn compress_spl_tokens(
     rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
         .await
 }
+
+async fn transfer_compressed_tokens(
+    rpc: &mut LightProgramTest,
+    payer: &Keypair,
+    recipient: Pubkey,
+    compressed_account: &CompressedTokenAccount,
+) -> Result<Signature, RpcError> {
+    let mut remaining_accounts = PackedAccounts::default();
+    let config = TokenAccountsMetaConfig::new(payer.pubkey(), payer.pubkey());
+    remaining_accounts.add_pre_accounts_signer_mut(payer.pubkey());
+    let metas = get_transfer_instruction_account_metas(config);
+    remaining_accounts.add_pre_accounts_metas(metas.as_slice());
+
+    // Get validity proof from RPC
+    let rpc_result = rpc
+        .get_validity_proof(vec![compressed_account.account.hash], vec![], None)
+        .await?
+        .value;
+
+    let packed_tree_info = rpc_result.pack_tree_infos(&mut remaining_accounts);
+    let output_tree_index = packed_tree_info
+        .state_trees
+        .as_ref()
+        .unwrap()
+        .output_tree_index;
+
+    // Use the tree info from the validity proof result
+    let tree_info = packed_tree_info
+        .state_trees
+        .as_ref()
+        .unwrap()
+        .packed_tree_infos[0];
+    println!("Transfer tree_info: {:?}", tree_info);
+
+    // Create input token data
+    let token_data = vec![InputTokenDataWithContext {
+        amount: compressed_account.token.amount,
+        delegate_index: None,
+        merkle_context: PackedMerkleContext {
+            merkle_tree_pubkey_index: tree_info.merkle_tree_pubkey_index,
+            nullifier_queue_pubkey_index: tree_info.queue_pubkey_index,
+            leaf_index: tree_info.leaf_index,
+            proof_by_index: tree_info.prove_by_index,
+        },
+        root_index: tree_info.root_index,
+        lamports: None,
+        tlv: None,
+    }];
+
+    let (remaining_accounts, _, _) = remaining_accounts.to_account_metas();
+    println!("remaining_accounts {:?}", remaining_accounts);
+    let instruction = Instruction {
+        program_id: sdk_token_test::ID,
+        accounts: [remaining_accounts].concat(),
+        data: sdk_token_test::instruction::Transfer {
+            validity_proof: rpc_result.proof,
+            token_data,
+            output_tree_index,
+            mint: compressed_account.token.mint,
+            recipient,
+        }
+        .data(),
+    };
+
+    rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
+        .await
+}

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

@@ -5,8 +5,8 @@ use solana_pubkey::Pubkey;
 use super::{
     response::{Items, ItemsWithCursor, Response},
     types::{
-        CompressedAccount, OwnerBalance, SignatureWithMetadata, TokenAccount, TokenBalance,
-        ValidityProofWithContext,
+        CompressedAccount, CompressedTokenAccount, OwnerBalance, SignatureWithMetadata,
+        TokenBalance, ValidityProofWithContext,
     },
     Address, AddressWithTree, BatchAddressUpdateIndexerResponse,
     GetCompressedAccountsByOwnerConfig, GetCompressedTokenAccountsByOwnerOrDelegateOptions, Hash,
@@ -75,14 +75,14 @@ pub trait Indexer: std::marker::Send + std::marker::Sync {
         delegate: &Pubkey,
         options: Option<GetCompressedTokenAccountsByOwnerOrDelegateOptions>,
         config: Option<IndexerRpcConfig>,
-    ) -> Result<Response<ItemsWithCursor<TokenAccount>>, IndexerError>;
+    ) -> Result<Response<ItemsWithCursor<CompressedTokenAccount>>, IndexerError>;
 
     async fn get_compressed_token_accounts_by_owner(
         &self,
         owner: &Pubkey,
         options: Option<GetCompressedTokenAccountsByOwnerOrDelegateOptions>,
         config: Option<IndexerRpcConfig>,
-    ) -> Result<Response<ItemsWithCursor<TokenAccount>>, IndexerError>;
+    ) -> Result<Response<ItemsWithCursor<CompressedTokenAccount>>, IndexerError>;
 
     /// Returns the token balances for a given owner.
     async fn get_compressed_token_balances_by_owner_v2(

sdk-libs/client/src/indexer/indexer_trait.rs

@@ -15,10 +15,10 @@ pub use indexer_trait::Indexer;
 pub use response::{Context, Items, ItemsWithCursor, Response};
 pub use types::{
     AccountProofInputs, Address, AddressMerkleTreeAccounts, AddressProofInputs, AddressQueueIndex,
-    AddressWithTree, BatchAddressUpdateIndexerResponse, CompressedAccount, Hash, MerkleProof,
-    MerkleProofWithContext, NewAddressProofWithContext, NextTreeInfo, OwnerBalance, ProofOfLeaf,
-    RootIndex, SignatureWithMetadata, StateMerkleTreeAccounts, TokenAccount, TokenBalance,
-    TreeInfo, ValidityProofWithContext,
+    AddressWithTree, BatchAddressUpdateIndexerResponse, CompressedAccount, CompressedTokenAccount,
+    Hash, MerkleProof, MerkleProofWithContext, NewAddressProofWithContext, NextTreeInfo,
+    OwnerBalance, ProofOfLeaf, RootIndex, SignatureWithMetadata, StateMerkleTreeAccounts,
+    TokenBalance, TreeInfo, ValidityProofWithContext,
 };
 mod options;
 pub use options::*;

sdk-libs/client/src/indexer/mod.rs

@@ -11,7 +11,10 @@ use solana_pubkey::Pubkey;
 use tracing::{debug, error, warn};
 
 use super::{
-    types::{CompressedAccount, OwnerBalance, SignatureWithMetadata, TokenAccount, TokenBalance},
+    types::{
+        CompressedAccount, CompressedTokenAccount, OwnerBalance, SignatureWithMetadata,
+        TokenBalance,
+    },
     BatchAddressUpdateIndexerResponse, MerkleProofWithContext,
 };
 use crate::indexer::{
@@ -543,7 +546,7 @@ impl Indexer for PhotonIndexer {
         delegate: &Pubkey,
         options: Option<GetCompressedTokenAccountsByOwnerOrDelegateOptions>,
         config: Option<IndexerRpcConfig>,
-    ) -> Result<Response<ItemsWithCursor<TokenAccount>>, IndexerError> {
+    ) -> Result<Response<ItemsWithCursor<CompressedTokenAccount>>, IndexerError> {
         let config = config.unwrap_or_default();
         self.retry(config.retry_config, || async {
             #[cfg(feature = "v2")]
@@ -575,7 +578,7 @@ impl Indexer for PhotonIndexer {
                     .value
                     .items
                     .iter()
-                    .map(TokenAccount::try_from)
+                    .map(CompressedTokenAccount::try_from)
                     .collect();
 
                 let cursor = response.value.cursor;
@@ -619,7 +622,7 @@ impl Indexer for PhotonIndexer {
                     .value
                     .items
                     .iter()
-                    .map(TokenAccount::try_from)
+                    .map(CompressedTokenAccount::try_from)
                     .collect();
 
                 let cursor = response.value.cursor;
@@ -643,7 +646,7 @@ impl Indexer for PhotonIndexer {
         owner: &Pubkey,
         options: Option<GetCompressedTokenAccountsByOwnerOrDelegateOptions>,
         config: Option<IndexerRpcConfig>,
-    ) -> Result<Response<ItemsWithCursor<TokenAccount>>, IndexerError> {
+    ) -> Result<Response<ItemsWithCursor<CompressedTokenAccount>>, IndexerError> {
         let config = config.unwrap_or_default();
         self.retry(config.retry_config, || async {
             #[cfg(feature = "v2")]
@@ -676,7 +679,7 @@ impl Indexer for PhotonIndexer {
                     .value
                     .items
                     .iter()
-                    .map(TokenAccount::try_from)
+                    .map(CompressedTokenAccount::try_from)
                     .collect();
 
                 let cursor = response.value.cursor;
@@ -727,7 +730,7 @@ impl Indexer for PhotonIndexer {
                     .value
                     .items
                     .iter()
-                    .map(TokenAccount::try_from)
+                    .map(CompressedTokenAccount::try_from)
                     .collect();
 
                 let cursor = response.value.cursor;