wip

SwenSchaeferjohann · SwenSchaeferjohann · commit 551f0f14a775 · 2025-07-04T12:04:47.000-04:00
diff --git a/program-tests/sdk-test/src/compress_from_pda.rs b/program-tests/sdk-test/src/compress_from_pda.rs
@@ -0,0 +1,141 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_sdk::{
+    account::LightAccount,
+    cpi::{CpiAccounts, CpiAccountsConfig, CpiInputs},
+    error::LightSdkError,
+    instruction::ValidityProof,
+};
+use solana_program::{
+    account_info::AccountInfo, clock::Clock, msg, program_error::ProgramError, pubkey::Pubkey,
+    sysvar::Sysvar,
+};
+
+use crate::{create_pda::MyCompressedAccount, decompress_to_pda::DecompressedPdaAccount};
+
+/// Compresses a PDA back into a compressed account
+/// Anyone can call this after the timeout period has elapsed
+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];
+    let pda_account = &accounts[1];
+    let rent_recipient = &accounts[2]; // Hardcoded by caller program
+    let _system_program = &accounts[3];
+
+    // 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);
+    }
+
+    // Read and deserialize PDA data
+    let pda_data = pda_account.try_borrow_data()?;
+
+    // Check discriminator
+    if &pda_data[..8] != b"decomppd" {
+        msg!("Invalid PDA discriminator");
+        return Err(LightSdkError::ConstraintViolation);
+    }
+
+    let decompressed_pda = DecompressedPdaAccount::deserialize(&mut &pda_data[8..])
+        .map_err(|_| LightSdkError::Borsh)?;
+
+    // Check if enough time has passed
+    let clock = Clock::get().map_err(|_| LightSdkError::Borsh)?;
+    let current_slot = clock.slot;
+    let slots_elapsed = current_slot.saturating_sub(decompressed_pda.last_written_slot);
+
+    if slots_elapsed < decompressed_pda.slots_until_compression {
+        msg!(
+            "Cannot compress yet. {} slots remaining",
+            decompressed_pda
+                .slots_until_compression
+                .saturating_sub(slots_elapsed)
+        );
+        return Err(LightSdkError::ConstraintViolation);
+    }
+
+    // Derive PDA to verify it matches
+    let (pda_pubkey, _pda_bump) = Pubkey::find_program_address(
+        &[
+            b"decompressed_pda",
+            &decompressed_pda.compressed_address,
+            &instruction_data.additional_seed,
+        ],
+        &crate::ID,
+    );
+
+    if pda_pubkey != *pda_account.key {
+        msg!("PDA derivation mismatch");
+        return Err(LightSdkError::ConstraintViolation);
+    }
+
+    // Drop the borrow before we close the account
+    drop(pda_data);
+
+    // Close the PDA account and send rent to recipient
+    let pda_lamports = pda_account.lamports();
+    **pda_account.try_borrow_mut_lamports()? = 0;
+    **rent_recipient.try_borrow_mut_lamports()? = rent_recipient
+        .lamports()
+        .checked_add(pda_lamports)
+        .ok_or(ProgramError::ArithmeticOverflow)?;
+
+    // Clear the PDA data
+    pda_account.try_borrow_mut_data()?.fill(0);
+
+    // Now create the compressed account with the latest data
+    let mut compressed_account = LightAccount::<'_, MyCompressedAccount>::new_init(
+        &crate::ID,
+        Some(decompressed_pda.compressed_address),
+        instruction_data.output_merkle_tree_index,
+    );
+
+    compressed_account.data = decompressed_pda.data;
+
+    // Set up CPI accounts for light system program
+    let mut config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
+    config.sol_pool_pda = true; // We're compressing SOL
+
+    let cpi_accounts = CpiAccounts::new_with_config(
+        fee_payer,
+        &accounts[instruction_data.system_accounts_offset as usize..],
+        config,
+    );
+
+    // Create CPI inputs
+    let mut cpi_inputs = CpiInputs::new_with_address(
+        instruction_data.proof,
+        vec![compressed_account.to_account_info()?],
+        vec![instruction_data.new_address_params],
+    );
+
+    // Set compression parameters
+    // We're compressing the lamports that were in the PDA
+    cpi_inputs.compress_or_decompress_lamports = Some(instruction_data.lamports_to_compress);
+    cpi_inputs.is_compress = true;
+
+    // Invoke light system program
+    cpi_inputs.invoke_light_system_program(cpi_accounts)?;
+
+    msg!("Successfully compressed PDA back to compressed account");
+    Ok(())
+}
+
+#[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
+pub struct CompressFromPdaInstructionData {
+    pub proof: ValidityProof,
+    pub new_address_params: light_sdk::address::PackedNewAddressParams,
+    pub output_merkle_tree_index: u8,
+    pub additional_seed: [u8; 32], // Must match the seed used in decompression
+    pub lamports_to_compress: u64,
+    pub system_accounts_offset: u8,
+}
diff --git a/program-tests/sdk-test/src/decompress_to_pda.rs b/program-tests/sdk-test/src/decompress_to_pda.rs
@@ -0,0 +1,189 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_sdk::{
+    account::LightAccount,
+    cpi::{CpiAccounts, CpiAccountsConfig, CpiInputs},
+    error::LightSdkError,
+    instruction::{
+        account_meta::{CompressedAccountMeta, CompressedAccountMetaTrait},
+        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;
+
+/// Account structure for the decompressed PDA
+#[derive(Clone, Debug, 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,
+}
+
+/// 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,
+}
+
+/// Decompresses a compressed account into a PDA
+/// The PDA is derived from the compressed account's address and other seeds
+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)?;
+
+    // Get accounts
+    let fee_payer = &accounts[0];
+    let pda_account = &accounts[1];
+    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
+
+    let cpi_accounts = CpiAccounts::new_with_config(
+        fee_payer,
+        &accounts[instruction_data.system_accounts_offset as usize..],
+        config,
+    );
+
+    // Create CPI inputs with decompression
+    let mut cpi_inputs = CpiInputs::new(
+        instruction_data.proof,
+        vec![marker_account.to_account_info()?],
+    );
+
+    // 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
+
+    // Invoke light system program
+    cpi_inputs.invoke_light_system_program(cpi_accounts)?;
+
+    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 system_accounts_offset: u8,
+}
+
+#[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
+pub struct DecompressMyCompressedAccount {
+    pub meta: CompressedAccountMeta,
+    pub data: [u8; 31],
+}
diff --git a/program-tests/sdk-test/src/lib.rs b/program-tests/sdk-test/src/lib.rs
@@ -4,7 +4,10 @@ use solana_program::{
     account_info::AccountInfo, entrypoint, program_error::ProgramError, pubkey::Pubkey,
 };
 
+pub mod compress_from_pda;
 pub mod create_pda;
+pub mod decompress_to_pda;
+pub mod update_decompressed_pda;
 pub mod update_pda;
 
 pub const ID: Pubkey = pubkey!("FNt7byTHev1k5x2cXZLBr8TdWiC3zoP5vcnZR4P682Uy");
@@ -17,6 +20,9 @@ entrypoint!(process_instruction);
 pub enum InstructionType {
     CreatePdaBorsh = 0,
     UpdatePdaBorsh = 1,
+    DecompressToPda = 2,
+    CompressFromPda = 3,
+    UpdateDecompressedPda = 4,
 }
 
 impl TryFrom<u8> for InstructionType {
@@ -26,6 +32,9 @@ impl TryFrom<u8> for InstructionType {
         match value {
             0 => Ok(InstructionType::CreatePdaBorsh),
             1 => Ok(InstructionType::UpdatePdaBorsh),
+            2 => Ok(InstructionType::DecompressToPda),
+            3 => Ok(InstructionType::CompressFromPda),
+            4 => Ok(InstructionType::UpdateDecompressedPda),
             _ => panic!("Invalid instruction discriminator."),
         }
     }
@@ -44,6 +53,15 @@ pub fn process_instruction(
         InstructionType::UpdatePdaBorsh => {
             update_pda::update_pda::<false>(accounts, &instruction_data[1..])
         }
+        InstructionType::DecompressToPda => {
+            decompress_to_pda::decompress_to_pda(accounts, &instruction_data[1..])
+        }
+        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(())
 }
diff --git a/program-tests/sdk-test/src/update_decompressed_pda.rs b/program-tests/sdk-test/src/update_decompressed_pda.rs
