Enum spl_token_2022::extension::ExtensionType

#[repr(u16)]
pub enum ExtensionType {
    Uninitialized = 0,
    TransferFeeConfig = 1,
    TransferFeeAmount = 2,
    MintCloseAuthority = 3,
    ConfidentialTransferMint = 4,
    ConfidentialTransferAccount = 5,
    DefaultAccountState = 6,
    ImmutableOwner = 7,
    MemoTransfer = 8,
    NonTransferable = 9,
    InterestBearingConfig = 10,
    CpiGuard = 11,
    PermanentDelegate = 12,
    NonTransferableAccount = 13,
    TransferHook = 14,
    TransferHookAccount = 15,
    ConfidentialTransferFeeConfig = 16,
    ConfidentialTransferFeeAmount = 17,
    MetadataPointer = 18,
    TokenMetadata = 19,
    GroupPointer = 20,
    TokenGroup = 21,
    GroupMemberPointer = 22,
    TokenGroupMember = 23,
}

Extensions that can be applied to mints or accounts. Mint extensions must only be applied to mint accounts, and account extensions must only be applied to token holding accounts.

Variants

Uninitialized = 0

Used as padding if the account size would otherwise be 355, same as a multisig

TransferFeeConfig = 1

Includes transfer fee rate info and accompanying authorities to withdraw and set the fee

TransferFeeAmount = 2

Includes withheld transfer fees

MintCloseAuthority = 3

Includes an optional mint close authority

ConfidentialTransferMint = 4

Auditor configuration for confidential transfers

ConfidentialTransferAccount = 5

State for confidential transfers

DefaultAccountState = 6

Specifies the default Account::state for new Accounts

ImmutableOwner = 7

Indicates that the Account owner authority cannot be changed

MemoTransfer = 8

Require inbound transfers to have memo

NonTransferable = 9

Indicates that the tokens from this mint can’t be transferred

InterestBearingConfig = 10

Tokens accrue interest over time,

CpiGuard = 11

Locks privileged token operations from happening via CPI

PermanentDelegate = 12

Includes an optional permanent delegate

NonTransferableAccount = 13

Indicates that the tokens in this account belong to a non-transferable mint

TransferHook = 14

Mint requires a CPI to a program implementing the “transfer hook” interface

TransferHookAccount = 15

Indicates that the tokens in this account belong to a mint with a transfer hook

ConfidentialTransferFeeConfig = 16

Includes encrypted withheld fees and the encryption public that they are encrypted under

ConfidentialTransferFeeAmount = 17

Includes confidential withheld transfer fees

MetadataPointer = 18

Mint contains a pointer to another account (or the same account) that holds metadata

TokenMetadata = 19

Mint contains token-metadata

GroupPointer = 20

Mint contains a pointer to another account (or the same account) that holds group configurations

TokenGroup = 21

Mint contains token group configurations

GroupMemberPointer = 22

Mint contains a pointer to another account (or the same account) that holds group member configurations

TokenGroupMember = 23

Mint contains token group member configurations

Implementations

impl ExtensionType

pub fn try_calculate_account_len<S: BaseState>( extension_types: &[Self], ) -> Result<usize, ProgramError>

Get the required account data length for the given ExtensionTypes

Fails if any of the extension types has a variable length

pub fn get_account_type(&self) -> AccountType

Get the associated account type

pub fn get_required_init_account_extensions( mint_extension_types: &[Self], ) -> Vec<Self>

Based on a set of AccountType::Mint ExtensionTypes, get the list of AccountType::Account ExtensionTypes required on InitializeAccount

pub fn check_for_invalid_mint_extension_combinations( mint_extension_types: &[Self], ) -> Result<(), TokenError>

Check for invalid combination of mint extensions

Trait Implementations

impl Clone for ExtensionType

fn clone(&self) -> ExtensionType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExtensionType

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

Formats the value using the given formatter.

impl From<ExtensionType> for [u8; 2]

fn from(a: ExtensionType) -> Self

Converts to this type from the input type.

impl From<ExtensionType> for u16

fn from(enum_value: ExtensionType) -> Self

Converts to this type from the input type.

impl PartialEq for ExtensionType

fn eq(&self, other: &ExtensionType) -> 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 TryFrom<&[u8]> for ExtensionType

type Error = ProgramError

The type returned in the event of a conversion error.

fn try_from(a: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u16> for ExtensionType

type Error = TryFromPrimitiveError<ExtensionType>

The type returned in the event of a conversion error.

fn try_from(number: u16) -> Result<Self, TryFromPrimitiveError<Self>>

Performs the conversion.

impl TryFromPrimitive for ExtensionType

type Primitive = u16

type Error = TryFromPrimitiveError<ExtensionType>

const NAME: &'static str = "ExtensionType"

fn try_from_primitive( number: Self::Primitive, ) -> Result<Self, TryFromPrimitiveError<Self>>

impl Copy for ExtensionType

impl StructuralPartialEq for ExtensionType