Struct 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( 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(&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_legacy().

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

Hashes token data of token accounts stored in concurrent Merkle trees.

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 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 IdlBuild for TokenData

fn create_type() -> Option<IdlTypeDef>

Create an IDL type definition for the type.

fn insert_types(types: &mut BTreeMap<String, IdlTypeDef>)

Insert all types that are included in the current type definition to the given map.

fn get_full_path() -> String

Get the full module path of the type.

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 Eq for TokenData

impl StructuralPartialEq for TokenData