Struct SignedMessage 

pub struct SignedMessage<T> { /* private fields */ }

A signed according to EIP-191 message,that contains the data and its signature. Always valid after construction.

Implementations

impl<T> SignedMessage<T>

pub fn data(&self) -> &T

pub fn signature(&self) -> &Signature

pub fn into_data(self) -> T

pub fn into_parts(self) -> (T, Signature)

pub fn into_parts_full(self) -> (T, Signature, Address)

pub fn address(&self) -> Address

Returns the address of the signer.

impl<T> SignedMessage<T>

where Digest: for<'a> From<&'a T>,

pub fn into_verified(self) -> VerifiedData<T>

impl<T> SignedMessage<T>

where Digest: for<'a> From<&'a T>,

pub fn create( private_key: PrivateKey, data: T, ) -> Result<SignedMessage<T>, SignerError>

pub fn try_from_parts( data: T, signature: Signature, address: Address, ) -> Result<SignedMessage<T>, &'static str>

pub unsafe fn from_parts_unchecked( data: T, signature: Signature, address: Address, ) -> SignedMessage<T>

The unsafe constructor for SignedMessage.

It is useful to optimize the constructing signed wrappers for types with the same ToDigest implementation.

Safety

Safety only in cases when you are sure when hashes are equal.

Trait Implementations

impl<T> Clone for SignedMessage<T>

where T: Clone,

fn clone(&self) -> SignedMessage<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SignedMessage<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Decode for SignedMessage<T>

where T: Decode, Digest: for<'a> From<&'a T>,

fn decode<I>(input: &mut I) -> Result<SignedMessage<T>, Error>

where I: Input,

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, T> Deserialize<'de> for SignedMessage<T>

where T: Deserialize<'de>, Digest: for<'a> From<&'a T>,

Available on crate feature std only.

fn deserialize<D>( deserializer: D, ) -> Result<SignedMessage<T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for SignedMessage<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T> Encode for SignedMessage<T>

where T: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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> EncodeLike for SignedMessage<T>

where T: Encode,

impl<T> Eq for SignedMessage<T>

where T: Eq,

impl From<SignedMessage<Receipt<CompactPromise>>> for SignedCompactTxReceipt

fn from(value: SignedMessage<Receipt<CompactPromise>>) -> Self

Converts to this type from the input type.

impl From<SignedMessage<Receipt<Promise>>> for SignedTxReceipt

fn from(value: SignedMessage<Receipt<Promise>>) -> Self

Converts to this type from the input type.

impl<T> Hash for SignedMessage<T>

where T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> MaxEncodedLen for SignedMessage<T>

where T: MaxEncodedLen,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T> PartialEq for SignedMessage<T>

where T: PartialEq,

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

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for SignedMessage<T>

where T: PartialEq,

impl<T> TypeInfo for SignedMessage<T>

where T: TypeInfo + 'static,

type Identity = SignedMessage<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.