Enum massa_models::operation::OperationType

pub enum OperationType {
    Transaction {
        recipient_address: Address,
        amount: Amount,
    },
    RollBuy {
        roll_count: u64,
    },
    RollSell {
        roll_count: u64,
    },
    ExecuteSC {
        data: Vec<u8>,
        max_gas: u64,
        max_coins: Amount,
        datastore: Datastore,
    },
    CallSC {
        target_addr: Address,
        target_func: String,
        param: Vec<u8>,
        max_gas: u64,
        coins: Amount,
    },
}

Type specific operation content

Variants

Transaction

transfer coins from sender to recipient

Fields

recipient_address: Address

recipient address

amount: Amount

amount

RollBuy

the sender buys roll_count rolls. Roll price is defined in configuration

Fields

roll_count: u64

roll count

RollSell

the sender sells roll_count rolls. Roll price is defined in configuration

Fields

roll_count: u64

roll count

ExecuteSC

Execute a smart contract.

Fields

data: Vec<u8>

Smart contract bytecode.

max_gas: u64

The maximum amount of gas that the execution of the contract is allowed to cost.

max_coins: Amount

Max amount of coins allowed to be spent by the execution

datastore: Datastore

A key-value store associating a hash to arbitrary bytes

CallSC

Calls an exported function from a stored smart contract

Fields

target_addr: Address

Target smart contract address

target_func: String

Target function name. No function is called if empty.

param: Vec<u8>

Parameter to pass to the target function

max_gas: u64

The maximum amount of gas that the execution of the contract is allowed to cost.

coins: Amount

Extra coins that are spent from the caller’s balance and transferred to the target

Trait Implementations

impl Clone for OperationType

fn clone(&self) -> OperationType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OperationType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OperationType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<OperationType> for OperationTypeDeserializer

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

Example:

use std::collections::BTreeMap;
use massa_models::{operation::{OperationTypeSerializer, OperationTypeDeserializer, OperationType}, address::Address, amount::Amount};
use massa_signature::KeyPair;
use massa_serialization::{Deserializer, Serializer, DeserializeError};
use std::str::FromStr;

let keypair = KeyPair::generate(0).unwrap();
let op = OperationType::ExecuteSC {
   data: vec![0x01, 0x02, 0x03],
   max_gas: 100,
   max_coins: Amount::from_str("5000000").unwrap(),
   datastore: BTreeMap::from([(vec![1, 2], vec![254, 255])])
};
let mut buffer = Vec::new();
OperationTypeSerializer::new().serialize(&op, &mut buffer).unwrap();
let (rest, op_deserialized) = OperationTypeDeserializer::new(10000, 10000, 10000, 10, 255, 10_000).deserialize::<DeserializeError>(&buffer).unwrap();
assert_eq!(rest.len(), 0);
match op_deserialized {
   OperationType::ExecuteSC {
     data,
     max_gas,
     max_coins,
     datastore
  } => {
    assert_eq!(data, vec![0x01, 0x02, 0x03]);
    assert_eq!(max_gas, 100);
    assert_eq!(max_coins, Amount::from_str("5000000").unwrap());
    assert_eq!(datastore, BTreeMap::from([(vec![1, 2], vec![254, 255])]))
  }
  _ => panic!("Unexpected operation type"),
};

impl Display for OperationType

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

Formats the value using the given formatter.

impl From<OperationType> for OpType

fn from(value: OperationType) -> Self

Converts to this type from the input type.

impl From<OperationType> for OperationType

fn from(operation_type: OperationType) -> OperationType

Converts to this type from the input type.

impl PartialEq for OperationType

fn eq(&self, other: &OperationType) -> 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 OperationType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<OperationType> for OperationTypeSerializer

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

Example:

use std::collections::BTreeMap;
use massa_models::{operation::{OperationTypeSerializer, OperationTypeDeserializer,OperationType}, address::Address, amount::Amount};
use massa_signature::KeyPair;
use massa_serialization::{Deserializer, Serializer, DeserializeError};
use std::str::FromStr;

let keypair = KeyPair::generate(0).unwrap();
let op = OperationType::ExecuteSC {
   data: vec![0x01, 0x02, 0x03],
   max_gas: 100,
   max_coins: Amount::from_str("5000000").unwrap(),
   datastore: BTreeMap::default(),
};
let mut buffer = Vec::new();
OperationTypeSerializer::new().serialize(&op, &mut buffer).unwrap();

impl StructuralPartialEq for OperationType