decompress_idempotent.rs

Author: SwenSchaeferjohann

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

@@ -7,11 +7,12 @@ use light_sdk::{
 use light_sdk_types::CpiAccountsConfig;
 use solana_program::account_info::AccountInfo;
 
-use crate::{decompress_to_pda::DecompressedPdaAccount, sdk::compress_pda::compress_pda};
+use crate::{decompress_to_pda::MyPdaAccount, 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.
+// TODO: add macro that create the full instruction. and takes: programid, account and seeds, rent_recipient (to hardcode). low code solution.
 pub fn compress_from_pda(
     accounts: &[AccountInfo],
     instruction_data: &[u8],
@@ -20,7 +21,7 @@ pub fn compress_from_pda(
     let instruction_data = CompressFromPdaInstructionData::deserialize(&mut instruction_data)
         .map_err(|_| LightSdkError::Borsh)?;
 
-    // based on program...
+    // Custom seeds for PDA derivation (must match decompress_idempotent)
     let custom_seeds: Vec<&[u8]> = vec![b"decompressed_pda"];
 
     let pda_account = &accounts[1];
@@ -34,10 +35,10 @@ pub fn compress_from_pda(
         config,
     );
 
-    compress_pda::<DecompressedPdaAccount>(
+    compress_pda::<MyPdaAccount>(
         pda_account,
         &instruction_data.compressed_account_meta,
-        Some(instruction_data.proof),
+        instruction_data.proof,
         cpi_accounts_struct,
         &crate::ID,
         rent_recipient,
@@ -53,6 +54,5 @@ pub fn compress_from_pda(
 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,54 +1,21 @@
 use borsh::{BorshDeserialize, BorshSerialize};
-use light_hasher::{DataHasher, Hasher};
 use light_sdk::{
-    account::LightAccount,
-    cpi::{CpiAccounts, CpiAccountsConfig, CpiInputs},
+    cpi::{CpiAccounts, CpiAccountsConfig},
     error::LightSdkError,
-    instruction::{
-        account_meta::{CompressedAccountMeta, CompressedAccountMetaTrait},
-        ValidityProof,
-    },
+    instruction::{account_meta::CompressedAccountMeta, ValidityProof},
     LightDiscriminator, LightHasher,
 };
-use solana_program::{
-    account_info::AccountInfo, clock::Clock, msg, program::invoke_signed, pubkey::Pubkey,
-    rent::Rent, system_instruction, sysvar::Sysvar,
-};
-
-pub const SLOTS_UNTIL_COMPRESSION: u64 = 100;
+use solana_program::account_info::AccountInfo;
 
-/// Account structure for the decompressed PDA
-#[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
-pub struct DecompressedPdaAccount {
-    /// The compressed account address this PDA was derived from
-    pub compressed_address: [u8; 32],
-    /// Slot when this account was last written
-    pub last_written_slot: u64,
-    /// Number of slots until this account can be compressed again
-    pub slots_until_compression: u64,
-    /// The actual account data
-    pub data: [u8; 31],
-    /// Flag to indicate if this is a decompressed account
-    pub is_decompressed: bool,
-}
+use crate::sdk::decompress_idempotent::decompress_idempotent;
 
-/// Compressed account structure with decompression flag
-#[derive(
-    Clone, Debug, Default, LightHasher, LightDiscriminator, BorshDeserialize, BorshSerialize,
-)]
-pub struct DecompressedMarkerAccount {
-    /// Flag to indicate this account has been decompressed
-    pub is_decompressed: bool,
-}
+pub const SLOTS_UNTIL_COMPRESSION: u64 = 100;
 
-/// Decompresses a compressed account into a PDA
-/// The PDA is derived from the compressed account's address and other seeds
+/// Decompresses a compressed account into a PDA idempotently.
 pub fn decompress_to_pda(
     accounts: &[AccountInfo],
     instruction_data: &[u8],
 ) -> Result<(), LightSdkError> {
-    msg!("Decompressing compressed account to PDA");
-
     let mut instruction_data = instruction_data;
     let instruction_data = DecompressToPdaInstructionData::deserialize(&mut instruction_data)
         .map_err(|_| LightSdkError::Borsh)?;
@@ -59,157 +26,75 @@ pub fn decompress_to_pda(
     let rent_payer = &accounts[2]; // Account that pays for PDA rent
     let system_program = &accounts[3];
 
-    // Derive PDA from compressed address
-    let compressed_address = instruction_data.compressed_account.meta.address;
-    let (pda_pubkey, pda_bump) = Pubkey::find_program_address(
-        &[
-            b"decompressed_pda",
-            &compressed_address,
-            &instruction_data.additional_seed,
-        ],
-        &crate::ID,
-    );
-
-    // Verify PDA matches
-    if pda_pubkey != *pda_account.key {
-        msg!("Invalid PDA pubkey");
-        return Err(LightSdkError::ConstraintViolation);
-    }
-
-    // Get current slot
-    let clock = Clock::get().map_err(|_| LightSdkError::Borsh)?;
-    let current_slot = clock.slot;
-
-    // Calculate space needed for PDA
-    let space = std::mem::size_of::<DecompressedPdaAccount>() + 8; // +8 for discriminator
-
-    // Get minimum rent
-    let rent = Rent::get().map_err(|_| LightSdkError::Borsh)?;
-    let minimum_balance = rent.minimum_balance(space);
-
-    // Create PDA account (rent payer pays for the PDA creation)
-    let create_account_ix = system_instruction::create_account(
-        rent_payer.key,
-        pda_account.key,
-        minimum_balance,
-        space as u64,
-        &crate::ID,
-    );
-
-    let signer_seeds = &[
-        b"decompressed_pda".as_ref(),
-        compressed_address.as_ref(),
-        instruction_data.additional_seed.as_ref(),
-        &[pda_bump],
-    ];
-
-    invoke_signed(
-        &create_account_ix,
-        &[
-            rent_payer.clone(),
-            pda_account.clone(),
-            system_program.clone(),
-        ],
-        &[signer_seeds],
-    )?;
-
-    // Initialize PDA with decompressed data
-    let decompressed_pda = DecompressedPdaAccount {
-        compressed_address,
-        last_written_slot: current_slot,
-        slots_until_compression: SLOTS_UNTIL_COMPRESSION,
-        data: instruction_data.compressed_account.data,
-        is_decompressed: true,
-    };
-
-    // Write data to PDA
-    decompressed_pda
-        .serialize(&mut &mut pda_account.try_borrow_mut_data()?[8..])
-        .map_err(|_| LightSdkError::Borsh)?;
-
-    // Write discriminator
-    pda_account.try_borrow_mut_data()?[..8].copy_from_slice(b"decomppd");
-
-    // Now handle the compressed account side
-    // Create a marker account that indicates this compressed account has been decompressed
-    let marker_account = LightAccount::<'_, DecompressedMarkerAccount>::new_mut(
-        &crate::ID,
-        &instruction_data.compressed_account.meta,
-        DecompressedMarkerAccount {
-            is_decompressed: true,
-        },
-    )?;
-
-    // Set up CPI accounts for light system program
-    let mut config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
-    config.sol_pool_pda = false;
-    config.sol_compression_recipient = true; // We need to decompress SOL to the PDA
-
+    // Cpi accounts
     let cpi_accounts = CpiAccounts::new_with_config(
         fee_payer,
         &accounts[instruction_data.system_accounts_offset as usize..],
-        config,
+        CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER),
     );
 
-    // Create CPI inputs with decompression
-    let mut cpi_inputs = CpiInputs::new(
-        instruction_data.proof,
-        vec![marker_account.to_account_info()?],
-    );
+    // Custom seeds for PDA derivation
+    let custom_seeds: Vec<&[u8]> = vec![b"decompressed_pda"];
 
-    // Set decompression parameters
-    // Transfer all lamports from compressed account to the PDA
-    let lamports_to_decompress = instruction_data
-        .compressed_account
-        .meta
-        .get_lamports()
-        .unwrap_or(0);
-
-    cpi_inputs.compress_or_decompress_lamports = Some(lamports_to_decompress);
-    cpi_inputs.is_compress = false; // This is decompression
+    // Call the SDK function to decompress idempotently
+    // this inits pda_account if not already initialized
+    decompress_idempotent::<MyPdaAccount>(
+        pda_account,
+        Some(&instruction_data.compressed_account.meta),
+        &instruction_data.compressed_account.data,
+        instruction_data.proof,
+        cpi_accounts,
+        &crate::ID,
+        rent_payer,
+        system_program,
+        &custom_seeds,
+        &instruction_data.additional_seed,
+    )?;
 
-    // Invoke light system program
-    cpi_inputs.invoke_light_system_program(cpi_accounts)?;
+    // do something with pda_account...
 
-    msg!("Successfully decompressed account to PDA");
     Ok(())
 }
 
 #[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
 pub struct DecompressToPdaInstructionData {
     pub proof: ValidityProof,
-    pub compressed_account: DecompressMyCompressedAccount,
-    pub additional_seed: [u8; 32], // Additional seed for PDA derivation
+    pub compressed_account: MyCompressedAccount,
+    pub additional_seed: [u8; 32], // ... some seed
     pub system_accounts_offset: u8,
 }
 
+// just a wrapper
 #[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
-pub struct DecompressMyCompressedAccount {
+pub struct MyCompressedAccount {
     pub meta: CompressedAccountMeta,
-    pub data: [u8; 31],
+    pub data: MyPdaAccount,
 }
 
-// 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];
+/// Account structure for the PDA
+#[derive(
+    Clone, Debug, LightHasher, LightDiscriminator, Default, BorshDeserialize, BorshSerialize,
+)]
+pub struct MyPdaAccount {
+    /// Slot when this account was last written
+    pub last_written_slot: u64,
+    /// Number of slots after last_written_slot until this account can be compressed again
+    pub slots_until_compression: u64,
+    /// The actual account data
+    pub data: [u8; 31],
 }
 
-impl crate::sdk::compress_pda::PdaTimingData for DecompressedPdaAccount {
+// We require this trait to be implemented for the custom PDA account.
+impl crate::sdk::compress_pda::PdaTimingData for MyPdaAccount {
     fn last_touched_slot(&self) -> u64 {
         self.last_written_slot
     }
 
     fn slots_buffer(&self) -> u64 {
         self.slots_until_compression
     }
+
+    fn set_last_written_slot(&mut self, slot: u64) {
+        self.last_written_slot = slot;
+    }
 }

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

@@ -8,7 +8,7 @@ pub mod compress_from_pda;
 pub mod create_pda;
 pub mod decompress_to_pda;
 pub mod sdk;
-pub mod update_decompressed_pda;
+
 pub mod update_pda;
 
 pub const ID: Pubkey = pubkey!("FNt7byTHev1k5x2cXZLBr8TdWiC3zoP5vcnZR4P682Uy");
@@ -23,7 +23,6 @@ pub enum InstructionType {
     UpdatePdaBorsh = 1,
     DecompressToPda = 2,
     CompressFromPda = 3,
-    UpdateDecompressedPda = 4,
 }
 
 impl TryFrom<u8> for InstructionType {
@@ -35,7 +34,6 @@ impl TryFrom<u8> for InstructionType {
             1 => Ok(InstructionType::UpdatePdaBorsh),
             2 => Ok(InstructionType::DecompressToPda),
             3 => Ok(InstructionType::CompressFromPda),
-            4 => Ok(InstructionType::UpdateDecompressedPda),
             _ => panic!("Invalid instruction discriminator."),
         }
     }
@@ -60,9 +58,6 @@ pub fn process_instruction(
         InstructionType::CompressFromPda => {
             compress_from_pda::compress_from_pda(accounts, &instruction_data[1..])
         }
-        InstructionType::UpdateDecompressedPda => {
-            update_decompressed_pda::update_decompressed_pda(accounts, &instruction_data[1..])
-        }
     }?;
     Ok(())
 }

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

@@ -1,8 +1,8 @@
 use borsh::{BorshDeserialize, BorshSerialize};
-use light_hasher::{DataHasher, Hasher};
+use light_hasher::DataHasher;
 use light_sdk::{
     account::LightAccount,
-    cpi::{CpiAccounts, CpiAccountsConfig, CpiInputs, CpiSigner},
+    cpi::{CpiAccounts, CpiInputs},
     error::LightSdkError,
     instruction::{account_meta::CompressedAccountMeta, ValidityProof},
     LightDiscriminator,
@@ -16,6 +16,7 @@ use solana_program::{
 pub trait PdaTimingData {
     fn last_touched_slot(&self) -> u64;
     fn slots_buffer(&self) -> u64;
+    fn set_last_written_slot(&mut self, slot: u64);
 }
 
 const DECOMP_SEED: &[u8] = b"decomp";
@@ -81,7 +82,7 @@ pub fn check_pda(
 pub fn compress_pda<A>(
     pda_account: &AccountInfo,
     compressed_account_meta: &CompressedAccountMeta,
-    proof: Option<ValidityProof>,
+    proof: ValidityProof,
     cpi_accounts: CpiAccounts,
     owner_program: &Pubkey,
     rent_recipient: &AccountInfo,
@@ -130,10 +131,7 @@ where
     compressed_account.account = pda_account_data;
 
     // Create CPI inputs
-    let cpi_inputs = CpiInputs::new(
-        proof.unwrap_or_default(),
-        vec![compressed_account.to_account_info()?],
-    );
+    let cpi_inputs = CpiInputs::new(proof, vec![compressed_account.to_account_info()?]);
 
     // Invoke light system program to create the compressed account
     cpi_inputs.invoke_light_system_program(cpi_accounts)?;