use config, add unified header struct (just last_written_slot) for now

Author: SwenSchaeferjohann

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

@@ -47,7 +47,7 @@ pub fn compress_dynamic_pda(
         cpi_accounts,
         &crate::ID,
         rent_recipient,
-        config.compression_delay as u64,
+        &config,
     )?;
 
     // any other program logic here...

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

@@ -1,8 +1,5 @@
 use borsh::{BorshDeserialize, BorshSerialize};
-use light_sdk::{
-    compressible::{create_config, CompressibleConfig},
-    error::LightSdkError,
-};
+use light_sdk::{compressible::create_compression_config_checked, error::LightSdkError};
 use solana_program::account_info::AccountInfo;
 use solana_program::pubkey::Pubkey;
 

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

@@ -1,14 +1,11 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
-    compressible::{compress_pda_new, CompressibleConfig},
+    compressible::{compress_pda_new, CompressibleConfig, CompressionMetadata},
     cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{PackedAddressTreeInfo, ValidityProof},
 };
-use light_sdk_types::CpiAccountsConfig;
-use solana_clock::Clock;
 use solana_program::account_info::AccountInfo;
-use solana_sysvar::Sysvar;
 
 use crate::decompress_dynamic_pda::MyPdaAccount;
 
@@ -48,8 +45,9 @@ pub fn create_dynamic_pda(
     // of this invocation.
     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 = config.compression_delay as u64;
+
+    // Initialize compression metadata with current slot
+    pda_account_data.compression_metadata = CompressionMetadata::new()?;
 
     compress_pda_new::<MyPdaAccount>(
         pda_account,

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

@@ -1,7 +1,7 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
     account::LightAccount,
-    compressible::{decompress_idempotent, CompressionTiming},
+    compressible::{decompress_idempotent, CompressionMetadata, HasCompressionMetadata},
     cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
@@ -176,22 +176,17 @@ pub struct MyCompressedAccount {
     Clone, Debug, Default, LightHasher, LightDiscriminator, BorshDeserialize, BorshSerialize,
 )]
 pub struct MyPdaAccount {
-    pub last_written_slot: u64,
-    pub compression_delay: u64,
+    pub compression_metadata: CompressionMetadata,
     pub data: [u8; 31],
 }
 
-// Implement the CompressionTiming trait
-impl CompressionTiming for MyPdaAccount {
-    fn last_written_slot(&self) -> u64 {
-        self.last_written_slot
+// Implement the HasCompressionMetadata trait
+impl HasCompressionMetadata for MyPdaAccount {
+    fn compression_metadata(&self) -> &CompressionMetadata {
+        &self.compression_metadata
     }
 
-    fn compression_delay(&self) -> u64 {
-        self.compression_delay
-    }
-
-    fn set_last_written_slot(&mut self, slot: u64) {
-        self.last_written_slot = slot;
+    fn compression_metadata_mut(&mut self) -> &mut CompressionMetadata {
+        &mut self.compression_metadata
     }
 }

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

@@ -246,8 +246,7 @@ pub async fn decompress_pda(
         compressed_account: MyCompressedAccount {
             meta,
             data: MyPdaAccount {
-                last_written_slot: compressed_account.compressed_account.lamports, // Use lamports field to store slot
-                compression_delay: COMPRESSION_DELAY,
+                compression_metadata: light_sdk::compressible::CompressionMetadata::default(),
                 data: compressed_account
                     .compressed_account
                     .data

sdk-libs/sdk/src/compressible/compress_pda.rs

@@ -1,5 +1,6 @@
 use crate::{
     account::LightAccount,
+    compressible::{metadata::CompressionMetadata, CompressibleConfig},
     cpi::{CpiAccounts, CpiInputs},
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
@@ -17,11 +18,10 @@ use solana_program_error::ProgramError;
 use solana_pubkey::Pubkey;
 use solana_sysvar::Sysvar;
 
-/// Trait for PDA accounts that can be compressed
-pub trait CompressionTiming {
-    fn last_written_slot(&self) -> u64;
-    fn compression_delay(&self) -> u64;
-    fn set_last_written_slot(&mut self, slot: u64);
+/// Trait for accounts that contain CompressionMetadata
+pub trait HasCompressionMetadata {
+    fn compression_metadata(&self) -> &CompressionMetadata;
+    fn compression_metadata_mut(&mut self) -> &mut CompressionMetadata;
 }
 
 /// Helper function to compress a PDA and reclaim rent.
@@ -41,6 +41,7 @@ pub trait CompressionTiming {
 /// * `cpi_accounts` - Accounts needed for CPI
 /// * `owner_program` - The program that will own the compressed account
 /// * `rent_recipient` - The account to receive the PDA's rent
+/// * `config` - The compression config containing delay settings
 //
 // TODO:
 // - check if any explicit checks required for compressed account?
@@ -52,15 +53,15 @@ pub fn compress_pda<A>(
     cpi_accounts: CpiAccounts,
     owner_program: &Pubkey,
     rent_recipient: &AccountInfo,
-    expected_compression_delay: u64,
+    config: &CompressibleConfig,
 ) -> Result<(), LightSdkError>
 where
     A: DataHasher
         + LightDiscriminator
         + BorshSerialize
         + BorshDeserialize
         + Default
-        + CompressionTiming,
+        + HasCompressionMetadata,
 {
     // Check that the PDA account is owned by the caller program
     if pda_account.owner != owner_program {
@@ -79,12 +80,12 @@ where
     let pda_account_data = A::try_from_slice(&pda_data[8..]).map_err(|_| LightSdkError::Borsh)?;
     drop(pda_data);
 
-    let last_written_slot = pda_account_data.last_written_slot();
+    let last_written_slot = pda_account_data.compression_metadata().last_written_slot();
 
-    if current_slot < last_written_slot + expected_compression_delay {
+    if current_slot < last_written_slot + config.compression_delay as u64 {
         msg!(
             "Cannot compress yet. {} slots remaining",
-            (last_written_slot + expected_compression_delay).saturating_sub(current_slot)
+            (last_written_slot + config.compression_delay as u64).saturating_sub(current_slot)
         );
         return Err(LightSdkError::ConstraintViolation);
     }

sdk-libs/sdk/src/compressible/compress_pda_new.rs

@@ -17,8 +17,6 @@ use solana_msg::msg;
 use solana_program_error::ProgramError;
 use solana_pubkey::Pubkey;
 
-use crate::compressible::compress_pda::CompressionTiming;
-
 /// Helper function to compress an onchain PDA into a new compressed account.
 ///
 /// This function handles the entire compression operation: creates a compressed account,
@@ -50,13 +48,7 @@ pub fn compress_pda_new<'info, A>(
     expected_address_space: &Pubkey,
 ) -> Result<(), LightSdkError>
 where
-    A: DataHasher
-        + LightDiscriminator
-        + BorshSerialize
-        + BorshDeserialize
-        + Default
-        + CompressionTiming
-        + Clone,
+    A: DataHasher + LightDiscriminator + BorshSerialize + BorshDeserialize + Default + Clone,
 {
     compress_multiple_pdas_new::<A>(
         &[pda_account],

sdk-libs/sdk/src/compressible/decompress_idempotent.rs

@@ -1,5 +1,6 @@
 use crate::{
     account::LightAccount,
+    compressible::compress_pda::HasCompressionMetadata,
     cpi::{CpiAccounts, CpiInputs},
     error::LightSdkError,
     instruction::ValidityProof,
@@ -20,8 +21,6 @@ use solana_rent::Rent;
 use solana_system_interface::instruction as system_instruction;
 use solana_sysvar::Sysvar;
 
-use crate::compressible::compress_pda::CompressionTiming;
-
 pub const COMPRESSION_DELAY: u64 = 100;
 
 /// Helper function to decompress a compressed account into a PDA idempotently with seeds.
@@ -57,7 +56,7 @@ where
         + BorshDeserialize
         + Default
         + Clone
-        + CompressionTiming,
+        + HasCompressionMetadata,
 {
     decompress_multiple_idempotent(
         &[pda_account],
@@ -103,7 +102,7 @@ where
         + BorshDeserialize
         + Default
         + Clone
-        + CompressionTiming,
+        + HasCompressionMetadata,
 {
     // Validate input lengths
     if pda_accounts.len() != compressed_accounts.len() || pda_accounts.len() != signer_seeds.len() {
@@ -181,7 +180,9 @@ where
 
         // Initialize PDA with decompressed data and update slot
         let mut decompressed_pda = compressed_account.account.clone();
-        decompressed_pda.set_last_written_slot(current_slot);
+        decompressed_pda
+            .compression_metadata_mut()
+            .set_last_written_slot_value(current_slot);
 
         // Write discriminator
         // TODO: we don't mind the onchain account being different?

sdk-libs/sdk/src/compressible/metadata.rs

@@ -0,0 +1,69 @@
+use crate::error::LightSdkError;
+#[cfg(feature = "anchor")]
+use anchor_lang::{AnchorDeserialize as BorshDeserialize, AnchorSerialize as BorshSerialize};
+#[cfg(not(feature = "anchor"))]
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_hasher::{to_byte_array::ToByteArray, DataHasher, Hasher, HasherError};
+use solana_clock::Clock;
+use solana_sysvar::Sysvar;
+
+/// Metadata for compressible accounts that tracks when the account was last written
+#[derive(Clone, Debug, Default, BorshSerialize, BorshDeserialize)]
+pub struct CompressionMetadata {
+    /// The slot when this account was last written/decompressed
+    pub last_written_slot: u64,
+}
+
+impl CompressionMetadata {
+    /// Creates new compression metadata with the current slot
+    pub fn new() -> Result<Self, LightSdkError> {
+        Ok(Self {
+            last_written_slot: Clock::get()?.slot,
+        })
+    }
+
+    /// Updates the last written slot to the current slot
+    pub fn set_last_written_slot(&mut self) -> Result<(), LightSdkError> {
+        self.last_written_slot = Clock::get()?.slot;
+        Ok(())
+    }
+
+    /// Sets the last written slot to a specific value
+    pub fn set_last_written_slot_value(&mut self, slot: u64) {
+        self.last_written_slot = slot;
+    }
+
+    /// Gets the last written slot
+    pub fn last_written_slot(&self) -> u64 {
+        self.last_written_slot
+    }
+
+    /// Checks if the account can be compressed based on the delay
+    pub fn can_compress(&self, compression_delay: u64) -> Result<bool, LightSdkError> {
+        let current_slot = Clock::get()?.slot;
+        Ok(current_slot >= self.last_written_slot + compression_delay)
+    }
+
+    /// Gets the number of slots remaining before compression is allowed
+    pub fn slots_until_compressible(&self, compression_delay: u64) -> Result<u64, LightSdkError> {
+        let current_slot = Clock::get()?.slot;
+        Ok((self.last_written_slot + compression_delay).saturating_sub(current_slot))
+    }
+}
+
+// Implement ToByteArray for CompressionMetadata
+impl ToByteArray for CompressionMetadata {
+    const NUM_FIELDS: usize = 1;
+    const IS_PRIMITIVE: bool = false;
+
+    fn to_byte_array(&self) -> Result<[u8; 32], HasherError> {
+        self.last_written_slot.to_byte_array()
+    }
+}
+
+// Implement DataHasher for CompressionMetadata
+impl DataHasher for CompressionMetadata {
+    fn hash<H: Hasher>(&self) -> Result<[u8; 32], HasherError> {
+        self.to_byte_array()
+    }
+}

sdk-libs/sdk/src/compressible/mod.rs

@@ -4,8 +4,13 @@ pub mod compress_pda;
 pub mod compress_pda_new;
 pub mod config;
 pub mod decompress_idempotent;
+pub mod metadata;
 
-pub use compress_pda::{compress_pda, CompressionTiming};
+pub use compress_pda::{compress_pda, HasCompressionMetadata};
 pub use compress_pda_new::{compress_multiple_pdas_new, compress_pda_new};
-pub use config::{create_config, update_config, CompressibleConfig, COMPRESSIBLE_CONFIG_SEED};
+pub use config::{
+    create_compression_config_checked, create_compression_config_unchecked, update_config,
+    CompressibleConfig, COMPRESSIBLE_CONFIG_SEED,
+};
 pub use decompress_idempotent::{decompress_idempotent, decompress_multiple_idempotent};
+pub use metadata::CompressionMetadata;