Enum pallet_ip_pallet::pallet::Event

pub enum Event<T: Config> {
    NftMinted {
        owner: T::AccountId,
        nft_id: T::NFTId,
    },
    NftEscrowed {
        nft_id: T::NFTId,
        owner: T::AccountId,
    },
    NftRemovedFromEscrow {
        nft_id: T::NFTId,
        owner: T::AccountId,
    },
    LicenseOffered {
        nft_id: T::NFTId,
        offer_id: T::OfferId,
        is_exclusive: bool,
    },
    PurchaseOffered {
        nft_id: T::NFTId,
        offer_id: T::OfferId,
    },
    ContractCreated {
        contract_id: T::ContractId,
        contract_type: ContractType,
        nft_id: T::NFTId,
        offered_by: T::AccountId,
        accepted_by: T::AccountId,
    },
    ContractCompleted {
        contract_id: T::ContractId,
        contract_type: ContractType,
        nft_id: T::NFTId,
        offered_by: T::AccountId,
        accepted_by: T::AccountId,
        total_paid: BalanceOf<T>,
    },
    ContractExpired {
        contract_id: T::ContractId,
        contract_type: ContractType,
        nft_id: T::NFTId,
        offered_by: T::AccountId,
        accepted_by: T::AccountId,
        payments_made: T::Index,
        total_paid: BalanceOf<T>,
    },
    ContractTerminated {
        contract_id: T::ContractId,
        contract_type: ContractType,
        nft_id: T::NFTId,
        offered_by: T::AccountId,
        accepted_by: T::AccountId,
        payments_made: T::Index,
        total_paid: BalanceOf<T>,
    },
    ContractPenalized {
        contract_id: T::ContractId,
        nft_id: T::NFTId,
        payer: T::AccountId,
        penalty_amount: BalanceOf<T>,
    },
    PaymentMade {
        payer: T::AccountId,
        payee: T::AccountId,
        amount: BalanceOf<T>,
    },
    PeriodicPaymentMade {
        contract_id: T::ContractId,
        nft_id: T::NFTId,
        payer: T::AccountId,
        payee: T::AccountId,
        amount: BalanceOf<T>,
    },
    PeriodicPaymentFailed {
        contract_id: T::ContractId,
        nft_id: T::NFTId,
        licensee: T::AccountId,
    },
    PaymentsCompleted {
        contract_id: T::ContractId,
        nft_id: T::NFTId,
    },
    // some variants omitted
}

The Event enum of this pallet

Variants

NftMinted

An NFT was successfully minted

Related Functions

• Pallet::mint_nft

Fields

owner: T::AccountId

nft_id: T::NFTId

NftEscrowed

An NFT was placed in escrow during a purchase

Related Functions

• Pallet::accept_purchase
• Pallet::escrow_nft

Fields

nft_id: T::NFTId

owner: T::AccountId

NftRemovedFromEscrow

An NFT was removed from escrow

Emitted when a purchase is completed or cancelled.

Fields

nft_id: T::NFTId

owner: T::AccountId

LicenseOffered

A new license offer was created

Related Functions

• Pallet::offer_license

Fields

nft_id: T::NFTId

offer_id: T::OfferId

is_exclusive: bool

PurchaseOffered

A new purchase offer was created

Related Functions

• Pallet::offer_purchase

Fields

nft_id: T::NFTId

offer_id: T::OfferId

ContractCreated

A new contract was created from an accepted offer

Related Functions

• Pallet::accept_license
• Pallet::accept_purchase

Fields

contract_id: T::ContractId

contract_type: ContractType

nft_id: T::NFTId

offered_by: T::AccountId

accepted_by: T::AccountId

ContractCompleted

A contract was successfully completed

Emitted when all payments are made and contract terms are fulfilled.

Parameters

• contract_id: ID of the completed contract
• contract_type: Type of contract completed
• nft_id: ID of the NFT involved
• offered_by: Original offer creator
• accepted_by: Contract acceptor
• total_paid: Total amount paid over contract lifetime

Fields

contract_id: T::ContractId

contract_type: ContractType

nft_id: T::NFTId

offered_by: T::AccountId

accepted_by: T::AccountId

total_paid: BalanceOf<T>

ContractExpired

A contract expired without completion

Emitted when a license duration ends before all payments are made.

Parameters

• contract_id: ID of the expired contract
• contract_type: Type of expired contract
• nft_id: ID of the NFT involved
• offered_by: Original offer creator
• accepted_by: Contract acceptor
• payments_made: Number of payments completed
• total_paid: Total amount paid before expiration

Fields

contract_id: T::ContractId

contract_type: ContractType

nft_id: T::NFTId

offered_by: T::AccountId

accepted_by: T::AccountId

payments_made: T::Index

total_paid: BalanceOf<T>

ContractTerminated

A contract was terminated due to missed payments

Emitted when two consecutive payments are missed.

Parameters

• contract_id: ID of the terminated contract
• contract_type: Type of terminated contract
• nft_id: ID of the NFT involved
• offered_by: Original offer creator
• accepted_by: Contract acceptor
• payments_made: Number of payments completed before termination
• total_paid: Total amount paid before termination

Fields

contract_id: T::ContractId

contract_type: ContractType

nft_id: T::NFTId

offered_by: T::AccountId

accepted_by: T::AccountId

payments_made: T::Index

total_paid: BalanceOf<T>

ContractPenalized

A penalty was applied to a contract

Emitted when a payment is missed and a 20% penalty is added.

Parameters

• contract_id: ID of the penalized contract
• nft_id: ID of the NFT involved
• payer: Account that missed the payment
• penalty_amount: Amount of penalty added (20% of payment)

Fields

contract_id: T::ContractId

nft_id: T::NFTId

payer: T::AccountId

penalty_amount: BalanceOf<T>

PaymentMade

Fields

payer: T::AccountId

payee: T::AccountId

amount: BalanceOf<T>

PeriodicPaymentMade

Fields

contract_id: T::ContractId

nft_id: T::NFTId

payer: T::AccountId

payee: T::AccountId

amount: BalanceOf<T>

PeriodicPaymentFailed

A periodic payment was missed

Parameters

• contract_id: ID of the contract with missed payment
• nft_id: ID of the NFT involved
• licensee: Account that missed the payment

Fields

contract_id: T::ContractId

nft_id: T::NFTId

licensee: T::AccountId

PaymentsCompleted

All payments for a contract have been completed

Parameters

• contract_id: ID of the contract
• nft_id: ID of the NFT involved

Fields

contract_id: T::ContractId

nft_id: T::NFTId

Trait Implementations

impl<T: Config> Clone for Event<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T: Config> Decode for Event<T>

where T::AccountId: Decode, T::NFTId: Decode, T::OfferId: Decode, T::ContractId: Decode, BalanceOf<T>: Decode, T::Index: Decode,

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: Config> Encode for Event<T>

where T::AccountId: Encode, T::NFTId: Encode, T::OfferId: Encode, T::ContractId: Encode, BalanceOf<T>: Encode, T::Index: Encode,

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<Event<T>> for ()

fn from(_: Event<T>)

Converts to this type from the input type.

impl<T: Config> PartialEq for Event<T>

fn eq(&self, other: &Self) -> 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<T> TypeInfo for Event<T>

where T::AccountId: TypeInfo + 'static, T::NFTId: TypeInfo + 'static, T::OfferId: TypeInfo + 'static, T::ContractId: TypeInfo + 'static, BalanceOf<T>: TypeInfo + 'static, T::Index: TypeInfo + 'static, PhantomData<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = Event<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> EncodeLike for Event<T>

where T::AccountId: Encode, T::NFTId: Encode, T::OfferId: Encode, T::ContractId: Encode, BalanceOf<T>: Encode, T::Index: Encode,

impl<T: Config> Eq for Event<T>