Enum Receipt 

pub enum Receipt<P> {
    Promise(P),
    Purged(PurgedTransaction),
}

Receipt for InjectedTransaction.

This type generic over promise type in purpose to support both CompactPromise and Promise.

CompactPromise generic uses only for transport purposes. End user always receives the full version.

Important: Receipt<CompactPromise> and Receipt<Promise> have the same digest. So it helps to reuses the producer’s signature to construct the full version from compact.

Variants

Promise(P)

Purged(PurgedTransaction)

No promise, transaction wasn’t executed.

Implementations

impl<P> Receipt<P>

pub const fn is_promise(&self) -> bool

Returns true if this value is of type Promise. Returns false otherwise

pub const fn is_purged(&self) -> bool

Returns true if this value is of type Purged. Returns false otherwise

impl<P> Receipt<P>

pub fn unwrap_promise(self) -> P

Unwraps this value to the Receipt::Promise variant. Panics if this value is of any other type.

pub fn unwrap_purged(self) -> PurgedTransaction

Unwraps this value to the Receipt::Purged variant. Panics if this value is of any other type.

impl<P: PromiseKind> Receipt<P>

pub fn tx_hash(&self) -> HashOf<InjectedTransaction>

Trait Implementations

impl<P: Clone> Clone for Receipt<P>

fn clone(&self) -> Receipt<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Receipt<P>

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

Formats the value using the given formatter.

impl<P> Decode for Receipt<P>

where P: 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<'de, P> Deserialize<'de> for Receipt<P>

where P: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P> Encode for Receipt<P>

where P: 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<P> EncodeLike for Receipt<P>

where P: Encode,

impl<P: Eq> Eq for Receipt<P>

impl<P: PartialEq> PartialEq for Receipt<P>

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

where P: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P: PartialEq> StructuralPartialEq for Receipt<P>

impl<P: ToDigest> ToDigest for Receipt<P>

fn update_hasher(&self, hasher: &mut Keccak256)

fn to_digest(&self) -> Digest