compress_pda compiling

Author: SwenSchaeferjohann

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

@@ -1,60 +1,58 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
+    cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
 };
-use solana_program::{
-    account_info::AccountInfo, clock::Clock, msg, pubkey::Pubkey, sysvar::Sysvar,
-};
+use light_sdk_types::CpiAccountsConfig;
+use solana_program::account_info::AccountInfo;
 
-use crate::{
-    create_pda::MyCompressedAccount, decompress_to_pda::DecompressedPdaAccount,
-    sdk::compress_pda::compress_pda,
-};
+use crate::{decompress_to_pda::DecompressedPdaAccount, sdk::compress_pda::compress_pda};
 
 /// Compresses a PDA back into a compressed account
 /// Anyone can call this after the timeout period has elapsed
 /// pda check missing yet.
-pub fn compress_from_pda<'a>(
-    accounts: &'a [AccountInfo<'a>],
+pub fn compress_from_pda(
+    accounts: &[AccountInfo],
     instruction_data: &[u8],
 ) -> Result<(), LightSdkError> {
-    msg!("Compressing PDA back to compressed account");
-
     let mut instruction_data = instruction_data;
     let instruction_data = CompressFromPdaInstructionData::deserialize(&mut instruction_data)
         .map_err(|_| LightSdkError::Borsh)?;
 
-    // Get accounts
-    let fee_payer = &accounts[0];
+    // based on program...
+    let custom_seeds: Vec<&[u8]> = vec![b"decompressed_pda"];
+
     let pda_account = &accounts[1];
     let rent_recipient = &accounts[2]; // can be hardcoded by caller program
 
-    // Verify the PDA account is owned by our program
-    if pda_account.owner != &crate::ID {
-        msg!("PDA account not owned by this program");
-        return Err(LightSdkError::ConstraintViolation);
-    }
+    // Cpi accounts
+    let config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
+    let cpi_accounts_struct = CpiAccounts::new_with_config(
+        &accounts[0],
+        &accounts[instruction_data.system_accounts_offset as usize..],
+        config,
+    );
 
-    compress_pda::<MyCompressedAccount>(
+    compress_pda::<DecompressedPdaAccount>(
         pda_account,
         &instruction_data.compressed_account_meta,
         Some(instruction_data.proof),
-        accounts,
-        instruction_data.system_accounts_offset,
-        fee_payer,
-        crate::LIGHT_CPI_SIGNER,
+        cpi_accounts_struct,
         &crate::ID,
         rent_recipient,
+        &custom_seeds,
     )?;
 
-    msg!("Successfully compressed PDA back to compressed account");
+    // any other program logic here...
+
     Ok(())
 }
 
 #[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
 pub struct CompressFromPdaInstructionData {
     pub proof: ValidityProof,
     pub compressed_account_meta: CompressedAccountMeta,
+    pub additional_seed: [u8; 32], // Must match the seed used in decompression
     pub system_accounts_offset: u8,
 }

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

@@ -1,4 +1,5 @@
 use borsh::{BorshDeserialize, BorshSerialize};
+use light_hasher::{DataHasher, Hasher};
 use light_sdk::{
     account::LightAccount,
     cpi::{CpiAccounts, CpiAccountsConfig, CpiInputs},
@@ -17,7 +18,7 @@ use solana_program::{
 pub const SLOTS_UNTIL_COMPRESSION: u64 = 100;
 
 /// Account structure for the decompressed PDA
-#[derive(Clone, Debug, BorshDeserialize, BorshSerialize)]
+#[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
 pub struct DecompressedPdaAccount {
     /// The compressed account address this PDA was derived from
     pub compressed_address: [u8; 32],
@@ -187,3 +188,28 @@ pub struct DecompressMyCompressedAccount {
     pub meta: CompressedAccountMeta,
     pub data: [u8; 31],
 }
+
+// Implement required traits for DecompressedPdaAccount
+impl DataHasher for DecompressedPdaAccount {
+    fn hash<H: Hasher>(&self) -> Result<[u8; 32], light_hasher::HasherError> {
+        let mut bytes = vec![];
+        self.serialize(&mut bytes).unwrap();
+        H::hashv(&[&bytes])
+    }
+}
+
+impl LightDiscriminator for DecompressedPdaAccount {
+    const LIGHT_DISCRIMINATOR: [u8; 8] = [0xDE, 0xC0, 0x11, 0x9D, 0xA0, 0x00, 0x00, 0x00];
+    const LIGHT_DISCRIMINATOR_SLICE: &'static [u8] =
+        &[0xDE, 0xC0, 0x11, 0x9D, 0xA0, 0x00, 0x00, 0x00];
+}
+
+impl crate::sdk::compress_pda::PdaTimingData for DecompressedPdaAccount {
+    fn last_touched_slot(&self) -> u64 {
+        self.last_written_slot
+    }
+
+    fn slots_buffer(&self) -> u64 {
+        self.slots_until_compression
+    }
+}

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

@@ -7,7 +7,51 @@ use light_sdk::{
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
     LightDiscriminator,
 };
-use solana_program::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+use solana_program::sysvar::Sysvar;
+use solana_program::{
+    account_info::AccountInfo, clock::Clock, msg, program_error::ProgramError, pubkey::Pubkey,
+};
+
+/// Trait for PDA accounts that can be compressed
+pub trait PdaTimingData {
+    fn last_touched_slot(&self) -> u64;
+    fn slots_buffer(&self) -> u64;
+}
+
+const DECOMP_SEED: &[u8] = b"decomp";
+
+/// Check that the PDA account is owned by the caller program and derived from the correct seeds.
+///
+/// # Arguments
+/// * `custom_seeds` - Custom seeds to check against
+/// * `c_pda_address` - The address of the compressed PDA
+/// * `pda_account` - The address of the PDA account
+/// * `caller_program` - The program that owns the PDA.
+pub fn check_pda(
+    custom_seeds: &[&[u8]],
+    c_pda_address: &[u8; 32],
+    pda_account: &Pubkey,
+    caller_program: &Pubkey,
+) -> Result<(), ProgramError> {
+    // Create seeds array: [custom_seeds..., c_pda_address, "decomp"]
+    let mut seeds: Vec<&[u8]> = custom_seeds.to_vec();
+    seeds.push(c_pda_address);
+    seeds.push(DECOMP_SEED);
+
+    let derived_pda =
+        Pubkey::create_program_address(&seeds, caller_program).expect("Invalid PDA seeds.");
+
+    if derived_pda != *pda_account {
+        msg!(
+            "Invalid PDA provided. Expected: {}. Found: {}.",
+            derived_pda,
+            pda_account
+        );
+        return Err(ProgramError::InvalidArgument);
+    }
+
+    Ok(())
+}
 
 /// Helper function to compress a PDA and reclaim rent.
 ///
@@ -32,40 +76,58 @@ use solana_program::{account_info::AccountInfo, program_error::ProgramError, pub
 /// * `rent_recipient` - The account to receive the PDA's rent
 //
 // TODO:
-// - rent recipient check, eg hardcoded in caller program
 // - check if any explicit checks required for compressed account?
-// - check that the account is owned by the owner program, and derived from the correct seeds.
-// - consider adding check here that the cAccount belongs to Account via seeds.
-pub fn compress_pda<'a, A>(
-    pda_account: &AccountInfo<'a>,
+// - consider multiple accounts per ix.
+pub fn compress_pda<A>(
+    pda_account: &AccountInfo,
     compressed_account_meta: &CompressedAccountMeta,
     proof: Option<ValidityProof>,
-    cpi_accounts: &'a [AccountInfo<'a>],
-    system_accounts_offset: u8,
-    fee_payer: &AccountInfo<'a>,
-    cpi_signer: CpiSigner,
+    cpi_accounts: CpiAccounts,
     owner_program: &Pubkey,
-    rent_recipient: &AccountInfo<'a>,
+    rent_recipient: &AccountInfo,
+    custom_seeds: &[&[u8]],
 ) -> Result<(), LightSdkError>
 where
-    A: DataHasher + LightDiscriminator + BorshSerialize + BorshDeserialize + Default,
+    A: DataHasher
+        + LightDiscriminator
+        + BorshSerialize
+        + BorshDeserialize
+        + Default
+        + PdaTimingData,
 {
+    // Check that the PDA account is owned by the caller program and derived from the address of the compressed PDA.
+    check_pda(
+        custom_seeds,
+        &compressed_account_meta.address,
+        pda_account.key,
+        owner_program,
+    )?;
+
+    let current_slot = Clock::get()?.slot;
+
+    // Deserialize the PDA data to check timing fields
+    let pda_data = pda_account.try_borrow_data()?;
+    let pda_account_data = A::try_from_slice(&pda_data[8..]).map_err(|_| LightSdkError::Borsh)?;
+    drop(pda_data);
+
+    let last_touched_slot = pda_account_data.last_touched_slot();
+    let slots_buffer = pda_account_data.slots_buffer();
+
+    if current_slot < last_touched_slot + slots_buffer {
+        msg!(
+            "Cannot compress yet. {} slots remaining",
+            (last_touched_slot + slots_buffer).saturating_sub(current_slot)
+        );
+        return Err(LightSdkError::ConstraintViolation);
+    }
+
     // Get the PDA lamports before we close it
     let pda_lamports = pda_account.lamports();
 
-    // Always use default/empty data since we're updating an existing compressed account
-    let compressed_account =
+    let mut compressed_account =
         LightAccount::<'_, A>::new_mut(owner_program, compressed_account_meta, A::default())?;
 
-    // Set up CPI configuration
-    let config = CpiAccountsConfig::new(cpi_signer);
-
-    // Create CPI accounts structure
-    let cpi_accounts_struct = CpiAccounts::new_with_config(
-        fee_payer,
-        &cpi_accounts[system_accounts_offset as usize..],
-        config,
-    );
+    compressed_account.account = pda_account_data;
 
     // Create CPI inputs
     let cpi_inputs = CpiInputs::new(
@@ -74,7 +136,7 @@ where
     );
 
     // Invoke light system program to create the compressed account
-    cpi_inputs.invoke_light_system_program(cpi_accounts_struct)?;
+    cpi_inputs.invoke_light_system_program(cpi_accounts)?;
 
     // Close the PDA account
     // 1. Transfer all lamports to the rent recipient