use hascompressioninfo and compressioninfo

Author: SwenSchaeferjohann

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

@@ -1,6 +1,6 @@
 use anchor_lang::prelude::*;
 use light_sdk::{
-    compressible::{CompressibleConfig, CompressionTiming},
+    compressible::{CompressibleConfig, CompressionInfo, HasCompressionInfo},
     cpi::CpiAccounts,
     instruction::{account_meta::CompressedAccountMeta, PackedAddressTreeInfo, ValidityProof},
     light_hasher::{DataHasher, Hasher},
@@ -42,8 +42,9 @@ pub mod anchor_compressible_user {
         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;
+        // Initialize compression info with current slot
+        user_record.compression_info = CompressionInfo::new()
+            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotDeserialize)?;
 
         // Verify rent recipient matches config
         if ctx.accounts.rent_recipient.key() != config.rent_recipient {
@@ -88,7 +89,9 @@ pub mod anchor_compressible_user {
         user_record.owner = ctx.accounts.user.key();
         user_record.name = name;
         user_record.score = 0;
-        user_record.compression_delay = COMPRESSION_DELAY;
+        // Initialize compression info with current slot
+        user_record.compression_info = CompressionInfo::new()
+            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotDeserialize)?;
 
         let cpi_accounts = CpiAccounts::new(
             &ctx.accounts.user,
@@ -243,7 +246,7 @@ pub mod anchor_compressible_user {
             cpi_accounts,
             &crate::ID,
             &ctx.accounts.rent_recipient,
-            COMPRESSION_DELAY, // Use the hardcoded value for legacy function
+            &COMPRESSION_DELAY as u32, // Use the hardcoded value for legacy function
         )
         .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?;
         Ok(())
@@ -278,7 +281,7 @@ pub mod anchor_compressible_user {
             cpi_accounts,
             &crate::ID,
             &ctx.accounts.rent_recipient,
-            config.compression_delay as u64,
+            &config.compression_delay,
         )
         .map_err(|e| anchor_lang::prelude::ProgramError::from(e))?;
         Ok(())
@@ -292,7 +295,7 @@ pub struct CreateRecordWithConfig<'info> {
     #[account(
         init,
         payer = user,
-        space = 8 + 32 + 4 + 32 + 8 + 8 + 8, // discriminator + owner + string len + name + score + last_written_slot + compression_delay
+        space = 8 + 32 + 4 + 32 + 8 + 9, // discriminator + owner + string len + name + score + compression_info
         seeds = [b"user_record", user.key().as_ref()],
         bump,
     )]
@@ -311,7 +314,7 @@ pub struct CreateRecord<'info> {
     #[account(
         init,
         payer = user,
-        space = 8 + 32 + 4 + 32 + 8, // discriminator + owner + string len + name + score
+        space = 8 + 32 + 4 + 32 + 8 + 9, // discriminator + owner + string len + name + score + compression_info
         seeds = [b"user_record", user.key().as_ref()],
         bump,
     )]
@@ -407,25 +410,18 @@ impl LightDiscriminator for CompressedAccountVariant {
     const LIGHT_DISCRIMINATOR_SLICE: &'static [u8] = &Self::LIGHT_DISCRIMINATOR;
 }
 
-impl CompressionTiming for CompressedAccountVariant {
-    fn last_written_slot(&self) -> u64 {
-        match self {
-            Self::UserRecord(data) => data.last_written_slot(),
-            Self::GameSession(data) => data.last_written_slot(),
-        }
-    }
-
-    fn compression_delay(&self) -> u64 {
+impl HasCompressionInfo for CompressedAccountVariant {
+    fn compression_info(&self) -> &CompressionInfo {
         match self {
-            Self::UserRecord(data) => data.compression_delay(),
-            Self::GameSession(data) => data.compression_delay(),
+            Self::UserRecord(data) => data.compression_info(),
+            Self::GameSession(data) => data.compression_info(),
         }
     }
 
-    fn set_last_written_slot(&mut self, slot: u64) {
+    fn compression_info_mut(&mut self) -> &mut CompressionInfo {
         match self {
-            Self::UserRecord(data) => data.set_last_written_slot(slot),
-            Self::GameSession(data) => data.set_last_written_slot(slot),
+            Self::UserRecord(data) => data.compression_info_mut(),
+            Self::GameSession(data) => data.compression_info_mut(),
         }
     }
 }
@@ -440,53 +436,45 @@ pub struct CompressedAccountData {
 #[derive(Default, Debug, LightHasher, LightDiscriminator)]
 #[account]
 pub struct UserRecord {
+    #[skip]
+    pub compression_info: CompressionInfo,
     #[hash]
     pub owner: Pubkey,
     pub name: String,
     pub score: u64,
-    pub last_written_slot: u64,
-    pub compression_delay: u64,
 }
 
-impl CompressionTiming for UserRecord {
-    fn last_written_slot(&self) -> u64 {
-        self.last_written_slot
-    }
-
-    fn compression_delay(&self) -> u64 {
-        self.compression_delay
+impl HasCompressionInfo for UserRecord {
+    fn compression_info(&self) -> &CompressionInfo {
+        &self.compression_info
     }
 
-    fn set_last_written_slot(&mut self, slot: u64) {
-        self.last_written_slot = slot;
+    fn compression_info_mut(&mut self) -> &mut CompressionInfo {
+        &mut self.compression_info
     }
 }
 
 #[derive(Default, Debug, LightHasher, LightDiscriminator)]
 #[account]
 pub struct GameSession {
+    #[skip]
+    pub compression_info: CompressionInfo,
     pub session_id: u64,
     #[hash]
     pub player: Pubkey,
     pub game_type: String,
     pub start_time: u64,
     pub end_time: Option<u64>,
     pub score: u64,
-    pub last_written_slot: u64,
-    pub compression_delay: u64,
 }
 
-impl CompressionTiming for GameSession {
-    fn last_written_slot(&self) -> u64 {
-        self.last_written_slot
-    }
-
-    fn compression_delay(&self) -> u64 {
-        self.compression_delay
+impl HasCompressionInfo for GameSession {
+    fn compression_info(&self) -> &CompressionInfo {
+        &self.compression_info
     }
 
-    fn set_last_written_slot(&mut self, slot: u64) {
-        self.last_written_slot = slot;
+    fn compression_info_mut(&mut self) -> &mut CompressionInfo {
+        &mut self.compression_info
     }
 }
 

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,
+        &config.compression_delay,
     )?;
 
     // any other program logic here...

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

@@ -1,6 +1,6 @@
 use borsh::{BorshDeserialize, BorshSerialize};
 use light_sdk::{
-    compressible::{compress_pda_new, CompressibleConfig, CompressionMetadata},
+    compressible::{compress_pda_new, CompressibleConfig, CompressionInfo},
     cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{PackedAddressTreeInfo, ValidityProof},
@@ -46,8 +46,8 @@ pub fn create_dynamic_pda(
     let mut pda_account_data = MyPdaAccount::try_from_slice(&pda_account.data.borrow())
         .map_err(|_| LightSdkError::Borsh)?;
 
-    // Initialize compression metadata with current slot
-    pda_account_data.compression_metadata = CompressionMetadata::new()?;
+    // Initialize compression info with current slot
+    pda_account_data.compression_info = CompressionInfo::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, CompressionMetadata, HasCompressionMetadata},
+    compressible::{decompress_idempotent, CompressionInfo, HasCompressionInfo},
     cpi::CpiAccounts,
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
@@ -41,8 +41,6 @@ pub fn decompress_dynamic_pda(
     // Extract the data field for use in seeds
     let account_data = compressed_account.data;
 
-    // Derive the PDA seeds and bump
-    // In a real implementation, you would pass these as part of the instruction data
     // For this example, we'll use the account data as part of the seed
     let seeds: &[&[u8]] = &[b"test_pda", &account_data];
     let (derived_pda, bump) =
@@ -176,17 +174,18 @@ pub struct MyCompressedAccount {
     Clone, Debug, Default, LightHasher, LightDiscriminator, BorshDeserialize, BorshSerialize,
 )]
 pub struct MyPdaAccount {
-    pub compression_metadata: CompressionMetadata,
+    #[skip]
+    pub compression_info: CompressionInfo,
     pub data: [u8; 31],
 }
 
-// Implement the HasCompressionMetadata trait
-impl HasCompressionMetadata for MyPdaAccount {
-    fn compression_metadata(&self) -> &CompressionMetadata {
-        &self.compression_metadata
+// Implement the HasCompressionInfo trait
+impl HasCompressionInfo for MyPdaAccount {
+    fn compression_info(&self) -> &CompressionInfo {
+        &self.compression_info
     }
 
-    fn compression_metadata_mut(&mut self) -> &mut CompressionMetadata {
-        &mut self.compression_metadata
+    fn compression_info_mut(&mut self) -> &mut CompressionInfo {
+        &mut self.compression_info
     }
 }

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

@@ -246,7 +246,7 @@ pub async fn decompress_pda(
         compressed_account: MyCompressedAccount {
             meta,
             data: MyPdaAccount {
-                compression_metadata: light_sdk::compressible::CompressionMetadata::default(),
+                compression_info: light_sdk::compressible::CompressionInfo::default(),
                 data: compressed_account
                     .compressed_account
                     .data

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

@@ -1,6 +1,9 @@
 use crate::{
     account::LightAccount,
-    compressible::{metadata::CompressionMetadata, CompressibleConfig},
+    compressible::{
+        compression_info::{CompressionInfo, HasCompressionInfo},
+        CompressibleConfig,
+    },
     cpi::{CpiAccounts, CpiInputs},
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
@@ -18,12 +21,6 @@ use solana_program_error::ProgramError;
 use solana_pubkey::Pubkey;
 use solana_sysvar::Sysvar;
 
-/// 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.
 ///
 /// 1. closes onchain PDA
@@ -41,27 +38,23 @@ pub trait HasCompressionMetadata {
 /// * `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?
-// - consider multiple accounts per ix.
+/// * `compression_delay` - The number of slots to wait before compression is allowed
 pub fn compress_pda<A>(
     pda_account: &AccountInfo,
     compressed_account_meta: &CompressedAccountMeta,
     proof: ValidityProof,
     cpi_accounts: CpiAccounts,
     owner_program: &Pubkey,
     rent_recipient: &AccountInfo,
-    config: &CompressibleConfig,
+    compression_delay: &u32,
 ) -> Result<(), LightSdkError>
 where
     A: DataHasher
         + LightDiscriminator
         + BorshSerialize
         + BorshDeserialize
         + Default
-        + HasCompressionMetadata,
+        + HasCompressionInfo,
 {
     // Check that the PDA account is owned by the caller program
     if pda_account.owner != owner_program {
@@ -75,17 +68,24 @@ where
 
     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 mut pda_data = pda_account.try_borrow_mut_data()?;
+    let mut pda_account_data =
+        A::try_from_slice(&pda_data[8..]).map_err(|_| LightSdkError::Borsh)?;
 
-    let last_written_slot = pda_account_data.compression_metadata().last_written_slot();
+    let last_written_slot = pda_account_data.compression_info().last_written_slot();
+
+    // ensure re-init attack is not possible
+    pda_account_data.compression_info_mut().set_compressed();
+
+    pda_account_data
+        .serialize(&mut &mut pda_data[8..])
+        .map_err(|_| LightSdkError::Borsh)?;
+    drop(pda_data);
 
-    if current_slot < last_written_slot + config.compression_delay as u64 {
+    if current_slot < last_written_slot + *compression_delay as u64 {
         msg!(
             "Cannot compress yet. {} slots remaining",
-            (last_written_slot + config.compression_delay as u64).saturating_sub(current_slot)
+            (last_written_slot + *compression_delay as u64).saturating_sub(current_slot)
         );
         return Err(LightSdkError::ConstraintViolation);
     }