wip

SwenSchaeferjohann · SwenSchaeferjohann · commit ad97e477c146 · 2025-08-17T19:04:16.000-04:00
diff --git a/js/stateless.js/src/constants.ts b/js/stateless.js/src/constants.ts
@@ -167,7 +167,7 @@ export const localTestActiveStateTreeInfos = (): TreeInfo[] => {
         {
             tree: new PublicKey(batchMerkleTree),
             queue: new PublicKey(batchQueue),
-            cpiContext: PublicKey.default,
+            cpiContext: new PublicKey(batchCpiContext),
             treeType: TreeType.StateV2,
             nextTreeInfo: null,
         },
@@ -258,7 +258,8 @@ export const cpiContext2Pubkey = 'cpi2cdhkH5roePvcudTgUL8ppEBfTay1desGh8G8QxK';
 // V2 testing.
 export const batchMerkleTree = 'HLKs5NJ8FXkJg8BrzJt56adFYYuwg5etzDtBbQYTsixu'; // v2 merkle tree (includes nullifier queue)
 export const batchQueue = '6L7SzhYB3anwEQ9cphpJ1U7Scwj57bx2xueReg7R9cKU'; // v2 output queue
-
+// export const batchCpiContext = '7Hp52chxaew8bW1ApR4fck2bh6Y8qA1pu3qwH6N9zaLj';
+export const batchCpiContext = 'HwtjxDvFEXiWnzeMeWkMBzpQN45A95rTJNZmz1Z3pe8R';
 export const confirmConfig: ConfirmOptions = {
     commitment: 'confirmed',
     preflightCommitment: 'confirmed',
diff --git a/js/stateless.js/src/utils/validation.ts b/js/stateless.js/src/utils/validation.ts
@@ -4,6 +4,7 @@ import {
     CompressedAccountWithMerkleContext,
     bn,
 } from '../state';
+import { featureFlags } from '../constants';
 
 export const validateSufficientBalance = (balance: BN) => {
     if (balance.lt(bn(0))) {
@@ -38,7 +39,15 @@ export const validateNumbersForProof = (
                 `Invalid number of compressed accounts for proof: ${hashesLength}. Allowed numbers: ${[1, 2, 3, 4].join(', ')}`,
             );
         }
-        validateNumbers(hashesLength, [1, 2, 3, 4], 'compressed accounts');
+        if (!featureFlags.isV2()) {
+            validateNumbers(hashesLength, [1, 2, 3, 4], 'compressed accounts');
+        } else {
+            validateNumbers(
+                hashesLength,
+                [1, 2, 3, 4, 8],
+                'compressed accounts',
+            );
+        }
         validateNumbersForNonInclusionProof(newAddressesLength);
     } else {
         if (hashesLength > 0) {
@@ -51,14 +60,22 @@ export const validateNumbersForProof = (
 
 /// Ensure that the amount if compressed accounts is allowed.
 export const validateNumbersForInclusionProof = (hashesLength: number) => {
-    validateNumbers(hashesLength, [1, 2, 3, 4, 8], 'compressed accounts');
+    if (!featureFlags.isV2()) {
+        validateNumbers(hashesLength, [1, 2, 3, 4], 'compressed accounts');
+    } else {
+        validateNumbers(hashesLength, [1, 2, 3, 4, 8], 'compressed accounts');
+    }
 };
 
 /// Ensure that the amount if new addresses is allowed.
 export const validateNumbersForNonInclusionProof = (
     newAddressesLength: number,
 ) => {
-    validateNumbers(newAddressesLength, [1, 2], 'new addresses');
+    if (!featureFlags.isV2()) {
+        validateNumbers(newAddressesLength, [1, 2], 'new addresses');
+    } else {
+        validateNumbers(newAddressesLength, [1, 2, 3, 4], 'new addresses');
+    }
 };
 
 /// V1 circuit safeguards.
diff --git a/program-libs/account-checks/src/checks.rs b/program-libs/account-checks/src/checks.rs
@@ -1,3 +1,6 @@
+use solana_msg::msg;
+use solana_pubkey::Pubkey;
+
 use crate::{
     discriminator::{Discriminator, DISCRIMINATOR_LEN},
     error::AccountError,
@@ -130,6 +133,12 @@ pub fn check_owner<A: AccountInfoTrait>(
     account_info: &A,
 ) -> Result<(), AccountError> {
     if !account_info.is_owned_by(owner) {
+        msg!("account_info.pubkey(): {:?}", account_info.pubkey());
+        msg!(
+            "account_info.key(): {:?}",
+            Pubkey::new_from_array(account_info.key())
+        );
+        msg!("owner: {}", Pubkey::new_from_array(*owner));
         return Err(AccountError::AccountOwnedByWrongProgram);
     }
     Ok(())
diff --git a/program-libs/zero-copy/src/vec.rs b/program-libs/zero-copy/src/vec.rs
@@ -7,6 +7,7 @@ use core::{
 #[cfg(feature = "std")]
 use std::vec::Vec;
 
+// use pinocchio::{format, msg};
 use zerocopy::{little_endian::U32, Ref};
 
 use crate::{add_padding, errors::ZeroCopyError, ZeroCopyTraits};
diff --git a/programs/system/src/cpi_context/process_cpi_context.rs b/programs/system/src/cpi_context/process_cpi_context.rs
@@ -59,32 +59,43 @@ pub fn process_cpi_context<'a, 'info, T: InstructionData<'a>>(
             Some(cpi_context_account_info) => cpi_context_account_info,
             None => return Err(SystemProgramError::CpiContextAccountUndefined.into()),
         };
+        msg!("deserializing cpi context account");
         let mut cpi_context_account = deserialize_cpi_context_account(cpi_context_account_info)?;
+        msg!("cpi context account deserialized");
         // We only validate when executing with the cpi context.
         if !cpi_context.first_set_context && !cpi_context.set_context {
+            msg!("validating cpi context associated with merkle tree");
             validate_cpi_context_associated_with_merkle_tree(
                 &instruction_data,
                 &cpi_context_account,
                 remaining_accounts,
             )?;
+            msg!("cpi context associated with merkle tree validated");
         }
         if cpi_context.set_context || cpi_context.first_set_context {
+            msg!("setting cpi context");
             set_cpi_context(fee_payer, cpi_context_account_info, instruction_data)?;
+            msg!("cpi context set");
             return Ok(None);
         } else {
             if cpi_context_account.is_empty() {
+                msg!("cpi context is empty");
                 return Err(SystemProgramError::CpiContextEmpty.into());
             }
+            msg!("checking fee payer");
             if (*cpi_context_account.fee_payer).to_bytes() != fee_payer {
+                msg!("fee payer mismatch");
                 msg!(format!(" {:?} != {:?}", fee_payer, cpi_context_account.fee_payer).as_str());
                 return Err(SystemProgramError::CpiContextFeePayerMismatch.into());
             }
             // Zero out the fee payer since the cpi context is being consumed in this instruction.
             *cpi_context_account.fee_payer = Pubkey::default().into();
             instruction_data.set_cpi_context(cpi_context_account)?;
+            msg!("cpi context set final exit");
             return Ok(Some((1, instruction_data)));
         }
     }
+    msg!("cpi context is none");
     Ok(Some((0, instruction_data)))
 }
 pub fn set_cpi_context<'a, 'info, T: InstructionData<'a>>(
@@ -106,20 +117,31 @@ pub fn set_cpi_context<'a, 'info, T: InstructionData<'a>>(
     // relay_fee
     // 2. Subsequent invocations check the proof and fee payer
 
+    msg!("set_cpi_context: deserializing cpi context account");
     let mut cpi_context_account =
         deserialize_cpi_context_account(cpi_context_account_info).map_err(ProgramError::from)?;
+    msg!("set_cpi_context: cpi context account deserialized");
 
     if instruction_data.cpi_context().unwrap().first_set_context {
+        msg!("set_cpi_context: clearing cpi context");
         cpi_context_account.clear();
+        msg!("set_cpi_context: setting fee payer");
         *cpi_context_account.fee_payer = fee_payer.into();
+        msg!("set_cpi_context: storing instruction data 1");
         cpi_context_account.store_data(&instruction_data)?;
+        msg!("set_cpi_context: instruction data stored 1");
     } else if *cpi_context_account.fee_payer == fee_payer && !cpi_context_account.is_empty() {
+        msg!("set_cpi_context: storing instruction data 2");
         cpi_context_account.store_data(&instruction_data)?;
+        msg!("set_cpi_context: instruction data stored 2");
     } else {
+        msg!("set_cpi_context: fee payer mismatch");
         msg!(format!(" {:?} != {:?}", fee_payer, cpi_context_account.fee_payer).as_str());
         return Err(SystemProgramError::CpiContextFeePayerMismatch.into());
     }
 
+    msg!("set_cpi_context: DONE. exit");
+
     Ok(())
 }
 /*
diff --git a/programs/system/src/cpi_context/state.rs b/programs/system/src/cpi_context/state.rs
@@ -72,9 +72,13 @@ impl<'a> ZCpiContextAccount<'a> {
         &'a mut self,
         instruction_data: &crate::context::WrappedInstructionData<'b, T>,
     ) -> Result<(), light_zero_copy::errors::ZeroCopyError> {
+        msg!("store_data: entry");
         let pre_address_len = self.new_addresses.len();
+        msg!(&format!("pre_address_len: {}", pre_address_len));
+
         // Store new addresses
         for address in instruction_data.new_addresses() {
+            msg!("store_data: new address loop");
             let new_address = CpiContextNewAddressParamsAssignedPacked {
                 owner: instruction_data.owner().to_bytes(), // Use instruction data owner
                 seed: address.seed(),
@@ -90,13 +94,22 @@ impl<'a> ZCpiContextAccount<'a> {
                     as u8
                     + pre_address_len as u8,
             };
-            // msg!(format!("cpi context new address {:?}", new_address).as_str());
+            msg!(&format!("cpi context new address {:?}", new_address));
+
+            msg!(&format!(
+                "push: entry to len {} capacity {}",
+                self.new_addresses.len(),
+                self.new_addresses.capacity()
+            ));
+            msg!(&format!("new_address: {:?}", new_address));
             self.new_addresses.push(new_address)?;
+            msg!("store_data: new address pushed");
         }
 
         // Store input accounts
         for input in instruction_data.input_accounts() {
             if input.skip() {
+                msg!("store_data: input account skipped");
                 continue;
             }
             let in_account = CpiContextInAccount {
@@ -137,6 +150,7 @@ impl<'a> ZCpiContextAccount<'a> {
         // Store output accounts
         for output in instruction_data.output_accounts() {
             if output.skip() {
+                msg!("store_data: output account skipped");
                 // TODO: check what skip does
                 continue;
             }
@@ -149,9 +163,11 @@ impl<'a> ZCpiContextAccount<'a> {
                 with_address: if output.address().is_some() { 1 } else { 0 },
                 address: output.address().unwrap_or([0; 32]),
             };
+            msg!("store_data: output account pushed");
             self.out_accounts.push(out_account)?;
             sol_log_compute_units();
             if let Some(data) = output.data() {
+                msg!("store_data: output data");
                 // 330 CU
                 *self.output_data_len += 1;
                 // TODO: add unchecked new at this will fail with MemoryNotZeroed
@@ -162,10 +178,11 @@ impl<'a> ZCpiContextAccount<'a> {
                 new_data.as_mut_slice().copy_from_slice(&data.data);
                 self.output_data.push(new_data);
                 self.remaining_data = remaining_data;
+                msg!("self.remaining_data: updated");
             }
             sol_log_compute_units();
         }
-
+        msg!("store_data: exit");
         Ok(())
     }
 }
@@ -178,38 +195,50 @@ impl Discriminator for ZCpiContextAccount<'_> {
 pub fn deserialize_cpi_context_account<'a>(
     account_info: &AccountInfo,
 ) -> std::result::Result<ZCpiContextAccount<'a>, ZeroCopyError> {
+    msg!("deserialize_cpi_context_account: checking owner");
     check_owner(&ID, account_info).map_err(|_| ZeroCopyError::IterFromOutOfBounds)?;
+    msg!("deserialize_cpi_context_account: owner checked");
     let mut account_data = account_info
         .try_borrow_mut_data()
         .map_err(|_| ZeroCopyError::IterFromOutOfBounds)?;
+    msg!("deserialize_cpi_context_account: account data borrowed");
     let data = unsafe { slice::from_raw_parts_mut(account_data.as_mut_ptr(), account_data.len()) };
+    msg!("deserialize_cpi_context_account: data sliced");
     let (discriminator, data) = data.split_at_mut(8);
+    msg!("deserialize_cpi_context_account: discriminator checked");
     if discriminator != &CPI_CONTEXT_ACCOUNT_DISCRIMINATOR {
         msg!("Invalid cpi context account discriminator.");
         return Err(ZeroCopyError::IterFromOutOfBounds);
     }
+    msg!("deserialize_cpi_context_account: fee payer checked");
     let (fee_payer, data) =
         Ref::<&'a mut [u8], light_compressed_account::pubkey::Pubkey>::from_prefix(data)?;
-
+    msg!("deserialize_cpi_context_account: associated merkle tree checked");
     let (associated_merkle_tree, data) =
         Ref::<&'a mut [u8], light_compressed_account::pubkey::Pubkey>::from_prefix(data)?;
-
+    msg!("deserialize_cpi_context_account: new addresses checked");
     let (new_addresses, data) =
         ZeroCopyVecU8::<'a, CpiContextNewAddressParamsAssignedPacked>::from_bytes_at(data)?;
+    msg!("deserialize_cpi_context_account: readonly addresses checked");
     let (readonly_addresses, data) =
         ZeroCopyVecU8::<'a, ZPackedReadOnlyAddress>::from_bytes_at(data)?;
+    msg!("deserialize_cpi_context_account: readonly accounts checked");
     let (readonly_accounts, data) =
         ZeroCopyVecU8::<'a, ZPackedReadOnlyCompressedAccount>::from_bytes_at(data)?;
+    msg!("deserialize_cpi_context_account: in accounts checked");
     let (in_accounts, data) = ZeroCopyVecU8::<'a, CpiContextInAccount>::from_bytes_at(data)?;
+    msg!("deserialize_cpi_context_account: in accounts checked");
     let (out_accounts, data) = ZeroCopyVecU8::<'a, CpiContextOutAccount>::from_bytes_at(data)?;
+    msg!("deserialize_cpi_context_account: out accounts checked");
     let (output_data_len, mut data) = Ref::<&'a mut [u8], U16>::from_prefix(data)?;
+    msg!("deserialize_cpi_context_account: output data len checked");
     let mut output_data = Vec::with_capacity(output_data_len.get() as usize);
     for _ in 0..output_data_len.get() {
         let (output_data_slice, inner_data) = ZeroCopySliceMut::<U16, u8>::from_bytes_at(data)?;
         output_data.push(output_data_slice);
         data = inner_data;
     }
-
+    msg!("deserialize_cpi_context_account: cpi context account created..");
     Ok(ZCpiContextAccount {
         fee_payer,
         associated_merkle_tree,
@@ -291,7 +320,7 @@ pub fn cpi_context_account_new<'a>(
             data,
         )?;
     let (readonly_addresses, data) =
-        ZeroCopyVecU8::<'a, ZPackedReadOnlyAddress>::new_at(params.readonly_accounts_len, data)?;
+        ZeroCopyVecU8::<'a, ZPackedReadOnlyAddress>::new_at(params.readonly_addresses_len, data)?;
     let (readonly_accounts, data) = ZeroCopyVecU8::<'a, ZPackedReadOnlyCompressedAccount>::new_at(
         params.readonly_accounts_len,
         data,
diff --git a/programs/system/src/invoke_cpi/instruction_small.rs b/programs/system/src/invoke_cpi/instruction_small.rs
@@ -1,8 +1,3 @@
-use light_account_checks::AccountIterator;
-use light_compressed_account::instruction_data::traits::AccountOptions;
-use pinocchio::account_info::AccountInfo;
-use pinocchio::msg;
-use pinocchio::pubkey::Pubkey;
 use crate::{
     accounts::{
         account_checks::{
@@ -14,6 +9,11 @@ use crate::{
     errors::SystemProgramError,
     Result,
 };
+use light_account_checks::AccountIterator;
+use light_compressed_account::instruction_data::traits::AccountOptions;
+use pinocchio::account_info::AccountInfo;
+use pinocchio::msg;
+use pinocchio::pubkey::Pubkey;
 
 #[derive(PartialEq, Eq)]
 pub struct ExecutionAccounts<'info> {
@@ -75,9 +75,16 @@ impl<'info> InvokeCpiInstructionSmall<'info> {
             None
         };
 
+        msg!("trying cpi context account");
         let cpi_context_account = check_option_cpi_context_account(&mut accounts, account_options)?;
+        msg!(&format!(
+            "trying cpi context account {:?}",
+            cpi_context_account.map(|a| a.key())
+        ));
         // msg!(&format!("!account_options.write_to_cpi_context: {:?}", !account_options.write_to_cpi_context));
+
         let remaining_accounts = if !account_options.write_to_cpi_context {
+            msg!("2222");
             accounts.remaining()?
         } else {
             &[]
@@ -90,7 +97,7 @@ impl<'info> InvokeCpiInstructionSmall<'info> {
         //             .map(|a| Pubkey::try_from(a.key().as_ref()).unwrap())
         //             .collect::<Vec<_>>()
         //     )
-        // );        
+        // );
         Ok((
             Self {
                 fee_payer,
diff --git a/programs/system/src/invoke_cpi/processor.rs b/programs/system/src/invoke_cpi/processor.rs
@@ -1,5 +1,5 @@
 use light_compressed_account::instruction_data::traits::InstructionData;
-use pinocchio::{account_info::AccountInfo, pubkey::Pubkey};
+use pinocchio::{account_info::AccountInfo, msg, pubkey::Pubkey};
 
 pub use crate::Result;
 use crate::{
@@ -29,13 +29,15 @@ pub fn process_invoke_cpi<
     instruction_data: T,
     remaining_accounts: &'info [AccountInfo],
 ) -> Result<()> {
+    msg!("process_invoke_cpi");
     let instruction_data = WrappedInstructionData::new(instruction_data)?;
 
     cpi_signer_checks::<T>(
         &invoking_program,
         accounts.get_authority().key(),
         &instruction_data,
     )?;
+    msg!("cpi_signer_checks done");
 
     let (cpi_context_inputs_len, instruction_data) = match process_cpi_context(
         instruction_data,
diff --git a/programs/system/src/lib.rs b/programs/system/src/lib.rs
diff --git a/sdk-libs/sdk/src/compressible/compress_account_on_init.rs b/sdk-libs/sdk/src/compressible/compress_account_on_init.rs
