sodot_mpc/

lib.rs

#![deny(missing_docs)]
#![doc(html_logo_url = "https://docs.sodot.dev/img/Sodot_shape_only.svg")]
#![doc(html_favicon_url = "https://docs.sodot.dev/img/favicon.ico")]
//! # Sodot MPC
//!
//! The Sodot MPC provides a secure and efficient implementation of threshold cryptography
//! using multi-party computation (MPC). This SDK enables distributed key generation and signing
//! for various cryptographic schemes without requiring a trusted dealer.

//!
//! ## Key Features
//!
//! - **Threshold Key Generation**: Generate cryptographic keys across multiple parties
//! - **Distributed Signing**: Sign messages collaboratively without exposing private keys
//! - **Key Refresh**: Update secret shares while maintaining the same public key
//! - **Multiple Schemes**: Support for ECDSA, Ed25519, BIP340, and SR25519
//! - **Secure MPC**: All operations use secure multi-party computation protocols
//!
//! ## Basic Usage
//!
//! ```rust
//! use sodot_mpc::{KeygenId, KeygenPrivateKey, RoomUUID};
//!
//! // Create types for MPC operations
//! let keygen_id = KeygenId::new("2WpjFqPh8TqQKqZKZXgW8a".to_string());
//! println!("Party ID: {:?}", keygen_id);
//!
//! // Create a private key from bytes
//! let key_bytes = [1u8; 32]; // Example 32-byte array
//! let private_key = KeygenPrivateKey::new(key_bytes);
//! println!("Private key created: {:?}", private_key);
//!
//! // Create a room UUID
//! let room_uuid = RoomUUID::new("550e8400-e29b-41d4-a716-446655440000".to_string());
//! println!("Room UUID: {:?}", room_uuid);
//! ```
//!
//! ## Error Handling
//!
//! All operations return [`Result`] types with [`SodotError`] providing detailed error information
//! for all threshold cryptography operations.

mod error;

mod ffi;
mod schemes;
#[cfg(test)]
#[allow(missing_docs)]
#[cfg(not(miri))] // These tests use the Executor and cannot be currently run under miri
mod tests;

#[cfg(test)]
pub(crate) const TEST_HOST_URL: &str = "us1-test.sodot.dev";

pub use error::SodotError;
pub use schemes::*;

/// A specialized [`Result`] type for Sodot SDK operations that defaults to [`SodotError`] for the error type.
pub type Result<T, E = SodotError> = std::result::Result<T, E>;

/// A base58 string representing the ID of a party in the key generation protocol.
///
/// The `KeygenId` uniquely identifies each participant in the multi-party computation
/// protocols for key generation, signing, and other operations. This ID is generated
/// during the initialization phase and must be shared with all other parties.
///
/// # Examples
///
/// ```rust
/// use sodot_mpc::KeygenId;
///
/// // Create a KeygenId from a base58 string
/// let id = KeygenId::new("2WpjFqPh8TqQKqZKZXgW8a".to_string());
/// println!("Keygen ID: {:?}", id);
///
/// // Access the inner string
/// assert_eq!(id.as_str(), "2WpjFqPh8TqQKqZKZXgW8a");
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct KeygenId(String);

/// A 32-byte private key used for initializing the key generation protocol.
///
/// The `KeygenPrivateKey` represents the private key material that corresponds to a
/// [`KeygenId`]. This key is used to authenticate and secure the participant's
/// involvement in the multi-party computation protocols.
///
/// # Security Notes
///
/// - This key should be kept secure and never shared with other parties
/// - The key is exactly 32 bytes in length
/// - It's generated automatically during the initialization phase
///
/// # Examples
///
/// ```rust
/// use sodot_mpc::KeygenPrivateKey;
///
/// // Create a KeygenPrivateKey from a 32-byte array
/// let key_bytes = [1u8; 32]; // Example 32-byte array
/// let private_key = KeygenPrivateKey::new(key_bytes);
/// println!("Created private key: {:?}", private_key);
/// ```
#[derive(Debug, Clone)]
pub struct KeygenPrivateKey([u8; 32]);

/// A hex string representing a room UUID for MPC operations.
///
/// A `RoomUUID` is created for each multi-party computation operation (such as key generation,
/// signing, refresh, etc.) and acts as a session identifier to synchronize all involved parties.
/// All parties participating in the same operation must use the same room UUID.
///
/// # Usage
///
/// Rooms are created by one party (typically the coordinator) and the UUID is shared with
/// all other participants. The room coordinates the communication and synchronization
/// between parties during the MPC protocol execution.
///
/// # Examples
///
/// ```rust
/// use sodot_mpc::RoomUUID;
///
/// // Create a RoomUUID from a string
/// let room_id = "00000002fddbfdea06319915f5862909".to_string();
/// let room_uuid = RoomUUID::new(room_id);
/// println!("Created room: {:?}", room_uuid);
///
/// // In tests, you can access the inner value
/// #[cfg(test)]
/// {
///     assert_eq!(room_uuid.as_str(), "00000002fddbfdea06319915f5862909");
/// }
/// ```
#[derive(Debug, Clone)]
pub struct RoomUUID(String);

impl KeygenId {
    /// Creates a new `KeygenId` from a string.
    pub fn new(id: String) -> Self {
        debug_assert!(!id.is_empty());
        KeygenId(id)
    }

    /// Returns the keygen ID as a string slice.
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl KeygenPrivateKey {
    /// Creates a new `KeygenPrivateKey` from a 32-byte array.
    pub fn new(bytes: [u8; 32]) -> Self {
        KeygenPrivateKey(bytes)
    }
    /// Returns a reference to the underlying 32-byte array.
    pub fn as_bytes(&self) -> &[u8; 32] {
        &self.0
    }
    /// Consumes the `KeygenPrivateKey` and returns the underlying 32-byte array.
    pub fn into_bytes(self) -> [u8; 32] {
        self.0
    }
}

impl RoomUUID {
    /// Creates a new `RoomUUID` from a string.
    ///
    /// # Arguments
    ///
    /// * `uuid` - A string representing the room UUID
    ///
    /// # Returns
    ///
    /// A new `RoomUUID` instance.
    pub fn new(uuid: String) -> Self {
        RoomUUID(uuid)
    }

    /// Returns the room UUID as a string slice.
    pub fn as_str(&self) -> &str {
        &self.0
    }
}