Enum pallet_contracts::pallet::Event

pub enum Event<T: Config> {
    Instantiated {
        deployer: T::AccountId,
        contract: T::AccountId,
    },
    Terminated {
        contract: T::AccountId,
        beneficiary: T::AccountId,
    },
    CodeStored {
        code_hash: T::Hash,
    },
    ContractEmitted {
        contract: T::AccountId,
        data: Vec<u8>,
    },
    CodeRemoved {
        code_hash: T::Hash,
    },
    ContractCodeUpdated {
        contract: T::AccountId,
        new_code_hash: T::Hash,
        old_code_hash: T::Hash,
    },
    Called {
        caller: Origin<T>,
        contract: T::AccountId,
    },
    DelegateCalled {
        contract: T::AccountId,
        code_hash: <T as Config>::Hash,
    },
    // some variants omitted
}

The Event enum of this pallet

Variants

Instantiated

Fields

deployer: T::AccountId

contract: T::AccountId

Contract deployed by address at the specified address.

Terminated

Fields

contract: T::AccountId

The contract that was terminated.

beneficiary: T::AccountId

The account that received the contracts remaining balance

Contract has been removed.

Note

The only way for a contract to be removed and emitting this event is by calling seal_terminate.

CodeStored

Fields

code_hash: T::Hash

Code with the specified hash has been stored.

ContractEmitted

Fields

contract: T::AccountId

The contract that emitted the event.

data: Vec<u8>

Data supplied by the contract. Metadata generated during contract compilation is needed to decode it.

A custom event emitted by the contract.

CodeRemoved

Fields

code_hash: T::Hash

A code with the specified hash was removed.

ContractCodeUpdated

Fields

contract: T::AccountId

The contract that has been updated.

new_code_hash: T::Hash

New code hash that was set for the contract.

old_code_hash: T::Hash

Previous code hash of the contract.

A contract’s code was updated.

Called

Fields

caller: Origin<T>

The caller of the contract.

contract: T::AccountId

The contract that was called.

A contract was called either by a plain account or another contract.

Note

Please keep in mind that like all events this is only emitted for successful calls. This is because on failure all storage changes including events are rolled back.

DelegateCalled

Fields

contract: T::AccountId

The contract that performed the delegate call and hence in whose context the code_hash is executed.

code_hash: <T as Config>::Hash

The code hash that was delegate called.

A contract delegate called a code hash.

Note

Please keep in mind that like all events this is only emitted for successful calls. This is because on failure all storage changes including events are rolled back.

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::Hash: Decode, Origin<T>: Decode, <T as Config>::Hash: 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::Hash: Encode, Origin<T>: Encode, <T as Config>::Hash: 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, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere 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<Event<T>> for Event<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method 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::Hash: TypeInfo + 'static, Origin<T>: TypeInfo + 'static, <T as Config>::Hash: 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<Event<T>> for Event<T>where T::AccountId: Encode, T::Hash: Encode, Origin<T>: Encode, <T as Config>::Hash: Encode,

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