chore: add missing compressible extension placeholder

Cargo.toml

@@ -229,7 +229,7 @@ groth16-solana = { version = "0.2.0" }
 bytemuck = { version = "1.19.0" }
 arrayvec = "0.7"
 tinyvec = "1.10.0"
-pinocchio-token-program = { git= "https://github.com/Lightprotocol/token", rev="38d8634353e5eeb8c015d364df0eaa39f5c48b05" }
+pinocchio-token-program = { git= "https://github.com/Lightprotocol/token", rev="fc39a485cf1b214e16a0f13fd6ddea0cd87aaa87" }
 # Math and crypto
 num-bigint = "0.4.6"
 tabled = "0.20"

forester/src/compressible/compressor.rs

@@ -140,7 +140,7 @@ impl<R: Rpc> Compressor<R> {
                 .ok_or_else(|| anyhow::anyhow!("Account missing compressible extension"))?;
 
             // Determine owner based on compress_to_pubkey flag
-            let compressed_token_owner = if compressible_ext.compress_to_pubkey != 0 {
+            let compressed_token_owner = if compressible_ext.info.compress_to_pubkey != 0 {
                 account_state.pubkey // Use account pubkey for PDAs
             } else {
                 Pubkey::new_from_array(account_state.account.owner.to_bytes()) // Use original owner
@@ -149,7 +149,7 @@ impl<R: Rpc> Compressor<R> {
             let owner_index = packed_accounts.insert_or_get(compressed_token_owner);
 
             // Extract rent_sponsor from extension
-            let rent_sponsor = Pubkey::new_from_array(compressible_ext.rent_sponsor);
+            let rent_sponsor = Pubkey::new_from_array(compressible_ext.info.rent_sponsor);
             let rent_sponsor_index = packed_accounts.insert_or_get(rent_sponsor);
 
             indices_vec.push(CompressAndCloseIndices {

forester/src/compressible/state.rs

@@ -31,6 +31,7 @@ fn calculate_compressible_slot(account: &CToken, lamports: u64) -> Result<u64> {
 
     // Calculate last funded epoch
     let last_funded_epoch = compressible_ext
+        .info
         .get_last_funded_epoch(
             COMPRESSIBLE_TOKEN_ACCOUNT_SIZE,
             lamports,

program-libs/ctoken-interface/src/constants.rs

@@ -1,6 +1,6 @@
 use light_macros::pubkey_array;
 
-use crate::state::CompressionInfo;
+use crate::state::extensions::CompressibleExtension;
 
 pub const CPI_AUTHORITY: [u8; 32] = pubkey_array!("GXtd2izAiMJPwMEjfgTRH3d7k9mjn4Jq3JrWFv9gySYy");
 pub const CTOKEN_PROGRAM_ID: [u8; 32] =
@@ -13,13 +13,15 @@ pub const BASE_TOKEN_ACCOUNT_SIZE: u64 = 165;
 /// Extension metadata overhead: AccountType (1) + Option discriminator (1) + Vec length (4) + Extension enum variant (1)
 pub const EXTENSION_METADATA: u64 = 7;
 
-/// Size of a token account with compressible extension 260 bytes.
+/// Size of a token account with compressible extension 261 bytes.
+/// CompressibleExtension = compression_only (1 byte) + CompressionInfo (88 bytes) = 89 bytes
 pub const COMPRESSIBLE_TOKEN_ACCOUNT_SIZE: u64 =
-    BASE_TOKEN_ACCOUNT_SIZE + CompressionInfo::LEN as u64 + EXTENSION_METADATA;
+    BASE_TOKEN_ACCOUNT_SIZE + CompressibleExtension::LEN as u64 + EXTENSION_METADATA;
 
 /// Rent exemption threshold for compressible token accounts (in lamports)
 /// This value determines when an account has sufficient rent to be considered not compressible
-pub const COMPRESSIBLE_TOKEN_RENT_EXEMPTION: u64 = 2700480;
+/// Calculation: (account_size + 128) * 3480 * 2 = (261 + 128) * 6960 = 2707440
+pub const COMPRESSIBLE_TOKEN_RENT_EXEMPTION: u64 = 2707440;
 
 /// Size of a Token-2022 mint account
 pub const MINT_ACCOUNT_SIZE: u64 = 82;

program-libs/ctoken-interface/src/state/ctoken/zero_copy.rs

@@ -10,8 +10,8 @@ use spl_pod::solana_msg::msg;
 
 use crate::{
     state::{
-        CToken, CompressionInfoConfig, ExtensionStruct, ExtensionStructConfig, ZExtensionStruct,
-        ZExtensionStructMut,
+        CToken, CompressibleExtensionConfig, CompressionInfoConfig, ExtensionStruct,
+        ExtensionStructConfig, ZExtensionStruct, ZExtensionStructMut,
     },
     AnchorDeserialize, AnchorSerialize,
 };
@@ -290,67 +290,72 @@ impl PartialEq<CToken> for ZCToken<'_> {
                             crate::state::extensions::ExtensionStruct::Compressible(regular_comp),
                         ) => {
                             // Compare config_account_version
-                            if zc_comp.config_account_version != regular_comp.config_account_version
+                            if zc_comp.info.config_account_version
+                                != regular_comp.info.config_account_version
                             {
                                 return false;
                             }
 
                             // Compare compress_to_pubkey
-                            if zc_comp.compress_to_pubkey != regular_comp.compress_to_pubkey {
+                            if zc_comp.info.compress_to_pubkey
+                                != regular_comp.info.compress_to_pubkey
+                            {
                                 return false;
                             }
 
                             // Compare account_version
-                            if zc_comp.account_version != regular_comp.account_version {
+                            if zc_comp.info.account_version != regular_comp.info.account_version {
                                 return false;
                             }
 
                             // Compare last_claimed_slot
-                            if u64::from(zc_comp.last_claimed_slot)
-                                != regular_comp.last_claimed_slot
+                            if u64::from(zc_comp.info.last_claimed_slot)
+                                != regular_comp.info.last_claimed_slot
                             {
                                 return false;
                             }
 
                             // Compare rent_config fields
-                            if u16::from(zc_comp.rent_config.base_rent)
-                                != regular_comp.rent_config.base_rent
+                            if u16::from(zc_comp.info.rent_config.base_rent)
+                                != regular_comp.info.rent_config.base_rent
                             {
                                 return false;
                             }
-                            if u16::from(zc_comp.rent_config.compression_cost)
-                                != regular_comp.rent_config.compression_cost
+                            if u16::from(zc_comp.info.rent_config.compression_cost)
+                                != regular_comp.info.rent_config.compression_cost
                             {
                                 return false;
                             }
-                            if zc_comp.rent_config.lamports_per_byte_per_epoch
-                                != regular_comp.rent_config.lamports_per_byte_per_epoch
+                            if zc_comp.info.rent_config.lamports_per_byte_per_epoch
+                                != regular_comp.info.rent_config.lamports_per_byte_per_epoch
                             {
                                 return false;
                             }
-                            if zc_comp.rent_config.max_funded_epochs
-                                != regular_comp.rent_config.max_funded_epochs
+                            if zc_comp.info.rent_config.max_funded_epochs
+                                != regular_comp.info.rent_config.max_funded_epochs
                             {
                                 return false;
                             }
-                            if u16::from(zc_comp.rent_config.max_top_up)
-                                != regular_comp.rent_config.max_top_up
+                            if u16::from(zc_comp.info.rent_config.max_top_up)
+                                != regular_comp.info.rent_config.max_top_up
                             {
                                 return false;
                             }
                             // Compare compression_authority ([u8; 32])
-                            if zc_comp.compression_authority != regular_comp.compression_authority {
+                            if zc_comp.info.compression_authority
+                                != regular_comp.info.compression_authority
+                            {
                                 return false;
                             }
 
                             // Compare rent_sponsor ([u8; 32])
-                            if zc_comp.rent_sponsor != regular_comp.rent_sponsor {
+                            if zc_comp.info.rent_sponsor != regular_comp.info.rent_sponsor {
                                 return false;
                             }
 
                             // Compare lamports_per_write (u32)
-                            if u32::from(zc_comp.lamports_per_write)
-                                != regular_comp.lamports_per_write
+                            if u32::from(zc_comp.info.lamports_per_write)
+                                != regular_comp.info.lamports_per_write
                             {
                                 return false;
                             }
@@ -647,9 +652,11 @@ impl CompressedTokenConfig {
             delegate,
             is_native,
             close_authority,
-            extensions: vec![ExtensionStructConfig::Compressible(CompressionInfoConfig {
-                rent_config: (),
-            })],
+            extensions: vec![ExtensionStructConfig::Compressible(
+                CompressibleExtensionConfig {
+                    info: CompressionInfoConfig { rent_config: () },
+                },
+            )],
         }
     }
 }

program-libs/ctoken-interface/src/state/extensions/extension_struct.rs

@@ -1,11 +1,9 @@
-use light_zero_copy::ZeroCopy;
+use aligned_sized::aligned_sized;
+use light_zero_copy::{ZeroCopy, ZeroCopyMut};
 use spl_pod::solana_msg::msg;
 
 use crate::{
-    state::{
-        extensions::{CompressionInfo, TokenMetadata, TokenMetadataConfig, ZTokenMetadataMut},
-        CompressionInfoConfig,
-    },
+    state::extensions::{CompressionInfo, TokenMetadata, TokenMetadataConfig, ZTokenMetadataMut},
     AnchorDeserialize, AnchorSerialize,
 };
 
@@ -48,7 +46,26 @@ pub enum ExtensionStruct {
     Placeholder30,
     Placeholder31,
     /// Account contains compressible timing data and rent authority
-    Compressible(CompressionInfo),
+    Compressible(CompressibleExtension),
+}
+
+#[derive(
+    Debug,
+    ZeroCopy,
+    ZeroCopyMut,
+    Clone,
+    Copy,
+    PartialEq,
+    Hash,
+    Eq,
+    AnchorSerialize,
+    AnchorDeserialize,
+)]
+#[repr(C)]
+#[aligned_sized]
+pub struct CompressibleExtension {
+    pub compression_only: bool,
+    pub info: CompressionInfo,
 }
 
 #[derive(Debug)]
@@ -89,7 +106,9 @@ pub enum ZExtensionStructMut<'a> {
     Placeholder30,
     Placeholder31,
     /// Account contains compressible timing data and rent authority
-    Compressible(<CompressionInfo as light_zero_copy::traits::ZeroCopyAtMut<'a>>::ZeroCopyAtMut),
+    Compressible(
+        <CompressibleExtension as light_zero_copy::traits::ZeroCopyAtMut<'a>>::ZeroCopyAtMut,
+    ),
 }
 
 impl<'a> light_zero_copy::traits::ZeroCopyAtMut<'a> for ExtensionStruct {
@@ -120,7 +139,7 @@ impl<'a> light_zero_copy::traits::ZeroCopyAtMut<'a> for ExtensionStruct {
             32 => {
                 // Compressible variant (index 32 to avoid Token-2022 overlap)
                 let (compressible_ext, remaining_bytes) =
-                    CompressionInfo::zero_copy_at_mut(remaining_data)?;
+                    CompressibleExtension::zero_copy_at_mut(remaining_data)?;
                 Ok((
                     ZExtensionStructMut::Compressible(compressible_ext),
                     remaining_bytes,
@@ -145,7 +164,7 @@ impl<'a> light_zero_copy::ZeroCopyNew<'a> for ExtensionStruct {
             }
             ExtensionStructConfig::Compressible(config) => {
                 // 1 byte for discriminant + CompressionInfo size
-                1 + CompressionInfo::byte_len(config)?
+                1 + CompressibleExtension::byte_len(config)?
             }
             _ => {
                 msg!("Invalid extension type returning");
@@ -187,7 +206,7 @@ impl<'a> light_zero_copy::ZeroCopyNew<'a> for ExtensionStruct {
                 bytes[0] = 32u8;
 
                 let (compressible_ext, remaining_bytes) =
-                    CompressionInfo::new_zero_copy(&mut bytes[1..], config)?;
+                    CompressibleExtension::new_zero_copy(&mut bytes[1..], config)?;
                 Ok((
                     ZExtensionStructMut::Compressible(compressible_ext),
                     remaining_bytes,
@@ -235,5 +254,5 @@ pub enum ExtensionStructConfig {
     Placeholder29,
     Placeholder30,
     Placeholder31,
-    Compressible(CompressionInfoConfig),
+    Compressible(CompressibleExtensionConfig),
 }