add compressible_config draft

Author: SwenSchaeferjohann

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

@@ -1,6 +1,6 @@
 use anchor_lang::prelude::*;
 use light_sdk::{
-    compressible::CompressionTiming,
+    compressible::{CompressibleConfig, CompressionTiming},
     cpi::CpiAccounts,
     instruction::{account_meta::CompressedAccountMeta, PackedAddressTreeInfo, ValidityProof},
     light_hasher::{DataHasher, Hasher},
@@ -24,7 +24,57 @@ pub mod anchor_compressible_user {
 
     use super::*;
 
-    /// Creates a new compressed user record.
+    /// Creates a new compressed user record using global config.
+    pub fn create_record_with_config<'info>(
+        ctx: Context<'_, '_, '_, 'info, CreateRecordWithConfig<'info>>,
+        name: String,
+        proof: ValidityProof,
+        compressed_address: [u8; 32],
+        address_tree_info: PackedAddressTreeInfo,
+        output_state_tree_index: u8,
+    ) -> Result<()> {
+        let user_record = &mut ctx.accounts.user_record;
+
+        // Load config from the config account
+        let config = CompressibleConfig::load(&ctx.accounts.config)
+            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotDeserialize)?;
+
+        user_record.owner = ctx.accounts.user.key();
+        user_record.name = name;
+        user_record.score = 0;
+        user_record.last_written_slot = Clock::get()?.slot;
+        user_record.compression_delay = config.compression_delay as u64;
+
+        // Verify rent recipient matches config
+        if ctx.accounts.rent_recipient.key() != config.rent_recipient {
+            return err!(ErrorCode::InvalidRentRecipient);
+        }
+
+        let cpi_accounts = CpiAccounts::new(
+            &ctx.accounts.user,
+            &ctx.remaining_accounts[..],
+            LIGHT_CPI_SIGNER,
+        );
+        let new_address_params =
+            address_tree_info.into_new_address_params_packed(user_record.key().to_bytes());
+
+        compress_pda_new::<UserRecord>(
+            &user_record.to_account_info(),
+            compressed_address,
+            new_address_params,
+            output_state_tree_index,
+            proof,
+            cpi_accounts,
+            &crate::ID,
+            &ctx.accounts.rent_recipient,
+            &config.address_space,
+        )
+        .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?;
+
+        Ok(())
+    }
+
+    /// Creates a new compressed user record (legacy - uses hardcoded values).
     pub fn create_record<'info>(
         ctx: Context<'_, '_, '_, 'info, CreateRecord<'info>>,
         name: String,
@@ -193,12 +243,67 @@ pub mod anchor_compressible_user {
             cpi_accounts,
             &crate::ID,
             &ctx.accounts.rent_recipient,
+            COMPRESSION_DELAY, // Use the hardcoded value for legacy function
+        )
+        .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?;
+        Ok(())
+    }
+
+    pub fn compress_record_with_config<'info>(
+        ctx: Context<'_, '_, '_, 'info, CompressRecordWithConfig<'info>>,
+        proof: ValidityProof,
+        compressed_account_meta: CompressedAccountMeta,
+    ) -> Result<()> {
+        let user_record = &mut ctx.accounts.user_record;
+
+        // Load config from the config account
+        let config = CompressibleConfig::load(&ctx.accounts.config)
+            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotDeserialize)?;
+
+        // Verify rent recipient matches config
+        if ctx.accounts.rent_recipient.key() != config.rent_recipient {
+            return err!(ErrorCode::InvalidRentRecipient);
+        }
+
+        let cpi_accounts = CpiAccounts::new(
+            &ctx.accounts.user,
+            &ctx.remaining_accounts[..],
+            LIGHT_CPI_SIGNER,
+        );
+
+        compress_pda::<UserRecord>(
+            &user_record.to_account_info(),
+            &compressed_account_meta,
+            proof,
+            cpi_accounts,
+            &crate::ID,
+            &ctx.accounts.rent_recipient,
+            config.compression_delay as u64,
         )
         .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?;
         Ok(())
     }
 }
 
+#[derive(Accounts)]
+pub struct CreateRecordWithConfig<'info> {
+    #[account(mut)]
+    pub user: Signer<'info>,
+    #[account(
+        init,
+        payer = user,
+        space = 8 + 32 + 4 + 32 + 8 + 8 + 8, // discriminator + owner + string len + name + score + last_written_slot + compression_delay
+        seeds = [b"user_record", user.key().as_ref()],
+        bump,
+    )]
+    pub user_record: Account<'info, UserRecord>,
+    pub system_program: Program<'info, System>,
+    /// The global config account
+    pub config: AccountInfo<'info>,
+    /// Rent recipient - must match config
+    pub rent_recipient: AccountInfo<'info>,
+}
+
 #[derive(Accounts)]
 pub struct CreateRecord<'info> {
     #[account(mut)]
@@ -229,6 +334,24 @@ pub struct UpdateRecord<'info> {
     pub user_record: Account<'info, UserRecord>,
 }
 
+#[derive(Accounts)]
+pub struct CompressRecordWithConfig<'info> {
+    #[account(mut)]
+    pub user: Signer<'info>,
+    #[account(
+        mut,
+        seeds = [b"user_record", user.key().as_ref()],
+        bump,
+        constraint = user_record.owner == user.key()
+    )]
+    pub user_record: Account<'info, UserRecord>,
+    pub system_program: Program<'info, System>,
+    /// The global config account
+    pub config: AccountInfo<'info>,
+    /// Rent recipient - must match config
+    pub rent_recipient: AccountInfo<'info>,
+}
+
 #[derive(Accounts)]
 pub struct CompressRecord<'info> {
     #[account(mut)]
@@ -371,4 +494,6 @@ impl CompressionTiming for GameSession {
 pub enum ErrorCode {
     #[msg("Invalid account count: PDAs and compressed accounts must match")]
     InvalidAccountCount,
+    #[msg("Rent recipient does not match config")]
+    InvalidRentRecipient,
 }

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

@@ -1,6 +1,6 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
-    compressible::compress_pda,
+    compressible::{compress_pda, CompressibleConfig},
     cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
@@ -21,19 +21,23 @@ pub fn compress_dynamic_pda(
         .map_err(|_| LightSdkError::Borsh)?;
 
     let pda_account = &accounts[1];
-
-    // CHECK: hardcoded rent recipient.
     let rent_recipient = &accounts[2];
-    if rent_recipient.key != &crate::create_dynamic_pda::RENT_RECIPIENT {
+    let config_account = &accounts[3];
+
+    // Load config
+    let config = CompressibleConfig::load(config_account)?;
+
+    // CHECK: rent recipient from config
+    if rent_recipient.key != &config.rent_recipient {
         return Err(LightSdkError::ConstraintViolation);
     }
 
     // Cpi accounts
-    let config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
+    let cpi_config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
     let cpi_accounts = CpiAccounts::new_with_config(
         &accounts[0],
         &accounts[instruction_data.system_accounts_offset as usize..],
-        config,
+        cpi_config,
     );
 
     compress_pda::<MyPdaAccount>(
@@ -43,6 +47,7 @@ pub fn compress_dynamic_pda(
         cpi_accounts,
         &crate::ID,
         rent_recipient,
+        config.compression_delay as u64,
     )?;
 
     // any other program logic here...

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

@@ -0,0 +1,50 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_sdk::{
+    compressible::{create_config, CompressibleConfig},
+    error::LightSdkError,
+};
+use solana_program::account_info::AccountInfo;
+use solana_program::pubkey::Pubkey;
+
+/// Creates a new compressible config PDA
+pub fn process_create_config(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), LightSdkError> {
+    let mut instruction_data = instruction_data;
+    let instruction_data = CreateConfigInstructionData::deserialize(&mut instruction_data)
+        .map_err(|_| LightSdkError::Borsh)?;
+
+    // Get accounts
+    let payer = &accounts[0];
+    let config_account = &accounts[1];
+    let system_program = &accounts[2];
+
+    // Verify the config PDA
+    let (expected_pda, _) = CompressibleConfig::derive_pda(&crate::ID);
+    if config_account.key != &expected_pda {
+        return Err(LightSdkError::ConstraintViolation);
+    }
+
+    // Create the config
+    create_config(
+        config_account,
+        &instruction_data.update_authority,
+        &instruction_data.rent_recipient,
+        &instruction_data.address_space,
+        instruction_data.compression_delay,
+        payer,
+        system_program,
+        &crate::ID,
+    )?;
+
+    Ok(())
+}
+
+#[derive(Clone, Debug, BorshDeserialize, BorshSerialize)]
+pub struct CreateConfigInstructionData {
+    pub update_authority: Pubkey,
+    pub rent_recipient: Pubkey,
+    pub address_space: Pubkey,
+    pub compression_delay: u32,
+}

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

@@ -1,21 +1,16 @@
 use borsh::{BorshDeserialize, BorshSerialize};
-use light_macros::pubkey;
 use light_sdk::{
-    compressible::compress_pda_new,
+    compressible::{compress_pda_new, CompressibleConfig},
     cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{PackedAddressTreeInfo, ValidityProof},
 };
 use light_sdk_types::CpiAccountsConfig;
 use solana_clock::Clock;
 use solana_program::account_info::AccountInfo;
-use solana_program::pubkey::Pubkey;
 use solana_sysvar::Sysvar;
 
-use crate::decompress_dynamic_pda::{MyPdaAccount, COMPRESSION_DELAY};
-
-pub const ADDRESS_SPACE: Pubkey = pubkey!("CLEuMG7pzJX9xAuKCFzBP154uiG1GaNo4Fq7x6KAcAfG");
-pub const RENT_RECIPIENT: Pubkey = pubkey!("CLEuMG7pzJX9xAuKCFzBP154uiG1GaNo4Fq7x6KAcAfG");
+use crate::decompress_dynamic_pda::MyPdaAccount;
 
 /// INITS a PDA and compresses it into a new compressed account.
 pub fn create_dynamic_pda(
@@ -29,16 +24,21 @@ pub fn create_dynamic_pda(
     let fee_payer = &accounts[0];
     // UNCHECKED: ...caller program checks this.
     let pda_account = &accounts[1];
-    // CHECK: hardcoded rent recipient.
     let rent_recipient = &accounts[2];
-    if rent_recipient.key != &RENT_RECIPIENT {
+    let config_account = &accounts[3];
+
+    // Load config
+    let config = CompressibleConfig::load(config_account)?;
+
+    // CHECK: rent recipient from config
+    if rent_recipient.key != &config.rent_recipient {
         return Err(LightSdkError::ConstraintViolation);
     }
 
     // Cpi accounts
     let cpi_accounts_struct = CpiAccounts::new_with_config(
         fee_payer,
-        &accounts[3..],
+        &accounts[4..],
         CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER),
     );
 
@@ -53,7 +53,7 @@ pub fn create_dynamic_pda(
     let mut pda_account_data = MyPdaAccount::try_from_slice(&pda_account.data.borrow())
         .map_err(|_| LightSdkError::Borsh)?;
     pda_account_data.last_written_slot = Clock::get()?.slot;
-    pda_account_data.compression_delay = COMPRESSION_DELAY;
+    pda_account_data.compression_delay = config.compression_delay as u64;
 
     compress_pda_new::<MyPdaAccount>(
         pda_account,
@@ -64,7 +64,7 @@ pub fn create_dynamic_pda(
         cpi_accounts_struct,
         &crate::ID,
         rent_recipient,
-        &ADDRESS_SPACE,
+        &config.address_space,
     )?;
 
     Ok(())

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

@@ -1,4 +1,3 @@
-use arrayvec::ArrayVec;
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
     account::LightAccount,
@@ -102,24 +101,20 @@ pub fn decompress_multiple_dynamic_pdas(
         crate::LIGHT_CPI_SIGNER,
     );
 
-    // Can be passed in; the custom program does not have to check the seeds.
+    // Store data and bumps to maintain ownership
     let mut compressed_accounts = Vec::new();
     let mut pda_account_refs = Vec::new();
+    let mut stored_bumps = Vec::new();
     let mut all_signer_seeds = Vec::new();
 
-    for (i, compressed_account_data) in instruction_data.compressed_accounts.into_iter().enumerate()
-    {
+    // First pass: collect all the data we need
+    for (i, compressed_account_data) in instruction_data.compressed_accounts.iter().enumerate() {
         let compressed_account = LightAccount::<'_, MyPdaAccount>::new_mut(
             &crate::ID,
             &compressed_account_data.meta,
             compressed_account_data.data.clone(),
         )?;
 
-        // 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) =
@@ -130,15 +125,21 @@ 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]);
+        stored_bumps.push(bump);
+    }
+
+    // Second pass: build signer seeds with stable references
+    for (i, compressed_account_data) in instruction_data.compressed_accounts.iter().enumerate() {
+        let mut signer_seeds = Vec::new();
+        signer_seeds.push(b"test_pda" as &[u8]);
+        signer_seeds.push(&compressed_account_data.data.data as &[u8]);
+        signer_seeds.push(&stored_bumps[i..i + 1] as &[u8]);
         all_signer_seeds.push(signer_seeds);
     }
 
-    // Convert ArrayVecs to the format needed by the SDK
+    // Convert to the format needed by the SDK
     let signer_seeds_refs: Vec<&[&[u8]]> = all_signer_seeds
         .iter()
         .map(|seeds| seeds.as_slice())