with cpi context works

Author: ananas-block

Cargo.lock

@@ -22,7 +22,7 @@ light-zero-copy = { workspace = true, features = ["std"] }
 light-macros = { workspace = true }
 pinocchio = { workspace = true, optional = true }
 solana-program-error = { workspace = true, optional = true }
-
+solana-msg = { workspace = true }
 # Feature-gated dependencies
 anchor-lang = { workspace = true, optional = true }
 bytemuck = { workspace = true, optional = true, features = ["derive"] }

program-libs/compressed-account/Cargo.toml

@@ -295,7 +295,8 @@ pub fn hash_with_hashed_values(
         vec.push(&discriminator_bytes);
         vec.push(data_hash);
     }
-
+    println!("hashed with hashed values {:?}", vec);
+    solana_msg::msg!("hashed with hashed values {:?}", vec);
     Ok(Poseidon::hashv(&vec)?)
 }
 

program-libs/compressed-account/src/compressed_account.rs

@@ -96,9 +96,10 @@ pub mod sdk_token_test {
             sol_pool_pda: false,
             sol_compression_recipient: false,
         };
+        let (token_account_infos, system_account_infos) = ctx.remaining_accounts.split_at(8);
         let light_cpi_accounts = CpiAccounts::new_with_config(
             ctx.accounts.signer.as_ref(),
-            ctx.remaining_accounts,
+            system_account_infos,
             config,
         );
 
@@ -109,7 +110,19 @@ pub mod sdk_token_test {
             mint,
             recipient,
             deposit_amount,
+            token_account_infos,
         )?;
+        let config = CpiAccountsConfig {
+            cpi_signer: crate::LIGHT_CPI_SIGNER,
+            cpi_context: true,
+            sol_pool_pda: false,
+            sol_compression_recipient: false,
+        };
+        let light_cpi_accounts = CpiAccounts::new_with_config(
+            ctx.accounts.signer.as_ref(),
+            system_account_infos,
+            config,
+        );
         process_create_compressed_account(
             light_cpi_accounts,
             proof,

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

@@ -21,7 +21,7 @@ pub struct MyTokenCompressedAccount {
     pub owner: Pubkey,
 }
 
-pub fn process_create_compressed_account<'info>(
+pub fn process_create_compressed_account(
     cpi_accounts: CpiAccounts,
     proof: ValidityProof,
     address_tree_info: PackedAddressTreeInfo,
@@ -58,56 +58,79 @@ pub fn process_create_compressed_account<'info>(
         cpi_context: Some(CompressedCpiContext {
             set_context: false,
             first_set_context: false,
-            cpi_context_account_index: (cpi_accounts.system_accounts_len() - 1) as u8, // TODO: confirm
+            cpi_context_account_index: 0, // seems to be useless. Seems to be unused.
+                                          // TODO: unify the account meta generation on and offchain.
         }),
         ..Default::default()
     };
-
+    msg!(
+        "(cpi_accounts.system_accounts_len() - 2) {}",
+        (cpi_accounts.system_accounts_len() - 2)
+    );
     cpi_inputs
         .invoke_light_system_program(cpi_accounts)
         .map_err(ProgramError::from)?;
 
     Ok(())
 }
 
-pub fn deposit_tokens(
-    cpi_accounts: &CpiAccounts,
-    token_metas: Vec<TokenAccountMeta>,
-    output_tree_index: u8,
+pub fn deposit_tokens<'info>(
+    cpi_accounts: &CpiAccounts<'_, 'info>,
+    mut token_metas: Vec<TokenAccountMeta>,
+    mut output_tree_index: u8,
     mint: Pubkey,
     recipient: Pubkey,
     amount: u64,
+    token_account_infos: &[AccountInfo<'info>],
 ) -> Result<()> {
+    // // Cpi context is part of the remaining accounts for the token program
+    // // but not for the system program.
+    // // We created the accounts from the system programs perspective
+    // this is true but there is a bug in the system program that adds the cpi context to the remaining accounts
+    // for token_meta in token_metas.iter_mut() {
+    //     token_meta.packed_tree_info.merkle_tree_pubkey_index += 1;
+    //     token_meta.packed_tree_info.queue_pubkey_index += 1;
+    // }
+    // output_tree_index += 1;
     let sender_account = CTokenAccount::new(
         mint,
         *cpi_accounts.fee_payer().key,
         token_metas,
         output_tree_index,
     );
+    let tree_pubkeys = cpi_accounts.tree_pubkeys().unwrap();
+    msg!("tree_pubkeys {:?}", tree_pubkeys);
+    let cpi_context_pubkey = tree_pubkeys[0];
+    msg!("cpi_context_pubkey {:?}", cpi_context_pubkey);
     let transfer_inputs = TransferInputs {
         fee_payer: *cpi_accounts.fee_payer().key,
         sender_account,
         // No validity proof necessary we are just storing things in the cpi context.
         validity_proof: None.into(),
         recipient,
-        tree_pubkeys: cpi_accounts.tree_pubkeys().unwrap(),
+        tree_pubkeys: tree_pubkeys[1..].to_vec(),
         config: Some(TransferConfig {
             cpi_context: Some(CompressedCpiContext {
                 set_context: true,
                 first_set_context: true,
-                cpi_context_account_index: (cpi_accounts.system_accounts_len() - 1) as u8,
+                cpi_context_account_index: 0, // TODO: replace with Pubkey (maybe not because it is in tree pubkeys 1 in this case)
             }),
+            cpi_context_pubkey: Some(cpi_context_pubkey),
             ..Default::default()
         }),
         amount,
     };
     let instruction =
         light_compressed_token_sdk::instructions::transfer::instruction::transfer(transfer_inputs)
             .unwrap();
+    msg!("instruction {:?}", instruction);
     // We can use the property that account infos don't have to be in order if you use
     // solana program invoke.
     let mut account_infos = cpi_accounts.account_infos().to_vec();
+    account_infos.extend_from_slice(token_account_infos);
     account_infos.push(cpi_accounts.fee_payer().clone());
+    account_infos.push(cpi_accounts.registered_program_pda().unwrap().clone());
+
     anchor_lang::solana_program::program::invoke(&instruction, account_infos.as_slice())?;
 
     Ok(())

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

@@ -1,10 +1,16 @@
 use anchor_lang::InstructionData;
+use light_client::indexer::CompressedTokenAccount;
 use light_compressed_token_sdk::{
-    instructions::batch_compress::{
-        get_batch_compress_instruction_account_metas, BatchCompressMetaConfig, Recipient,
+    instructions::{
+        batch_compress::{
+            get_batch_compress_instruction_account_metas, BatchCompressMetaConfig, Recipient,
+        },
+        transfer::account_metas::{
+            get_transfer_instruction_account_metas, TokenAccountsMetaConfig,
+        },
     },
     token_pool::find_token_pool_pda_with_index,
-    SPL_TOKEN_PROGRAM_ID,
+    TokenAccountMeta, SPL_TOKEN_PROGRAM_ID,
 };
 use light_program_test::{AddressWithTree, Indexer, LightProgramTest, ProgramTestConfig, Rpc};
 use light_sdk::{
@@ -32,49 +38,72 @@ async fn test_deposit_compressed_account() {
     .unwrap();
 
     let payer = rpc.get_payer().insecure_clone();
-    let owner = Keypair::new();
     let deposit_amount = 1000u64;
 
-    // Create recipients for batch compression
-    let recipient1 = Keypair::new().pubkey();
-    let recipient2 = Keypair::new().pubkey();
-
-    let recipients = vec![
-        Recipient {
-            pubkey: recipient1,
-            amount: 100_000,
-        },
-        Recipient {
-            pubkey: recipient2,
-            amount: 200_000,
-        },
-    ];
+    let recipients = vec![Recipient {
+        pubkey: payer.pubkey(),
+        amount: 100_000,
+    }];
 
     // Execute batch compress (this will create mint, token account, and compress)
-    batch_compress_spl_tokens(&mut rpc, &payer, recipients)
+    batch_compress_spl_tokens(&mut rpc, &payer, recipients.clone())
         .await
         .unwrap();
 
     println!("Batch compressed tokens successfully");
 
+    // Fetch the compressed token accounts created by batch compress
+    let recipient1 = recipients[0].pubkey;
+    let compressed_accounts = rpc
+        .indexer()
+        .unwrap()
+        .get_compressed_token_accounts_by_owner(&recipient1, None, None)
+        .await
+        .unwrap()
+        .value
+        .items;
+
+    assert!(
+        !compressed_accounts.is_empty(),
+        "Should have compressed token accounts"
+    );
+    let ctoken_account = &compressed_accounts[0];
+
+    println!(
+        "Found compressed token account: amount={}, owner={}",
+        ctoken_account.token.amount, ctoken_account.token.owner
+    );
+
     // Derive the address that will be created for deposit
     let address_tree_info = rpc.get_address_tree_v1();
-    let (address, _) = derive_address(
-        &[b"deposit", owner.pubkey().to_bytes().as_ref()],
+    let (deposit_address, _) = derive_address(
+        &[b"deposit", payer.pubkey().to_bytes().as_ref()],
         &address_tree_info.tree,
         &sdk_token_test::ID,
     );
 
-    // Create deposit instruction
-    create_deposit_compressed_account(&mut rpc, &payer, owner.pubkey(), deposit_amount)
-        .await
-        .unwrap();
+    // Derive recipient PDA from the deposit address
+    let (recipient_pda, _) = Pubkey::find_program_address(
+        &[b"recipient", deposit_address.as_ref()],
+        &sdk_token_test::ID,
+    );
+
+    // Create deposit instruction with the compressed token account
+    create_deposit_compressed_account(
+        &mut rpc,
+        &payer,
+        ctoken_account,
+        recipient_pda,
+        deposit_amount,
+    )
+    .await
+    .unwrap();
 
     println!("Created compressed account deposit successfully");
 
     // Verify the compressed account was created at the expected address
     let compressed_account = rpc
-        .get_compressed_account(address, None)
+        .get_compressed_account(deposit_address, None)
         .await
         .unwrap()
         .value;
@@ -87,33 +116,45 @@ async fn test_deposit_compressed_account() {
 async fn create_deposit_compressed_account(
     rpc: &mut LightProgramTest,
     payer: &Keypair,
-    owner: Pubkey,
+    ctoken_account: &CompressedTokenAccount,
+    recipient: Pubkey,
     amount: u64,
 ) -> Result<Signature, RpcError> {
     let tree_info = rpc.get_random_state_tree_info().unwrap();
+    println!("tree_info {:?}", tree_info);
 
     let mut remaining_accounts = PackedAccounts::default();
+    let config = TokenAccountsMetaConfig::new_client();
+    let metas = get_transfer_instruction_account_metas(config);
+    println!("metas {:?}", metas);
+    println!("metas len() {}", metas.len());
+    remaining_accounts.add_pre_accounts_metas(metas.as_slice());
 
-    let output_tree_index = tree_info
-        .pack_output_tree_index(&mut remaining_accounts)
-        .unwrap();
     let config = SystemAccountMetaConfig::new_with_cpi_context(
         sdk_token_test::ID,
         tree_info.cpi_context.unwrap(),
     );
+    println!("cpi_context {:?}", config);
     remaining_accounts.add_system_accounts(config);
-
     let address_tree_info = rpc.get_address_tree_v1();
 
     let (address, _) = derive_address(
-        &[b"deposit", owner.to_bytes().as_ref()],
+        &[b"deposit", payer.pubkey().to_bytes().as_ref()],
         &address_tree_info.tree,
         &sdk_token_test::ID,
     );
 
+    // Get mint from the compressed token account
+    let mint = ctoken_account.token.mint;
+    println!(
+        "ctoken_account.account.hash {:?}",
+        ctoken_account.account.hash
+    );
+    println!("ctoken_account.account {:?}", ctoken_account.account);
+    // Get validity proof for the compressed token account and new address
     let rpc_result = rpc
         .get_validity_proof(
-            vec![],
+            vec![ctoken_account.account.hash],
             vec![AddressWithTree {
                 address,
                 tree: address_tree_info.tree,
@@ -123,9 +164,25 @@ async fn create_deposit_compressed_account(
         .await?
         .value;
     let packed_accounts = rpc_result.pack_tree_infos(&mut remaining_accounts);
+    println!("packed_accounts {:?}", packed_accounts.state_trees);
 
-    let (remaining_accounts, _, _) = remaining_accounts.to_account_metas();
+    // Create token meta from compressed account
+    let tree_info = packed_accounts
+        .state_trees
+        .as_ref()
+        .unwrap()
+        .packed_tree_infos[0];
+
+    let token_metas = vec![TokenAccountMeta {
+        amount: ctoken_account.token.amount,
+        delegate_index: None,
+        packed_tree_info: tree_info,
+        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: [
@@ -136,8 +193,11 @@ async fn create_deposit_compressed_account(
         data: sdk_token_test::instruction::Deposit {
             proof: rpc_result.proof,
             address_tree_info: packed_accounts.address_trees[0],
-            output_tree_index,
+            output_tree_index: packed_accounts.state_trees.unwrap().output_tree_index,
             deposit_amount: amount,
+            token_metas,
+            mint,
+            recipient,
         }
         .data(),
     };
@@ -150,7 +210,7 @@ async fn batch_compress_spl_tokens(
     rpc: &mut LightProgramTest,
     payer: &Keypair,
     recipients: Vec<Recipient>,
-) -> Result<Signature, RpcError> {
+) -> Result<Pubkey, RpcError> {
     // Create mint and token account
     let mint = create_mint_helper(rpc, payer).await;
     println!("Created mint: {}", mint);
@@ -214,5 +274,7 @@ async fn batch_compress_spl_tokens(
     };
 
     rpc.create_and_send_transaction(&[instruction], &payer.pubkey(), &[payer])
-        .await
+        .await?;
+
+    Ok(mint)
 }