Struct CompressionInfo 

#[repr(C)]
pub struct CompressionInfo {
    pub config_account_version: u16,
    pub compress_to_pubkey: u8,
    pub account_version: u8,
    pub lamports_per_write: u32,
    pub compression_authority: [u8; 32],
    pub rent_sponsor: [u8; 32],
    pub last_claimed_slot: u64,
    pub rent_exemption_paid: u32,
    pub _reserved: u32,
    pub rent_config: RentConfig,
}

Compressible extension for ctoken accounts.

Fields

config_account_version: u16

compress_to_pubkey: u8

Compress to account pubkey instead of account owner.

account_version: u8

Version of the compressed token account when ctoken account is compressed and closed. (The account_version specifies the hashing scheme.)

lamports_per_write: u32

Lamports amount the account is topped up with at every write by the fee payer.

compression_authority: [u8; 32]

Authority that can compress and close the account.

rent_sponsor: [u8; 32]

Recipient for rent exemption lamports up on account closure.

last_claimed_slot: u64

Last slot rent was claimed from this account.

rent_exemption_paid: u32

Rent exemption lamports paid at account creation. Used instead of querying the Rent sysvar to ensure rent sponsor gets back exactly what they paid regardless of future rent changes.

_reserved: u32

Reserved for future use.

rent_config: RentConfig

Rent function parameters, used to calculate whether the account is compressible.

Implementations

impl CompressionInfo

pub const LEN: usize

impl CompressionInfo

pub fn is_compressible( &self, bytes: u64, current_slot: u64, current_lamports: u64, ) -> Result<Option<u64>, CompressibleError>

current - last epoch = num epochs due rent_due available_balance = current_lamports - last_lamports (we can never claim more lamports than rent is due) remaining_balance = available_balance - rent_due

pub fn compress_to_pubkey(&self) -> bool

Converts the compress_to_pubkey field into a boolean.

pub fn calculate_top_up_lamports( &self, num_bytes: u64, current_slot: u64, current_lamports: u64, ) -> Result<u64, CompressibleError>

Calculate the amount of lamports to top up during a write operation. Returns 0 if no top-up is needed (account is well-funded). Returns write_top_up + rent_deficit if account is compressible. Returns write_top_up if account needs more funding but isn’t compressible yet.

impl CompressionInfo

pub fn get_last_funded_epoch( &self, num_bytes: u64, current_lamports: u64, rent_exemption_lamports: u64, ) -> Result<u64, CompressibleError>

Get the last epoch that has been paid for. Returns the epoch number through which rent has been prepaid.

Trait Implementations

impl BorshDeserialize for CompressionInfo

where u16: BorshDeserialize, u8: BorshDeserialize, u32: BorshDeserialize, [u8; 32]: BorshDeserialize, u64: 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 u16: BorshSerialize, u8: BorshSerialize, u32: BorshSerialize, [u8; 32]: BorshSerialize, u64: 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 Hash for CompressionInfo

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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<'a> ZeroCopyAt<'a> for CompressionInfo

type ZeroCopyAt = ZCompressionInfo<'a>

fn zero_copy_at( __remaining_bytes: &'a [u8], ) -> Result<(<CompressionInfo as ZeroCopyAt<'a>>::ZeroCopyAt, &'a [u8]), ZeroCopyError>

impl<'a> ZeroCopyAtMut<'a> for CompressionInfo

type ZeroCopyAtMut = ZCompressionInfoMut<'a>

fn zero_copy_at_mut( __remaining_bytes: &'a mut [u8], ) -> Result<(<CompressionInfo as ZeroCopyAtMut<'a>>::ZeroCopyAtMut, &'a mut [u8]), ZeroCopyError>

impl<'a> ZeroCopyNew<'a> for CompressionInfo

type ZeroCopyConfig = CompressionInfoConfig

Configuration type needed to initialize this type

type Output = <CompressionInfo as ZeroCopyAtMut<'a>>::ZeroCopyAtMut

Output type - the mutable zero-copy view of this type

fn byte_len( config: &<CompressionInfo as ZeroCopyNew<'a>>::ZeroCopyConfig, ) -> Result<usize, ZeroCopyError>

Calculate the byte length needed for this type with the given configuration

fn new_zero_copy( __remaining_bytes: &'a mut [u8], config: <CompressionInfo as ZeroCopyNew<'a>>::ZeroCopyConfig, ) -> Result<(<CompressionInfo as ZeroCopyNew<'a>>::Output, &'a mut [u8]), ZeroCopyError>

Initialize this type in a mutable byte slice with the given configuration

impl ZeroCopyStructInner for CompressionInfo

type ZeroCopyInner = ZCompressionInfo<'static>

impl ZeroCopyStructInnerMut for CompressionInfo

type ZeroCopyInnerMut = ZCompressionInfoMut<'static>

impl Zeroable for CompressionInfo

fn zeroed() -> Self

Calls zeroed.

impl Copy for CompressionInfo

impl Eq for CompressionInfo

impl Pod for CompressionInfo

impl StructuralPartialEq for CompressionInfo