add test-sdk-derived program

Author: SwenSchaeferjohann

Cargo.lock

@@ -50,6 +50,7 @@ members = [
     "sparse-merkle-tree",
     "program-tests/anchor-compressible-user",
     "program-tests/anchor-compressible-user-derived",
+    "program-tests/sdk-test-derived",
 ]
 
 resolver = "2"

Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "sdk-test-derived"
+version = "1.0.0"
+description = "Test program using generalized account compression"
+repository = "https://github.com/Lightprotocol/light-protocol"
+license = "Apache-2.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "sdk_test_derived"
+
+[features]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+test-sbf = []
+default = []
+
+[dependencies]
+light-sdk = { workspace = true }
+light-sdk-types = { workspace = true }
+light-hasher = { workspace = true, features = ["solana"] }
+solana-program = { workspace = true }
+light-macros = { workspace = true, features = ["solana"] }
+borsh = { workspace = true }
+light-compressed-account = { workspace = true, features = ["solana"] }
+solana-clock = { workspace = true }
+solana-sysvar = { workspace = true }
+arrayvec = { workspace = true }
+
+[dev-dependencies]
+light-program-test = { workspace = true, features = ["devenv"] }
+tokio = { workspace = true }
+solana-sdk = { workspace = true }
+
+[lints.rust.unexpected_cfgs]
+level = "allow"
+check-cfg = [
+    'cfg(target_os, values("solana"))',
+    'cfg(feature, values("frozen-abi", "no-entrypoint"))',
+]
+

program-tests/sdk-test-derived/Cargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

program-tests/sdk-test-derived/Xargo.toml

@@ -0,0 +1,63 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_sdk::{
+    compressible::{compress_pda, CompressibleConfig},
+    cpi::CpiAccounts,
+    error::LightSdkError,
+    instruction::{account_meta::CompressedAccountMeta, ValidityProof},
+};
+use light_sdk_types::CpiAccountsConfig;
+use solana_program::account_info::AccountInfo;
+
+use crate::decompress_dynamic_pda::MyPdaAccount;
+
+/// Compresses a PDA back into a compressed account
+/// Anyone can call this after the timeout period has elapsed
+pub fn compress_dynamic_pda(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), LightSdkError> {
+    let mut instruction_data = instruction_data;
+    let instruction_data = CompressFromPdaInstructionData::deserialize(&mut instruction_data)
+        .map_err(|_| LightSdkError::Borsh)?;
+
+    let pda_account = &accounts[1];
+    let rent_recipient = &accounts[2];
+    let config_account = &accounts[3];
+
+    // Load config
+    let config = CompressibleConfig::load_checked(config_account, &crate::ID)?;
+
+    // CHECK: rent recipient from config
+    if rent_recipient.key != &config.rent_recipient {
+        return Err(LightSdkError::ConstraintViolation);
+    }
+
+    // Cpi accounts
+    let cpi_config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER);
+    let cpi_accounts = CpiAccounts::new_with_config(
+        &accounts[0],
+        &accounts[instruction_data.system_accounts_offset as usize..],
+        cpi_config,
+    );
+
+    compress_pda::<MyPdaAccount>(
+        pda_account,
+        &instruction_data.compressed_account_meta,
+        instruction_data.proof,
+        cpi_accounts,
+        &crate::ID,
+        rent_recipient,
+        &config.compression_delay,
+    )?;
+
+    // any other program logic here...
+
+    Ok(())
+}
+
+#[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
+pub struct CompressFromPdaInstructionData {
+    pub proof: ValidityProof,
+    pub compressed_account_meta: CompressedAccountMeta,
+    pub system_accounts_offset: u8,
+}

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

@@ -0,0 +1,43 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_sdk::{compressible::create_compression_config_checked, error::LightSdkError};
+use solana_program::account_info::AccountInfo;
+use solana_program::pubkey::Pubkey;
+
+/// Creates a new compressible config PDA
+pub fn process_create_compression_config_checked(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), LightSdkError> {
+    let mut instruction_data = instruction_data;
+    let instruction_data = CreateConfigInstructionData::deserialize(&mut instruction_data)
+        .map_err(|_| LightSdkError::Borsh)?;
+
+    // Get accounts
+    let payer = &accounts[0];
+    let config_account = &accounts[1];
+    let update_authority = &accounts[2];
+    let system_program = &accounts[3];
+    let program_data_account = &accounts[4];
+
+    create_compression_config_checked(
+        config_account,
+        update_authority,
+        program_data_account,
+        &instruction_data.rent_recipient,
+        instruction_data.address_space,
+        instruction_data.compression_delay,
+        payer,
+        system_program,
+        &crate::ID,
+    )?;
+
+    Ok(())
+}
+
+#[derive(Clone, Debug, BorshDeserialize, BorshSerialize)]
+pub struct CreateConfigInstructionData {
+    pub rent_recipient: Pubkey,
+    /// Address spaces (1-4 allowed, first is primary for writing)
+    pub address_space: Vec<Pubkey>,
+    pub compression_delay: u32,
+}

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

@@ -0,0 +1,77 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_compressed_account::instruction_data::data::ReadOnlyAddress;
+use light_sdk::{
+    compressible::{compress_pda_new, CompressibleConfig, CompressionInfo},
+    cpi::CpiAccounts,
+    error::LightSdkError,
+    instruction::{PackedAddressTreeInfo, ValidityProof},
+};
+use solana_program::account_info::AccountInfo;
+
+use crate::decompress_dynamic_pda::MyPdaAccount;
+
+/// INITS a PDA and compresses it into a new compressed account.
+pub fn create_dynamic_pda(
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> Result<(), LightSdkError> {
+    let mut instruction_data = instruction_data;
+    let instruction_data = CreateDynamicPdaInstructionData::deserialize(&mut instruction_data)
+        .map_err(|_| LightSdkError::Borsh)?;
+
+    let fee_payer = &accounts[0];
+    // UNCHECKED: ...caller program checks this.
+    let pda_account = &accounts[1];
+    let rent_recipient = &accounts[2];
+    let config_account = &accounts[3];
+
+    // Load config
+    let config = CompressibleConfig::load_checked(config_account, &crate::ID)?;
+
+    // CHECK: rent recipient from config
+    if rent_recipient.key != &config.rent_recipient {
+        return Err(LightSdkError::ConstraintViolation);
+    }
+
+    // Cpi accounts
+    let cpi_accounts_struct = CpiAccounts::new(fee_payer, &accounts[4..], crate::LIGHT_CPI_SIGNER);
+
+    // the onchain PDA is the seed for the cPDA. this way devs don't have to
+    // change their onchain PDA checks.
+    let new_address_params = instruction_data
+        .address_tree_info
+        .into_new_address_params_packed(pda_account.key.to_bytes());
+
+    // We do not have to serialize into the PDA account, it's closed at the end
+    // of this invocation.
+    let mut pda_account_data = MyPdaAccount::try_from_slice(&pda_account.data.borrow())
+        .map_err(|_| LightSdkError::Borsh)?;
+
+    // Initialize compression info with current slot and decompressed state
+    pda_account_data.compression_info = CompressionInfo::new()?;
+
+    compress_pda_new::<MyPdaAccount>(
+        pda_account,
+        instruction_data.compressed_address,
+        new_address_params,
+        instruction_data.output_state_tree_index,
+        instruction_data.proof,
+        cpi_accounts_struct,
+        &crate::ID,
+        rent_recipient,
+        &config.address_space,
+        instruction_data.read_only_addresses,
+    )?;
+
+    Ok(())
+}
+
+#[derive(Clone, Debug, Default, BorshDeserialize, BorshSerialize)]
+pub struct CreateDynamicPdaInstructionData {
+    pub proof: ValidityProof,
+    pub compressed_address: [u8; 32],
+    pub address_tree_info: PackedAddressTreeInfo,
+    /// Optional read-only addresses for exclusion proofs (same address, different trees)
+    pub read_only_addresses: Option<Vec<ReadOnlyAddress>>,
+    pub output_state_tree_index: u8,
+}