Struct massa_ledger_exports::Key

pub struct Key {
    pub key_type: KeyType,
    pub address: Address,
}

Disk ledger keys representation

Fields

key_type: KeyType

address: Address

Implementations

impl Key

pub fn new(address: &Address, key_type: KeyType) -> Self

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Key

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

Formats the value using the given formatter.

impl Deserializer<Key> for KeyDeserializer

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

Example

use massa_models::address::Address;
use massa_ledger_exports::{KeyDeserializer, KeySerializer, DATASTORE_IDENT, BALANCE_IDENT, KeyType, Key};
use massa_serialization::{Deserializer, Serializer, DeserializeError};
use massa_hash::Hash;
use std::str::FromStr;

let address = Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap();
let store_key = Hash::compute_from(b"test");

let mut key = Key::new(&address, KeyType::DATASTORE(store_key.into_bytes().to_vec()));
let mut serialized = Vec::new();
KeySerializer::new(true).serialize(&key, &mut serialized).unwrap();
let (rest, key_deser) = KeyDeserializer::new(255, true).deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(key_deser, key);

let mut key = Key::new(&address, KeyType::BALANCE);
let mut serialized = Vec::new();
KeySerializer::new(true).serialize(&key, &mut serialized).unwrap();
let (rest, key_deser) = KeyDeserializer::new(255, true).deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(key_deser, key);

impl PartialEq for Key

fn eq(&self, other: &Key) -> 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 Serializer<Key> for KeySerializer

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

use massa_models::address::Address;
use massa_ledger_exports::{KeySerializer, KeyType, Key};
use massa_serialization::Serializer;
use massa_hash::Hash;
use std::str::FromStr;

let mut serialized = Vec::new();
let address = Address::from_str("AU12dG5xP1RDEB5ocdHkymNVvvSJmUL9BgHwCksDowqmGWxfpm93x").unwrap();
let store_key = Hash::compute_from(b"test");
let mut key = Key::new(&address, KeyType::DATASTORE(store_key.into_bytes().to_vec()));
KeySerializer::new(true).serialize(&key, &mut serialized).unwrap();

impl Eq for Key

impl StructuralPartialEq for Key