Enum TokenError 

#[repr(u32)]
pub enum TokenError {
    NotRentExempt = 0,
    InsufficientFunds = 1,
    InvalidMint = 2,
    MintMismatch = 3,
    OwnerMismatch = 4,
    FixedSupply = 5,
    AlreadyInUse = 6,
    InvalidNumberOfProvidedSigners = 7,
    InvalidNumberOfRequiredSigners = 8,
    UninitializedState = 9,
    NativeNotSupported = 10,
    NonNativeHasBalance = 11,
    InvalidInstruction = 12,
    InvalidState = 13,
    Overflow = 14,
    AuthorityTypeNotSupported = 15,
    MintCannotFreeze = 16,
    AccountFrozen = 17,
    MintDecimalsMismatch = 18,
    NonNativeNotSupported = 19,
    ExtensionTypeMismatch = 20,
    ExtensionBaseMismatch = 21,
    ExtensionAlreadyInitialized = 22,
    ConfidentialTransferAccountHasBalance = 23,
    ConfidentialTransferAccountNotApproved = 24,
    ConfidentialTransferDepositsAndTransfersDisabled = 25,
    ConfidentialTransferElGamalPubkeyMismatch = 26,
    ConfidentialTransferBalanceMismatch = 27,
    MintHasSupply = 28,
    NoAuthorityExists = 29,
    TransferFeeExceedsMaximum = 30,
    MintRequiredForTransfer = 31,
    FeeMismatch = 32,
    FeeParametersMismatch = 33,
    ImmutableOwner = 34,
    AccountHasWithheldTransferFees = 35,
    NoMemo = 36,
    NonTransferable = 37,
    NonTransferableNeedsImmutableOwnership = 38,
    MaximumPendingBalanceCreditCounterExceeded = 39,
    MaximumDepositAmountExceeded = 40,
    CpiGuardSettingsLocked = 41,
    CpiGuardTransferBlocked = 42,
    CpiGuardBurnBlocked = 43,
    CpiGuardCloseAccountBlocked = 44,
    CpiGuardApproveBlocked = 45,
    CpiGuardSetAuthorityBlocked = 46,
    CpiGuardOwnerChangeBlocked = 47,
    ExtensionNotFound = 48,
    NonConfidentialTransfersDisabled = 49,
    ConfidentialTransferFeeAccountHasWithheldFee = 50,
    InvalidExtensionCombination = 51,
    InvalidLengthForAlloc = 52,
    AccountDecryption = 53,
    ProofGeneration = 54,
    InvalidProofInstructionOffset = 55,
    HarvestToMintDisabled = 56,
    SplitProofContextStateAccountsNotSupported = 57,
    NotEnoughProofContextStateAccounts = 58,
    MalformedCiphertext = 59,
    CiphertextArithmeticFailed = 60,
    PedersenCommitmentMismatch = 61,
    RangeProofLengthMismatch = 62,
    IllegalBitLength = 63,
    FeeCalculation = 64,
    IllegalMintBurnConversion = 65,
    InvalidScale = 66,
    MintPaused = 67,
    PendingBalanceNonZero = 68,
}

Errors that may be returned by the Token program.

Variants

NotRentExempt = 0

Lamport balance below rent-exempt threshold.

InsufficientFunds = 1

Insufficient funds for the operation requested.

InvalidMint = 2

Invalid Mint.

MintMismatch = 3

Account not associated with this Mint.

OwnerMismatch = 4

Owner does not match.

FixedSupply = 5

This token’s supply is fixed and new tokens cannot be minted.

AlreadyInUse = 6

The account cannot be initialized because it is already being used.

InvalidNumberOfProvidedSigners = 7

Invalid number of provided signers.

InvalidNumberOfRequiredSigners = 8

Invalid number of required signers.

UninitializedState = 9

State is uninitialized.

NativeNotSupported = 10

Instruction does not support native tokens

NonNativeHasBalance = 11

Non-native account can only be closed if its balance is zero

InvalidInstruction = 12

Invalid instruction

InvalidState = 13

State is invalid for requested operation.

Overflow = 14

Operation overflowed

AuthorityTypeNotSupported = 15

Account does not support specified authority type.

MintCannotFreeze = 16

This token mint cannot freeze accounts.

AccountFrozen = 17

Account is frozen; all account operations will fail

MintDecimalsMismatch = 18

Mint decimals mismatch between the client and mint

NonNativeNotSupported = 19

Instruction does not support non-native tokens

ExtensionTypeMismatch = 20

Extension type does not match already existing extensions

ExtensionBaseMismatch = 21

Extension does not match the base type provided

ExtensionAlreadyInitialized = 22

Extension already initialized on this account

ConfidentialTransferAccountHasBalance = 23

An account can only be closed if its confidential balance is zero

ConfidentialTransferAccountNotApproved = 24

Account not approved for confidential transfers

ConfidentialTransferDepositsAndTransfersDisabled = 25

Account not accepting deposits or transfers

ConfidentialTransferElGamalPubkeyMismatch = 26

ElGamal public key mismatch

ConfidentialTransferBalanceMismatch = 27

Balance mismatch

MintHasSupply = 28

Mint has non-zero supply. Burn all tokens before closing the mint.

NoAuthorityExists = 29

No authority exists to perform the desired operation

TransferFeeExceedsMaximum = 30

Transfer fee exceeds maximum of 10,000 basis points

MintRequiredForTransfer = 31

Mint required for this account to transfer tokens, use transfer_checked or transfer_checked_with_fee

FeeMismatch = 32

Calculated fee does not match expected fee

FeeParametersMismatch = 33

Fee parameters associated with confidential transfer zero-knowledge proofs do not match fee parameters in mint

ImmutableOwner = 34

The owner authority cannot be changed

AccountHasWithheldTransferFees = 35

An account can only be closed if its withheld fee balance is zero, harvest fees to the mint and try again

NoMemo = 36

No memo in previous instruction; required for recipient to receive a transfer

NonTransferable = 37

Transfer is disabled for this mint

NonTransferableNeedsImmutableOwnership = 38

Non-transferable tokens can’t be minted to an account without immutable ownership

MaximumPendingBalanceCreditCounterExceeded = 39

The total number of Deposit and Transfer instructions to an account cannot exceed the associated maximum_pending_balance_credit_counter

MaximumDepositAmountExceeded = 40

The deposit amount for the confidential extension exceeds the maximum limit

CpiGuardSettingsLocked = 41

CPI Guard cannot be enabled or disabled in CPI

CpiGuardTransferBlocked = 42

CPI Guard is enabled, and a program attempted to transfer user funds without using a delegate

CpiGuardBurnBlocked = 43

CPI Guard is enabled, and a program attempted to burn user funds without using a delegate

CpiGuardCloseAccountBlocked = 44

CPI Guard is enabled, and a program attempted to close an account without returning lamports to owner

CpiGuardApproveBlocked = 45

CPI Guard is enabled, and a program attempted to approve a delegate

CpiGuardSetAuthorityBlocked = 46

CPI Guard is enabled, and a program attempted to add or replace an authority

CpiGuardOwnerChangeBlocked = 47

Account ownership cannot be changed while CPI Guard is enabled

ExtensionNotFound = 48

Extension not found in account data

NonConfidentialTransfersDisabled = 49

Account does not accept non-confidential transfers

ConfidentialTransferFeeAccountHasWithheldFee = 50

An account can only be closed if the confidential withheld fee is zero

InvalidExtensionCombination = 51

A mint or an account is initialized to an invalid combination of extensions

InvalidLengthForAlloc = 52

Extension allocation with overwrite must use the same length

AccountDecryption = 53

Failed to decrypt a confidential transfer account

ProofGeneration = 54

Failed to generate a zero-knowledge proof needed for a token instruction

InvalidProofInstructionOffset = 55

An invalid proof instruction offset was provided

HarvestToMintDisabled = 56

Harvest of withheld tokens to mint is disabled

SplitProofContextStateAccountsNotSupported = 57

Split proof context state accounts not supported for instruction

NotEnoughProofContextStateAccounts = 58

Not enough proof context state accounts provided

MalformedCiphertext = 59

Ciphertext is malformed

CiphertextArithmeticFailed = 60

Ciphertext arithmetic failed

PedersenCommitmentMismatch = 61

Pedersen commitments did not match

RangeProofLengthMismatch = 62

Range proof length did not match

IllegalBitLength = 63

Illegal transfer amount bit length

FeeCalculation = 64

Fee calculation failed

IllegalMintBurnConversion = 65

Withdraw / Deposit not allowed for confidential-mint-burn

InvalidScale = 66

Invalid scale for scaled ui amount

MintPaused = 67

Transferring, minting, and burning is paused on this mint

PendingBalanceNonZero = 68

Pending supply is not zero

Trait Implementations

impl Clone for TokenError

fn clone(&self) -> TokenError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TokenError

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

Formats the value using the given formatter.

impl Display for TokenError

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

Formats the value using the given formatter.

impl Error for TokenError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<TokenError> for ProgramError

fn from(e: TokenError) -> Self

Converts to this type from the input type.

impl From<TokenProofExtractionError> for TokenError

fn from(e: TokenProofExtractionError) -> Self

Converts to this type from the input type.

impl From<TokenProofGenerationError> for TokenError

Available on non-target_os=solana only.

fn from(e: TokenProofGenerationError) -> Self

Converts to this type from the input type.

impl FromPrimitive for TokenError

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl PartialEq for TokenError

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

fn to_str(&self) -> &'static str

impl TryFrom<u32> for TokenError

type Error = ProgramError

The type returned in the event of a conversion error.

fn try_from(code: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for TokenError

impl StructuralPartialEq for TokenError