Struct light_compressed_token::token_data::TokenData

pub struct TokenData {
    pub mint: Pubkey,
    pub owner: Pubkey,
    pub amount: u64,
    pub delegate: Option<Pubkey>,
    pub state: AccountState,
    pub tlv: Option<Vec<u8>>,
}

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

tlv: Option<Vec<u8>>

Placeholder for TokenExtension tlv data (unimplemented)

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<H: Hasher>( hashed_mint: &[u8; 32], hashed_owner: &[u8; 32], amount_bytes: &[u8; 8], hashed_delegate: &Option<&[u8; 32]>, ) -> Result<[u8; 32], HasherError>

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

pub fn hash_inputs_with_hashed_values<H: Hasher, const FROZEN_INPUTS: bool>( mint: &[u8; 32], owner: &[u8; 32], amount_bytes: &[u8; 8], 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.

Trait Implementations

impl BorshDeserialize for TokenData

where Pubkey: BorshDeserialize, u64: BorshDeserialize, Option<Pubkey>: BorshDeserialize, AccountState: BorshDeserialize, Option<Vec<u8>>: 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, AccountState: BorshSerialize, Option<Vec<u8>>: 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 copy of the value.

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

Performs copy-assignment from source.

impl DataHasher for TokenData

fn hash<H: Hasher>(&self) -> Result<[u8; 32], HasherError>

impl Debug for TokenData

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

Formats the value using the given formatter.

impl IdlBuild for TokenData

fn __anchor_private_full_path() -> String

Returns the full module path of the type.

fn __anchor_private_gen_idl_type() -> Option<IdlTypeDefinition>

Returns the IDL type definition of the type or None if it doesn’t exist.

fn __anchor_private_insert_idl_defined( defined_types: &mut HashMap<String, IdlTypeDefinition>, )

Insert the type definition to the defined types hashmap.

impl PartialEq for TokenData

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for TokenData

impl StructuralPartialEq for TokenData