refactor: ctoken sdk builder instructions

Cargo.toml

@@ -55,6 +55,7 @@ members = [
     "sdk-tests/sdk-v1-native-test",
     "sdk-tests/sdk-token-test",
     "sdk-tests/sdk-compressible-test",
+    "sdk-tests/sdk-ctoken-test",
     "forester-utils",
     "forester",
     "sparse-merkle-tree",

forester/src/compressible/compressor.rs

@@ -3,7 +3,7 @@ use std::{str::FromStr, sync::Arc};
 use anchor_lang::{InstructionData, ToAccountMetas};
 use forester_utils::rpc_pool::SolanaRpcPool;
 use light_client::rpc::Rpc;
-use light_compressed_token_sdk::instructions::compress_and_close::CompressAndCloseAccounts as CTokenAccounts;
+use light_compressed_token_sdk::compressed_token::compress_and_close::CompressAndCloseAccounts as CTokenAccounts;
 use light_compressible::config::CompressibleConfig;
 use light_ctoken_types::COMPRESSED_TOKEN_PROGRAM_ID;
 use light_registry::{

forester/tests/test_compressible_ctoken.rs

@@ -9,7 +9,7 @@ use light_client::{
     local_test_validator::{spawn_validator, LightValidatorConfig},
     rpc::{LightClient, LightClientConfig, Rpc},
 };
-use light_compressed_token_sdk::instructions::create_compressed_mint;
+use light_compressed_token_sdk::compressed_token::create_compressed_mint;
 use light_ctoken_types::state::TokenDataVersion;
 use light_registry::{
     protocol_config::state::ProtocolConfigPda,

program-libs/compressed-account/src/instruction_data/traits.rs

@@ -28,6 +28,7 @@ pub trait LightInstructionData: InstructionDiscriminator + AnchorSerialize {
             .map_err(|_| CompressedAccountError::InvalidArgument)?;
         let mut data = crate::Vec::with_capacity(8 + inputs.len());
         data.extend_from_slice(self.discriminator());
+
         data.extend_from_slice(inputs.as_slice());
         Ok(data)
     }

program-tests/compressed-token-test/tests/ctoken/compress_and_close.rs

@@ -110,7 +110,7 @@ async fn test_compress_and_close_owner_scenarios() {
         .await;
 
         // Set token balance on ATA
-        use light_compressed_token_sdk::instructions::create_associated_token_account::derive_ctoken_ata;
+        use light_compressed_token_sdk::ctoken::derive_ctoken_ata;
         let (ata_pubkey, _bump) =
             derive_ctoken_ata(&context.owner_keypair.pubkey(), &context.mint_pubkey);
 
@@ -439,22 +439,24 @@ async fn test_compressible_account_with_custom_rent_payer_close_with_compression
     let lamports_per_write = Some(100);
 
     // Initialize compressible token account
-    let create_token_account_ix =
-        light_compressed_token_sdk::instructions::create_compressible_token_account_instruction(
-            light_compressed_token_sdk::instructions::CreateCompressibleTokenAccount {
-                account_pubkey: token_account_pubkey,
-                mint_pubkey: context.mint_pubkey,
-                owner_pubkey: context.owner_keypair.pubkey(),
-                compressible_config: context.compressible_config,
-                rent_sponsor: payer_pubkey,
-                pre_pay_num_epochs: num_prepaid_epochs,
-                lamports_per_write,
-                payer: payer_pubkey,
-                compress_to_account_pubkey: None,
-                token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
-            },
-        )
-        .unwrap();
+    let compressible_params = CompressibleParams {
+        compressible_config: context.compressible_config,
+        rent_sponsor: payer_pubkey,
+        pre_pay_num_epochs: num_prepaid_epochs,
+        lamports_per_write,
+        compress_to_account_pubkey: None,
+        token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
+    };
+
+    let create_token_account_ix = CreateCTokenAccount::new(
+        payer_pubkey,
+        token_account_pubkey,
+        context.mint_pubkey,
+        context.owner_keypair.pubkey(),
+        compressible_params,
+    )
+    .instruction()
+    .unwrap();
     // Verify pool PDA balance decreased by only the rent-exempt amount (not the additional rent)
     let pool_balance_before = context
         .rpc

program-tests/compressed-token-test/tests/ctoken/create.rs

@@ -226,22 +226,24 @@ async fn test_create_compressible_token_account_failing() {
         let poor_payer_pubkey = poor_payer.pubkey();
         let token_account_pubkey = Keypair::new();
 
-        let create_token_account_ix =
-            light_compressed_token_sdk::instructions::create_compressible_token_account_instruction(
-                light_compressed_token_sdk::instructions::CreateCompressibleTokenAccount {
-                    account_pubkey: token_account_pubkey.pubkey(),
-                    mint_pubkey: context.mint_pubkey,
-                    owner_pubkey: context.owner_keypair.pubkey(),
-                    compressible_config: context.compressible_config,
-                    rent_sponsor: context.rent_sponsor,
-                    pre_pay_num_epochs: 10, // High number to require more lamports
-                    lamports_per_write: Some(1000),
-                    payer: poor_payer_pubkey,
-                    compress_to_account_pubkey: None,
-                    token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
-                },
-            )
-            .unwrap();
+        let compressible_params = CompressibleParams {
+            compressible_config: context.compressible_config,
+            rent_sponsor: context.rent_sponsor,
+            pre_pay_num_epochs: 10, // High number to require more lamports
+            lamports_per_write: Some(1000),
+            compress_to_account_pubkey: None,
+            token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
+        };
+
+        let create_token_account_ix = CreateCTokenAccount::new(
+            poor_payer_pubkey,
+            token_account_pubkey.pubkey(),
+            context.mint_pubkey,
+            context.owner_keypair.pubkey(),
+            compressible_params,
+        )
+        .instruction()
+        .unwrap();
 
         let result = context
             .rpc
@@ -363,22 +365,24 @@ async fn test_create_compressible_token_account_failing() {
             seeds: vec![b"invalid_seed".to_vec(), b"wrong".to_vec()],
         };
 
-        let create_token_account_ix =
-            light_compressed_token_sdk::instructions::create_compressible_token_account_instruction(
-                light_compressed_token_sdk::instructions::CreateCompressibleTokenAccount {
-                    account_pubkey: token_account_pubkey,
-                    mint_pubkey: context.mint_pubkey,
-                    owner_pubkey: context.owner_keypair.pubkey(),
-                    compressible_config: context.compressible_config,
-                    rent_sponsor: context.rent_sponsor,
-                    pre_pay_num_epochs: 2,
-                    lamports_per_write: Some(100),
-                    payer: payer_pubkey,
-                    compress_to_account_pubkey: Some(invalid_compress_to_pubkey),
-                    token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
-                },
-            )
-            .unwrap();
+        let compressible_params = CompressibleParams {
+            compressible_config: context.compressible_config,
+            rent_sponsor: context.rent_sponsor,
+            pre_pay_num_epochs: 2,
+            lamports_per_write: Some(100),
+            compress_to_account_pubkey: Some(invalid_compress_to_pubkey),
+            token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
+        };
+
+        let create_token_account_ix = CreateCTokenAccount::new(
+            payer_pubkey,
+            token_account_pubkey,
+            context.mint_pubkey,
+            context.owner_keypair.pubkey(),
+            compressible_params,
+        )
+        .instruction()
+        .unwrap();
 
         let result = context
             .rpc
@@ -411,22 +415,24 @@ async fn test_create_compressible_token_account_failing() {
             .await
             .unwrap();
 
-        let create_token_account_ix =
-            light_compressed_token_sdk::instructions::create_compressible_token_account_instruction(
-                light_compressed_token_sdk::instructions::CreateCompressibleTokenAccount {
-                    account_pubkey: context.token_account_keypair.pubkey(),
-                    mint_pubkey: context.mint_pubkey,
-                    owner_pubkey: context.owner_keypair.pubkey(),
-                    compressible_config: fake_config_pubkey, // Wrong owner
-                    rent_sponsor: context.rent_sponsor,
-                    pre_pay_num_epochs: 2,
-                    lamports_per_write: Some(100),
-                    payer: payer_pubkey,
-                    compress_to_account_pubkey: None,
-                    token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
-                },
-            )
-            .unwrap();
+        let compressible_params = CompressibleParams {
+            compressible_config: fake_config_pubkey, // Wrong owner
+            rent_sponsor: context.rent_sponsor,
+            pre_pay_num_epochs: 2,
+            lamports_per_write: Some(100),
+            compress_to_account_pubkey: None,
+            token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
+        };
+
+        let create_token_account_ix = CreateCTokenAccount::new(
+            payer_pubkey,
+            context.token_account_keypair.pubkey(),
+            context.mint_pubkey,
+            context.owner_keypair.pubkey(),
+            compressible_params,
+        )
+        .instruction()
+        .unwrap();
 
         let result = context
             .rpc
@@ -451,22 +457,24 @@ async fn test_create_compressible_token_account_failing() {
         // Use protocol config account - owned by registry but wrong type
         let wrong_account_type = context.rpc.test_accounts.protocol.governance_authority_pda;
 
-        let create_token_account_ix =
-            light_compressed_token_sdk::instructions::create_compressible_token_account_instruction(
-                light_compressed_token_sdk::instructions::CreateCompressibleTokenAccount {
-                    account_pubkey: context.token_account_keypair.pubkey(),
-                    mint_pubkey: context.mint_pubkey,
-                    owner_pubkey: context.owner_keypair.pubkey(),
-                    compressible_config: wrong_account_type, // Wrong account type
-                    rent_sponsor: context.rent_sponsor,
-                    pre_pay_num_epochs: 2,
-                    lamports_per_write: Some(100),
-                    payer: payer_pubkey,
-                    compress_to_account_pubkey: None,
-                    token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
-                },
-            )
-            .unwrap();
+        let compressible_params = CompressibleParams {
+            compressible_config: wrong_account_type, // Wrong account type
+            rent_sponsor: context.rent_sponsor,
+            pre_pay_num_epochs: 2,
+            lamports_per_write: Some(100),
+            compress_to_account_pubkey: None,
+            token_account_version: light_ctoken_types::state::TokenDataVersion::ShaFlat,
+        };
+
+        let create_token_account_ix = CreateCTokenAccount::new(
+            payer_pubkey,
+            context.token_account_keypair.pubkey(),
+            context.mint_pubkey,
+            context.owner_keypair.pubkey(),
+            compressible_params,
+        )
+        .instruction()
+        .unwrap();
 
         let result = context
             .rpc