force apps to pass the whole signer_seeds directly

Author: SwenSchaeferjohann

Cargo.lock

@@ -6,7 +6,6 @@ use light_sdk::{
     light_hasher::{DataHasher, Hasher},
 };
 use light_sdk::{derive_light_cpi_signer, LightDiscriminator, LightHasher};
-use light_sdk_types::CpiAccountsConfig;
 use light_sdk_types::CpiSigner;
 
 declare_id!("CompUser11111111111111111111111111111111111");
@@ -81,14 +80,15 @@ pub mod anchor_compressible_user {
         ctx: Context<'_, '_, '_, 'info, DecompressMultiplePdas<'info>>,
         proof: ValidityProof,
         compressed_accounts: Vec<CompressedAccountData>,
+        bumps: Vec<u8>,
         system_accounts_offset: u8,
     ) -> Result<()> {
         // Get PDA accounts from remaining accounts
         let pda_accounts_end = system_accounts_offset as usize;
         let pda_accounts = &ctx.remaining_accounts[..pda_accounts_end];
 
-        // Validate we have matching number of PDAs and compressed accounts
-        if pda_accounts.len() != compressed_accounts.len() {
+        // Validate we have matching number of PDAs, compressed accounts, and bumps
+        if pda_accounts.len() != compressed_accounts.len() || pda_accounts.len() != bumps.len() {
             return err!(ErrorCode::InvalidAccountCount);
         }
 
@@ -101,8 +101,13 @@ pub mod anchor_compressible_user {
         // Convert to unified enum accounts
         let mut light_accounts = Vec::new();
         let mut pda_account_refs = Vec::new();
+        let mut signer_seeds_storage = Vec::new();
 
-        for (i, compressed_data) in compressed_accounts.into_iter().enumerate() {
+        for (i, (compressed_data, bump)) in compressed_accounts
+            .into_iter()
+            .zip(bumps.iter())
+            .enumerate()
+        {
             // Convert to unified enum type
             let unified_account = match compressed_data.data {
                 CompressedAccountVariant::UserRecord(data) => {
@@ -116,23 +121,52 @@ pub mod anchor_compressible_user {
             let light_account = LightAccount::<'_, CompressedAccountVariant>::new_mut(
                 &crate::ID,
                 &compressed_data.meta,
-                unified_account,
+                unified_account.clone(),
             )
             .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?;
 
+            // Build signer seeds based on account type
+            let seeds = match &unified_account {
+                CompressedAccountVariant::UserRecord(data) => {
+                    vec![
+                        b"user_record".to_vec(),
+                        data.owner.to_bytes().to_vec(),
+                        vec![*bump],
+                    ]
+                }
+                CompressedAccountVariant::GameSession(data) => {
+                    vec![
+                        b"game_session".to_vec(),
+                        data.session_id.to_le_bytes().to_vec(),
+                        vec![*bump],
+                    ]
+                }
+            };
+
+            signer_seeds_storage.push(seeds);
             light_accounts.push(light_account);
             pda_account_refs.push(&pda_accounts[i]);
         }
 
+        // Convert to the format needed by the SDK
+        let signer_seeds_refs: Vec<Vec<&[u8]>> = signer_seeds_storage
+            .iter()
+            .map(|seeds| seeds.iter().map(|s| s.as_slice()).collect())
+            .collect();
+        let signer_seeds_slices: Vec<&[&[u8]]> = signer_seeds_refs
+            .iter()
+            .map(|seeds| seeds.as_slice())
+            .collect();
+
         // Single CPI call with unified enum type
         decompress_multiple_idempotent::<CompressedAccountVariant>(
             &pda_account_refs,
             light_accounts,
+            &signer_seeds_slices,
             proof,
             cpi_accounts,
             &crate::ID,
             &ctx.accounts.rent_payer,
-            &ctx.accounts.system_program.to_account_info(),
         )
         .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?;
 

program-tests/anchor-compressible-user/src/lib.rs

@@ -28,6 +28,7 @@ borsh = { workspace = true }
 light-compressed-account = { workspace = true, features = ["solana"] }
 solana-clock = { workspace = true }
 solana-sysvar = { workspace = true }
+arrayvec = { workspace = true }
 
 [dev-dependencies]
 light-program-test = { workspace = true, features = ["devenv"] }

program-tests/sdk-test/Cargo.toml

@@ -1,8 +1,9 @@
+use arrayvec::ArrayVec;
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
     account::LightAccount,
     compressible::{decompress_idempotent, CompressionTiming},
-    cpi::{CpiAccounts, CpiAccountsConfig},
+    cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
     LightDiscriminator, LightHasher,
@@ -24,14 +25,12 @@ pub fn decompress_dynamic_pda(
     let fee_payer = &accounts[0];
     let pda_account = &accounts[1];
     let rent_payer = &accounts[2];
-    let system_program = &accounts[3];
 
     // Set up CPI accounts
-    let config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
-    let cpi_accounts = CpiAccounts::new_with_config(
+    let cpi_accounts = CpiAccounts::new(
         fee_payer,
         &accounts[instruction_data.system_accounts_offset as usize..],
-        config,
+        crate::LIGHT_CPI_SIGNER,
     );
 
     let compressed_account = LightAccount::<'_, MyPdaAccount>::new_mut(
@@ -56,16 +55,15 @@ pub fn decompress_dynamic_pda(
     }
 
     // Call decompress_idempotent with seeds - this should work whether PDA exists or not
+    let signer_seeds: &[&[u8]] = &[b"test_pda", &account_data, &[bump]];
     decompress_idempotent::<MyPdaAccount>(
         pda_account,
         compressed_account,
-        seeds,
-        bump,
+        signer_seeds,
         instruction_data.proof,
         cpi_accounts,
         &crate::ID,
         rent_payer,
-        system_program,
     )?;
 
     Ok(())
@@ -92,10 +90,9 @@ pub fn decompress_multiple_dynamic_pdas(
     // Get fixed accounts
     let fee_payer = &accounts[0];
     let rent_payer = &accounts[1];
-    let system_program = &accounts[2];
 
     // Get PDA accounts (after fixed accounts, before system accounts)
-    let pda_accounts_start = 3;
+    let pda_accounts_start = 2;
     let pda_accounts_end = instruction_data.system_accounts_offset as usize;
     let pda_accounts = &accounts[pda_accounts_start..pda_accounts_end];
 
@@ -105,11 +102,10 @@ pub fn decompress_multiple_dynamic_pdas(
         crate::LIGHT_CPI_SIGNER,
     );
 
-    // Build inputs for batch decompression
+    // Can be passed in; the custom program does not have to check the seeds.
     let mut compressed_accounts = Vec::new();
     let mut pda_account_refs = Vec::new();
-    let mut all_seeds = Vec::new();
-    let mut bumps = Vec::new();
+    let mut all_signer_seeds = Vec::new();
 
     for (i, compressed_account_data) in instruction_data.compressed_accounts.into_iter().enumerate()
     {
@@ -119,19 +115,13 @@ pub fn decompress_multiple_dynamic_pdas(
             compressed_account_data.data.clone(),
         )?;
 
-        // Store seeds in a vector to ensure they live long enough
-        all_seeds.push(vec![
-            b"test_pda".to_vec(),
-            compressed_account_data.data.data.to_vec(),
-        ]);
-
-        // Create references to the seeds
-        let seeds: Vec<&[u8]> = all_seeds
-            .last()
-            .unwrap()
-            .iter()
-            .map(|s| s.as_slice())
-            .collect();
+        // Create signer seeds with ArrayVec
+        let mut signer_seeds = ArrayVec::<&[u8], 3>::new();
+        signer_seeds.push(b"test_pda");
+        signer_seeds.push(&compressed_account_data.data.data);
+
+        // Derive bump for verification
+        let seeds: Vec<&[u8]> = vec![b"test_pda", &compressed_account_data.data.data];
         let (derived_pda, bump) =
             solana_program::pubkey::Pubkey::find_program_address(&seeds, &crate::ID);
 
@@ -140,29 +130,29 @@ pub fn decompress_multiple_dynamic_pdas(
             return Err(LightSdkError::ConstraintViolation);
         }
 
+        // Add bump to signer seeds
+        signer_seeds.push(&[bump]);
+
         compressed_accounts.push(compressed_account);
         pda_account_refs.push(&pda_accounts[i]);
-        bumps.push(bump);
+        all_signer_seeds.push(signer_seeds);
     }
 
-    // Create seeds references for the function call
-    let seeds_refs: Vec<Vec<&[u8]>> = all_seeds
+    // Convert ArrayVecs to the format needed by the SDK
+    let signer_seeds_refs: Vec<&[&[u8]]> = all_signer_seeds
         .iter()
-        .map(|seeds| seeds.iter().map(|s| s.as_slice()).collect())
+        .map(|seeds| seeds.as_slice())
         .collect();
-    let seeds_list: Vec<&[&[u8]]> = seeds_refs.iter().map(|seeds| seeds.as_slice()).collect();
 
     // Decompress all accounts in one CPI call
     decompress_multiple_idempotent::<MyPdaAccount>(
         &pda_account_refs,
         compressed_accounts,
-        &seeds_list,
-        &bumps,
+        &signer_seeds_refs,
         instruction_data.proof,
         cpi_accounts,
         &crate::ID,
         rent_payer,
-        system_program,
     )?;
 
     Ok(())

program-tests/sdk-test/src/decompress_dynamic_pda.rs

@@ -7,7 +7,6 @@ use crate::{
 };
 #[cfg(feature = "anchor")]
 use anchor_lang::{AnchorDeserialize as BorshDeserialize, AnchorSerialize as BorshSerialize};
-use arrayvec::ArrayVec;
 #[cfg(not(feature = "anchor"))]
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_compressed_account::address::derive_address;
@@ -33,27 +32,23 @@ pub const COMPRESSION_DELAY: u64 = 100;
 /// # Arguments
 /// * `pda_account` - The PDA account to decompress into
 /// * `compressed_account` - The compressed account to decompress
-/// * `seeds` - The seeds used to derive the PDA
-/// * `bump` - The bump seed for the PDA
+/// * `signer_seeds` - The signer seeds including bump (standard Solana format)
 /// * `proof` - Validity proof
 /// * `cpi_accounts` - Accounts needed for CPI
 /// * `owner_program` - The program that will own the PDA
 /// * `rent_payer` - The account to pay for PDA rent
-/// * `system_program` - The system program
 ///
 /// # Returns
 /// * `Ok(())` if the compressed account was decompressed successfully or PDA already exists
 /// * `Err(LightSdkError)` if there was an error
 pub fn decompress_idempotent<'info, A>(
     pda_account: &AccountInfo<'info>,
     compressed_account: LightAccount<'_, A>,
-    seeds: &[&[u8]],
-    bump: u8,
+    signer_seeds: &[&[u8]],
     proof: ValidityProof,
     cpi_accounts: CpiAccounts<'_, 'info>,
     owner_program: &Pubkey,
     rent_payer: &AccountInfo<'info>,
-    system_program: &AccountInfo<'info>,
 ) -> Result<(), LightSdkError>
 where
     A: DataHasher
@@ -67,13 +62,11 @@ where
     decompress_multiple_idempotent(
         &[pda_account],
         vec![compressed_account],
-        &[seeds],
-        &[bump],
+        &[signer_seeds],
         proof,
         cpi_accounts,
         owner_program,
         rent_payer,
-        system_program,
     )
 }
 
@@ -85,27 +78,23 @@ where
 /// # Arguments
 /// * `pda_accounts` - The PDA accounts to decompress into
 /// * `compressed_accounts` - The compressed accounts to decompress
-/// * `seeds_list` - List of seeds for each PDA (one per account)
-/// * `bumps` - List of bump seeds for each PDA (one per account)
+/// * `signer_seeds` - Signer seeds for each PDA including bump (standard Solana format)
 /// * `proof` - Single validity proof for all accounts
 /// * `cpi_accounts` - Accounts needed for CPI
 /// * `owner_program` - The program that will own the PDAs
 /// * `rent_payer` - The account to pay for PDA rent
-/// * `system_program` - The system program
 ///
 /// # Returns
 /// * `Ok(())` if all compressed accounts were decompressed successfully or PDAs already exist
 /// * `Err(LightSdkError)` if there was an error
 pub fn decompress_multiple_idempotent<'info, A>(
     pda_accounts: &[&AccountInfo<'info>],
     compressed_accounts: Vec<LightAccount<'_, A>>,
-    seeds_list: &[&[&[u8]]],
-    bumps: &[u8],
+    signer_seeds: &[&[&[u8]]],
     proof: ValidityProof,
     cpi_accounts: CpiAccounts<'_, 'info>,
     owner_program: &Pubkey,
     rent_payer: &AccountInfo<'info>,
-    system_program: &AccountInfo<'info>,
 ) -> Result<(), LightSdkError>
 where
     A: DataHasher
@@ -117,10 +106,7 @@ where
         + CompressionTiming,
 {
     // Validate input lengths
-    if pda_accounts.len() != compressed_accounts.len()
-        || pda_accounts.len() != seeds_list.len()
-        || pda_accounts.len() != bumps.len()
-    {
+    if pda_accounts.len() != compressed_accounts.len() || pda_accounts.len() != signer_seeds.len() {
         return Err(LightSdkError::ConstraintViolation);
     }
 
@@ -131,11 +117,10 @@ where
 
     let mut compressed_accounts_for_cpi = Vec::new();
 
-    for (((pda_account, mut compressed_account), seeds), &bump) in pda_accounts
+    for ((pda_account, mut compressed_account), seeds) in pda_accounts
         .iter()
         .zip(compressed_accounts.into_iter())
-        .zip(seeds_list.iter())
-        .zip(bumps.iter())
+        .zip(signer_seeds.iter())
     {
         // TODO: consider a COMPRESSED_DISCIMINATOR.
         // compress -> set compressed
@@ -184,22 +169,14 @@ where
             owner_program,
         );
 
-        // cpi for each pda
-        let bump_seed = [bump];
-        let mut signer_seeds = ArrayVec::<&[u8], 16>::new();
-        for seed in seeds.iter() {
-            signer_seeds.push(*seed);
-        }
-        signer_seeds.push(&bump_seed);
-
         invoke_signed(
             &create_account_ix,
             &[
                 rent_payer.clone(),
                 (*pda_account).clone(),
-                system_program.clone(),
+                cpi_accounts.system_program()?.clone(),
             ],
-            &[&signer_seeds],
+            &[seeds],
         )?;
 
         // Initialize PDA with decompressed data and update slot