Enum massa_signature::signature_impl::Signature

pub enum Signature {
    SignatureV0(SignatureV0),
}

Signature generated from a message and a KeyPair.

Variants

SignatureV0(SignatureV0)

Implementations

impl Signature

pub fn to_bs58_check(&self) -> String

Serialize a Signature using bs58 encoding with checksum.

Example

let keypair = KeyPair::generate(0).unwrap();
let data = Hash::compute_from("Hello World!".as_bytes());
let signature = keypair.sign(&data).unwrap();

let serialized: String = signature.to_bs58_check();

pub fn from_bs58_check(data: &str) -> Result<Signature, MassaSignatureError>

Deserialize a Signature using bs58 encoding with checksum.

Example

let keypair = KeyPair::generate(0).unwrap();
let data = Hash::compute_from("Hello World!".as_bytes());
let signature = keypair.sign(&data).unwrap();

let serialized: String = signature.to_bs58_check();
let deserialized: Signature = Signature::from_bs58_check(&serialized).unwrap();

pub fn get_ser_len(&self) -> usize

Return the total length after serialization

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

Serialize a Signature into bytes.

Example

let keypair = KeyPair::generate(0).unwrap();
let data = Hash::compute_from("Hello World!".as_bytes());
let signature = keypair.sign(&data).unwrap();

let serialized = signature.to_bytes();

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

Deserialize a Signature from bytes.

Example

let keypair = KeyPair::generate(0).unwrap();
let data = Hash::compute_from("Hello World!".as_bytes());
let signature = keypair.sign(&data).unwrap();

let serialized = signature.to_bytes();
let deserialized: Signature = Signature::from_bytes(&serialized).unwrap();

Trait Implementations

impl Clone for Signature

fn clone(&self) -> Signature

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Signature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Signature

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

::serde::Deserialize trait for Signature if the deserializer is human readable, deserialization is done using from_bs58_check else, it uses from_bytes

Example

Human readable deserialization :

let keypair = KeyPair::generate(0).unwrap();
let data = Hash::compute_from("Hello World!".as_bytes());
let signature = keypair.sign(&data).unwrap();

let serialized = serde_json::to_string(&signature).unwrap();
let deserialized: Signature = serde_json::from_str(&serialized).unwrap();

impl Deserializer<Signature> for SignatureDeserializer

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

use massa_signature::{Signature, SignatureDeserializer, KeyPair};
use massa_serialization::{DeserializeError, Deserializer};
use massa_hash::Hash;

let keypair = KeyPair::generate(0).unwrap();
let data = Hash::compute_from("Hello World!".as_bytes());
let signature = keypair.sign(&data).unwrap();
let serialized = signature.to_bytes();
let (rest, deser_signature) = SignatureDeserializer::new().deserialize::<DeserializeError>(&serialized).unwrap();
assert!(rest.is_empty());
assert_eq!(signature, deser_signature);

impl Display for Signature

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

Formats the value using the given formatter.

impl FromStr for Signature

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

Example

let hash = Hash::compute_from("Hello World!".as_bytes());
let signature = KeyPair::generate(0).unwrap().sign(&hash).unwrap();
let string = signature.to_string();
let signature_2 = Signature::from_str(&string).unwrap();
assert_eq!(signature, signature_2);

type Err = MassaSignatureError

The associated error which can be returned from parsing.

impl PartialEq for Signature

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

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

::serde::Serialize trait for Signature if the serializer is human readable, serialization is done using to_bs58_check else, it uses to_bytes

Example

Human readable serialization :

let keypair = KeyPair::generate(0).unwrap();
let data = Hash::compute_from("Hello World!".as_bytes());
let signature = keypair.sign(&data).unwrap();

let serialized: String = serde_json::to_string(&signature).unwrap();

impl Copy for Signature

impl Eq for Signature

impl StructuralPartialEq for Signature