Overview
The KeyPair enum represents asymmetric key pairs used for cryptographic operations in TAPLE. It supports multiple cryptographic algorithms through its variants.
KeyPair Enum
pub enum KeyPair {
Ed25519(Ed25519KeyPair),
#[cfg(feature = "secp256k1")]
Secp256k1(Secp256k1KeyPair),
}
KeyPair enum provides a unified interface for different cryptographic key pair types. Each variant wraps a specific key pair implementation.
Methods
get_key_derivator
pub fn get_key_derivator(&self) -> KeyDerivator
KeyDerivator enum value corresponding to the key pair type.
from_hex
pub fn from_hex(derivator: &KeyDerivator, hex_key: &str) -> Result<KeyPair, Error>
KeyPair from a hexadecimal-encoded secret key.
The key derivator type (Ed25519 or Secp256k1)
Hexadecimal string representation of the secret key
Result containing the KeyPair or an Error.
Example
use taple_core::crypto::{KeyPair, KeyGenerator, Ed25519KeyPair};
use taple_core::identifier::derive::KeyDerivator;
// Create a new Ed25519 key pair
let key_pair = KeyPair::Ed25519(Ed25519KeyPair::new());
// Get the key derivator
let derivator = key_pair.get_key_derivator();
// Create from hex
let hex_key = "48s8j34fuadfeuijakqp93d56829ki21";
let kp = KeyPair::from_hex(&KeyDerivator::Ed25519, hex_key)?;
Ed25519KeyPair
pub type Ed25519KeyPair = BaseKeyPair<PublicKey, SecretKey>;
BaseKeyPair specialized with Ed25519 key types.
Creating Key Pairs
new
Generates a new random Ed25519 key pair.
Returns: A new Ed25519KeyPair with randomly generated keys.
from_seed
fn from_seed(seed: &[u8]) -> Self
Byte array seed (maximum 32 bytes). Empty slice generates random keys.
Ed25519KeyPair derived from the seed.
from_public_key
fn from_public_key(public_key: &[u8]) -> Self
Raw bytes of the Ed25519 public key
Ed25519KeyPair with only the public key set.
from_secret_key
fn from_secret_key(secret_key: &[u8]) -> Self
Raw bytes of the Ed25519 secret key (32 bytes)
Ed25519KeyPair with both public and secret keys.
Key Material Access
public_key_bytes
fn public_key_bytes(&self) -> Vec<u8>
secret_key_bytes
fn secret_key_bytes(&self) -> Vec<u8>
to_bytes
fn to_bytes(&self) -> Vec<u8>
Digital Signatures
sign
fn sign(&self, payload: Payload) -> Result<Vec<u8>, Error>
The data to sign (must be Payload::Buffer variant)
Result containing the 64-byte signature or an error.
verify
fn verify(&self, payload: Payload, signature: &[u8]) -> Result<(), Error>
The original data that was signed
The signature bytes to verify
Ok(()) if verification succeeds, otherwise an error.
Example
use taple_core::crypto::{Ed25519KeyPair, KeyGenerator, Payload, DSA};
// Generate a new key pair
let key_pair = Ed25519KeyPair::new();
// Sign a message
let message = b"Hello, TAPLE!";
let signature = key_pair.sign(Payload::Buffer(message.to_vec()))?;
// Verify the signature
key_pair.verify(Payload::Buffer(message.to_vec()), &signature)?;
// Get key material
let public_key = key_pair.public_key_bytes();
let secret_key = key_pair.secret_key_bytes();
Secp256k1KeyPair
pub type Secp256k1KeyPair = BaseKeyPair<PublicKey, SecretKey>;
secp256k1 feature is enabled.
Creating Key Pairs
new
Generates a new random Secp256k1 key pair.
Returns: A new Secp256k1KeyPair with randomly generated keys.
from_seed
fn from_seed(seed: &[u8]) -> Self
Byte array seed (maximum 32 bytes). Empty slice generates random keys.
Secp256k1KeyPair derived from the seed.
from_public_key
fn from_public_key(public_key: &[u8]) -> Self
Raw bytes of the Secp256k1 public key (65 bytes for uncompressed format)
Secp256k1KeyPair with only the public key set.
from_secret_key
fn from_secret_key(secret_key: &[u8]) -> Self
Raw bytes of the Secp256k1 secret key (32 bytes)
Secp256k1KeyPair with both public and secret keys.
Key Material Access
The Secp256k1KeyPair implements the same KeyMaterial trait methods as Ed25519KeyPair:
public_key_bytes() - Returns the 65-byte public keysecret_key_bytes() - Returns the 32-byte secret keyto_bytes() - Returns the complete 97-byte key pair
Digital Signatures
Secp256k1KeyPair implements ECDSA (Elliptic Curve Digital Signature Algorithm):
sign
fn sign(&self, payload: Payload) -> Result<Vec<u8>, Error>
The data to sign (must be Payload::Buffer variant)
Result containing the 64-byte signature or an error.
verify
fn verify(&self, payload: Payload, signature: &[u8]) -> Result<(), Error>
The original data that was signed
The signature bytes to verify
Ok(()) if verification succeeds, otherwise an error.
Example
use taple_core::crypto::{Secp256k1KeyPair, KeyGenerator, Payload, DSA};
// Generate a new key pair
let key_pair = Secp256k1KeyPair::new();
// Sign a message
let message = b"Transaction data";
let signature = key_pair.sign(Payload::Buffer(message.to_vec()))?;
// Verify the signature
key_pair.verify(Payload::Buffer(message.to_vec()), &signature)?;
Traits
KeyGenerator
Provides methods to initialize key pairs in various ways:
pub trait KeyGenerator: KeyMaterial {
fn new() -> Self;
fn from_seed(seed: &[u8]) -> Self;
fn from_public_key(public_key: &[u8]) -> Self;
fn from_secret_key(private_key: &[u8]) -> Self;
}
KeyMaterial
Provides access to key material bytes:
pub trait KeyMaterial {
fn public_key_bytes(&self) -> Vec<u8>;
fn secret_key_bytes(&self) -> Vec<u8>;
fn to_bytes(&self) -> Vec<u8>;
fn to_str(&self) -> String;
}
DSA (Digital Signature Algorithm)
Provides signing and verification capabilities:
pub trait DSA {
fn sign(&self, payload: Payload) -> Result<Vec<u8>, Error>;
fn verify(&self, payload: Payload, signature: &[u8]) -> Result<(), Error>;
}
Payload
pub enum Payload {
Buffer(Vec<u8>),
BufferArray(Vec<Vec<u8>>),
}
BaseKeyPair
pub struct BaseKeyPair<P, K> {
pub public_key: P,
pub secret_key: Option<K>,
}
