mpl-token-metadata 5.1.2-alpha.2

//! This code was AUTOGENERATED using the kinobi library.
//! Please DO NOT EDIT THIS FILE, instead use visitors
//! to add features, then rerun kinobi to update it.
//!
//! [https://github.com/metaplex-foundation/kinobi]
//!

use num_derive::FromPrimitive;
use solana_program_error::{ProgramError, ToStr};
use thiserror::Error;

#[derive(Clone, Debug, Eq, Error, FromPrimitive, PartialEq)]
pub enum MplTokenMetadataError {
    /// 0 (0x0) -
    #[error("")]
    InstructionUnpackError,
    /// 1 (0x1) -
    #[error("")]
    InstructionPackError,
    /// 2 (0x2) - Lamport balance below rent-exempt threshold
    #[error("Lamport balance below rent-exempt threshold")]
    NotRentExempt,
    /// 3 (0x3) - Already initialized
    #[error("Already initialized")]
    AlreadyInitialized,
    /// 4 (0x4) - Uninitialized
    #[error("Uninitialized")]
    Uninitialized,
    /// 5 (0x5) -  Metadata's key must match seed of ['metadata', program id, mint] provided
    #[error(" Metadata's key must match seed of ['metadata', program id, mint] provided")]
    InvalidMetadataKey,
    /// 6 (0x6) - Edition's key must match seed of ['metadata', program id, name, 'edition'] provided
    #[error("Edition's key must match seed of ['metadata', program id, name, 'edition'] provided")]
    InvalidEditionKey,
    /// 7 (0x7) - Update Authority given does not match
    #[error("Update Authority given does not match")]
    UpdateAuthorityIncorrect,
    /// 8 (0x8) - Update Authority needs to be signer to update metadata
    #[error("Update Authority needs to be signer to update metadata")]
    UpdateAuthorityIsNotSigner,
    /// 9 (0x9) - You must be the mint authority and signer on this transaction
    #[error("You must be the mint authority and signer on this transaction")]
    NotMintAuthority,
    /// 10 (0xA) - Mint authority provided does not match the authority on the mint
    #[error("Mint authority provided does not match the authority on the mint")]
    InvalidMintAuthority,
    /// 11 (0xB) - Name too long
    #[error("Name too long")]
    NameTooLong,
    /// 12 (0xC) - Symbol too long
    #[error("Symbol too long")]
    SymbolTooLong,
    /// 13 (0xD) - URI too long
    #[error("URI too long")]
    UriTooLong,
    /// 14 (0xE) -
    #[error("")]
    UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner,
    /// 15 (0xF) - Mint given does not match mint on Metadata
    #[error("Mint given does not match mint on Metadata")]
    MintMismatch,
    /// 16 (0x10) - Editions must have exactly one token
    #[error("Editions must have exactly one token")]
    EditionsMustHaveExactlyOneToken,
    /// 17 (0x11) -
    #[error("")]
    MaxEditionsMintedAlready,
    /// 18 (0x12) -
    #[error("")]
    TokenMintToFailed,
    /// 19 (0x13) -
    #[error("")]
    MasterRecordMismatch,
    /// 20 (0x14) -
    #[error("")]
    DestinationMintMismatch,
    /// 21 (0x15) -
    #[error("")]
    EditionAlreadyMinted,
    /// 22 (0x16) -
    #[error("")]
    PrintingMintDecimalsShouldBeZero,
    /// 23 (0x17) -
    #[error("")]
    OneTimePrintingAuthorizationMintDecimalsShouldBeZero,
    /// 24 (0x18) - EditionMintDecimalsShouldBeZero
    #[error("EditionMintDecimalsShouldBeZero")]
    EditionMintDecimalsShouldBeZero,
    /// 25 (0x19) -
    #[error("")]
    TokenBurnFailed,
    /// 26 (0x1A) -
    #[error("")]
    TokenAccountOneTimeAuthMintMismatch,
    /// 27 (0x1B) - Derived key invalid
    #[error("Derived key invalid")]
    DerivedKeyInvalid,
    /// 28 (0x1C) - The Printing mint does not match that on the master edition!
    #[error("The Printing mint does not match that on the master edition!")]
    PrintingMintMismatch,
    /// 29 (0x1D) - The One Time Printing Auth mint does not match that on the master edition!
    #[error("The One Time Printing Auth mint does not match that on the master edition!")]
    OneTimePrintingAuthMintMismatch,
    /// 30 (0x1E) - The mint of the token account does not match the Printing mint!
    #[error("The mint of the token account does not match the Printing mint!")]
    TokenAccountMintMismatch,
    /// 31 (0x1F) - The mint of the token account does not match the master metadata mint!
    #[error("The mint of the token account does not match the master metadata mint!")]
    TokenAccountMintMismatchV2,
    /// 32 (0x20) - Not enough tokens to mint a limited edition
    #[error("Not enough tokens to mint a limited edition")]
    NotEnoughTokens,
    /// 33 (0x21) -
    #[error("")]
    PrintingMintAuthorizationAccountMismatch,
    /// 34 (0x22) -
    #[error("")]
    AuthorizationTokenAccountOwnerMismatch,
    /// 35 (0x23) -
    #[error("")]
    Disabled,
    /// 36 (0x24) - Creators list too long
    #[error("Creators list too long")]
    CreatorsTooLong,
    /// 37 (0x25) - Creators must be at least one if set
    #[error("Creators must be at least one if set")]
    CreatorsMustBeAtleastOne,
    /// 38 (0x26) -
    #[error("")]
    MustBeOneOfCreators,
    /// 39 (0x27) - This metadata does not have creators
    #[error("This metadata does not have creators")]
    NoCreatorsPresentOnMetadata,
    /// 40 (0x28) - This creator address was not found
    #[error("This creator address was not found")]
    CreatorNotFound,
    /// 41 (0x29) - Basis points cannot be more than 10000
    #[error("Basis points cannot be more than 10000")]
    InvalidBasisPoints,
    /// 42 (0x2A) - Primary sale can only be flipped to true and is immutable
    #[error("Primary sale can only be flipped to true and is immutable")]
    PrimarySaleCanOnlyBeFlippedToTrue,
    /// 43 (0x2B) - Owner does not match that on the account given
    #[error("Owner does not match that on the account given")]
    OwnerMismatch,
    /// 44 (0x2C) - This account has no tokens to be used for authorization
    #[error("This account has no tokens to be used for authorization")]
    NoBalanceInAccountForAuthorization,
    /// 45 (0x2D) - Share total must equal 100 for creator array
    #[error("Share total must equal 100 for creator array")]
    ShareTotalMustBe100,
    /// 46 (0x2E) -
    #[error("")]
    ReservationExists,
    /// 47 (0x2F) -
    #[error("")]
    ReservationDoesNotExist,
    /// 48 (0x30) -
    #[error("")]
    ReservationNotSet,
    /// 49 (0x31) -
    #[error("")]
    ReservationAlreadyMade,
    /// 50 (0x32) -
    #[error("")]
    BeyondMaxAddressSize,
    /// 51 (0x33) - NumericalOverflowError
    #[error("NumericalOverflowError")]
    NumericalOverflowError,
    /// 52 (0x34) -
    #[error("")]
    ReservationBreachesMaximumSupply,
    /// 53 (0x35) -
    #[error("")]
    AddressNotInReservation,
    /// 54 (0x36) - You cannot unilaterally verify another creator, they must sign
    #[error("You cannot unilaterally verify another creator, they must sign")]
    CannotVerifyAnotherCreator,
    /// 55 (0x37) - You cannot unilaterally unverify another creator
    #[error("You cannot unilaterally unverify another creator")]
    CannotUnverifyAnotherCreator,
    /// 56 (0x38) -
    #[error("")]
    SpotMismatch,
    /// 57 (0x39) - Incorrect account owner
    #[error("Incorrect account owner")]
    IncorrectOwner,
    /// 58 (0x3A) -
    #[error("")]
    PrintingWouldBreachMaximumSupply,
    /// 59 (0x3B) - Data is immutable
    #[error("Data is immutable")]
    DataIsImmutable,
    /// 60 (0x3C) - No duplicate creator addresses
    #[error("No duplicate creator addresses")]
    DuplicateCreatorAddress,
    /// 61 (0x3D) -
    #[error("")]
    ReservationSpotsRemainingShouldMatchTotalSpotsAtStart,
    /// 62 (0x3E) - Invalid token program
    #[error("Invalid token program")]
    InvalidTokenProgram,
    /// 63 (0x3F) - Data type mismatch
    #[error("Data type mismatch")]
    DataTypeMismatch,
    /// 64 (0x40) -
    #[error("")]
    BeyondAlottedAddressSize,
    /// 65 (0x41) -
    #[error("")]
    ReservationNotComplete,
    /// 66 (0x42) -
    #[error("")]
    TriedToReplaceAnExistingReservation,
    /// 67 (0x43) - Invalid operation
    #[error("Invalid operation")]
    InvalidOperation,
    /// 68 (0x44) - Invalid Owner
    #[error("Invalid Owner")]
    InvalidOwner,
    /// 69 (0x45) - Printing mint supply must be zero for conversion
    #[error("Printing mint supply must be zero for conversion")]
    PrintingMintSupplyMustBeZeroForConversion,
    /// 70 (0x46) - One Time Auth mint supply must be zero for conversion
    #[error("One Time Auth mint supply must be zero for conversion")]
    OneTimeAuthMintSupplyMustBeZeroForConversion,
    /// 71 (0x47) - You tried to insert one edition too many into an edition mark pda
    #[error("You tried to insert one edition too many into an edition mark pda")]
    InvalidEditionIndex,
    /// 72 (0x48) -
    #[error("")]
    ReservationArrayShouldBeSizeOne,
    /// 73 (0x49) - Is Mutable can only be flipped to false
    #[error("Is Mutable can only be flipped to false")]
    IsMutableCanOnlyBeFlippedToFalse,
    /// 74 (0x4A) - Collection cannot be verified in this instruction
    #[error("Collection cannot be verified in this instruction")]
    CollectionCannotBeVerifiedInThisInstruction,
    /// 75 (0x4B) - This instruction was deprecated in a previous release and is now removed
    #[error("This instruction was deprecated in a previous release and is now removed")]
    Removed,
    /// 76 (0x4C) -
    #[error("")]
    MustBeBurned,
    /// 77 (0x4D) - This use method is invalid
    #[error("This use method is invalid")]
    InvalidUseMethod,
    /// 78 (0x4E) - Cannot Change Use Method after the first use
    #[error("Cannot Change Use Method after the first use")]
    CannotChangeUseMethodAfterFirstUse,
    /// 79 (0x4F) - Cannot Change Remaining or Available uses after the first use
    #[error("Cannot Change Remaining or Available uses after the first use")]
    CannotChangeUsesAfterFirstUse,
    /// 80 (0x50) - Collection Not Found on Metadata
    #[error("Collection Not Found on Metadata")]
    CollectionNotFound,
    /// 81 (0x51) - Collection Update Authority is invalid
    #[error("Collection Update Authority is invalid")]
    InvalidCollectionUpdateAuthority,
    /// 82 (0x52) - Collection Must Be a Unique Master Edition v2
    #[error("Collection Must Be a Unique Master Edition v2")]
    CollectionMustBeAUniqueMasterEdition,
    /// 83 (0x53) - The Use Authority Record Already Exists, to modify it Revoke, then Approve
    #[error("The Use Authority Record Already Exists, to modify it Revoke, then Approve")]
    UseAuthorityRecordAlreadyExists,
    /// 84 (0x54) - The Use Authority Record is empty or already revoked
    #[error("The Use Authority Record is empty or already revoked")]
    UseAuthorityRecordAlreadyRevoked,
    /// 85 (0x55) - This token has no uses
    #[error("This token has no uses")]
    Unusable,
    /// 86 (0x56) - There are not enough Uses left on this token.
    #[error("There are not enough Uses left on this token.")]
    NotEnoughUses,
    /// 87 (0x57) - This Collection Authority Record Already Exists.
    #[error("This Collection Authority Record Already Exists.")]
    CollectionAuthorityRecordAlreadyExists,
    /// 88 (0x58) - This Collection Authority Record Does Not Exist.
    #[error("This Collection Authority Record Does Not Exist.")]
    CollectionAuthorityDoesNotExist,
    /// 89 (0x59) - This Use Authority Record is invalid.
    #[error("This Use Authority Record is invalid.")]
    InvalidUseAuthorityRecord,
    /// 90 (0x5A) -
    #[error("")]
    InvalidCollectionAuthorityRecord,
    /// 91 (0x5B) - Metadata does not match the freeze authority on the mint
    #[error("Metadata does not match the freeze authority on the mint")]
    InvalidFreezeAuthority,
    /// 92 (0x5C) - All tokens in this account have not been delegated to this user.
    #[error("All tokens in this account have not been delegated to this user.")]
    InvalidDelegate,
    /// 93 (0x5D) -
    #[error("")]
    CannotAdjustVerifiedCreator,
    /// 94 (0x5E) - Verified creators cannot be removed.
    #[error("Verified creators cannot be removed.")]
    CannotRemoveVerifiedCreator,
    /// 95 (0x5F) -
    #[error("")]
    CannotWipeVerifiedCreators,
    /// 96 (0x60) -
    #[error("")]
    NotAllowedToChangeSellerFeeBasisPoints,
    /// 97 (0x61) - Edition override cannot be zero
    #[error("Edition override cannot be zero")]
    EditionOverrideCannotBeZero,
    /// 98 (0x62) - Invalid User
    #[error("Invalid User")]
    InvalidUser,
    /// 99 (0x63) - Revoke Collection Authority signer is incorrect
    #[error("Revoke Collection Authority signer is incorrect")]
    RevokeCollectionAuthoritySignerIncorrect,
    /// 100 (0x64) -
    #[error("")]
    TokenCloseFailed,
    /// 101 (0x65) - Can't use this function on unsized collection
    #[error("Can't use this function on unsized collection")]
    UnsizedCollection,
    /// 102 (0x66) - Can't use this function on a sized collection
    #[error("Can't use this function on a sized collection")]
    SizedCollection,
    /// 103 (0x67) - Missing collection metadata account
    #[error("Missing collection metadata account")]
    MissingCollectionMetadata,
    /// 104 (0x68) - This NFT is not a member of the specified collection.
    #[error("This NFT is not a member of the specified collection.")]
    NotAMemberOfCollection,
    /// 105 (0x69) - This NFT is not a verified member of the specified collection.
    #[error("This NFT is not a verified member of the specified collection.")]
    NotVerifiedMemberOfCollection,
    /// 106 (0x6A) - This NFT is not a collection parent NFT.
    #[error("This NFT is not a collection parent NFT.")]
    NotACollectionParent,
    /// 107 (0x6B) - Could not determine a TokenStandard type.
    #[error("Could not determine a TokenStandard type.")]
    CouldNotDetermineTokenStandard,
    /// 108 (0x6C) - This mint account has an edition but none was provided.
    #[error("This mint account has an edition but none was provided.")]
    MissingEditionAccount,
    /// 109 (0x6D) - This edition is not a Master Edition
    #[error("This edition is not a Master Edition")]
    NotAMasterEdition,
    /// 110 (0x6E) - This Master Edition has existing prints
    #[error("This Master Edition has existing prints")]
    MasterEditionHasPrints,
    /// 111 (0x6F) -
    #[error("")]
    BorshDeserializationError,
    /// 112 (0x70) - Cannot update a verified collection in this command
    #[error("Cannot update a verified collection in this command")]
    CannotUpdateVerifiedCollection,
    /// 113 (0x71) - Edition account doesnt match collection
    #[error("Edition account doesnt match collection ")]
    CollectionMasterEditionAccountInvalid,
    /// 114 (0x72) - Item is already verified.
    #[error("Item is already verified.")]
    AlreadyVerified,
    /// 115 (0x73) -
    #[error("")]
    AlreadyUnverified,
    /// 116 (0x74) - This edition is not a Print Edition
    #[error("This edition is not a Print Edition")]
    NotAPrintEdition,
    /// 117 (0x75) - Invalid Master Edition
    #[error("Invalid Master Edition")]
    InvalidMasterEdition,
    /// 118 (0x76) - Invalid Print Edition
    #[error("Invalid Print Edition")]
    InvalidPrintEdition,
    /// 119 (0x77) - Invalid Edition Marker
    #[error("Invalid Edition Marker")]
    InvalidEditionMarker,
    /// 120 (0x78) - Reservation List is Deprecated
    #[error("Reservation List is Deprecated")]
    ReservationListDeprecated,
    /// 121 (0x79) - Print Edition does not match Master Edition
    #[error("Print Edition does not match Master Edition")]
    PrintEditionDoesNotMatchMasterEdition,
    /// 122 (0x7A) - Edition Number greater than max supply
    #[error("Edition Number greater than max supply")]
    EditionNumberGreaterThanMaxSupply,
    /// 123 (0x7B) - Must unverify before migrating collections.
    #[error("Must unverify before migrating collections.")]
    MustUnverify,
    /// 124 (0x7C) - Invalid Escrow Account Bump Seed
    #[error("Invalid Escrow Account Bump Seed")]
    InvalidEscrowBumpSeed,
    /// 125 (0x7D) - Must Escrow Authority
    #[error("Must Escrow Authority")]
    MustBeEscrowAuthority,
    /// 126 (0x7E) - Invalid System Program
    #[error("Invalid System Program")]
    InvalidSystemProgram,
    /// 127 (0x7F) - Must be a Non Fungible Token
    #[error("Must be a Non Fungible Token")]
    MustBeNonFungible,
    /// 128 (0x80) - Insufficient tokens for transfer
    #[error("Insufficient tokens for transfer")]
    InsufficientTokens,
    /// 129 (0x81) - Borsh Serialization Error
    #[error("Borsh Serialization Error")]
    BorshSerializationError,
    /// 130 (0x82) - Cannot create NFT with no Freeze Authority.
    #[error("Cannot create NFT with no Freeze Authority.")]
    NoFreezeAuthoritySet,
    /// 131 (0x83) - Invalid collection size change
    #[error("Invalid collection size change")]
    InvalidCollectionSizeChange,
    /// 132 (0x84) - Invalid bubblegum signer
    #[error("Invalid bubblegum signer")]
    InvalidBubblegumSigner,
    /// 133 (0x85) - Escrow parent cannot have a delegate
    #[error("Escrow parent cannot have a delegate")]
    EscrowParentHasDelegate,
    /// 134 (0x86) - Mint needs to be signer to initialize the account
    #[error("Mint needs to be signer to initialize the account")]
    MintIsNotSigner,
    /// 135 (0x87) - Invalid token standard
    #[error("Invalid token standard")]
    InvalidTokenStandard,
    /// 136 (0x88) - Invalid mint account for specified token standard
    #[error("Invalid mint account for specified token standard")]
    InvalidMintForTokenStandard,
    /// 137 (0x89) - Invalid authorization rules account
    #[error("Invalid authorization rules account")]
    InvalidAuthorizationRules,
    /// 138 (0x8A) - Missing authorization rules account
    #[error("Missing authorization rules account")]
    MissingAuthorizationRules,
    /// 139 (0x8B) - Missing programmable configuration
    #[error("Missing programmable configuration")]
    MissingProgrammableConfig,
    /// 140 (0x8C) - Invalid programmable configuration
    #[error("Invalid programmable configuration")]
    InvalidProgrammableConfig,
    /// 141 (0x8D) - Delegate already exists
    #[error("Delegate already exists")]
    DelegateAlreadyExists,
    /// 142 (0x8E) - Delegate not found
    #[error("Delegate not found")]
    DelegateNotFound,
    /// 143 (0x8F) - Required account not set in instruction builder
    #[error("Required account not set in instruction builder")]
    MissingAccountInBuilder,
    /// 144 (0x90) - Required argument not set in instruction builder
    #[error("Required argument not set in instruction builder")]
    MissingArgumentInBuilder,
    /// 145 (0x91) - Feature not supported currently
    #[error("Feature not supported currently")]
    FeatureNotSupported,
    /// 146 (0x92) - Invalid system wallet
    #[error("Invalid system wallet")]
    InvalidSystemWallet,
    /// 147 (0x93) - Only the sale delegate can transfer while its set
    #[error("Only the sale delegate can transfer while its set")]
    OnlySaleDelegateCanTransfer,
    /// 148 (0x94) - Missing token account
    #[error("Missing token account")]
    MissingTokenAccount,
    /// 149 (0x95) - Missing SPL token program
    #[error("Missing SPL token program")]
    MissingSplTokenProgram,
    /// 150 (0x96) - Missing authorization rules program
    #[error("Missing authorization rules program")]
    MissingAuthorizationRulesProgram,
    /// 151 (0x97) - Invalid delegate role for transfer
    #[error("Invalid delegate role for transfer")]
    InvalidDelegateRoleForTransfer,
    /// 152 (0x98) - Invalid transfer authority
    #[error("Invalid transfer authority")]
    InvalidTransferAuthority,
    /// 153 (0x99) - Instruction not supported for ProgrammableNonFungible assets
    #[error("Instruction not supported for ProgrammableNonFungible assets")]
    InstructionNotSupported,
    /// 154 (0x9A) - Public key does not match expected value
    #[error("Public key does not match expected value")]
    KeyMismatch,
    /// 155 (0x9B) - Token is locked
    #[error("Token is locked")]
    LockedToken,
    /// 156 (0x9C) - Token is unlocked
    #[error("Token is unlocked")]
    UnlockedToken,
    /// 157 (0x9D) - Missing delegate role
    #[error("Missing delegate role")]
    MissingDelegateRole,
    /// 158 (0x9E) - Invalid authority type
    #[error("Invalid authority type")]
    InvalidAuthorityType,
    /// 159 (0x9F) - Missing token record account
    #[error("Missing token record account")]
    MissingTokenRecord,
    /// 160 (0xA0) - Mint supply must be zero for programmable assets
    #[error("Mint supply must be zero for programmable assets")]
    MintSupplyMustBeZero,
    /// 161 (0xA1) - Data is empty or zeroed
    #[error("Data is empty or zeroed")]
    DataIsEmptyOrZeroed,
    /// 162 (0xA2) - Missing token owner
    #[error("Missing token owner")]
    MissingTokenOwnerAccount,
    /// 163 (0xA3) - Master edition account has an invalid length
    #[error("Master edition account has an invalid length")]
    InvalidMasterEditionAccountLength,
    /// 164 (0xA4) - Incorrect token state
    #[error("Incorrect token state")]
    IncorrectTokenState,
    /// 165 (0xA5) - Invalid delegate role
    #[error("Invalid delegate role")]
    InvalidDelegateRole,
    /// 166 (0xA6) - Print supply is required for non-fungibles
    #[error("Print supply is required for non-fungibles")]
    MissingPrintSupply,
    /// 167 (0xA7) - Missing master edition account
    #[error("Missing master edition account")]
    MissingMasterEditionAccount,
    /// 168 (0xA8) - Amount must be greater than zero
    #[error("Amount must be greater than zero")]
    AmountMustBeGreaterThanZero,
    /// 169 (0xA9) - Invalid delegate args
    #[error("Invalid delegate args")]
    InvalidDelegateArgs,
    /// 170 (0xAA) - Missing address for locked transfer
    #[error("Missing address for locked transfer")]
    MissingLockedTransferAddress,
    /// 171 (0xAB) - Invalid destination address for locked transfer
    #[error("Invalid destination address for locked transfer")]
    InvalidLockedTransferAddress,
    /// 172 (0xAC) - Exceeded account realloc increase limit
    #[error("Exceeded account realloc increase limit")]
    DataIncrementLimitExceeded,
    /// 173 (0xAD) - Cannot update the rule set of a programmable asset that has a delegate
    #[error("Cannot update the rule set of a programmable asset that has a delegate")]
    CannotUpdateAssetWithDelegate,
    /// 174 (0xAE) - Invalid token amount for this operation or token standard
    #[error("Invalid token amount for this operation or token standard")]
    InvalidAmount,
    /// 175 (0xAF) - Missing master edition mint account
    #[error("Missing master edition mint account")]
    MissingMasterEditionMintAccount,
    /// 176 (0xB0) - Missing master edition token account
    #[error("Missing master edition token account")]
    MissingMasterEditionTokenAccount,
    /// 177 (0xB1) - Missing edition marker account
    #[error("Missing edition marker account")]
    MissingEditionMarkerAccount,
    /// 178 (0xB2) - Cannot burn while persistent delegate is set
    #[error("Cannot burn while persistent delegate is set")]
    CannotBurnWithDelegate,
    /// 179 (0xB3) - Missing edition account
    #[error("Missing edition account")]
    MissingEdition,
    /// 180 (0xB4) - Invalid Associated Token Account Program
    #[error("Invalid Associated Token Account Program")]
    InvalidAssociatedTokenAccountProgram,
    /// 181 (0xB5) - Invalid InstructionsSysvar
    #[error("Invalid InstructionsSysvar")]
    InvalidInstructionsSysvar,
    /// 182 (0xB6) - Invalid or Unneeded parent accounts
    #[error("Invalid or Unneeded parent accounts")]
    InvalidParentAccounts,
    /// 183 (0xB7) - Authority cannot apply all update args
    #[error("Authority cannot apply all update args")]
    InvalidUpdateArgs,
    /// 184 (0xB8) - Token account does not have enough tokens
    #[error("Token account does not have enough tokens")]
    InsufficientTokenBalance,
    /// 185 (0xB9) - Missing collection account
    #[error("Missing collection account")]
    MissingCollectionMint,
    /// 186 (0xBA) - Missing collection master edition account
    #[error("Missing collection master edition account")]
    MissingCollectionMasterEdition,
    /// 187 (0xBB) - Invalid token record account
    #[error("Invalid token record account")]
    InvalidTokenRecord,
    /// 188 (0xBC) - The close authority needs to be revoked by the Utility Delegate
    #[error("The close authority needs to be revoked by the Utility Delegate")]
    InvalidCloseAuthority,
    /// 189 (0xBD) - Invalid or removed instruction
    #[error("Invalid or removed instruction")]
    InvalidInstruction,
    /// 190 (0xBE) - Missing delegate record
    #[error("Missing delegate record")]
    MissingDelegateRecord,
    /// 191 (0xBF) -
    #[error("")]
    InvalidFeeAccount,
    /// 192 (0xC0) -
    #[error("")]
    InvalidMetadataFlags,
    /// 193 (0xC1) - Cannot change the update authority with a delegate
    #[error("Cannot change the update authority with a delegate")]
    CannotChangeUpdateAuthorityWithDelegate,
    /// 194 (0xC2) - Invalid mint extension type
    #[error("Invalid mint extension type")]
    InvalidMintExtensionType,
    /// 195 (0xC3) - Invalid mint close authority
    #[error("Invalid mint close authority")]
    InvalidMintCloseAuthority,
    /// 196 (0xC4) - Invalid metadata pointer
    #[error("Invalid metadata pointer")]
    InvalidMetadataPointer,
    /// 197 (0xC5) - Invalid token extension type
    #[error("Invalid token extension type")]
    InvalidTokenExtensionType,
    /// 198 (0xC6) - Missing immutable owner extension
    #[error("Missing immutable owner extension")]
    MissingImmutableOwnerExtension,
    /// 199 (0xC7) - Expected account to be uninitialized
    #[error("Expected account to be uninitialized")]
    ExpectedUninitializedAccount,
    /// 200 (0xC8) - Edition account has an invalid length
    #[error("Edition account has an invalid length")]
    InvalidEditionAccountLength,
    /// 201 (0xC9) - Account has already been resized
    #[error("Account has already been resized")]
    AccountAlreadyResized,
    /// 202 (0xCA) - Conditions for closing not met
    #[error("Conditions for closing not met")]
    ConditionsForClosingNotMet,
}

impl From<MplTokenMetadataError> for ProgramError {
    fn from(e: MplTokenMetadataError) -> Self {
        ProgramError::Custom(e as u32)
    }
}

impl TryFrom<u32> for MplTokenMetadataError {
    type Error = ProgramError;
    fn try_from(error: u32) -> Result<Self, Self::Error> {
        match error {
            0 => Ok(MplTokenMetadataError::InstructionUnpackError),
            1 => Ok(MplTokenMetadataError::InstructionPackError),
            2 => Ok(MplTokenMetadataError::NotRentExempt),
            3 => Ok(MplTokenMetadataError::AlreadyInitialized),
            4 => Ok(MplTokenMetadataError::Uninitialized),
            5 => Ok(MplTokenMetadataError::InvalidMetadataKey),
            6 => Ok(MplTokenMetadataError::InvalidEditionKey),
            7 => Ok(MplTokenMetadataError::UpdateAuthorityIncorrect),
            8 => Ok(MplTokenMetadataError::UpdateAuthorityIsNotSigner),
            9 => Ok(MplTokenMetadataError::NotMintAuthority),
            10 => Ok(MplTokenMetadataError::InvalidMintAuthority),
            11 => Ok(MplTokenMetadataError::NameTooLong),
            12 => Ok(MplTokenMetadataError::SymbolTooLong),
            13 => Ok(MplTokenMetadataError::UriTooLong),
            14 => Ok(MplTokenMetadataError::UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner),
            15 => Ok(MplTokenMetadataError::MintMismatch),
            16 => Ok(MplTokenMetadataError::EditionsMustHaveExactlyOneToken),
            17 => Ok(MplTokenMetadataError::MaxEditionsMintedAlready),
            18 => Ok(MplTokenMetadataError::TokenMintToFailed),
            19 => Ok(MplTokenMetadataError::MasterRecordMismatch),
            20 => Ok(MplTokenMetadataError::DestinationMintMismatch),
            21 => Ok(MplTokenMetadataError::EditionAlreadyMinted),
            22 => Ok(MplTokenMetadataError::PrintingMintDecimalsShouldBeZero),
            23 => Ok(MplTokenMetadataError::OneTimePrintingAuthorizationMintDecimalsShouldBeZero),
            24 => Ok(MplTokenMetadataError::EditionMintDecimalsShouldBeZero),
            25 => Ok(MplTokenMetadataError::TokenBurnFailed),
            26 => Ok(MplTokenMetadataError::TokenAccountOneTimeAuthMintMismatch),
            27 => Ok(MplTokenMetadataError::DerivedKeyInvalid),
            28 => Ok(MplTokenMetadataError::PrintingMintMismatch),
            29 => Ok(MplTokenMetadataError::OneTimePrintingAuthMintMismatch),
            30 => Ok(MplTokenMetadataError::TokenAccountMintMismatch),
            31 => Ok(MplTokenMetadataError::TokenAccountMintMismatchV2),
            32 => Ok(MplTokenMetadataError::NotEnoughTokens),
            33 => Ok(MplTokenMetadataError::PrintingMintAuthorizationAccountMismatch),
            34 => Ok(MplTokenMetadataError::AuthorizationTokenAccountOwnerMismatch),
            35 => Ok(MplTokenMetadataError::Disabled),
            36 => Ok(MplTokenMetadataError::CreatorsTooLong),
            37 => Ok(MplTokenMetadataError::CreatorsMustBeAtleastOne),
            38 => Ok(MplTokenMetadataError::MustBeOneOfCreators),
            39 => Ok(MplTokenMetadataError::NoCreatorsPresentOnMetadata),
            40 => Ok(MplTokenMetadataError::CreatorNotFound),
            41 => Ok(MplTokenMetadataError::InvalidBasisPoints),
            42 => Ok(MplTokenMetadataError::PrimarySaleCanOnlyBeFlippedToTrue),
            43 => Ok(MplTokenMetadataError::OwnerMismatch),
            44 => Ok(MplTokenMetadataError::NoBalanceInAccountForAuthorization),
            45 => Ok(MplTokenMetadataError::ShareTotalMustBe100),
            46 => Ok(MplTokenMetadataError::ReservationExists),
            47 => Ok(MplTokenMetadataError::ReservationDoesNotExist),
            48 => Ok(MplTokenMetadataError::ReservationNotSet),
            49 => Ok(MplTokenMetadataError::ReservationAlreadyMade),
            50 => Ok(MplTokenMetadataError::BeyondMaxAddressSize),
            51 => Ok(MplTokenMetadataError::NumericalOverflowError),
            52 => Ok(MplTokenMetadataError::ReservationBreachesMaximumSupply),
            53 => Ok(MplTokenMetadataError::AddressNotInReservation),
            54 => Ok(MplTokenMetadataError::CannotVerifyAnotherCreator),
            55 => Ok(MplTokenMetadataError::CannotUnverifyAnotherCreator),
            56 => Ok(MplTokenMetadataError::SpotMismatch),
            57 => Ok(MplTokenMetadataError::IncorrectOwner),
            58 => Ok(MplTokenMetadataError::PrintingWouldBreachMaximumSupply),
            59 => Ok(MplTokenMetadataError::DataIsImmutable),
            60 => Ok(MplTokenMetadataError::DuplicateCreatorAddress),
            61 => Ok(MplTokenMetadataError::ReservationSpotsRemainingShouldMatchTotalSpotsAtStart),
            62 => Ok(MplTokenMetadataError::InvalidTokenProgram),
            63 => Ok(MplTokenMetadataError::DataTypeMismatch),
            64 => Ok(MplTokenMetadataError::BeyondAlottedAddressSize),
            65 => Ok(MplTokenMetadataError::ReservationNotComplete),
            66 => Ok(MplTokenMetadataError::TriedToReplaceAnExistingReservation),
            67 => Ok(MplTokenMetadataError::InvalidOperation),
            68 => Ok(MplTokenMetadataError::InvalidOwner),
            69 => Ok(MplTokenMetadataError::PrintingMintSupplyMustBeZeroForConversion),
            70 => Ok(MplTokenMetadataError::OneTimeAuthMintSupplyMustBeZeroForConversion),
            71 => Ok(MplTokenMetadataError::InvalidEditionIndex),
            72 => Ok(MplTokenMetadataError::ReservationArrayShouldBeSizeOne),
            73 => Ok(MplTokenMetadataError::IsMutableCanOnlyBeFlippedToFalse),
            74 => Ok(MplTokenMetadataError::CollectionCannotBeVerifiedInThisInstruction),
            75 => Ok(MplTokenMetadataError::Removed),
            76 => Ok(MplTokenMetadataError::MustBeBurned),
            77 => Ok(MplTokenMetadataError::InvalidUseMethod),
            78 => Ok(MplTokenMetadataError::CannotChangeUseMethodAfterFirstUse),
            79 => Ok(MplTokenMetadataError::CannotChangeUsesAfterFirstUse),
            80 => Ok(MplTokenMetadataError::CollectionNotFound),
            81 => Ok(MplTokenMetadataError::InvalidCollectionUpdateAuthority),
            82 => Ok(MplTokenMetadataError::CollectionMustBeAUniqueMasterEdition),
            83 => Ok(MplTokenMetadataError::UseAuthorityRecordAlreadyExists),
            84 => Ok(MplTokenMetadataError::UseAuthorityRecordAlreadyRevoked),
            85 => Ok(MplTokenMetadataError::Unusable),
            86 => Ok(MplTokenMetadataError::NotEnoughUses),
            87 => Ok(MplTokenMetadataError::CollectionAuthorityRecordAlreadyExists),
            88 => Ok(MplTokenMetadataError::CollectionAuthorityDoesNotExist),
            89 => Ok(MplTokenMetadataError::InvalidUseAuthorityRecord),
            90 => Ok(MplTokenMetadataError::InvalidCollectionAuthorityRecord),
            91 => Ok(MplTokenMetadataError::InvalidFreezeAuthority),
            92 => Ok(MplTokenMetadataError::InvalidDelegate),
            93 => Ok(MplTokenMetadataError::CannotAdjustVerifiedCreator),
            94 => Ok(MplTokenMetadataError::CannotRemoveVerifiedCreator),
            95 => Ok(MplTokenMetadataError::CannotWipeVerifiedCreators),
            96 => Ok(MplTokenMetadataError::NotAllowedToChangeSellerFeeBasisPoints),
            97 => Ok(MplTokenMetadataError::EditionOverrideCannotBeZero),
            98 => Ok(MplTokenMetadataError::InvalidUser),
            99 => Ok(MplTokenMetadataError::RevokeCollectionAuthoritySignerIncorrect),
            100 => Ok(MplTokenMetadataError::TokenCloseFailed),
            101 => Ok(MplTokenMetadataError::UnsizedCollection),
            102 => Ok(MplTokenMetadataError::SizedCollection),
            103 => Ok(MplTokenMetadataError::MissingCollectionMetadata),
            104 => Ok(MplTokenMetadataError::NotAMemberOfCollection),
            105 => Ok(MplTokenMetadataError::NotVerifiedMemberOfCollection),
            106 => Ok(MplTokenMetadataError::NotACollectionParent),
            107 => Ok(MplTokenMetadataError::CouldNotDetermineTokenStandard),
            108 => Ok(MplTokenMetadataError::MissingEditionAccount),
            109 => Ok(MplTokenMetadataError::NotAMasterEdition),
            110 => Ok(MplTokenMetadataError::MasterEditionHasPrints),
            111 => Ok(MplTokenMetadataError::BorshDeserializationError),
            112 => Ok(MplTokenMetadataError::CannotUpdateVerifiedCollection),
            113 => Ok(MplTokenMetadataError::CollectionMasterEditionAccountInvalid),
            114 => Ok(MplTokenMetadataError::AlreadyVerified),
            115 => Ok(MplTokenMetadataError::AlreadyUnverified),
            116 => Ok(MplTokenMetadataError::NotAPrintEdition),
            117 => Ok(MplTokenMetadataError::InvalidMasterEdition),
            118 => Ok(MplTokenMetadataError::InvalidPrintEdition),
            119 => Ok(MplTokenMetadataError::InvalidEditionMarker),
            120 => Ok(MplTokenMetadataError::ReservationListDeprecated),
            121 => Ok(MplTokenMetadataError::PrintEditionDoesNotMatchMasterEdition),
            122 => Ok(MplTokenMetadataError::EditionNumberGreaterThanMaxSupply),
            123 => Ok(MplTokenMetadataError::MustUnverify),
            124 => Ok(MplTokenMetadataError::InvalidEscrowBumpSeed),
            125 => Ok(MplTokenMetadataError::MustBeEscrowAuthority),
            126 => Ok(MplTokenMetadataError::InvalidSystemProgram),
            127 => Ok(MplTokenMetadataError::MustBeNonFungible),
            128 => Ok(MplTokenMetadataError::InsufficientTokens),
            129 => Ok(MplTokenMetadataError::BorshSerializationError),
            130 => Ok(MplTokenMetadataError::NoFreezeAuthoritySet),
            131 => Ok(MplTokenMetadataError::InvalidCollectionSizeChange),
            132 => Ok(MplTokenMetadataError::InvalidBubblegumSigner),
            133 => Ok(MplTokenMetadataError::EscrowParentHasDelegate),
            134 => Ok(MplTokenMetadataError::MintIsNotSigner),
            135 => Ok(MplTokenMetadataError::InvalidTokenStandard),
            136 => Ok(MplTokenMetadataError::InvalidMintForTokenStandard),
            137 => Ok(MplTokenMetadataError::InvalidAuthorizationRules),
            138 => Ok(MplTokenMetadataError::MissingAuthorizationRules),
            139 => Ok(MplTokenMetadataError::MissingProgrammableConfig),
            140 => Ok(MplTokenMetadataError::InvalidProgrammableConfig),
            141 => Ok(MplTokenMetadataError::DelegateAlreadyExists),
            142 => Ok(MplTokenMetadataError::DelegateNotFound),
            143 => Ok(MplTokenMetadataError::MissingAccountInBuilder),
            144 => Ok(MplTokenMetadataError::MissingArgumentInBuilder),
            145 => Ok(MplTokenMetadataError::FeatureNotSupported),
            146 => Ok(MplTokenMetadataError::InvalidSystemWallet),
            147 => Ok(MplTokenMetadataError::OnlySaleDelegateCanTransfer),
            148 => Ok(MplTokenMetadataError::MissingTokenAccount),
            149 => Ok(MplTokenMetadataError::MissingSplTokenProgram),
            150 => Ok(MplTokenMetadataError::MissingAuthorizationRulesProgram),
            151 => Ok(MplTokenMetadataError::InvalidDelegateRoleForTransfer),
            152 => Ok(MplTokenMetadataError::InvalidTransferAuthority),
            153 => Ok(MplTokenMetadataError::InstructionNotSupported),
            154 => Ok(MplTokenMetadataError::KeyMismatch),
            155 => Ok(MplTokenMetadataError::LockedToken),
            156 => Ok(MplTokenMetadataError::UnlockedToken),
            157 => Ok(MplTokenMetadataError::MissingDelegateRole),
            158 => Ok(MplTokenMetadataError::InvalidAuthorityType),
            159 => Ok(MplTokenMetadataError::MissingTokenRecord),
            160 => Ok(MplTokenMetadataError::MintSupplyMustBeZero),
            161 => Ok(MplTokenMetadataError::DataIsEmptyOrZeroed),
            162 => Ok(MplTokenMetadataError::MissingTokenOwnerAccount),
            163 => Ok(MplTokenMetadataError::InvalidMasterEditionAccountLength),
            164 => Ok(MplTokenMetadataError::IncorrectTokenState),
            165 => Ok(MplTokenMetadataError::InvalidDelegateRole),
            166 => Ok(MplTokenMetadataError::MissingPrintSupply),
            167 => Ok(MplTokenMetadataError::MissingMasterEditionAccount),
            168 => Ok(MplTokenMetadataError::AmountMustBeGreaterThanZero),
            169 => Ok(MplTokenMetadataError::InvalidDelegateArgs),
            170 => Ok(MplTokenMetadataError::MissingLockedTransferAddress),
            171 => Ok(MplTokenMetadataError::InvalidLockedTransferAddress),
            172 => Ok(MplTokenMetadataError::DataIncrementLimitExceeded),
            173 => Ok(MplTokenMetadataError::CannotUpdateAssetWithDelegate),
            174 => Ok(MplTokenMetadataError::InvalidAmount),
            175 => Ok(MplTokenMetadataError::MissingMasterEditionMintAccount),
            176 => Ok(MplTokenMetadataError::MissingMasterEditionTokenAccount),
            177 => Ok(MplTokenMetadataError::MissingEditionMarkerAccount),
            178 => Ok(MplTokenMetadataError::CannotBurnWithDelegate),
            179 => Ok(MplTokenMetadataError::MissingEdition),
            180 => Ok(MplTokenMetadataError::InvalidAssociatedTokenAccountProgram),
            181 => Ok(MplTokenMetadataError::InvalidInstructionsSysvar),
            182 => Ok(MplTokenMetadataError::InvalidParentAccounts),
            183 => Ok(MplTokenMetadataError::InvalidUpdateArgs),
            184 => Ok(MplTokenMetadataError::InsufficientTokenBalance),
            185 => Ok(MplTokenMetadataError::MissingCollectionMint),
            186 => Ok(MplTokenMetadataError::MissingCollectionMasterEdition),
            187 => Ok(MplTokenMetadataError::InvalidTokenRecord),
            188 => Ok(MplTokenMetadataError::InvalidCloseAuthority),
            189 => Ok(MplTokenMetadataError::InvalidInstruction),
            190 => Ok(MplTokenMetadataError::MissingDelegateRecord),
            191 => Ok(MplTokenMetadataError::InvalidFeeAccount),
            192 => Ok(MplTokenMetadataError::InvalidMetadataFlags),
            193 => Ok(MplTokenMetadataError::CannotChangeUpdateAuthorityWithDelegate),
            194 => Ok(MplTokenMetadataError::InvalidMintExtensionType),
            195 => Ok(MplTokenMetadataError::InvalidMintCloseAuthority),
            196 => Ok(MplTokenMetadataError::InvalidMetadataPointer),
            197 => Ok(MplTokenMetadataError::InvalidTokenExtensionType),
            198 => Ok(MplTokenMetadataError::MissingImmutableOwnerExtension),
            199 => Ok(MplTokenMetadataError::ExpectedUninitializedAccount),
            200 => Ok(MplTokenMetadataError::InvalidEditionAccountLength),
            201 => Ok(MplTokenMetadataError::AccountAlreadyResized),
            202 => Ok(MplTokenMetadataError::ConditionsForClosingNotMet),
            _ => Err(ProgramError::InvalidArgument),
        }
    }
}

impl ToStr for MplTokenMetadataError {
    fn to_str(&self) -> &'static str {
        match self {
                            MplTokenMetadataError::InstructionUnpackError => "",
                            MplTokenMetadataError::InstructionPackError => "",
                            MplTokenMetadataError::NotRentExempt => "Lamport balance below rent-exempt threshold",
                            MplTokenMetadataError::AlreadyInitialized => "Already initialized",
                            MplTokenMetadataError::Uninitialized => "Uninitialized",
                            MplTokenMetadataError::InvalidMetadataKey => " Metadata's key must match seed of ['metadata', program id, mint] provided",
                            MplTokenMetadataError::InvalidEditionKey => "Edition's key must match seed of ['metadata', program id, name, 'edition'] provided",
                            MplTokenMetadataError::UpdateAuthorityIncorrect => "Update Authority given does not match",
                            MplTokenMetadataError::UpdateAuthorityIsNotSigner => "Update Authority needs to be signer to update metadata",
                            MplTokenMetadataError::NotMintAuthority => "You must be the mint authority and signer on this transaction",
                            MplTokenMetadataError::InvalidMintAuthority => "Mint authority provided does not match the authority on the mint",
                            MplTokenMetadataError::NameTooLong => "Name too long",
                            MplTokenMetadataError::SymbolTooLong => "Symbol too long",
                            MplTokenMetadataError::UriTooLong => "URI too long",
                            MplTokenMetadataError::UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner => "",
                            MplTokenMetadataError::MintMismatch => "Mint given does not match mint on Metadata",
                            MplTokenMetadataError::EditionsMustHaveExactlyOneToken => "Editions must have exactly one token",
                            MplTokenMetadataError::MaxEditionsMintedAlready => "",
                            MplTokenMetadataError::TokenMintToFailed => "",
                            MplTokenMetadataError::MasterRecordMismatch => "",
                            MplTokenMetadataError::DestinationMintMismatch => "",
                            MplTokenMetadataError::EditionAlreadyMinted => "",
                            MplTokenMetadataError::PrintingMintDecimalsShouldBeZero => "",
                            MplTokenMetadataError::OneTimePrintingAuthorizationMintDecimalsShouldBeZero => "",
                            MplTokenMetadataError::EditionMintDecimalsShouldBeZero => "EditionMintDecimalsShouldBeZero",
                            MplTokenMetadataError::TokenBurnFailed => "",
                            MplTokenMetadataError::TokenAccountOneTimeAuthMintMismatch => "",
                            MplTokenMetadataError::DerivedKeyInvalid => "Derived key invalid",
                            MplTokenMetadataError::PrintingMintMismatch => "The Printing mint does not match that on the master edition!",
                            MplTokenMetadataError::OneTimePrintingAuthMintMismatch => "The One Time Printing Auth mint does not match that on the master edition!",
                            MplTokenMetadataError::TokenAccountMintMismatch => "The mint of the token account does not match the Printing mint!",
                            MplTokenMetadataError::TokenAccountMintMismatchV2 => "The mint of the token account does not match the master metadata mint!",
                            MplTokenMetadataError::NotEnoughTokens => "Not enough tokens to mint a limited edition",
                            MplTokenMetadataError::PrintingMintAuthorizationAccountMismatch => "",
                            MplTokenMetadataError::AuthorizationTokenAccountOwnerMismatch => "",
                            MplTokenMetadataError::Disabled => "",
                            MplTokenMetadataError::CreatorsTooLong => "Creators list too long",
                            MplTokenMetadataError::CreatorsMustBeAtleastOne => "Creators must be at least one if set",
                            MplTokenMetadataError::MustBeOneOfCreators => "",
                            MplTokenMetadataError::NoCreatorsPresentOnMetadata => "This metadata does not have creators",
                            MplTokenMetadataError::CreatorNotFound => "This creator address was not found",
                            MplTokenMetadataError::InvalidBasisPoints => "Basis points cannot be more than 10000",
                            MplTokenMetadataError::PrimarySaleCanOnlyBeFlippedToTrue => "Primary sale can only be flipped to true and is immutable",
                            MplTokenMetadataError::OwnerMismatch => "Owner does not match that on the account given",
                            MplTokenMetadataError::NoBalanceInAccountForAuthorization => "This account has no tokens to be used for authorization",
                            MplTokenMetadataError::ShareTotalMustBe100 => "Share total must equal 100 for creator array",
                            MplTokenMetadataError::ReservationExists => "",
                            MplTokenMetadataError::ReservationDoesNotExist => "",
                            MplTokenMetadataError::ReservationNotSet => "",
                            MplTokenMetadataError::ReservationAlreadyMade => "",
                            MplTokenMetadataError::BeyondMaxAddressSize => "",
                            MplTokenMetadataError::NumericalOverflowError => "NumericalOverflowError",
                            MplTokenMetadataError::ReservationBreachesMaximumSupply => "",
                            MplTokenMetadataError::AddressNotInReservation => "",
                            MplTokenMetadataError::CannotVerifyAnotherCreator => "You cannot unilaterally verify another creator, they must sign",
                            MplTokenMetadataError::CannotUnverifyAnotherCreator => "You cannot unilaterally unverify another creator",
                            MplTokenMetadataError::SpotMismatch => "",
                            MplTokenMetadataError::IncorrectOwner => "Incorrect account owner",
                            MplTokenMetadataError::PrintingWouldBreachMaximumSupply => "",
                            MplTokenMetadataError::DataIsImmutable => "Data is immutable",
                            MplTokenMetadataError::DuplicateCreatorAddress => "No duplicate creator addresses",
                            MplTokenMetadataError::ReservationSpotsRemainingShouldMatchTotalSpotsAtStart => "",
                            MplTokenMetadataError::InvalidTokenProgram => "Invalid token program",
                            MplTokenMetadataError::DataTypeMismatch => "Data type mismatch",
                            MplTokenMetadataError::BeyondAlottedAddressSize => "",
                            MplTokenMetadataError::ReservationNotComplete => "",
                            MplTokenMetadataError::TriedToReplaceAnExistingReservation => "",
                            MplTokenMetadataError::InvalidOperation => "Invalid operation",
                            MplTokenMetadataError::InvalidOwner => "Invalid Owner",
                            MplTokenMetadataError::PrintingMintSupplyMustBeZeroForConversion => "Printing mint supply must be zero for conversion",
                            MplTokenMetadataError::OneTimeAuthMintSupplyMustBeZeroForConversion => "One Time Auth mint supply must be zero for conversion",
                            MplTokenMetadataError::InvalidEditionIndex => "You tried to insert one edition too many into an edition mark pda",
                            MplTokenMetadataError::ReservationArrayShouldBeSizeOne => "",
                            MplTokenMetadataError::IsMutableCanOnlyBeFlippedToFalse => "Is Mutable can only be flipped to false",
                            MplTokenMetadataError::CollectionCannotBeVerifiedInThisInstruction => "Collection cannot be verified in this instruction",
                            MplTokenMetadataError::Removed => "This instruction was deprecated in a previous release and is now removed",
                            MplTokenMetadataError::MustBeBurned => "",
                            MplTokenMetadataError::InvalidUseMethod => "This use method is invalid",
                            MplTokenMetadataError::CannotChangeUseMethodAfterFirstUse => "Cannot Change Use Method after the first use",
                            MplTokenMetadataError::CannotChangeUsesAfterFirstUse => "Cannot Change Remaining or Available uses after the first use",
                            MplTokenMetadataError::CollectionNotFound => "Collection Not Found on Metadata",
                            MplTokenMetadataError::InvalidCollectionUpdateAuthority => "Collection Update Authority is invalid",
                            MplTokenMetadataError::CollectionMustBeAUniqueMasterEdition => "Collection Must Be a Unique Master Edition v2",
                            MplTokenMetadataError::UseAuthorityRecordAlreadyExists => "The Use Authority Record Already Exists, to modify it Revoke, then Approve",
                            MplTokenMetadataError::UseAuthorityRecordAlreadyRevoked => "The Use Authority Record is empty or already revoked",
                            MplTokenMetadataError::Unusable => "This token has no uses",
                            MplTokenMetadataError::NotEnoughUses => "There are not enough Uses left on this token.",
                            MplTokenMetadataError::CollectionAuthorityRecordAlreadyExists => "This Collection Authority Record Already Exists.",
                            MplTokenMetadataError::CollectionAuthorityDoesNotExist => "This Collection Authority Record Does Not Exist.",
                            MplTokenMetadataError::InvalidUseAuthorityRecord => "This Use Authority Record is invalid.",
                            MplTokenMetadataError::InvalidCollectionAuthorityRecord => "",
                            MplTokenMetadataError::InvalidFreezeAuthority => "Metadata does not match the freeze authority on the mint",
                            MplTokenMetadataError::InvalidDelegate => "All tokens in this account have not been delegated to this user.",
                            MplTokenMetadataError::CannotAdjustVerifiedCreator => "",
                            MplTokenMetadataError::CannotRemoveVerifiedCreator => "Verified creators cannot be removed.",
                            MplTokenMetadataError::CannotWipeVerifiedCreators => "",
                            MplTokenMetadataError::NotAllowedToChangeSellerFeeBasisPoints => "",
                            MplTokenMetadataError::EditionOverrideCannotBeZero => "Edition override cannot be zero",
                            MplTokenMetadataError::InvalidUser => "Invalid User",
                            MplTokenMetadataError::RevokeCollectionAuthoritySignerIncorrect => "Revoke Collection Authority signer is incorrect",
                            MplTokenMetadataError::TokenCloseFailed => "",
                            MplTokenMetadataError::UnsizedCollection => "Can't use this function on unsized collection",
                            MplTokenMetadataError::SizedCollection => "Can't use this function on a sized collection",
                            MplTokenMetadataError::MissingCollectionMetadata => "Missing collection metadata account",
                            MplTokenMetadataError::NotAMemberOfCollection => "This NFT is not a member of the specified collection.",
                            MplTokenMetadataError::NotVerifiedMemberOfCollection => "This NFT is not a verified member of the specified collection.",
                            MplTokenMetadataError::NotACollectionParent => "This NFT is not a collection parent NFT.",
                            MplTokenMetadataError::CouldNotDetermineTokenStandard => "Could not determine a TokenStandard type.",
                            MplTokenMetadataError::MissingEditionAccount => "This mint account has an edition but none was provided.",
                            MplTokenMetadataError::NotAMasterEdition => "This edition is not a Master Edition",
                            MplTokenMetadataError::MasterEditionHasPrints => "This Master Edition has existing prints",
                            MplTokenMetadataError::BorshDeserializationError => "",
                            MplTokenMetadataError::CannotUpdateVerifiedCollection => "Cannot update a verified collection in this command",
                            MplTokenMetadataError::CollectionMasterEditionAccountInvalid => "Edition account doesnt match collection ",
                            MplTokenMetadataError::AlreadyVerified => "Item is already verified.",
                            MplTokenMetadataError::AlreadyUnverified => "",
                            MplTokenMetadataError::NotAPrintEdition => "This edition is not a Print Edition",
                            MplTokenMetadataError::InvalidMasterEdition => "Invalid Master Edition",
                            MplTokenMetadataError::InvalidPrintEdition => "Invalid Print Edition",
                            MplTokenMetadataError::InvalidEditionMarker => "Invalid Edition Marker",
                            MplTokenMetadataError::ReservationListDeprecated => "Reservation List is Deprecated",
                            MplTokenMetadataError::PrintEditionDoesNotMatchMasterEdition => "Print Edition does not match Master Edition",
                            MplTokenMetadataError::EditionNumberGreaterThanMaxSupply => "Edition Number greater than max supply",
                            MplTokenMetadataError::MustUnverify => "Must unverify before migrating collections.",
                            MplTokenMetadataError::InvalidEscrowBumpSeed => "Invalid Escrow Account Bump Seed",
                            MplTokenMetadataError::MustBeEscrowAuthority => "Must Escrow Authority",
                            MplTokenMetadataError::InvalidSystemProgram => "Invalid System Program",
                            MplTokenMetadataError::MustBeNonFungible => "Must be a Non Fungible Token",
                            MplTokenMetadataError::InsufficientTokens => "Insufficient tokens for transfer",
                            MplTokenMetadataError::BorshSerializationError => "Borsh Serialization Error",
                            MplTokenMetadataError::NoFreezeAuthoritySet => "Cannot create NFT with no Freeze Authority.",
                            MplTokenMetadataError::InvalidCollectionSizeChange => "Invalid collection size change",
                            MplTokenMetadataError::InvalidBubblegumSigner => "Invalid bubblegum signer",
                            MplTokenMetadataError::EscrowParentHasDelegate => "Escrow parent cannot have a delegate",
                            MplTokenMetadataError::MintIsNotSigner => "Mint needs to be signer to initialize the account",
                            MplTokenMetadataError::InvalidTokenStandard => "Invalid token standard",
                            MplTokenMetadataError::InvalidMintForTokenStandard => "Invalid mint account for specified token standard",
                            MplTokenMetadataError::InvalidAuthorizationRules => "Invalid authorization rules account",
                            MplTokenMetadataError::MissingAuthorizationRules => "Missing authorization rules account",
                            MplTokenMetadataError::MissingProgrammableConfig => "Missing programmable configuration",
                            MplTokenMetadataError::InvalidProgrammableConfig => "Invalid programmable configuration",
                            MplTokenMetadataError::DelegateAlreadyExists => "Delegate already exists",
                            MplTokenMetadataError::DelegateNotFound => "Delegate not found",
                            MplTokenMetadataError::MissingAccountInBuilder => "Required account not set in instruction builder",
                            MplTokenMetadataError::MissingArgumentInBuilder => "Required argument not set in instruction builder",
                            MplTokenMetadataError::FeatureNotSupported => "Feature not supported currently",
                            MplTokenMetadataError::InvalidSystemWallet => "Invalid system wallet",
                            MplTokenMetadataError::OnlySaleDelegateCanTransfer => "Only the sale delegate can transfer while its set",
                            MplTokenMetadataError::MissingTokenAccount => "Missing token account",
                            MplTokenMetadataError::MissingSplTokenProgram => "Missing SPL token program",
                            MplTokenMetadataError::MissingAuthorizationRulesProgram => "Missing authorization rules program",
                            MplTokenMetadataError::InvalidDelegateRoleForTransfer => "Invalid delegate role for transfer",
                            MplTokenMetadataError::InvalidTransferAuthority => "Invalid transfer authority",
                            MplTokenMetadataError::InstructionNotSupported => "Instruction not supported for ProgrammableNonFungible assets",
                            MplTokenMetadataError::KeyMismatch => "Public key does not match expected value",
                            MplTokenMetadataError::LockedToken => "Token is locked",
                            MplTokenMetadataError::UnlockedToken => "Token is unlocked",
                            MplTokenMetadataError::MissingDelegateRole => "Missing delegate role",
                            MplTokenMetadataError::InvalidAuthorityType => "Invalid authority type",
                            MplTokenMetadataError::MissingTokenRecord => "Missing token record account",
                            MplTokenMetadataError::MintSupplyMustBeZero => "Mint supply must be zero for programmable assets",
                            MplTokenMetadataError::DataIsEmptyOrZeroed => "Data is empty or zeroed",
                            MplTokenMetadataError::MissingTokenOwnerAccount => "Missing token owner",
                            MplTokenMetadataError::InvalidMasterEditionAccountLength => "Master edition account has an invalid length",
                            MplTokenMetadataError::IncorrectTokenState => "Incorrect token state",
                            MplTokenMetadataError::InvalidDelegateRole => "Invalid delegate role",
                            MplTokenMetadataError::MissingPrintSupply => "Print supply is required for non-fungibles",
                            MplTokenMetadataError::MissingMasterEditionAccount => "Missing master edition account",
                            MplTokenMetadataError::AmountMustBeGreaterThanZero => "Amount must be greater than zero",
                            MplTokenMetadataError::InvalidDelegateArgs => "Invalid delegate args",
                            MplTokenMetadataError::MissingLockedTransferAddress => "Missing address for locked transfer",
                            MplTokenMetadataError::InvalidLockedTransferAddress => "Invalid destination address for locked transfer",
                            MplTokenMetadataError::DataIncrementLimitExceeded => "Exceeded account realloc increase limit",
                            MplTokenMetadataError::CannotUpdateAssetWithDelegate => "Cannot update the rule set of a programmable asset that has a delegate",
                            MplTokenMetadataError::InvalidAmount => "Invalid token amount for this operation or token standard",
                            MplTokenMetadataError::MissingMasterEditionMintAccount => "Missing master edition mint account",
                            MplTokenMetadataError::MissingMasterEditionTokenAccount => "Missing master edition token account",
                            MplTokenMetadataError::MissingEditionMarkerAccount => "Missing edition marker account",
                            MplTokenMetadataError::CannotBurnWithDelegate => "Cannot burn while persistent delegate is set",
                            MplTokenMetadataError::MissingEdition => "Missing edition account",
                            MplTokenMetadataError::InvalidAssociatedTokenAccountProgram => "Invalid Associated Token Account Program",
                            MplTokenMetadataError::InvalidInstructionsSysvar => "Invalid InstructionsSysvar",
                            MplTokenMetadataError::InvalidParentAccounts => "Invalid or Unneeded parent accounts",
                            MplTokenMetadataError::InvalidUpdateArgs => "Authority cannot apply all update args",
                            MplTokenMetadataError::InsufficientTokenBalance => "Token account does not have enough tokens",
                            MplTokenMetadataError::MissingCollectionMint => "Missing collection account",
                            MplTokenMetadataError::MissingCollectionMasterEdition => "Missing collection master edition account",
                            MplTokenMetadataError::InvalidTokenRecord => "Invalid token record account",
                            MplTokenMetadataError::InvalidCloseAuthority => "The close authority needs to be revoked by the Utility Delegate",
                            MplTokenMetadataError::InvalidInstruction => "Invalid or removed instruction",
                            MplTokenMetadataError::MissingDelegateRecord => "Missing delegate record",
                            MplTokenMetadataError::InvalidFeeAccount => "",
                            MplTokenMetadataError::InvalidMetadataFlags => "",
                            MplTokenMetadataError::CannotChangeUpdateAuthorityWithDelegate => "Cannot change the update authority with a delegate",
                            MplTokenMetadataError::InvalidMintExtensionType => "Invalid mint extension type",
                            MplTokenMetadataError::InvalidMintCloseAuthority => "Invalid mint close authority",
                            MplTokenMetadataError::InvalidMetadataPointer => "Invalid metadata pointer",
                            MplTokenMetadataError::InvalidTokenExtensionType => "Invalid token extension type",
                            MplTokenMetadataError::MissingImmutableOwnerExtension => "Missing immutable owner extension",
                            MplTokenMetadataError::ExpectedUninitializedAccount => "Expected account to be uninitialized",
                            MplTokenMetadataError::InvalidEditionAccountLength => "Edition account has an invalid length",
                            MplTokenMetadataError::AccountAlreadyResized => "Account has already been resized",
                            MplTokenMetadataError::ConditionsForClosingNotMet => "Conditions for closing not met",
                    }
    }
}