Struct jormungandr_lib::crypto::key::SigningKey

pub struct SigningKey<A: AsymmetricKey>(pub(crate) SecretKey<A>);

A cryptographic signing key (or secret key). Can be used to sign transaction, certificates or blocks.

A Signing key is always associated with its Identifier which can be extracted from the SigningKey.

More info at the module documentation

Tuple Fields

0: SecretKey<A>

Implementations

impl<A: SigningAlgorithm> SigningKey<A>where <A as AsymmetricKey>::PubAlg: VerificationAlgorithm,

pub fn sign<T: AsRef<[u8]>>( &self, object: &T ) -> Signature<T, <A as AsymmetricKey>::PubAlg>

impl<A: AsymmetricKey> SigningKey<A>

pub fn into_secret_key(self) -> SecretKey<A>

pub fn generate<RNG>(rng: RNG) -> Selfwhere RNG: RngCore + CryptoRng,

generate a new signing key

pub fn identifier(&self) -> Identifier<<A as AsymmetricKey>::PubAlg>

get the identifier associated to this key.

impl<A> SigningKey<A>where A: AsymmetricKey, SecretKey<A>: Bech32,

pub fn to_bech32_str(&self) -> String

encode the SigningKey into a bech32 string.

This is a human readable encoding that allows to check input validation. When displaying this signing key to the user it is preferable to provide the output of this function.

Serde implementation of SigningKey provides the bech32 string support.

Example

let key : SigningKey<Ed25519> = SigningKey::generate(thread_rng());

println!("key: {}", key.to_bech32_str());

pub fn from_bech32_str(s: &str) -> Result<Self, Error>

try to decode the given bech32 string into a valid signing key

Trait Implementations

impl<A: AsymmetricKey> AsRef<SecretKey<A>> for SigningKey<A>

fn as_ref(&self) -> &SecretKey<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: AsymmetricKey> Clone for SigningKey<A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: AsymmetricKey> Debug for SigningKey<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for SigningKey<A>where A: AsymmetricKey, SecretKey<A>: Bech32,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: AsymmetricKey> From<SecretKey<A>> for SigningKey<A>

fn from(key: SecretKey<A>) -> Self

Converts to this type from the input type.

impl<A: AsymmetricKey> From<SigningKey<A>> for SecretKey<A>

fn from(key: SigningKey<A>) -> Self

Converts to this type from the input type.

impl<A> Serialize for SigningKey<A>where A: AsymmetricKey, SecretKey<A>: Bech32,

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

Serialize this value into the given Serde serializer.