Struct Message

pub struct Message<Specification>
where
    Specification: MessageSpecification,
{
    pub sender: Address,
    pub recipient: Address,
    pub amount: Word,
    pub nonce: Nonce,
    pub witness_index: Specification::Witness,
    pub predicate_gas_used: Specification::PredicateGasUsed,
    pub data: Specification::Data,
    pub predicate: Specification::Predicate,
    pub predicate_data: Specification::PredicateData,
}

It is a full representation of the message from the specification: https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputmessage.

The specification defines the layout of the Message in the serialized form for the fuel-vm. But on the business logic level, we don’t use all fields at the same time. It is why in the super::Input the message is represented by several forms based on the usage context. Leaving some fields empty reduces the memory consumption by the structure and erases the empty useless fields.

The MessageSpecification trait specifies the sub-messages for the corresponding usage context. It allows us to write the common logic of all sub-messages without the overhead and duplication.

Sub-messages from specifications:

• specifications::MessageData with specifications::Signed usage rules.
• specifications::MessageData with specifications::Predicate usage rules.
• specifications::Full.

Fields

sender: Address

The sender from the L1 chain.

recipient: Address

The receiver on the Fuel chain.

amount: Word

nonce: Nonce

witness_index: Specification::Witness

predicate_gas_used: Specification::PredicateGasUsed

Exact amount of gas used by the predicate. If the predicate consumes different amount of gas, it’s considered to be false.

data: Specification::Data

predicate: Specification::Predicate

predicate_data: Specification::PredicateData

Implementations

impl<Specification> Message<Specification>

where Specification: MessageSpecification,

pub fn prepare_sign(&mut self)

pub fn message_id(&self) -> MessageId

impl Message<Full>

pub fn into_message_data_signed(self) -> MessageDataSigned

pub fn into_message_data_predicate(self) -> MessageDataPredicate

pub fn into_coin_signed(self) -> MessageCoinSigned

pub fn into_coin_predicate(self) -> MessageCoinPredicate

impl Message<MessageCoin<Signed>>

pub fn into_full(self) -> FullMessage

impl Message<MessageCoin<Predicate>>

pub fn into_full(self) -> FullMessage

impl Message<MessageData<Predicate>>

pub fn into_full(self) -> FullMessage

impl Message<MessageData<Signed>>

pub fn into_full(self) -> FullMessage

Trait Implementations

impl<Specification> Clone for Message<Specification>

where Specification: MessageSpecification + Clone, Specification::Witness: Clone, Specification::PredicateGasUsed: Clone, Specification::Data: Clone, Specification::Predicate: Clone, Specification::PredicateData: Clone,

fn clone(&self) -> Message<Specification>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Specification> Debug for Message<Specification>

where Specification: MessageSpecification,

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

Formats the value using the given formatter.

impl<Specification> Default for Message<Specification>

where Specification: MessageSpecification + Default, Specification::Witness: Default, Specification::PredicateGasUsed: Default, Specification::Data: Default, Specification::Predicate: Default, Specification::PredicateData: Default,

fn default() -> Message<Specification>

Returns the “default value” for a type.

impl<'de, Specification> Deserialize<'de> for Message<Specification>

where Specification: MessageSpecification, Specification::Witness: Deserialize<'de>, Specification::PredicateGasUsed: Deserialize<'de>, Specification::Data: Deserialize<'de>, Specification::Predicate: Deserialize<'de>, Specification::PredicateData: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Specification> Deserialize for Message<Specification>

where Specification: MessageSpecification, Specification::Witness: Deserialize, Specification::PredicateGasUsed: Deserialize, Specification::Data: Deserialize, Specification::Predicate: Deserialize, Specification::PredicateData: Deserialize,

fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error>

Decodes static part of Self from the buffer.

fn decode_dynamic<I: Input + ?Sized>( &mut self, buffer: &mut I, ) -> Result<(), Error>

Decodes dynamic part of the information from the buffer to fill Self. The default implementation does nothing. Dynamically-sized contains should override this.

fn decode<I>(buffer: &mut I) -> Result<Self, Error>

where I: Input + ?Sized,

Decodes Self from the buffer.

fn from_bytes(buffer: &[u8]) -> Result<Self, Error>

Helper method for deserializing Self from bytes.

impl<Specification> Hash for Message<Specification>

where Specification: MessageSpecification + Hash, Specification::Witness: Hash, Specification::PredicateGasUsed: Hash, Specification::Data: Hash, Specification::Predicate: Hash, Specification::PredicateData: Hash,

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

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<Specification> PartialEq for Message<Specification>

where Specification: MessageSpecification + PartialEq, Specification::Witness: PartialEq, Specification::PredicateGasUsed: PartialEq, Specification::Data: PartialEq, Specification::Predicate: PartialEq, Specification::PredicateData: PartialEq,

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

where Specification: MessageSpecification, Specification::Witness: Serialize, Specification::PredicateGasUsed: Serialize, Specification::Data: Serialize, Specification::Predicate: Serialize, Specification::PredicateData: Serialize,

fn size_static(&self) -> usize

Size of the static part of the serialized object, in bytes. Saturates to usize::MAX on overflow.

fn size_dynamic(&self) -> usize

Size of the dynamic part, in bytes. Saturates to usize::MAX on overflow.

fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error>

Encodes staticly-sized part of Self.

fn encode_dynamic<O: Output + ?Sized>( &self, buffer: &mut O, ) -> Result<(), Error>

Encodes dynamically-sized part of Self. The default implementation does nothing. Dynamically-sized contains should override this.

fn size(&self) -> usize

Total size of the serialized object, in bytes. Saturates to usize::MAX on overflow.

fn encode<O>(&self, buffer: &mut O) -> Result<(), Error>

where O: Output + ?Sized,

Encodes Self into the buffer.

fn to_bytes(&self) -> Vec<u8>

Encodes Self into bytes vector. Required known size.

impl<Specification> Serialize for Message<Specification>

where Specification: MessageSpecification, Specification::Witness: Serialize, Specification::PredicateGasUsed: Serialize, Specification::Data: Serialize, Specification::Predicate: Serialize, Specification::PredicateData: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Specification> Eq for Message<Specification>

where Specification: MessageSpecification + Eq, Specification::Witness: Eq, Specification::PredicateGasUsed: Eq, Specification::Data: Eq, Specification::Predicate: Eq, Specification::PredicateData: Eq,

impl<Specification> StructuralPartialEq for Message<Specification>

where Specification: MessageSpecification,