Enum massa_signature::PublicKey

pub enum PublicKey {
    PublicKeyV0(PublicKeyV0),
}

Public key used to check if a message was encoded by the corresponding PublicKey. Generated from the KeyPair using SignatureEngine

Variants

PublicKeyV0(PublicKeyV0)

Implementations

impl PublicKey

pub fn verify_signature( &self, hash: &Hash, signature: &Signature, ) -> Result<(), MassaSignatureError>

Checks if the Signature associated with data bytes was produced with the KeyPair associated to given PublicKey

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

Serialize a PublicKey as bytes.

Example

let keypair = KeyPair::generate(0).unwrap();

let serialize = keypair.get_public_key().to_bytes();

pub fn get_ser_len(&self) -> usize

Return the total length after serialization

pub fn from_bytes(data: &[u8]) -> Result<PublicKey, MassaSignatureError>

Deserialize a PublicKey from bytes.

Example

let keypair = KeyPair::generate(0).unwrap();

let serialized = keypair.get_public_key().to_bytes();
let deserialized: PublicKey = PublicKey::from_bytes(&serialized).unwrap();

Trait Implementations

impl Clone for PublicKey

fn clone(&self) -> PublicKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PublicKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PublicKey

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<PublicKey, D::Error>

::serde::Deserialize trait for PublicKey if the deserializer is human readable, deserialization is done using deserialize_bs58_check else, it uses deserialize_binary

Example

Human readable deserialization :

let keypair = KeyPair::generate(0).unwrap();

let serialized = serde_json::to_string(&keypair.get_public_key()).unwrap();
let deserialized: PublicKey = serde_json::from_str(&serialized).unwrap();

impl Deserializer<PublicKey> for PublicKeyDeserializer

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

use massa_signature::{PublicKey, PublicKeyDeserializer, KeyPair};
use massa_serialization::{DeserializeError, Deserializer};
use massa_hash::Hash;

let keypair = KeyPair::generate(0).unwrap();
let public_key = keypair.get_public_key();
let serialized = public_key.to_bytes();
let (rest, deser_public_key) = PublicKeyDeserializer::new().deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(keypair.get_public_key(), deser_public_key);

impl Display for PublicKey

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

Formats the value using the given formatter.

impl FromStr for PublicKey

fn from_str(s: &str) -> Result<Self, Self::Err>

Example

let pubkey = KeyPair::generate(0).unwrap().get_public_key();
let string = pubkey.to_string();
let pubkey_2 = PublicKey::from_str(&string).unwrap();
assert_eq!(pubkey.to_string(), pubkey_2.to_string());

type Err = MassaSignatureError

The associated error which can be returned from parsing.

impl Hash for PublicKey

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 Ord for PublicKey

fn cmp(&self, other: &PublicKey) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for PublicKey

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

fn partial_cmp(&self, other: &PublicKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for PublicKey

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

::serde::Serialize trait for PublicKey if the serializer is human readable, serialization is done using serialize_bs58_check else, it uses serialize_binary

Example

Human readable serialization :

let keypair = KeyPair::generate(0).unwrap();
let serialized: String = serde_json::to_string(&keypair.get_public_key()).unwrap();

impl Copy for PublicKey

impl Eq for PublicKey

impl StructuralPartialEq for PublicKey