Enum ContractsEvent 

pub enum ContractsEvent {
    Instantiated {
        deployer: AccountId,
        contract: AccountId,
    },
    Terminated {
        contract: AccountId,
        beneficiary: AccountId,
    },
    CodeStored {
        code_hash: H256,
    },
    ContractEmitted {
        contract: AccountId,
        data: Vec<u8>,
    },
    CodeRemoved {
        code_hash: H256,
    },
    ContractCodeUpdated {
        contract: AccountId,
        new_code_hash: H256,
        old_code_hash: H256,
    },
    Called {
        caller: AccountId,
        contract: AccountId,
    },
    DelegateCalled {
        contract: AccountId,
        code_hash: H256,
    },
}

The event emitted by this pallet.

Variants

Instantiated

Contract deployed by address at the specified address.

Fields

deployer: AccountId

contract: AccountId

Terminated

Contract has been removed.

Note

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

Fields

contract: AccountId

The contract that was terminated.

beneficiary: AccountId

The account that received the contracts remaining balance

CodeStored

Code with the specified hash has been stored.

Fields

code_hash: H256

ContractEmitted

A custom event emitted by the contract.

Fields

contract: 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.

CodeRemoved

A code with the specified hash was removed.

Fields

code_hash: H256

ContractCodeUpdated

A contract’s code was updated.

Fields

contract: AccountId

The contract that has been updated.

new_code_hash: H256

New code hash that was set for the contract.

old_code_hash: H256

Previous code hash of the contract.

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.

Fields

caller: AccountId

The account that called the contract.

contract: AccountId

The contract that was called.

DelegateCalled

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.

Fields

contract: AccountId

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

code_hash: H256

The code hash that was delegate called.

Implementations

impl ContractsEvent

pub fn as_static_str(&self) -> &'static str

Trait Implementations

impl Clone for ContractsEvent

fn clone(&self) -> ContractsEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContractsEvent

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

Formats the value using the given formatter.

impl Decode for ContractsEvent

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<'de> Deserialize<'de> for ContractsEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for ContractsEvent

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 EnumInfo for ContractsEvent

fn as_name(&self) -> &'static str

fn as_docs(&self) -> &'static [&'static str]

fn as_short_doc(&self) -> &'static str

impl From<&ContractsEvent> for &'static str

fn from(v: &ContractsEvent) -> Self

Converts to this type from the input type.

impl From<ContractsEvent> for &'static str

fn from(v: ContractsEvent) -> Self

Converts to this type from the input type.

impl PartialEq for ContractsEvent

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl EncodeLike for ContractsEvent

impl Eq for ContractsEvent

impl StructuralPartialEq for ContractsEvent