Enum MetaplexError 

pub enum MetaplexError {
    InstructionUnpackError,
    NotRentExempt,
    AlreadyInitialized,
    Uninitialized,
    IncorrectOwner,
    NumericalOverflowError,
    TokenTransferFailed,
    InvalidTransferAuthority,
    VaultAuthorityMismatch,
    AuctionAuthorityMismatch,
    AuctionManagerAuthorityMismatch,
    AuctionManagerVaultMismatch,
    SafetyDepositBoxVaultMismatch,
    SafetyDepositBoxStoreMismatch,
    SafetyDepositBoxMetadataMismatch,
    SafetyDepositBoxMasterEditionOneTimeAuthMintMismatch,
    SafetyDepositBoxMintMismatch,
    AuctionManagerTokenMetadataProgramMismatch,
    TokenProgramMismatch,
    AuctionManagerAuctionMismatch,
    AuctionManagerAuctionProgramMismatch,
    AuctionManagerTokenProgramMismatch,
    AuctionManagerTokenVaultProgramMismatch,
    VaultNotCombined,
    VaultCannotEmpty,
    InvalidSafetyDepositBox,
    CantUseLimitedSupplyEditionsWithOpenEditionAuction,
    SafetyDepositBoxNotUsedInAuction,
    InvalidEditionAddress,
    NotEnoughEditionsAvailableForAuction,
    StoreIsEmpty,
    NotEnoughTokensToSupplyWinners,
    AuctionManagerMustOwnPayoffAccount,
    AuctionManagerMustOwnOutstandingSharesAccount,
    SafetyDepositIndexMismatch,
    PrizeAlreadyClaimed,
    BidRedemptionMismatch,
    BidAlreadyRedeemed,
    AuctionHasNotEnded,
    OriginalAuthorityLookupKeyMismatch,
    OriginalAuthorityMismatch,
    WrongBidEndpointForPrize,
    BidderMetadataBidderMismatch,
    MasterEditionMintMismatch,
    MasterEditionOneTimeAuthMintMismatch,
    PrintingTokenAccountMintMismatch,
    DestinationMintMismatch,
    InvalidEditionKey,
    TokenMintToFailed,
    MasterMintAuthorityMismatch,
    MasterEditionOneTimeAuthorizationMintMismatch,
    AuctionAcceptPaymentMintMismatch,
    AcceptPaymentOwnerMismatch,
    AcceptPaymentMismatch,
    NotEligibleForParticipation,
    AuctionManagerMustBeValidated,
    SafetyDepositBoxMasterMintMismatch,
    AcceptPaymentMintMismatch,
    NotEnoughBalanceForParticipation,
    DerivedKeyInvalid,
    WhitelistedCreatorInactive,
    InvalidWhitelistedCreator,
    AuctionManagerStoreMismatch,
    InvalidCreatorIndex,
    InvalidWinningConfigIndex,
    CreatorIndexExpected,
    WinningConfigSafetyDepositMismatch,
    ParticipationSafetyDepositMismatch,
    ParticipationNotPresent,
    NotAllBidsClaimed,
    InvalidWinningConfigItemIndex,
    OneTimeAuthorizationTokenMustBeOne,
    AddReservationListFailed,
    CloseAccountFailed,
    CreatorHasNotVerifiedMetadata,
    DuplicateWinningConfigItemDetected,
    PrintingAuthorizationTokenAccountMismatch,
    TransientAuthAccountMintMismatch,
    ParticipationPrintingEmpty,
    PrintingAuthorizationTokensFailed,
    InvalidTokenProgram,
    AuctionManagerTokenMetadataMismatch,
    AlreadyValidated,
    AuctionMustBeCreated,
    DelegateShouldBeNone,
    CloseAuthorityShouldBeNone,
    DataTypeMismatch,
    AuctioneerCantClaimWonPrize,
    MustBeAuctioneer,
    WinnerAmountMismatch,
    InvalidStatus,
    InvalidEditionNumber,
    InvalidOperation,
    ProvidedAccountDoesNotContainOneToken,
    WinnerIndexMismatch,
    InvalidWinningConfigSafetyDepositIndex,
    SafetyDepositConfigOrderMismatch,
    WinnerIndexNotFound,
    AlreadyHasOneParticipationPrize,
    NoTokensForThisWinner,
    PrintingV1NotAllowedWithAuctionManagerV2,
    InvalidSystemProgram,
    DuplicateKeyDetected,
    MaxMetadataCacheSizeReached,
    InvalidCacheOffset,
    ExpectedAboveAuctionCacheToBeProvided,
    ExpectedBelowAuctionCacheToBeProvided,
    CacheMismatch,
    CacheAboveIsNewer,
    CacheBelowIsOlder,
    AuctionManagerInFishedState,
    PublicKeyMismatch,
}

Errors that may be returned by the Metaplex program.

Variants

InstructionUnpackError

Invalid instruction data passed in.

NotRentExempt

Lamport balance below rent-exempt threshold.

AlreadyInitialized

Already initialized

Uninitialized

Uninitialized

IncorrectOwner

Account does not have correct owner

NumericalOverflowError

NumericalOverflowError

TokenTransferFailed

Token transfer failed

InvalidTransferAuthority

Invalid transfer authority provided

VaultAuthorityMismatch

Vault’s authority does not match the expected pda with seed [‘metaplex’, auction_key]

AuctionAuthorityMismatch

Auction’s authority does not match the expected pda with seed [‘metaplex’, auction_key]

AuctionManagerAuthorityMismatch

The authority passed to the call does not match the authority on the auction manager!

AuctionManagerVaultMismatch

Vault given does not match that on given auction manager!

SafetyDepositBoxVaultMismatch

The safety deposit box given does not belong to the given vault!

SafetyDepositBoxStoreMismatch

The store given does not belong to the safety deposit box given!

SafetyDepositBoxMetadataMismatch

The metadata given does not match the mint on the safety deposit box given!

SafetyDepositBoxMasterEditionOneTimeAuthMintMismatch

The Safety Deposit Box mint does not match the one time auth mint on the master edition

SafetyDepositBoxMintMismatch

The mint given does not match the mint on the given safety deposit box!

AuctionManagerTokenMetadataProgramMismatch

The token metadata program given does not match the token metadata program on this auction manager!

TokenProgramMismatch

The mint is owned by a different token program than the one used by this auction manager!

AuctionManagerAuctionMismatch

The auction given does not match the auction on the auction manager!

AuctionManagerAuctionProgramMismatch

The auction program given does not match the auction program on the auction manager!

AuctionManagerTokenProgramMismatch

The token program given does not match the token program on the auction manager!

AuctionManagerTokenVaultProgramMismatch

The token vault program given does not match the token vault program on the auction manager!

VaultNotCombined

Only combined vaults may be used in auction managers!

VaultCannotEmpty

Cannot auction off an empty vault!

InvalidSafetyDepositBox

Listed a safety deposit box index that does not exist in this vault

CantUseLimitedSupplyEditionsWithOpenEditionAuction

Cant use a limited supply edition for an open edition as you may run out of editions to print

SafetyDepositBoxNotUsedInAuction

This safety deposit box is not listed as a prize in this auction manager!

InvalidEditionAddress

Either you have given a non-existent edition address or you have given the address to a different token-metadata program than was used to make this edition!

NotEnoughEditionsAvailableForAuction

There are not enough editions available for this auction!

StoreIsEmpty

The store in the safety deposit is empty, so you have nothing to auction!

NotEnoughTokensToSupplyWinners

Not enough tokens to supply winners!

AuctionManagerMustOwnPayoffAccount

The auction manager must own the payoff account!

AuctionManagerMustOwnOutstandingSharesAccount

The auction manager must own the oustanding shares account!

SafetyDepositIndexMismatch

The safety deposit box for your winning bid or participation placement does not match the safety deposit box you provided!

PrizeAlreadyClaimed

This prize has already been claimed!

BidRedemptionMismatch

The bid redemption key does not match the expected PDA with seed [‘metaplex’, auction key, bidder metadata key]

BidAlreadyRedeemed

This bid has already been redeemed!

AuctionHasNotEnded

Auction has not ended yet!

OriginalAuthorityLookupKeyMismatch

The original authority lookup does not match the expected PDA of [‘metaplex’, auction key, metadata key]

OriginalAuthorityMismatch

The original authority given does not match that on the original authority lookup account!

WrongBidEndpointForPrize

The prize you are attempting to claim needs to be claimed from a different endpoint than this one.

BidderMetadataBidderMismatch

The bidder given is not the bidder on the bidder metadata!

MasterEditionMintMismatch

Printing mint given does not match the mint on master edition!

MasterEditionOneTimeAuthMintMismatch

One Time Auth mint given does not match the mint on master edition!

PrintingTokenAccountMintMismatch

The printing token account must be of the printing mint type to hold authorization tokens after auction end

DestinationMintMismatch

Destination does not have the proper mint!

InvalidEditionKey

Invalid edition key

TokenMintToFailed

Token mint to failed

MasterMintAuthorityMismatch

The Printing mint authority provided does not match that on the mint

MasterEditionOneTimeAuthorizationMintMismatch

The safety deposit box is not using the one time authorization mint of the master edition

AuctionAcceptPaymentMintMismatch

The accept payment account for this auction manager must match the auction’s token mint!

AcceptPaymentOwnerMismatch

The accept payment owner must be the auction manager!

AcceptPaymentMismatch

The accept payment given does not match the accept payment account on the auction manager!

NotEligibleForParticipation

You are not eligible for an participation NFT!

AuctionManagerMustBeValidated

Auction manager must be validated to start auction!

SafetyDepositBoxMasterMintMismatch

The safety deposit mint type must be the Printing mint of the limited edition!

AcceptPaymentMintMismatch

The mints between the accept payment and account provided do not match

NotEnoughBalanceForParticipation

You do not have enough to buy this participation NFT!

DerivedKeyInvalid

Derived key invalid

WhitelistedCreatorInactive

Creator is not active on this store!

InvalidWhitelistedCreator

This creator is not whitelisted

AuctionManagerStoreMismatch

Store given does not match store on auction manager!

InvalidCreatorIndex

Supplied an invalid creator index to empty payment account

InvalidWinningConfigIndex

Supplied an invalid winning config index

CreatorIndexExpected

Metadata has creators and no creator index was supplied!

WinningConfigSafetyDepositMismatch

This winning config does not contain this safety deposit box as one of it’s prizes

ParticipationSafetyDepositMismatch

The participation prize does not match the safety deposit given

ParticipationNotPresent

Participation NFT not present on this auction, so cannot collect money for it

NotAllBidsClaimed

Not possible to settle until all bids have been claimed

InvalidWinningConfigItemIndex

Invalid winning config item index provided

OneTimeAuthorizationTokenMustBeOne

When using a one time authorization token in a winning config item, you can never have amount > 1

AddReservationListFailed

Adding a reservation list failed

CloseAccountFailed

Close account command failed

CreatorHasNotVerifiedMetadata

A creator on this metadata has not verified it

DuplicateWinningConfigItemDetected

Duplicate winning config item detected

PrintingAuthorizationTokenAccountMismatch

The authorization account provided does not match that on the participation state

TransientAuthAccountMintMismatch

The transient account provided does not have the correct mint

ParticipationPrintingEmpty

The participation printing authorization token account is empty. One person needs to call populate on it!

PrintingAuthorizationTokensFailed

The printing authorization token command failed

InvalidTokenProgram

Invalid token program

AuctionManagerTokenMetadataMismatch

Token metadata program does not match

AlreadyValidated

This safety deposit box has already been validated

AuctionMustBeCreated

Auction must be created

DelegateShouldBeNone

Accept payment delegate should be none

CloseAuthorityShouldBeNone

Accept payment close authority should be none

DataTypeMismatch

Data type mismatch

AuctioneerCantClaimWonPrize

Auctioneer can’t claim a won prize

MustBeAuctioneer

Auctioneer is the only one who can override win indices

WinnerAmountMismatch

The auction provided has a different amount of winners set than does the auction manager settings

InvalidStatus

Invalid Auction Manager Status

InvalidEditionNumber

You are not eligible for this edition offset

InvalidOperation

Invalid operation

ProvidedAccountDoesNotContainOneToken

The provided account needs to contain one token of this mint type

WinnerIndexMismatch

You are not the winner at this index

InvalidWinningConfigSafetyDepositIndex

You supplied a safety deposit index in a winning configuration that does not exist

SafetyDepositConfigOrderMismatch

The order provided on the safety deposit config does not match that on the safety deposit box!

WinnerIndexNotFound

Winner index not found in safety deposit config ranges

AlreadyHasOneParticipationPrize

Currently metaplex auctions are limited to a single participation prize

NoTokensForThisWinner

This winner was not found in any ranges in the unique token type list, this should never happen

PrintingV1NotAllowedWithAuctionManagerV2

Not allowed to use Master Edition V1 printing with Auction Manager v2

InvalidSystemProgram

Invalid system

DuplicateKeyDetected

Duplicate key detected

MaxMetadataCacheSizeReached

Max metadata cache size reached

InvalidCacheOffset

Invalid cache offset

ExpectedAboveAuctionCacheToBeProvided

You needed to provide an auction cache for the element above you but did not

ExpectedBelowAuctionCacheToBeProvided

You needed to provide an auction cache for the element below you but did not

CacheMismatch

Cache given does not match cache at this offset

CacheAboveIsNewer

Cache above is newer

CacheBelowIsOlder

Cache below is older

AuctionManagerInFishedState

Auction manager already in finished state

PublicKeyMismatch

Public keys don’t match in assert check.

Trait Implementations

impl Clone for MetaplexError

fn clone(&self) -> MetaplexError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetaplexError

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

Formats the value using the given formatter.

impl<T> DecodeError<T> for MetaplexError

fn type_of() -> &'static str

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

where E: FromPrimitive,

impl Display for MetaplexError

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

Formats the value using the given formatter.

impl Error for MetaplexError

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

fn from(e: MetaplexError) -> Self

Converts to this type from the input type.

impl FromPrimitive for MetaplexError

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 MetaplexError

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

fn print<E>(&self)

impl Eq for MetaplexError

impl StructuralPartialEq for MetaplexError