Struct Token 

pub struct Token {
    pub mint: Pubkey,
    pub owner: Pubkey,
    pub amount: u64,
    pub delegate: Option<Pubkey>,
    pub state: AccountState,
    pub is_native: Option<u64>,
    pub delegated_amount: u64,
    pub close_authority: Option<Pubkey>,
    pub account_type: u8,
    pub extensions: Option<Vec<ExtensionStruct>>,
}

Ctoken account structure (same as SPL Token Account but with extensions). Ctokens are solana accounts, compressed tokens are stored as TokenData that is optimized for compressed accounts.

Fields

mint: Pubkey

The mint associated with this account

owner: Pubkey

The owner of this account.

amount: u64

The amount of tokens this account holds.

delegate: Option<Pubkey>

If delegate is Some then delegated_amount represents the amount authorized by the delegate

state: AccountState

The account’s state

is_native: Option<u64>

If is_some, this is a native token, and the value logs the rent-exempt reserve. An Account is required to be rent-exempt, so the value is used by the Processor to ensure that wrapped SOL accounts do not drop below this threshold.

delegated_amount: u64

The amount delegated

close_authority: Option<Pubkey>

Optional authority to close the account.

account_type: u8

Account type discriminator (at byte 165 when extensions present). For valid Token accounts this is ACCOUNT_TYPE_TOKEN_ACCOUNT (2).

extensions: Option<Vec<ExtensionStruct>>

Extensions for the token account (including compressible config)

Implementations

impl Token

pub fn amount_from_slice(data: &[u8]) -> Result<u64, ZeroCopyError>

Extract amount directly from account data slice using hardcoded offset Token layout: mint (32 bytes) + owner (32 bytes) + amount (8 bytes)

pub fn is_frozen(&self) -> bool

Checks if account is frozen

pub fn is_native(&self) -> bool

Checks if account is native

pub fn is_initialized(&self) -> bool

Checks if account is initialized

pub fn account_type(&self) -> u8

Returns the account type discriminator

pub fn is_token_account(&self) -> bool

Checks if account_type matches Token discriminator value

impl Token

pub fn zero_copy_at_checked( bytes: &[u8], ) -> Result<(ZToken<'_>, &[u8]), TokenError>

Zero-copy deserialization with initialization and account_type check. Returns an error if:

• Account is uninitialized (byte 108 == 0)
• Account type is not ACCOUNT_TYPE_TOKEN_ACCOUNT (byte 165 != 2) Allows both Initialized (1) and Frozen (2) states.

pub fn zero_copy_at_mut_checked( bytes: &mut [u8], ) -> Result<(ZTokenMut<'_>, &mut [u8]), TokenError>

Mutable zero-copy deserialization with initialization and account_type check. Returns an error if:

• Account is uninitialized (state == 0)
• Account type is not ACCOUNT_TYPE_TOKEN_ACCOUNT

pub fn from_account_info_checked<'a>( account_info: &AccountInfo, ) -> Result<ZToken<'a>, TokenError>

Deserialize a Token from account info with validation using zero-copy.

Checks:

1. Account is owned by the CTOKEN program
2. Account is initialized (state != 0)
3. Account type is ACCOUNT_TYPE_TOKEN_ACCOUNT (byte 165 == 2)
4. No trailing bytes after the Token structure

Safety: The returned ZToken references the account data which is valid for the duration of the transaction. The caller must ensure the account is not modified through other means while this reference exists.

pub fn from_account_info_mut_checked<'a>( account_info: &AccountInfo, ) -> Result<ZTokenMut<'a>, TokenError>

Mutable version of from_account_info_checked. Deserialize a Token from account info with validation using zero-copy.

Checks:

1. Account is owned by the CTOKEN program
2. Account is initialized (state != 0)
3. Account type is ACCOUNT_TYPE_TOKEN_ACCOUNT (byte 165 == 2)
4. No trailing bytes after the Token structure

Trait Implementations

impl BorshDeserialize for Token

fn deserialize_reader<R>(buf: &mut R) -> Result<Token, 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 Token

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 Token

fn clone(&self) -> Token

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

Formats the value using the given formatter.

impl Hash for Token

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 Token

fn eq(&self, other: &Token) -> 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 Token

type ZeroCopyAt = ZToken<'a>

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

impl<'a> ZeroCopyAtMut<'a> for Token

type ZeroCopyAtMut = ZTokenMut<'a>

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

impl<'a> ZeroCopyNew<'a> for Token

type ZeroCopyConfig = TokenConfig

Configuration type needed to initialize this type

type Output = ZTokenMut<'a>

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

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

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

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

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

impl Eq for Token

impl StructuralPartialEq for Token