Struct CompressionInfo 

#[repr(C)]
pub struct CompressionInfo {
    pub last_claimed_slot: u64,
    pub lamports_per_write: u32,
    pub config_version: u16,
    pub state: CompressionState,
    pub _padding: u8,
    pub rent_config: RentConfig,
}

SDK CompressionInfo - a compact 24-byte struct for custom zero-copy PDAs.

This is the lightweight version of compression info used in the SDK. CToken has its own compression handling via light_compressible::CompressionInfo.

Memory Layout (24 bytes with #[repr(C)])

• last_claimed_slot: u64 @ offset 0 (8 bytes, 8-byte aligned)
• lamports_per_write: u32 @ offset 8 (4 bytes)
• config_version: u16 @ offset 12 (2 bytes)
• state: CompressionState @ offset 14 (1 byte)
• _padding: u8 @ offset 15 (1 byte)
• rent_config: RentConfig @ offset 16 (8 bytes, 2-byte aligned)

Fields are ordered for optimal alignment to achieve exactly 24 bytes.

Fields

last_claimed_slot: u64

Slot when rent was last claimed (epoch boundary accounting).

lamports_per_write: u32

Lamports to top up on each write (from config, stored per-account to avoid passing config on every write)

config_version: u16

Version of the compressible config used to initialize this account.

state: CompressionState

Account compression state.

_padding: u8

rent_config: RentConfig

Rent function parameters for determining compressibility/claims.

Implementations

impl CompressionInfo

pub fn compressed() -> CompressionInfo

pub fn new_from_config(cfg: &LightConfig, current_slot: u64) -> CompressionInfo

Create a new CompressionInfo initialized from a compressible config.

Rent sponsor is always the config’s rent_sponsor (not stored per-account). This means rent always flows to the protocol’s rent pool upon compression, regardless of who paid for account creation.

pub fn new_decompressed(current_slot: u64) -> CompressionInfo

Backward-compat constructor; initializes minimal fields. Rent will flow to config’s rent_sponsor upon compression.

pub fn bump_last_claimed_slot(&mut self, current_slot: u64)

Update last_claimed_slot to the given slot.

pub fn set_last_claimed_slot(&mut self, slot: u64)

Explicitly set last_claimed_slot.

pub fn last_claimed_slot(&self) -> u64

Get last_claimed_slot.

pub fn set_compressed(&mut self)

pub fn is_compressed(&self) -> bool

impl CompressionInfo

pub fn calculate_top_up_lamports( &self, num_bytes: u64, current_slot: u64, current_lamports: u64, rent_exemption_lamports: u64, ) -> u64

Calculate top-up lamports required for a write.

Logic (same as CTokens):

• If account is compressible (can’t pay current + next epoch): return lamports_per_write + deficit
• If account has >= max_funded_epochs: return 0 (no top-up needed)
• Otherwise: return lamports_per_write (maintenance mode)

pub fn top_up_rent<AI>( &self, account_info: &AI, payer_info: &AI, ) -> Result<(), LightSdkTypesError>

where AI: AccountInfoTrait,

Top up rent on write if needed and transfer lamports from payer to account. This is the standard pattern for all write operations on compressible PDAs. Generic over AccountInfoTrait to work with both solana and pinocchio.

Arguments

• account_info - The PDA account to top up
• payer_info - The payer account (will be debited)

Trait Implementations

impl BorshDeserialize for CompressionInfo

where u64: BorshDeserialize, u32: BorshDeserialize, u16: BorshDeserialize, CompressionState: BorshDeserialize, u8: BorshDeserialize, RentConfig: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<CompressionInfo, Error>

where R: Read,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for CompressionInfo

where u64: BorshSerialize, u32: BorshSerialize, u16: BorshSerialize, CompressionState: BorshSerialize, u8: BorshSerialize, RentConfig: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write,

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for CompressionInfo

fn clone(&self) -> CompressionInfo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompressionInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for CompressionInfo

fn default() -> CompressionInfo

Returns the “default value” for a type.

impl PartialEq for CompressionInfo

fn eq(&self, other: &CompressionInfo) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Space for CompressionInfo

const INIT_SPACE: usize

impl Zeroable for CompressionInfo

fn zeroed() -> Self

Calls zeroed.

impl Copy for CompressionInfo

impl Pod for CompressionInfo

impl StructuralPartialEq for CompressionInfo