Struct TokenData 

#[repr(C)]
pub struct TokenData {
    pub mint: Pubkey,
    pub owner: Pubkey,
    pub amount: u64,
    pub delegate: Option<Pubkey>,
    pub state: u8,
    pub tlv: Option<Vec<ExtensionStruct>>,
}

TokenData of Compressed Tokens.

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: u8

The account’s state

tlv: Option<Vec<ExtensionStruct>>

Extensions for the compressed token account

Implementations

impl TokenData

Hashing schema: H(mint, owner, amount, delegate, delegated_amount, is_native, state)

delegate, delegated_amount, is_native and state have dynamic positions. Always hash mint, owner and amount If delegate hash delegate and delegated_amount together. If is native hash is_native else is omitted. If frozen hash AccountState::Frozen else is omitted.

Security: to prevent the possibility that different fields with the same value to result in the same hash we add a prefix to the delegated amount, is native and state fields. This way we can have a dynamic hashing schema and hash only used values.

pub fn is_native(&self) -> bool

Only the spl representation of native tokens (wrapped SOL) is compressed. The sol value is stored in the token pool account. The sol value in the compressed account is independent from the wrapped sol amount.

pub fn hash_with_hashed_values( hashed_mint: &[u8; 32], hashed_owner: &[u8; 32], amount_bytes: &[u8; 32], hashed_delegate: &Option<&[u8; 32]>, ) -> Result<[u8; 32], HasherError>

pub fn hash_frozen_with_hashed_values( hashed_mint: &[u8; 32], hashed_owner: &[u8; 32], amount_bytes: &[u8; 32], hashed_delegate: &Option<&[u8; 32]>, ) -> Result<[u8; 32], HasherError>

pub fn hash_inputs_with_hashed_values<const FROZEN_INPUTS: bool>( mint: &[u8; 32], owner: &[u8; 32], amount_bytes: &[u8], hashed_delegate: &Option<&[u8; 32]>, ) -> Result<[u8; 32], HasherError>

We should not hash pubkeys multiple times. For all we can assume mints are equal. For all input compressed accounts we assume owners are equal.

impl TokenData

pub fn hash_sha_flat(&self) -> Result<[u8; 32], HasherError>

TokenDataVersion 3 CompressedAccount Discriminator [0,0,0,0,0,0,0,4]

pub fn hash_v2(&self) -> Result<[u8; 32], HasherError>

Hashes token data of token accounts.

Note, hashing changed for token account data in batched Merkle trees. For hashing of token account data stored in concurrent Merkle trees use hash_v1(). TokenDataVersion 2 CompressedAccount Discriminator [0,0,0,0,0,0,0,3]

pub fn hash_v1(&self) -> Result<[u8; 32], HasherError>

Hashes token data of token accounts stored in concurrent Merkle trees. TokenDataVersion 1 CompressedAccount Discriminator [2,0,0,0,0,0,0,0]

impl TokenData

pub fn state(&self) -> Result<CompressedTokenAccountState, TokenError>

Trait Implementations

impl BorshDeserialize for TokenData

where Pubkey: BorshDeserialize, u64: BorshDeserialize, Option<Pubkey>: BorshDeserialize, u8: BorshDeserialize, Option<Vec<ExtensionStruct>>: BorshDeserialize,

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

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 TokenData

where Pubkey: BorshSerialize, u64: BorshSerialize, Option<Pubkey>: BorshSerialize, u8: BorshSerialize, Option<Vec<ExtensionStruct>>: BorshSerialize,

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

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

Serialize this instance into a vector of bytes.

impl Clone for TokenData

fn clone(&self) -> TokenData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokenData

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

Formats the value using the given formatter.

impl PartialEq for TokenData

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

type ZeroCopyAt = ZTokenData<'a>

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

impl<'a> ZeroCopyAtMut<'a> for TokenData

type ZeroCopyAtMut = ZTokenDataMut<'a>

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

impl<'a> ZeroCopyNew<'a> for TokenData

type ZeroCopyConfig = TokenDataConfig

Configuration type needed to initialize this type

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

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

fn byte_len(config: &Self::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: Self::ZeroCopyConfig, ) -> Result<(Self::Output, &'a mut [u8]), ZeroCopyError>

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

impl ZeroCopyStructInner for TokenData

type ZeroCopyInner = ZTokenData<'static>

impl ZeroCopyStructInnerMut for TokenData

type ZeroCopyInnerMut = ZTokenDataMut<'static>

impl Eq for TokenData

impl StructuralPartialEq for TokenData