Struct iop_keyvault::secp256k1::Secp256k1

pub struct Secp256k1;

This elliptic curve cryptography implements both the AsymmetricCrypto and KeyDerivationCrypto traits so for BTC, ETH and IOP as examples.

Trait Implementations

impl AsymmetricCrypto for Secp256k1

type KeyId = SecpKeyId

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

type PublicKey = SecpPublicKey

See PublicKey for more details.

type PrivateKey = SecpPrivateKey

See PrivateKey for more details.

type Signature = SecpSignature

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

impl Clone for Secp256k1

fn clone(&self) -> Secp256k1

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Secp256k1

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

Formats the value using the given formatter.

impl ExtendedPrivateKey<Secp256k1> for SecpExtPrivateKey

fn derive_normal_child(&self, idx: i32) -> Result<SecpExtPrivateKey>

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<SecpExtPrivateKey>

Hardened derivation makes it impossible to the neutered extended public key to calculate children. It uses a different derivation algorithm.

fn neuter(&self) -> SecpExtPublicKey

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) -> SecpPrivateKey

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

impl ExtendedPublicKey<Secp256k1> for SecpExtPublicKey

fn derive_normal_child(&self, idx: i32) -> Result<SecpExtPublicKey>

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) -> SecpPublicKey

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

impl KeyDerivationCrypto for Secp256k1

type ExtendedPrivateKey = SecpExtPrivateKey

See ExtendedPrivateKey for more details.

type ExtendedPublicKey = SecpExtPublicKey

See ExtendedPublicKey for more details.

fn master(seed: &Seed) -> SecpExtPrivateKey

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<Secp256k1> for SecpPrivateKey

fn public_key(&self) -> SecpPublicKey

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) -> SecpSignature

Panics

There is a 2^-256 chance this message cannot be signed by this key. The C implementation in bitcoin does not fail, but this pure rust version does. Then we panic.

impl PublicKey<Secp256k1> for SecpPublicKey

fn key_id(&self) -> SecpKeyId

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: &SecpKeyId) -> 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: &SecpSignature) -> bool

This method can be used to verify if a given signature for a message was made using the private key that belongs to this public key. See also PrivateKey::sign