Struct ExecutionReceipt

pub struct ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance> {
    pub domain_block_number: DomainNumber,
    pub domain_block_hash: DomainHash,
    pub domain_block_extrinsic_root: DomainHash,
    pub parent_domain_block_receipt_hash: DomainHash,
    pub consensus_block_number: Number,
    pub consensus_block_hash: Hash,
    pub inboxed_bundles: Vec<InboxedBundle<DomainHash>>,
    pub final_state_root: DomainHash,
    pub execution_trace: Vec<DomainHash>,
    pub execution_trace_root: H256,
    pub block_fees: BlockFees<Balance>,
    pub transfers: Transfers<Balance>,
}

Receipt of a domain block execution.

Fields

domain_block_number: DomainNumber

The index of the current domain block that forms the basis of this ER.

domain_block_hash: DomainHash

The block hash corresponding to domain_block_number.

domain_block_extrinsic_root: DomainHash

Extrinsic root field of the header of domain block referenced by this ER.

parent_domain_block_receipt_hash: DomainHash

The hash of the ER for the last domain block.

consensus_block_number: Number

A pointer to the consensus block index which contains all of the bundles that were used to derive and order all extrinsics executed by the current domain block for this ER.

consensus_block_hash: Hash

The block hash corresponding to consensus_block_number.

inboxed_bundles: Vec<InboxedBundle<DomainHash>>

All the bundles that being included in the consensus block.

final_state_root: DomainHash

The final state root for the current domain block reflected by this ER.

Used for verifying storage proofs for domains.

execution_trace: Vec<DomainHash>

List of storage roots collected during the domain block execution.

execution_trace_root: H256

The Merkle root of the execution trace for the current domain block.

Used for verifying fraud proofs.

block_fees: BlockFees<Balance>

Compute and Domain storage fees are shared across operators and Consensus storage fees are given to the consensus block author.

transfers: Transfers<Balance>

List of transfers from this Domain to other chains

Implementations

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

pub fn bundles_extrinsics_roots(&self) -> Vec<&DomainHash>

pub fn valid_bundle_digest_at(&self, index: usize) -> Option<DomainHash>

where DomainHash: Copy,

pub fn valid_bundle_digests(&self) -> Vec<DomainHash>

where DomainHash: Copy,

pub fn valid_bundle_indexes(&self) -> Vec<u32>

impl<Number: Encode + Zero, Hash: Encode + Default, DomainNumber: Encode + Zero, DomainHash: Clone + Encode + Default, Balance: Encode + Zero + Default> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

pub fn hash<DomainHashing: HashT<Output = DomainHash>>(&self) -> DomainHash

Returns the hash of this execution receipt.

pub fn genesis( genesis_state_root: DomainHash, genesis_extrinsic_root: DomainHash, genesis_domain_block_hash: DomainHash, ) -> Self

pub fn dummy<DomainHashing>( consensus_block_number: Number, consensus_block_hash: Hash, domain_block_number: DomainNumber, parent_domain_block_receipt_hash: DomainHash, ) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

where DomainHashing: HashT<Output = DomainHash>,

Trait Implementations

impl<Number: Clone, Hash: Clone, DomainNumber: Clone, DomainHash: Clone, Balance: Clone> Clone for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

fn clone( &self, ) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Number: Debug, Hash: Debug, DomainNumber: Debug, DomainHash: Debug, Balance: Debug> Debug for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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

Formats the value using the given formatter.

impl<Number, Hash, DomainNumber, DomainHash, Balance> Decode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

where DomainNumber: Decode, DomainHash: Decode, Number: Decode, Hash: Decode, Vec<InboxedBundle<DomainHash>>: Decode, Vec<DomainHash>: Decode, BlockFees<Balance>: Decode, Transfers<Balance>: 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<Number, Hash, DomainNumber, DomainHash, Balance> Encode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

where DomainNumber: Encode, DomainHash: Encode, Number: Encode, Hash: Encode, Vec<InboxedBundle<DomainHash>>: Encode, Vec<DomainHash>: Encode, BlockFees<Balance>: Encode, Transfers<Balance>: 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<Number: PartialEq, Hash: PartialEq, DomainNumber: PartialEq, DomainHash: PartialEq, Balance: PartialEq> PartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

fn eq( &self, other: &ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>, ) -> 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<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

where DomainNumber: TypeInfo + 'static, DomainHash: TypeInfo + 'static, Number: TypeInfo + 'static, Hash: TypeInfo + 'static, Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static, Vec<DomainHash>: TypeInfo + 'static, BlockFees<Balance>: TypeInfo + 'static, Transfers<Balance>: TypeInfo + 'static, Balance: TypeInfo + 'static,

type Identity = ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

where DomainNumber: Encode, DomainHash: Encode, Number: Encode, Hash: Encode, Vec<InboxedBundle<DomainHash>>: Encode, Vec<DomainHash>: Encode, BlockFees<Balance>: Encode, Transfers<Balance>: Encode,

impl<Number: Eq, Hash: Eq, DomainNumber: Eq, DomainHash: Eq, Balance: Eq> Eq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralPartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>