Struct iop_keyvault::ed25519::Ed25519

pub struct Ed25519;

This elliptic curve cryptography implements both the AsymmetricCrypto and KeyDerivationCrypto traits so it can be used in EcDSA, Cardano and of course, Mopheus/Prometheus/Mercury.

Trait Implementations

impl AsymmetricCrypto for Ed25519

type KeyId = EdKeyId

The ID (also called fingerprint or address in some literature) of the public key. See PublicKey::key_id for more details.

type PublicKey = EdPublicKey

See PublicKey for more details.

type PrivateKey = EdPrivateKey

See PrivateKey for more details.

type Signature = EdSignature

The signature of a given message with a given private key. Its size and representation is up to the implementation.

impl Clone for Ed25519

fn clone(&self) -> Ed25519

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ed25519

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

Formats the value using the given formatter.

impl ExtendedPrivateKey<Ed25519> for EdExtPrivateKey

fn derive_normal_child(&self, _idx: i32) -> Result<EdExtPrivateKey>

Normal derivation allows the neutered extended public key to calculate child extended public keys without revealing any private keys.

fn derive_hardened_child(&self, idx: i32) -> Result<EdExtPrivateKey>

There is a potential vulnerability in that might affect all SLIP-0010 compatible Ed25519 wallets. We should never assume that there is only 1 public key that can verify a given signature. Actually, there are 8 public keys.

fn neuter(&self) -> EdPublicKey

Neutering an extended private key gives an extended public key that contains the private key neutered, plus the chain code. It is useless to reveal the chain code when hardened derivation is used.

fn private_key(&self) -> EdPrivateKey

Throws away the chain code and gives back only the private key from the extended private key.

impl ExtendedPublicKey<Ed25519> for EdPublicKey

fn derive_normal_child(&self, _idx: i32) -> Result<EdPublicKey>

Derive child extended public keys. Useful for auditing hierarchical deterministic wallets, or generating a new address for each on-chain transaction knowing the owner of the corresponding extended private key can spend the received coins.

fn public_key(&self) -> EdPublicKey

Throws away the chain code and gives back only the public key from the extended public key.

impl KeyDerivationCrypto for Ed25519

type ExtendedPrivateKey = EdExtPrivateKey

See ExtendedPrivateKey for more details.

type ExtendedPublicKey = EdPublicKey

See ExtendedPublicKey for more details.

fn master(seed: &Seed) -> EdExtPrivateKey

Does not seem to completely belong here, but calculates the master extended private key - the root of a hierarchical deterministic wallet - from a given seed. All other keys are derived from this one extended private key.

impl PrivateKey<Ed25519> for EdPrivateKey

fn public_key(&self) -> EdPublicKey

Calculates the PublicKey that belongs to this private key. These two keys together form an asymmetric keypair, where the private key cannot be calculated from the public key with a reasonable effort, but the public key can be calculated from the private key cheaply.

fn sign<D: AsRef<[u8]>>(&self, data: D) -> EdSignature

Calculates the signature of a message that can be then verified using PublicKey::verify

impl PublicKey<Ed25519> for EdPublicKey

fn key_id(&self) -> EdKeyId

Calculates the ID (also called fingerprint or address in some literature) of the public key. In some algorithms the public key is only revealed in point-to-point communications and a keypair is identified only by the digest of the public key in all other channels.

fn validate_id(&self, key_id: &EdKeyId) -> bool

We do not have multiple versions of KeyIds for the same multicipher public key, so for now this comparison is trivial. But when we introduce newer versions, we need to take the version of the key_id argument into account and calculate that possibly older version from self.

fn verify<D: AsRef<[u8]>>(&self, data: D, sig: &EdSignature) -> bool

We should never assume that there is only 1 public key that can verify a given signature. Actually, there are 8 public keys.