Struct massa_models::async_msg::AsyncMessage

pub struct AsyncMessage {

    pub emission_slot: Slot,
    pub emission_index: u64,
    pub sender: Address,
    pub destination: Address,
    pub function: String,
    pub max_gas: u64,
    pub fee: Amount,
    pub coins: Amount,
    pub validity_start: Slot,
    pub validity_end: Slot,
    pub function_params: Vec<u8>,
    pub trigger: Option<AsyncMessageTrigger>,
    pub can_be_executed: bool,
}

Structure defining an asynchronous smart contract message

Fields

emission_slot: Slot

Slot at which the message was emitted

emission_index: u64

Index of the emitted message within the emission_slot. This is used for disambiguate the emission of multiple messages at the same slot.

sender: Address

The address that sent the message

destination: Address

The address towards which the message is being sent

function: String

the function function name within the destination address’ bytecode

max_gas: u64

Maximum gas to use when processing the message

fee: Amount

Fee paid by the sender when the message is processed.

coins: Amount

Coins sent from the sender to the target address of the message. Those coins are spent by the sender address when the message is sent, and credited to the destination address when receiving the message. In case of failure or discard, those coins are reimbursed to the sender.

validity_start: Slot

Slot at which the message starts being valid (bound included in the validity range)

validity_end: Slot

Slot at which the message stops being valid (bound not included in the validity range)

function_params: Vec<u8>

Raw payload parameters to call the function with

trigger: Option<AsyncMessageTrigger>

Trigger that define whenever a message can be executed

can_be_executed: bool

Boolean that determine if the message can be executed. For messages without filter this boolean is always true. For messages with filter, this boolean is true if the filter has been matched between validity_start and current slot.

Implementations

impl AsyncMessage

pub fn new( emission_slot: Slot, emission_index: u64, sender: Address, destination: Address, function: String, max_gas: u64, fee: Amount, coins: Amount, validity_start: Slot, validity_end: Slot, function_params: Vec<u8>, trigger: Option<AsyncMessageTrigger>, can_be_executed: Option<bool>, ) -> Self

Take an AsyncMessage and return it

pub fn compute_id(&self) -> AsyncMessageId

Compute the ID of the message for use when choosing which operations to keep in priority (highest score) on pool overflow.

Trait Implementations

impl Applicable<AsyncMessageUpdate> for AsyncMessage

fn apply(&mut self, update: AsyncMessageUpdate)

extends the AsyncMessage with a AsyncMessageUpdate

impl Clone for AsyncMessage

fn clone(&self) -> AsyncMessage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AsyncMessage

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

Formats the value using the given formatter.

impl Default for AsyncMessage

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AsyncMessage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<AsyncMessage> for AsyncMessageDeserializer

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>( &self, buffer: &'a [u8], ) -> IResult<&'a [u8], AsyncMessage, E>

Example

use massa_models::{address::Address, amount::Amount, slot::Slot, async_msg::{AsyncMessage, AsyncMessageSerializer, AsyncMessageDeserializer, AsyncMessageTrigger}};
use massa_serialization::{Serializer, Deserializer, DeserializeError};
use std::str::FromStr;

let message = AsyncMessage::new(
    Slot::new(1, 0),
    0,
    Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap(),
    Address::from_str("AS12htxRWiEm8jDJpJptr6cwEhWNcCSFWstN1MLSa96DDkVM9Y42G").unwrap(),
    String::from("test"),
    10000000,
    Amount::from_str("1").unwrap(),
    Amount::from_str("1").unwrap(),
    Slot::new(2, 0),
    Slot::new(3, 0),
    vec![1, 2, 3, 4],
    Some(AsyncMessageTrigger {
       address: Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap(),
       datastore_key: Some(vec![1, 2, 3, 4]),
    }),
    None,
);
let message_serializer = AsyncMessageSerializer::new(false);
let mut serialized = Vec::new();
message_serializer.serialize(&message, &mut serialized).unwrap();
let message_deserializer = AsyncMessageDeserializer::new(32, 10000, 100000, 255, false);
// dbg!(&serialized);
let (rest, message_deserialized) = message_deserializer.deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(message, message_deserialized);

impl From<AsyncMessage> for AsyncMessage

fn from(value: AsyncMessage) -> Self

Converts to this type from the input type.

impl PartialEq for AsyncMessage

fn eq(&self, other: &AsyncMessage) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AsyncMessage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<AsyncMessage> for AsyncMessageSerializer

fn serialize( &self, value: &AsyncMessage, buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

Example

use massa_models::{address::Address, amount::Amount, slot::Slot, async_msg::{AsyncMessage, AsyncMessageSerializer, AsyncMessageTrigger}};
use massa_serialization::Serializer;
use std::str::FromStr;

let message = AsyncMessage::new(
    Slot::new(1, 0),
    0,
    Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap(),
    Address::from_str("AU12htxRWiEm8jDJpJptr6cwEhWNcCSFWstN1MLSa96DDkVM9Y42G").unwrap(),
    String::from("test"),
    10000000,
    Amount::from_str("1").unwrap(),
    Amount::from_str("1").unwrap(),
    Slot::new(2, 0),
    Slot::new(3, 0),
    vec![1, 2, 3, 4],
    Some(AsyncMessageTrigger {
        address: Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap(),
        datastore_key: Some(vec![1, 2, 3, 4])
    }),
    None,
);
let mut buffer = Vec::new();
let message_serializer = AsyncMessageSerializer::new(false);
message_serializer.serialize(&message, &mut buffer).unwrap();

impl Eq for AsyncMessage

impl StructuralPartialEq for AsyncMessage