Enum pallet_ip_pallet::pallet::Error

pub enum Error<T> {
    NameTooLong,
    DescriptionTooLong,
    FilingDateTooLong,
    JurisdictionTooLong,
    NftNotFound,
    NotNftOwner,
    NftInEscrow,
    OfferNotFound,
    ContractNotFound,
    NotALicenseOffer,
    NotAPurchaseOffer,
    NotALicenseContract,
    NotAPurchaseContract,
    ActiveLicensesExist,
    ExclusiveLicenseExists,
    LicenseNotExpired,
    ZeroPayment,
    InsufficientBalance,
    PaymentNotDue,
    PaymentNotCompleted,
    NotPeriodicPayment,
    // some variants omitted
}

The Error enum of this pallet.

Variants

NameTooLong

Input name exceeds Config::MaxNameLength

Emitted by Pallet::mint_nft when the NFT name is too long.

DescriptionTooLong

Input description exceeds Config::MaxDescriptionLength

Emitted by Pallet::mint_nft when the NFT description is too long.

FilingDateTooLong

Input filing date exceeds Config::MaxNameLength

Emitted by Pallet::mint_nft when the filing date string is too long.

JurisdictionTooLong

Input jurisdiction exceeds Config::MaxNameLength

Emitted by Pallet::mint_nft when the jurisdiction string is too long.

NftNotFound

The requested NFT does not exist in storage

See Nfts storage.

NotNftOwner

Account is not the owner of this NFT

Emitted when trying to create offers or modify an NFT without ownership. See NFT::owner.

NftInEscrow

NFT is currently held in escrow

Emitted when trying to create new offers for an NFT that’s locked in a purchase contract. See EscrowedNfts storage.

OfferNotFound

The requested offer does not exist in storage

See Offers storage.

ContractNotFound

The requested contract does not exist in storage

See Contracts storage.

NotALicenseOffer

Expected a license offer but found a different type

Emitted by Pallet::accept_license when the offer is not a crate::types::Offer::License.

NotAPurchaseOffer

Expected a purchase offer but found a different type

Emitted by Pallet::accept_purchase when the offer is not a crate::types::Offer::Purchase.

NotALicenseContract

Expected a license contract but found a different type

Emitted when trying to perform license-specific operations on a purchase contract.

NotAPurchaseContract

Expected a purchase contract but found a different type

Emitted when trying to perform purchase-specific operations on a license contract.

ActiveLicensesExist

NFT already has active license contracts

Emitted when trying to create a purchase offer while licenses are active. See NFTContracts storage.

ExclusiveLicenseExists

NFT already has an exclusive license contract

Emitted when trying to create a new license offer while an exclusive license exists. See crate::types::License::is_exclusive.

LicenseNotExpired

License contract has not yet expired

Emitted by Pallet::expire_license when trying to expire a license before its duration ends. See crate::types::License::duration.

ZeroPayment

Attempted to make a zero-value payment

Emitted by payment functions when amount is 0.

InsufficientBalance

Payer account has insufficient balance

Emitted when trying to process a payment that exceeds available funds. See Config::Currency.

PaymentNotDue

No payment is currently due for this contract

Emitted by Pallet::make_periodic_payment when called before the next payment is due. See crate::types::PaymentSchedule::next_payment_block.

PaymentNotCompleted

Contract payments are not yet completed

Emitted when trying to finalize a contract before all payments are made. See crate::types::PaymentSchedule::payments_due.

NotPeriodicPayment

Contract does not use periodic payments

Emitted when trying to make periodic payments on a one-time payment contract. See crate::types::PaymentType.

Trait Implementations

impl<T: Config> Debug for Error<T>

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

Formats the value using the given formatter.

impl<T> Decode for Error<T>

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T> Encode for Error<T>

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> From<Error<T>> for &'static str

fn from(err: Error<T>) -> &'static str

Converts to this type from the input type.

impl<T: Config> From<Error<T>> for DispatchError

fn from(err: Error<T>) -> Self

Converts to this type from the input type.

impl<T> PalletError for Error<T>

const MAX_ENCODED_SIZE: usize = 1usize

The maximum encoded size for the implementing type.

impl<T> TypeInfo for Error<T>

where PhantomData<T>: TypeInfo + 'static, T: 'static,

type Identity = Error<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T> EncodeLike for Error<T>