Trait iota_signing_preview::PrivateKeyGenerator

pub trait PrivateKeyGenerator {
    type Seed: Seed;
    type PrivateKey: PrivateKey;
    type Error;
    fn generate(
        &self, 
        seed: &Self::Seed, 
        index: u64
    ) -> Result<Self::PrivateKey, Self::Error>;
}

Associated Types

type Seed: Seed

type PrivateKey: PrivateKey

The type of the generated private keys

type Error

Loading content...

Required methods

fn generate(
    &self,
    seed: &Self::Seed,
    index: u64
) -> Result<Self::PrivateKey, Self::Error>

Deterministically generates and returns a private key

Arguments

• seed A seed to deterministically derive a private key from
• index An index to deterministically derive a private key from

Example

use iota_crypto_preview::Kerl;
use iota_signing_preview::{
    IotaSeed,
    PrivateKeyGenerator,
    Seed,
    WotsPrivateKeyGeneratorBuilder,
    WotsSecurityLevel,
};

let seed = IotaSeed::<Kerl>::new();
let private_key_generator = WotsPrivateKeyGeneratorBuilder::<Kerl>::default()
    .security_level(WotsSecurityLevel::Medium)
    .build()
    .unwrap();
let private_key = private_key_generator.generate(&seed, 0);

Loading content...

Implementors

impl<S, G> PrivateKeyGenerator for MssPrivateKeyGenerator<S, G> where
    S: Sponge + Default,
    G: PrivateKeyGenerator,
    <<<G as PrivateKeyGenerator>::PrivateKey as PrivateKey>::PublicKey as PublicKey>::Signature: RecoverableSignature, 

type Seed = G::Seed

type PrivateKey = MssPrivateKey<S, G::PrivateKey>

type Error = MssError

fn generate(
    &self,
    seed: &Self::Seed,
    _: u64
) -> Result<Self::PrivateKey, Self::Error>

impl<S: Sponge + Default> PrivateKeyGenerator for WotsPrivateKeyGenerator<S>

type Seed = IotaSeed<S>

type PrivateKey = WotsPrivateKey<S>

type Error = WotsError

fn generate(
    &self,
    seed: &Self::Seed,
    index: u64
) -> Result<Self::PrivateKey, Self::Error>

Loading content...