wip

SwenSchaeferjohann · SwenSchaeferjohann · commit 091fb97c2ae7 · 2025-08-10T18:28:48.000-04:00
diff --git a/program-tests/sdk-token-test/src/pda_ctoken/mint.rs b/program-tests/sdk-token-test/src/pda_ctoken/mint.rs
@@ -82,13 +82,13 @@ pub fn process_mint_action<'c, 'info>(
     account_infos.push(ctx.accounts.payer.to_account_info());
     account_infos.push(ctx.accounts.token_account.to_account_info());
     msg!("mint_action_instruction {:?}", mint_action_instruction);
-    msg!(
-        "account infos pubkeys {:?}",
-        account_infos
-            .iter()
-            .map(|info| info.key)
-            .collect::<Vec<_>>()
-    );
+    // msg!(
+    //     "account infos pubkeys {:?}",
+    //     account_infos
+    //         .iter()
+    //         .map(|info| info.key)
+    //         .collect::<Vec<_>>()
+    // );
     // Invoke the mint action instruction directly
     invoke(&mint_action_instruction, &account_infos)?;
 
diff --git a/programs/system/src/processor/create_address_cpi_data.rs b/programs/system/src/processor/create_address_cpi_data.rs
@@ -5,7 +5,7 @@ use light_compressed_account::{
     },
     Pubkey,
 };
-use pinocchio::{account_info::AccountInfo, program_error::ProgramError};
+use pinocchio::{account_info::AccountInfo, msg, program_error::ProgramError};
 
 use crate::{
     accounts::remaining_account_checks::AcpAccount, context::SystemContext,
@@ -24,6 +24,40 @@ pub fn derive_new_addresses<'info, 'a, 'b: 'a, const ADDRESS_ASSIGNMENT: bool>(
     let invoking_program_id_clone = context.invoking_program_id;
 
     for (i, new_address_params) in new_address_params.enumerate() {
+        let tree_index = new_address_params.address_merkle_tree_account_index() as usize;
+
+        let account_type = match &accounts[tree_index] {
+            AcpAccount::Authority(_) => "Authority",
+            AcpAccount::RegisteredProgramPda(_) => "RegisteredProgramPda",
+            AcpAccount::SystemProgram(_) => "SystemProgram",
+            AcpAccount::OutputQueue(_) => "OutputQueue",
+            AcpAccount::BatchedStateTree(_) => "BatchedStateTree",
+            AcpAccount::BatchedAddressTree(_) => "BatchedAddressTree",
+            AcpAccount::StateTree(_) => "StateTree",
+            AcpAccount::AddressTree(_) => "AddressTree",
+            AcpAccount::AddressQueue(_, _) => "AddressQueue",
+            AcpAccount::V1Queue(_) => "V1Queue",
+            AcpAccount::Unknown() => "Unknown",
+        };
+        msg!(&format!("accounts[{}] type: {}", tree_index, account_type));
+        let pubkey = match &accounts[tree_index] {
+            AcpAccount::AddressTree((pubkey, _)) => pubkey,
+            AcpAccount::BatchedAddressTree(tree) => tree.pubkey(),
+            _ => {
+                msg!(&format!(
+                    "Account at index {:?} is not an address tree",
+                    tree_index
+                ));
+
+                return Err(
+                    SystemProgramError::AddressMerkleTreeAccountDiscriminatorMismatch.into(),
+                );
+            }
+        };
+        msg!(&format!(
+            "new_address_params: address_merkle_tree_account_index = {}, pubkey = {:?}",
+            tree_index, pubkey
+        ));
         let (address, rollover_fee) =
             match &accounts[new_address_params.address_merkle_tree_account_index() as usize] {
                 AcpAccount::AddressTree((pubkey, _)) => {
diff --git a/programs/system/src/processor/process.rs b/programs/system/src/processor/process.rs
@@ -102,6 +102,17 @@ pub fn process<
 
     let cpi_outputs_data_len =
         inputs.get_cpi_context_outputs_end_offset() - inputs.get_cpi_context_outputs_start_offset();
+    msg!(&format!("cpi_outputs_data_len {:?}", cpi_outputs_data_len));
+    msg!(&format!(
+        "cpi_context_inputs_len {:?}",
+        cpi_context_inputs_len
+    ));
+    msg!(&format!("num_new_addresses {:?}", num_new_addresses));
+    msg!(&format!("num_input_accounts {:?}", num_input_accounts));
+    msg!(&format!(
+        "num_output_compressed_accounts {:?}",
+        num_output_compressed_accounts
+    ));
     // 1. Allocate cpi data and initialize context
     let (mut context, mut cpi_ix_bytes) = create_cpi_data_and_context(
         ctx,
diff --git a/programs/system/src/processor/verify_proof.rs b/programs/system/src/processor/verify_proof.rs
@@ -115,6 +115,32 @@ fn read_root<const IS_READ_ONLY: bool, const IS_STATE: bool>(
     roots: &mut Vec<[u8; 32]>,
 ) -> Result<u8, SystemProgramError> {
     let height;
+
+    let account_type = match &merkle_tree_account {
+        AcpAccount::Authority(_) => "Authority",
+        AcpAccount::RegisteredProgramPda(_) => "RegisteredProgramPda",
+        AcpAccount::SystemProgram(_) => "SystemProgram",
+        AcpAccount::OutputQueue(_) => "OutputQueue",
+        AcpAccount::BatchedStateTree(_) => "BatchedStateTree",
+        AcpAccount::BatchedAddressTree(_) => "BatchedAddressTree",
+        AcpAccount::StateTree(_) => "StateTree",
+        AcpAccount::AddressTree(_) => "AddressTree",
+        AcpAccount::AddressQueue(_, _) => "AddressQueue",
+        AcpAccount::V1Queue(_) => "V1Queue",
+        AcpAccount::Unknown() => "Unknown",
+    };
+    msg!(&format!("merkle_tree_account type: {}", account_type));
+    let pubkey = match &merkle_tree_account {
+        AcpAccount::AddressTree((pubkey, _)) => pubkey,
+        AcpAccount::BatchedAddressTree(tree) => tree.pubkey(),
+        _ => {
+            msg!("fu");
+            return Err(SystemProgramError::AddressMerkleTreeAccountDiscriminatorMismatch.into());
+        }
+    };
+
+    msg!(&format!("root_index:{:?} pubkey: {:?}", root_index, pubkey));
+
     match merkle_tree_account {
         AcpAccount::AddressTree((_, merkle_tree)) => {
             if IS_READ_ONLY {
@@ -146,6 +172,7 @@ fn read_root<const IS_READ_ONLY: bool, const IS_STATE: bool>(
             return if IS_STATE {
                 Err(SystemProgramError::StateMerkleTreeAccountDiscriminatorMismatch)
             } else {
+                msg!("is_state: false");
                 Err(SystemProgramError::AddressMerkleTreeAccountDiscriminatorMismatch)
             }
         }
diff --git a/sdk-libs/program-test/src/indexer/test_indexer.rs b/sdk-libs/program-test/src/indexer/test_indexer.rs
@@ -1918,6 +1918,8 @@ impl TestIndexer {
                 queues.push(bundle.accounts.nullifier_queue);
                 cpi_contextes.push(bundle.accounts.cpi_context);
                 tree_types.push(bundle.tree_type);
+                println!("merkle_tree {:?}", merkle_tree);
+                println!("account {:?}", account);
                 let leaf_index = merkle_tree.get_leaf_index(account).unwrap();
                 let proof = merkle_tree.get_proof_of_leaf(leaf_index, true).unwrap();
 
diff --git a/sdk-tests/anchor-compressible/src/lib.rs b/sdk-tests/anchor-compressible/src/lib.rs
@@ -33,8 +33,10 @@ pub const LIGHT_CPI_SIGNER: CpiSigner =
 pub mod anchor_compressible {
 
     use light_compressed_token_sdk::instructions::{
-        mint_action::MintActionCpiWriteAccounts, mint_action_cpi_write, MintActionInputsCpiWrite,
+        create_mint_action_cpi, mint_action::MintActionCpiWriteAccounts, mint_action_cpi_write,
+        MintActionInputs, MintActionInputsCpiWrite,
     };
+    use light_sdk_types::cpi_context_write::CpiContextWriteAccounts;
 
     use super::*;
 
@@ -180,7 +182,7 @@ pub mod anchor_compressible {
             "program: remaining_accounts len: {:?}",
             ctx.remaining_accounts.len()
         );
-        msg!("program: remaining_accounts: {:?}", ctx.remaining_accounts);
+        // msg!("program: remaining_accounts: {:?}", ctx.remaining_accounts);
         // Validate we have matching number of PDAs, compressed accounts, and bumps
         if solana_accounts.len() != compressed_accounts.len()
             || solana_accounts.len() != bumps.len()
@@ -399,91 +401,27 @@ pub mod anchor_compressible {
         game_session.end_time = None;
         game_session.score = 0;
 
-        let cpi_config = CpiAccountsConfig::new_with_cpi_context(LIGHT_CPI_SIGNER);
-
-        msg!("program: remaining_accounts: {:?}", ctx.remaining_accounts);
         // Create CPI accounts from remaining accounts
         let cpi_accounts = CpiAccountsSmall::new_with_config(
             ctx.accounts.user.as_ref(),
             ctx.remaining_accounts,
-            cpi_config,
+            CpiAccountsConfig::new_with_cpi_context(LIGHT_CPI_SIGNER),
         );
+        let cpi_context_pubkey = cpi_accounts.cpi_context().unwrap().key();
+        let cpi_context_account = cpi_accounts.cpi_context().unwrap();
 
         msg!(
             "program: cpi_accounts.cpi_context(): {:?}",
             cpi_accounts.cpi_context()
         );
 
-        let actions = vec![
-            // MintActionType::MintTo {
-            //     recipients: input.token_recipients.clone(),
-            //     lamports: input.lamports,
-            //     token_account_version: input.compressed_mint_with_context.mint.version,
-            // },
-            // MintActionType::UpdateMintAuthority {
-            //     new_authority: input.final_mint_authority,
-            // },
-            // MintActionType::MintToDecompressed {
-            //     account: ctx.accounts.token_account.key(),
-            //     amount: input
-            //         .token_recipients
-            //         .first()
-            //         .map(|r| r.amount)
-            //         .unwrap_or(1000),
-            //     compressible_config: None,
-            // },
-        ];
-
-        let mint_action_inputs = MintActionInputsCpiWrite {
-            compressed_mint_inputs: compression_params.mint_with_context.clone().into(),
-            mint_seed: Some(ctx.accounts.mint_signer.key()),
-            mint_bump: Some(compression_params.mint_bump),
-            create_mint: true,
-            authority: ctx.accounts.mint_authority.key(),
-            payer: ctx.accounts.user.key(),
-            actions,
-            input_queue: None, // Not needed for create_mint: true
-            cpi_context: light_ctoken_types::instructions::mint_actions::CpiContext {
-                set_context: false,
-                first_set_context: true,
-                in_tree_index: 0,
-                in_queue_index: 1,
-                out_queue_index: 1,
-                token_out_queue_index: 1,
-                assigned_account_index: 0,
-            },
-            cpi_context_pubkey: *cpi_accounts.cpi_context().unwrap().key,
-        };
-
-        let mint_action_instruction = mint_action_cpi_write(mint_action_inputs).unwrap();
-        let mint_action_account_infos = MintActionCpiWriteAccounts {
-            light_system_program: cpi_accounts.system_program().unwrap(),
-            mint_signer: Some(ctx.accounts.mint_signer.as_ref()),
-            authority: ctx.accounts.mint_authority.as_ref(),
-            fee_payer: ctx.accounts.user.as_ref(),
-            cpi_authority_pda: ctx.accounts.compress_token_program_cpi_authority.as_ref(),
-            cpi_context: cpi_accounts.cpi_context().unwrap(),
-            cpi_signer: crate::LIGHT_CPI_SIGNER,
-            recipient_token_accounts: vec![], // why needed.
-        };
-
-        msg!("invoke token start!");
-        msg!("mint_action_account_infos: {:?}", mint_action_account_infos);
-
-        invoke(
-            &mint_action_instruction,
-            &mint_action_account_infos.to_account_infos(),
-        )?;
-
-        msg!("invoke token done!");
-
         // Prepare new address params. One per pda account.
         let user_new_address_params = compression_params
             .user_address_tree_info
-            .into_new_address_params_assigned_packed(user_record.key().to_bytes(), true, Some(1));
+            .into_new_address_params_assigned_packed(user_record.key().to_bytes(), true, Some(0));
         let game_new_address_params = compression_params
             .game_address_tree_info
-            .into_new_address_params_assigned_packed(game_session.key().to_bytes(), true, Some(2));
+            .into_new_address_params_assigned_packed(game_session.key().to_bytes(), true, Some(1));
 
         let mut all_compressed_infos = Vec::new();
 
@@ -521,28 +459,99 @@ pub mod anchor_compressible {
         )?;
         all_compressed_infos.extend(game_compressed_infos);
 
-        // Create CPI inputs with all compressed accounts and new addresses
-        // let cpi_inputs = CpiInputs::new_with_address(
-        //     compression_params.proof,
-        //     all_compressed_infos,
-        //     vec![user_new_address_params, game_new_address_params],
-        // );
         let cpi_inputs = CpiInputs {
-            proof: compression_params.proof,
+            proof: ValidityProof(None), //compression_params.proof,
             account_infos: Some(all_compressed_infos),
             new_assigned_addresses: Some(vec![user_new_address_params, game_new_address_params]),
             cpi_context: Some(CompressedCpiContext {
                 set_context: false,
-                first_set_context: false,
-                cpi_context_account_index: 0,
+                first_set_context: true,
+                cpi_context_account_index: 0, // Unused
             }),
             ..Default::default()
         };
         msg!("invoke .pda");
 
-        // Invoke light system program to create all compressed accounts in one
-        // CPI. Call at the end of your init instruction.
-        cpi_inputs.invoke_light_system_program_small(cpi_accounts)?;
+        let cpi_context_accounts = CpiContextWriteAccounts {
+            fee_payer: cpi_accounts.fee_payer(),
+            authority: cpi_accounts.authority().unwrap(),
+            cpi_context: cpi_context_account,
+            cpi_signer: LIGHT_CPI_SIGNER,
+        };
+        cpi_inputs.invoke_light_system_program_cpi_context(cpi_context_accounts)?;
+
+        let actions = vec![];
+
+        // TODO: pass.
+        msg!("TREE ACCOUNTS {:?}", cpi_accounts.tree_accounts().unwrap());
+        let output_queue = *cpi_accounts.tree_accounts().unwrap()[0].key; // Same tree as PDA
+        let address_tree_pubkey = *cpi_accounts.tree_accounts().unwrap()[1].key; // Same tree as PDA
+
+        msg!("output_queue {:?}", output_queue);
+        msg!("address_tree_pubkey {:?}", address_tree_pubkey);
+        msg!("mint_authority {:?}", ctx.accounts.mint_authority.key);
+        msg!("mint_authority {:?}", ctx.accounts.mint_authority.is_signer);
+        msg!("mint_signer {:?}", ctx.accounts.mint_signer.key);
+        msg!("mint_signer {:?}", ctx.accounts.mint_signer.is_signer);
+        let mint_action_inputs = MintActionInputs {
+            compressed_mint_inputs: compression_params.mint_with_context.clone().into(),
+            mint_seed: ctx.accounts.mint_signer.key(),
+            mint_bump: Some(compression_params.mint_bump),
+            create_mint: true,
+            authority: ctx.accounts.mint_authority.key(),
+            payer: ctx.accounts.user.key(),
+            proof: compression_params.proof.into(),
+            actions,
+            input_queue: None, // Not needed for create_mint: true
+            output_queue,
+            tokens_out_queue: Some(output_queue), // For MintTo actions
+            address_tree_pubkey,
+        };
+
+        let mint_action_instruction = create_mint_action_cpi(
+            mint_action_inputs,
+            Some(light_ctoken_types::instructions::mint_actions::CpiContext {
+                set_context: false,
+                first_set_context: false,
+                in_tree_index: 1, // address tree
+                in_queue_index: 0,
+                out_queue_index: 0,
+                token_out_queue_index: 0,
+                assigned_account_index: 2,
+            }),
+            Some(cpi_context_pubkey),
+        )
+        .unwrap();
+
+        msg!("invoke token start!");
+        // Get all account infos needed for the mint action
+        let mut account_infos = cpi_accounts.to_account_infos();
+        account_infos.push(
+            ctx.accounts
+                .compress_token_program_cpi_authority
+                .to_account_info(),
+        );
+        account_infos.push(ctx.accounts.compressed_token_program.to_account_info());
+        account_infos.push(ctx.accounts.mint_authority.to_account_info());
+        account_infos.push(ctx.accounts.mint_signer.to_account_info());
+        account_infos.push(ctx.accounts.user.to_account_info());
+        // account_infos.push(ctx.accounts.token_account.to_account_info());
+        msg!(
+            "mint_action_instruction {:?}",
+            mint_action_instruction.accounts
+        );
+        // msg!("account_infos {:?}", account_infos);
+        msg!(
+            "account infos pubkeys {:?}",
+            account_infos
+                .iter()
+                .map(|info| info.key)
+                .collect::<Vec<_>>()
+        );
+        // Invoke the mint action instruction directly
+        invoke(&mint_action_instruction, &account_infos)?;
+
+        msg!("invoke token done!");
 
         Ok(())
     }
diff --git a/sdk-tests/anchor-compressible/tests/test_decompress_multiple.rs b/sdk-tests/anchor-compressible/tests/test_decompress_multiple.rs
