Struct ripple_keypairs::Seed

pub struct Seed { /* fields omitted */ }

A seed that can be used to generate keypairs

Examples

Generate a new seed

use ripple_keypairs::{Seed, Entropy, Algorithm};

let seed = Seed::new(Entropy::Random, &Algorithm::Secp256k1);

assert!(seed.to_string().starts_with("s"));

Implementations

impl Seed

pub fn new(entropy: Entropy, kind: &'static Algorithm) -> Self

Generate a new seed

Examples

use ripple_keypairs::{Seed, Entropy, Algorithm};

let seed_secp256k1 = Seed::new(Entropy::Random, &Algorithm::Secp256k1);

assert!(seed_secp256k1.to_string().starts_with("s"));
assert_eq!(seed_secp256k1.as_kind(), &Algorithm::Secp256k1);

let seed_ed25519 = Seed::new(Entropy::Random, &Algorithm::Ed25519);

assert!(seed_ed25519.to_string().starts_with("s"));
assert_eq!(seed_ed25519.as_kind(), &Algorithm::Ed25519);

Panics

Panics only if something goes wrong with the random generator when using the Entropy::Random parameter.

pub fn random() -> Self

Generate a random seed

The algorithm defaults to Secp256k1.

Examples

use ripple_keypairs::{Seed, Algorithm};

let seed = Seed::random();

assert_eq!(seed.as_kind(), &Algorithm::Secp256k1);
assert_ne!(Seed::random(), Seed::random());

pub fn derive_keypair(&self) -> Result<(PrivateKey, PublicKey)>

Derive a public and private key from a seed

Examples

use ripple_keypairs::Seed;

let seed = Seed::random();
let (private_key, public_key) = seed.derive_keypair()?;
let msg = "Test message";

assert_eq!(public_key.verify(&msg, &private_key.sign(&msg)), Ok(()));

Errors

May return error::DeriveKeyPairError if the derived keypair did not generate a verifiable signature

pub fn as_entropy(&self) -> &EntropyArray

Seed as EntropyArray

Examples

use ripple_keypairs::{Seed, Entropy, Algorithm, EntropyArray};

let seed = Seed::new(Entropy::Array([0; 16]), &Algorithm::Secp256k1);

assert_eq!(seed.as_entropy(), &[0; 16]);
assert_eq!(seed.as_entropy(), <Seed as AsRef<EntropyArray>>::as_ref(&seed));

Traits

This method is used in AsRef trait.

pub fn as_kind(&self) -> &Algorithm

Seed as Algorithm

Examples

use ripple_keypairs::{Seed, Entropy, Algorithm};

let seed = Seed::new(Entropy::Random, &Algorithm::Ed25519);

assert_eq!(seed.as_kind(), &Algorithm::Ed25519);
assert_eq!(seed.as_kind(), <Seed as AsRef<Algorithm>>::as_ref(&seed));

Traits

This method is used in AsRef trait.

Trait Implementations

impl AsRef<[u8; 16]> for Seed

fn as_ref(&self) -> &EntropyArray

Performs the conversion.

impl AsRef<Algorithm> for Seed

fn as_ref(&self) -> &Algorithm

Performs the conversion.

impl Clone for Seed

fn clone(&self) -> Seed

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Seed

impl Debug for Seed

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

Formats the value using the given formatter.

impl Display for Seed

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

Formats the value using the given formatter.

impl Eq for Seed

impl FromStr for Seed

type Err = Error

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for Seed

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Seed> for Seed

fn eq(&self, other: &Seed) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Seed) -> bool

This method tests for !=.

impl StructuralEq for Seed

impl StructuralPartialEq for Seed