Enum MetadataError 

pub enum MetadataError {
    InstructionUnpackError,
    InstructionPackError,
    NotRentExempt,
    AlreadyInitialized,
    Uninitialized,
    InvalidMetadataKey,
    InvalidEditionKey,
    UpdateAuthorityIncorrect,
    UpdateAuthorityIsNotSigner,
    NotMintAuthority,
    InvalidMintAuthority,
    NameTooLong,
    SymbolTooLong,
    UriTooLong,
    UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner,
    MintMismatch,
    EditionsMustHaveExactlyOneToken,
    MaxEditionsMintedAlready,
    TokenMintToFailed,
    MasterRecordMismatch,
    DestinationMintMismatch,
    EditionAlreadyMinted,
    PrintingMintDecimalsShouldBeZero,
    OneTimePrintingAuthorizationMintDecimalsShouldBeZero,
    EditionMintDecimalsShouldBeZero,
    TokenBurnFailed,
    TokenAccountOneTimeAuthMintMismatch,
    DerivedKeyInvalid,
    PrintingMintMismatch,
    OneTimePrintingAuthMintMismatch,
    TokenAccountMintMismatch,
    TokenAccountMintMismatchV2,
    NotEnoughTokens,
    PrintingMintAuthorizationAccountMismatch,
    AuthorizationTokenAccountOwnerMismatch,
    Disabled,
    CreatorsTooLong,
    CreatorsMustBeAtleastOne,
    MustBeOneOfCreators,
    NoCreatorsPresentOnMetadata,
    CreatorNotFound,
    InvalidBasisPoints,
    PrimarySaleCanOnlyBeFlippedToTrue,
    OwnerMismatch,
    NoBalanceInAccountForAuthorization,
    ShareTotalMustBe100,
    ReservationExists,
    ReservationDoesNotExist,
    ReservationNotSet,
    ReservationAlreadyMade,
    BeyondMaxAddressSize,
    NumericalOverflowError,
    ReservationBreachesMaximumSupply,
    AddressNotInReservation,
    CannotVerifyAnotherCreator,
    CannotUnverifyAnotherCreator,
    SpotMismatch,
    IncorrectOwner,
    PrintingWouldBreachMaximumSupply,
    DataIsImmutable,
    DuplicateCreatorAddress,
    ReservationSpotsRemainingShouldMatchTotalSpotsAtStart,
    InvalidTokenProgram,
    DataTypeMismatch,
    BeyondAlottedAddressSize,
    ReservationNotComplete,
    TriedToReplaceAnExistingReservation,
    InvalidOperation,
    InvalidOwner,
    PrintingMintSupplyMustBeZeroForConversion,
    OneTimeAuthMintSupplyMustBeZeroForConversion,
    InvalidEditionIndex,
    ReservationArrayShouldBeSizeOne,
    IsMutableCanOnlyBeFlippedToFalse,
    CollectionCannotBeVerifiedInThisInstruction,
    Removed,
    MustBeBurned,
    InvalidUseMethod,
    CannotChangeUseMethodAfterFirstUse,
    CannotChangeUsesAfterFirstUse,
    CollectionNotFound,
    InvalidCollectionUpdateAuthority,
    CollectionMustBeAUniqueMasterEdition,
    UseAuthorityRecordAlreadyExists,
    UseAuthorityRecordAlreadyRevoked,
    Unusable,
    NotEnoughUses,
    CollectionAuthorityRecordAlreadyExists,
    CollectionAuthorityDoesNotExist,
}

Errors that may be returned by the Metadata program.

Variants

InstructionUnpackError

Failed to unpack instruction data

InstructionPackError

Failed to pack instruction data

NotRentExempt

Lamport balance below rent-exempt threshold.

AlreadyInitialized

Already initialized

Uninitialized

Uninitialized

InvalidMetadataKey

Metadata’s key must match seed of [‘metadata’, program id, mint] provided

InvalidEditionKey

Edition’s key must match seed of [‘metadata’, program id, name, ‘edition’] provided

UpdateAuthorityIncorrect

Update Authority given does not match

UpdateAuthorityIsNotSigner

Update Authority needs to be signer to update metadata

NotMintAuthority

You must be the mint authority and signer on this transaction

InvalidMintAuthority

Mint authority provided does not match the authority on the mint

NameTooLong

Name too long

SymbolTooLong

Symbol too long

UriTooLong

URI too long

UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner

Update authority must be equivalent to the metadata’s authority and also signer of this transaction

MintMismatch

Mint given does not match mint on Metadata

EditionsMustHaveExactlyOneToken

Editions must have exactly one token

MaxEditionsMintedAlready

Maximum editions printed already

TokenMintToFailed

Token mint to failed

MasterRecordMismatch

The master edition record passed must match the master record on the edition given

DestinationMintMismatch

The destination account does not have the right mint

EditionAlreadyMinted

An edition can only mint one of its kind!

PrintingMintDecimalsShouldBeZero

Printing mint decimals should be zero

OneTimePrintingAuthorizationMintDecimalsShouldBeZero

OneTimePrintingAuthorizationMint mint decimals should be zero

EditionMintDecimalsShouldBeZero

Edition mint decimals should be zero

TokenBurnFailed

Token burn failed

TokenAccountOneTimeAuthMintMismatch

The One Time authorization mint does not match that on the token account!

DerivedKeyInvalid

Derived key invalid

PrintingMintMismatch

The Printing mint does not match that on the master edition!

OneTimePrintingAuthMintMismatch

The One Time Printing Auth mint does not match that on the master edition!

TokenAccountMintMismatch

The mint of the token account does not match the Printing mint!

TokenAccountMintMismatchV2

The mint of the token account does not match the master metadata mint!

NotEnoughTokens

Not enough tokens to mint a limited edition

PrintingMintAuthorizationAccountMismatch

The mint on your authorization token holding account does not match your Printing mint!

AuthorizationTokenAccountOwnerMismatch

The authorization token account has a different owner than the update authority for the master edition!

Disabled

This feature is currently disabled.

CreatorsTooLong

Creators list too long

CreatorsMustBeAtleastOne

Creators must be at least one if set

MustBeOneOfCreators

If using a creators array, you must be one of the creators listed

NoCreatorsPresentOnMetadata

This metadata does not have creators

CreatorNotFound

This creator address was not found

InvalidBasisPoints

Basis points cannot be more than 10000

PrimarySaleCanOnlyBeFlippedToTrue

Primary sale can only be flipped to true and is immutable

OwnerMismatch

Owner does not match that on the account given

NoBalanceInAccountForAuthorization

This account has no tokens to be used for authorization

ShareTotalMustBe100

Share total must equal 100 for creator array

ReservationExists

This reservation list already exists!

ReservationDoesNotExist

This reservation list does not exist!

ReservationNotSet

This reservation list exists but was never set with reservations

ReservationAlreadyMade

This reservation list has already been set!

BeyondMaxAddressSize

Provided more addresses than max allowed in single reservation

NumericalOverflowError

NumericalOverflowError

ReservationBreachesMaximumSupply

This reservation would go beyond the maximum supply of the master edition!

AddressNotInReservation

Address not in reservation!

CannotVerifyAnotherCreator

You cannot unilaterally verify another creator, they must sign

CannotUnverifyAnotherCreator

You cannot unilaterally unverify another creator

SpotMismatch

In initial reservation setting, spots remaining should equal total spots

IncorrectOwner

Incorrect account owner

PrintingWouldBreachMaximumSupply

printing these tokens would breach the maximum supply limit of the master edition

DataIsImmutable

Data is immutable

DuplicateCreatorAddress

No duplicate creator addresses

ReservationSpotsRemainingShouldMatchTotalSpotsAtStart

Reservation spots remaining should match total spots when first being created

InvalidTokenProgram

Invalid token program

DataTypeMismatch

Data type mismatch

BeyondAlottedAddressSize

Beyond alotted address size in reservation!

ReservationNotComplete

The reservation has only been partially alotted

TriedToReplaceAnExistingReservation

You cannot splice over an existing reservation!

InvalidOperation

Invalid operation

InvalidOwner

Invalid owner

PrintingMintSupplyMustBeZeroForConversion

Printing mint supply must be zero for conversion

OneTimeAuthMintSupplyMustBeZeroForConversion

One Time Auth mint supply must be zero for conversion

InvalidEditionIndex

You tried to insert one edition too many into an edition mark pda

ReservationArrayShouldBeSizeOne

IsMutableCanOnlyBeFlippedToFalse

Is Mutable can only be flipped to false

CollectionCannotBeVerifiedInThisInstruction

Removed

MustBeBurned

InvalidUseMethod

CannotChangeUseMethodAfterFirstUse

CannotChangeUsesAfterFirstUse

CollectionNotFound

InvalidCollectionUpdateAuthority

CollectionMustBeAUniqueMasterEdition

UseAuthorityRecordAlreadyExists

UseAuthorityRecordAlreadyRevoked

Unusable

NotEnoughUses

CollectionAuthorityRecordAlreadyExists

CollectionAuthorityDoesNotExist

Trait Implementations

impl Clone for MetadataError

fn clone(&self) -> MetadataError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetadataError

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

Formats the value using the given formatter.

impl<T> DecodeError<T> for MetadataError

fn type_of() -> &'static str

fn decode_custom_error_to_enum(custom: u32) -> Option<E>

where E: FromPrimitive,

impl Display for MetadataError

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

Formats the value using the given formatter.

impl Error for MetadataError

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<MetadataError> for ProgramError

fn from(e: MetadataError) -> Self

Converts to this type from the input type.

impl FromPrimitive for MetadataError

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 MetadataError

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

fn print<E>(&self)

impl Eq for MetadataError

impl StructuralPartialEq for MetadataError