Enum TokenEvent 

pub enum TokenEvent {
    Mint(TokenAmount, RecipientIdentifier, TokenEventPublicNote),
    Burn(TokenAmount, BurnFromIdentifier, TokenEventPublicNote),
    Freeze(FrozenIdentifier, TokenEventPublicNote),
    Unfreeze(FrozenIdentifier, TokenEventPublicNote),
    DestroyFrozenFunds(FrozenIdentifier, TokenAmount, TokenEventPublicNote),
    Transfer(RecipientIdentifier, TokenEventPublicNote, TokenEventSharedEncryptedNote, TokenEventPersonalEncryptedNote, TokenAmount),
    Claim(TokenDistributionTypeWithResolvedRecipient, TokenAmount, TokenEventPublicNote),
    EmergencyAction(TokenEmergencyAction, TokenEventPublicNote),
    ConfigUpdate(TokenConfigurationChangeItem, TokenEventPublicNote),
    ChangePriceForDirectPurchase(Option<TokenPricingSchedule>, TokenEventPublicNote),
    DirectPurchase(TokenAmount, Credits),
}

Represents a recorded token-related operation for use in historical documents and group actions.

TokenEvent is designed to encapsulate a single logical token operation, such as minting, burning, transferring, or freezing tokens. These events are typically:

• Persisted as historical records of state transitions, enabling auditability and tracking.
• Used in group (multisig) actions, where multiple identities collaborate to authorize complex transitions.

This enum includes rich metadata for each type of operation, such as optional notes (plaintext or encrypted), involved identities, and amounts. It is externally versioned and marked as unversioned in platform serialization, meaning each variant is self-contained without requiring version dispatching logic.

Variants

Mint(TokenAmount, RecipientIdentifier, TokenEventPublicNote)

Event representing the minting of tokens to a recipient.

• TokenAmount: The amount of tokens minted.
• RecipientIdentifier: The identity receiving the minted tokens.
• TokenEventPublicNote: Optional note associated with the event.

Burn(TokenAmount, BurnFromIdentifier, TokenEventPublicNote)

Event representing the burning of tokens, removing them from circulation.

• TokenAmount: The amount of tokens burned.
• BurnFromIdentifier: The account to burn from.
• TokenEventPublicNote: Optional note associated with the event.

Freeze(FrozenIdentifier, TokenEventPublicNote)

Event representing freezing of tokens for a specific identity.

• FrozenIdentifier: The identity whose tokens are frozen.
• TokenEventPublicNote: Optional note associated with the event.

Unfreeze(FrozenIdentifier, TokenEventPublicNote)

Event representing unfreezing of tokens for a specific identity.

• FrozenIdentifier: The identity whose tokens are unfrozen.
• TokenEventPublicNote: Optional note associated with the event.

DestroyFrozenFunds(FrozenIdentifier, TokenAmount, TokenEventPublicNote)

Event representing destruction of tokens that were previously frozen.

• FrozenIdentifier: The identity whose frozen tokens are destroyed.
• TokenAmount: The amount of frozen tokens destroyed.
• TokenEventPublicNote: Optional note associated with the event.

Transfer(RecipientIdentifier, TokenEventPublicNote, TokenEventSharedEncryptedNote, TokenEventPersonalEncryptedNote, TokenAmount)

Event representing a transfer of tokens from one identity to another.

• RecipientIdentifier: The recipient of the tokens.
• TokenEventPublicNote: Optional plaintext note.
• TokenEventSharedEncryptedNote: Optional shared encrypted metadata (multi-party).
• TokenEventPersonalEncryptedNote: Optional private encrypted metadata (recipient-only).
• TokenAmount: The amount of tokens transferred.

Claim(TokenDistributionTypeWithResolvedRecipient, TokenAmount, TokenEventPublicNote)

Event representing a claim of tokens from a distribution pool or source.

• TokenDistributionTypeWithResolvedRecipient: Type and resolved recipient of the claim.
• TokenAmount: The amount of tokens claimed.
• TokenEventPublicNote: Optional note associated with the event.

EmergencyAction(TokenEmergencyAction, TokenEventPublicNote)

Event representing an emergency action taken on a token or identity.

• TokenEmergencyAction: The type of emergency action performed.
• TokenEventPublicNote: Optional note associated with the event.

ConfigUpdate(TokenConfigurationChangeItem, TokenEventPublicNote)

Event representing an update to the configuration of a token.

• TokenConfigurationChangeItem: The configuration change that was applied.
• TokenEventPublicNote: Optional note associated with the event.

ChangePriceForDirectPurchase(Option<TokenPricingSchedule>, TokenEventPublicNote)

Event representing a change in the direct purchase price of a token.

• Option<TokenPricingSchedule>: The new pricing schedule. None disables direct purchase.
• TokenEventPublicNote: Optional note associated with the event.

DirectPurchase(TokenAmount, Credits)

Event representing the direct purchase of tokens by a user.

• TokenAmount: The amount of tokens purchased.
• Credits: The number of credits paid.

Implementations

impl TokenEvent

pub fn associated_document_type_name(&self) -> &str

pub fn public_note(&self) -> Option<&str>

Returns a reference to the public note if the variant includes one.

pub fn associated_document_type<'a>( &self, token_history_contract: &'a DataContract, ) -> Result<DocumentTypeRef<'a>, ProtocolError>

pub fn build_historical_document_owned( self, token_id: Identifier, owner_id: Identifier, owner_nonce: IdentityNonce, block_info: &BlockInfo, platform_version: &PlatformVersion, ) -> Result<Document, ProtocolError>

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for TokenEvent

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for TokenEvent

fn clone(&self) -> TokenEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokenEvent

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for TokenEvent

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for TokenEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TokenEvent

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

Formats the value using the given formatter.

impl Encode for TokenEvent

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl JsonConvertible for TokenEvent

Available on crate feature json-conversion only.

fn to_json(&self) -> Result<JsonValue, ProtocolError>

fn from_json(json: JsonValue) -> Result<Self, ProtocolError>

impl PartialEq for TokenEvent

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

fn partial_cmp(&self, other: &TokenEvent) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PlatformDeserializable for TokenEvent

fn deserialize_from_bytes(data: &[u8]) -> Result<Self, ProtocolError>

where Self: Sized,

fn deserialize_from_bytes_no_limit(data: &[u8]) -> Result<Self, ProtocolError>

where Self: Sized,

impl PlatformSerializable for TokenEvent

type Error = ProtocolError

fn serialize_to_bytes(&self) -> Result<Vec<u8>, Self::Error>

fn serialize_consume_to_bytes(self) -> Result<Vec<u8>, Self::Error>

If the trait is not used just do a simple serialize

impl PlatformVersionEncode for TokenEvent

fn platform_encode<__E: Encoder>( &self, encoder: &mut __E, platform_version: &PlatformVersion, ) -> Result<(), EncodeError>

Encode a given type.

impl<'__de> PlatformVersionedBorrowDecode<'__de> for TokenEvent

fn platform_versioned_borrow_decode<__D: BorrowDecoder<'__de, Context = BincodeContext>>( decoder: &mut __D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl PlatformVersionedDecode for TokenEvent

fn platform_versioned_decode<__D: Decoder<Context = BincodeContext>>( decoder: &mut __D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl Serialize for TokenEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ValueConvertible for TokenEvent

fn to_object(&self) -> Result<Value, ProtocolError>

where Self: Sized,

fn into_object(self) -> Result<Value, ProtocolError>

where Self: Sized,

fn from_object(value: Value) -> Result<Self, ProtocolError>

where Self: Sized,

fn from_object_ref(value: &Value) -> Result<Self, ProtocolError>

where Self: Sized,

impl Eq for TokenEvent

impl JsonSafeFields for TokenEvent

impl StructuralPartialEq for TokenEvent