Struct massa_models::operation::Operation

pub struct Operation {
    pub fee: Amount,
    pub expire_period: u64,
    pub op: OperationType,
}

the operation as sent in the network

Fields

fee: Amount

the fee they have decided for this operation

expire_period: u64

after expire_period slot the operation won’t be included in a block

op: OperationType

the type specific operation part

Trait Implementations

impl Clone for Operation

fn clone(&self) -> Operation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Operation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Operation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<Operation> for OperationDeserializer

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

Example:

use massa_models::{amount::Amount, address::Address, operation::{OperationType, OperationSerializer, Operation, OperationDeserializer}};
use massa_signature::KeyPair;
use massa_serialization::{Serializer, Deserializer, DeserializeError};
use std::str::FromStr;

let keypair = KeyPair::generate(0).unwrap();
let op = OperationType::Transaction {
   recipient_address: Address::from_public_key(&keypair.get_public_key()),
   amount: Amount::from_str("300").unwrap(),
};
let operation = Operation {
  fee: Amount::from_str("20").unwrap(),
  op,
  expire_period: 50,
};
let mut buffer = Vec::new();
OperationSerializer::new().serialize(&operation, &mut buffer).unwrap();
let (rest, deserialized_operation) = OperationDeserializer::new(10000, 10000, 10000, 100, 255, 10_000).deserialize::<DeserializeError>(&buffer).unwrap();
assert_eq!(rest.len(), 0);
assert_eq!(deserialized_operation.fee, operation.fee);
assert_eq!(deserialized_operation.expire_period, operation.expire_period);
match deserialized_operation.op {
  OperationType::Transaction {
    recipient_address,
    amount,
  } => {
    assert_eq!(recipient_address, Address::from_public_key(&keypair.get_public_key()));
    assert_eq!(amount, Amount::from_str("300").unwrap());
  }
  _ => panic!("wrong operation type"),
};

impl Display for Operation

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

Formats the value using the given formatter.

impl From<Operation> for Operation

fn from(op: Operation) -> Self

Converts to this type from the input type.

impl SecureShareContent for Operation

fn compute_hash( &self, content_serialized: &[u8], content_creator_pub_key: &PublicKey, chain_id: u64, ) -> Hash

Compute hash

fn sign( &self, keypair: &KeyPair, content_hash: &Hash, ) -> Result<Signature, ModelsError>

Sign the SecureShare given the content

fn verify_signature( &self, public_key: &PublicKey, content_hash: &Hash, signature: &Signature, ) -> Result<(), ModelsError>

verify signature

fn new_verifiable<Ser: Serializer<Self>, ID: Id>( self, content_serializer: Ser, keypair: &KeyPair, chain_id: u64, ) -> Result<SecureShare<Self, ID>, ModelsError>

Using the provided key-pair, applies a cryptographic signature, and packages the data required to share and verify the data in a trust-free network of peers.

fn compute_signed_hash( &self, _public_key: &PublicKey, content_hash: &Hash, ) -> Hash

Compute hash used for signature

fn serialize( signature: &Signature, creator_public_key: &PublicKey, serialized_content: &[u8], buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

Serialize the secured structure

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>, Deser: Deserializer<Self>, ID: Id>( content_serializer: Option<&dyn Serializer<Self>>, signature_deserializer: &SignatureDeserializer, creator_public_key_deserializer: &PublicKeyDeserializer, content_deserializer: &Deser, buffer: &'a [u8], chain_id: u64, ) -> IResult<&'a [u8], SecureShare<Self, ID>, E>

Deserialize the secured structure

impl Serialize for Operation

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<Operation> for OperationSerializer

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

Example:

use massa_models::{amount::Amount, address::Address, operation::{OperationType, OperationSerializer, Operation}};
use massa_signature::KeyPair;
use massa_serialization::Serializer;
use std::str::FromStr;

let keypair = KeyPair::generate(0).unwrap();
let op = OperationType::Transaction {
   recipient_address: Address::from_public_key(&keypair.get_public_key()),
   amount: Amount::from_str("300").unwrap(),
};
let operation = Operation {
  fee: Amount::from_str("20").unwrap(),
  op,
  expire_period: 50,
};
let mut buffer = Vec::new();
OperationSerializer::new().serialize(&operation, &mut buffer).unwrap();